// Copyright (c) 1998-2010 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include <s32file.h>

 #include <e32test.h>

 #include <e32math.h>

 const TInt KTestCleanupStack=0x20;

 // This is a path specification and should not be used as is

 _LIT(KFileLocationSpec, "Z:\\STOR-TST\\T_COMPACT.DAT");

 _LIT(KResultsFile,"RESULTS_%d.TXT");

 static TFileName TheResultsFile;

 static TBool AllTests=ETrue;

 static TInt Iterations=10000;

 static TInt DataVolume=160;

 static TInt CompactFrequency=40;

 class RLog

 	{

 public:

 	void CreateL(RFs& aFs, const TDesC& aFile);

 	void Close();

 	void PrintL(const char* aFormat, ...);

 private:

 	RFileWriteStream iLog;

 	};

 LOCAL_D CTrapCleanup* TheTrapCleanup;

 LOCAL_D RTest test(_L("t_storfcomp"));

 LOCAL_D RFs TheFs;

 LOCAL_D RLog TheLog;

 class StopWatch

 	{

 public:

 	void Start();

 	TUint Stop();

 private:

 	TTime iTime;

 	};

 void StopWatch::Start()

 	{

 	iTime.UniversalTime();

 	}

 TUint StopWatch::Stop()

 	{

  	TTime t;

  	t.UniversalTime();

  	TInt64 i = ((t.MicroSecondsFrom(iTime).Int64()) + 500)/1000;

  	return I64LOW(i);

 	}

 StopWatch CompactSW;

 void CompactL(CFileStore& aStore)

 //

 // Compact the file and record the stats

 //

 	{

 	aStore.CommitL();

 	TInt startSize;

 	User::LeaveIfError(aStore.File().Size(startSize));

 	CompactSW.Start();

 	TInt wasted = aStore.CompactL();

 	aStore.CommitL();

 	TUint ms = CompactSW.Stop();

 	TInt endSize;

 	User::LeaveIfError(aStore.File().Size(endSize));

 	TheLog.PrintL("%d\t%d\t%d\t%u\n",startSize, endSize, wasted, ms);

 	}

 void ReclaimCompactL(CFileStore& aStore, TInt aTrigger)

 //

 // Reclaim the file and compact on trigger

 //

 	{

 	TInt startSize;

 	User::LeaveIfError(aStore.File().Size(startSize));

 	CompactSW.Start();

 	TBool compacted = EFalse;

 	if (aTrigger == 0 || aStore.ReclaimL() * 100 > startSize * aTrigger)

 		{

 		aStore.CompactL();

 		aStore.CommitL();

 		compacted = ETrue;

 		}

 	TUint ms = CompactSW.Stop();

 	TInt endSize;

 	User::LeaveIfError(aStore.File().Size(endSize));

 	TheLog.PrintL("%s\t%d\t%u\n",compacted ? "Compact" : "Reclaim", startSize - endSize, ms);

 	}

 void WriteBytesL(RWriteStream& s, TInt aCount)

 	{

 	const TInt KBufSize = 512;

 	TUint8 buf[KBufSize];

 	while (aCount > KBufSize)

 		{

 		s.WriteL(buf, KBufSize);

 		aCount -= KBufSize;

 		}

 	s.WriteL(buf, aCount);

 	s.CommitL();

 	}

 TStreamId CreateStreamL(CStreamStore& aStore, TInt aSize)

 	{

 	RStoreWriteStream s;

 	TStreamId id = s.CreateLC(aStore);

 	WriteBytesL(s, aSize);

 	CleanupStack::PopAndDestroy(&s);

 	return id;

 	}

 TInt Random(TUint aLimit)

 	{

 	return Math::Random() % aLimit;

 	}

 TBool AllocationFailure()

 	{

 	User::__DbgSetAllocFail(RHeap::EUser,RHeap::EFailNext,1);

 	TAny* cell = User::Alloc(4);

 	User::Free(cell);

 	User::__DbgSetAllocFail(RHeap::EUser,RHeap::ENone,1);

 	return cell == 0;

 	}

 /**

 @SYMTestCaseID          SYSLIB-STORE-CT-1144

 @SYMTestCaseDesc	    Tests for CFileStore::CompactL() function

 @SYMTestPriority 	    High

 @SYMTestActions  	    Attempt for compaction process on the store.Tests for KErrNone flag

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 void BasicCompactionTestsL()

 	{

 	const TInt KTestCount = 40;

 	const TInt KTestSize = 50;

 	TParsePtrC parse(KFileLocationSpec);

 //

 	test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1144 "));

 	CFileStore* store = CPermanentFileStore::ReplaceLC(TheFs, parse.NameAndExt(), EFileRead|EFileWrite);

 	store->SetTypeL(store->Layout());

 //

 	TheLog.PrintL("Compact uncommitted empty store\n");

 	TRAPD(r, store->CompactL());

 	test (r == KErrNone);

 //

 	TheLog.PrintL("Compact committed empty store\n");

 	r = store->Commit();

 	test (r == KErrNone);

 	TRAP(r, store->CompactL());

 	test (r == KErrNone);

 //

 	TheLog.PrintL("Compact empty store with full TOC\n");

 	TStreamId streams[KTestCount];

 	TInt i;

 	for (i = 0; i < KTestCount; ++i)

 		streams[i] = CreateStreamL(*store, KTestSize);

 	store->CommitL();

 	for (i = 0; i < KTestCount; ++i)

 		store->DeleteL(streams[i]);

 	store->CommitL();

 	TRAP(r, store->CompactL());

 	test (r == KErrNone);

 //

 	TheLog.PrintL("Compact empty store with delta TOC\n");

 	streams[0] = CreateStreamL(*store, KTestSize);

 	store->CommitL();

 	store->DeleteL(streams[0]);

 	store->CommitL();

 	TRAP(r, store->CompactL());

 	test (r == KErrNone);

 //

 	CleanupStack::PopAndDestroy(store);

 	}

 /**

 @SYMTestCaseID          SYSLIB-STORE-CT-1145

 @SYMTestCaseDesc	    Testing fallback compaction algorithm

 @SYMTestPriority 	    High

 @SYMTestActions  	    Tests for compaction process on the store,

                         If we have allocation failure we can test that the fallback algorithm is in place

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 void CompactionAlgorithmTestL()

 	{

 	const TInt KTestCount = 200;

 	const TInt KTestSize = 50;

 	const TInt KBeyondSuccess = 2;

 	TInt stopat = KMaxTInt;

 	TInt bestTime = -1;

 	TParsePtrC parse(KFileLocationSpec);

 //

 	test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1145 "));

 	TheLog.PrintL("Testing fallback compaction algorithm\n");

 //

 	for (TInt failat = 1; failat <= stopat; ++failat)

 		{

 		TheLog.PrintL("Fail allocation #%d: ", failat);

 //

 		// prepare the store. Leave a single hole at the beginning

 		CFileStore* store = CPermanentFileStore::ReplaceLC(TheFs, parse.NameAndExt(), EFileRead|EFileWrite);

 		store->SetTypeL(store->Layout());

 		TStreamId first = CreateStreamL(*store, KTestSize);

 		for (TInt i = 1; i < KTestCount; ++i)

 			CreateStreamL(*store, KTestSize);

 		store->CommitL();

 		store->DeleteL(first);

 		store->CommitL();

 		//

 		User::__DbgSetAllocFail(RHeap::EUser,RHeap::EFailNext,failat);

 		CompactSW.Start();

 		TRAPD(r, store->CompactL();	store->CommitL();)

 		TInt ms = CompactSW.Stop();

 		User::__DbgSetAllocFail(RHeap::EUser,RHeap::ENone,1);

 		//

 		if (r != KErrNone)

 			{

 			test (bestTime == -1);

 			TheLog.PrintL("compaction failed\n");

 			}

 		else

 			{

 			TheLog.PrintL("compaction succeeded in %u ms\n", ms);

 			if (bestTime == -1)

 				{

 				bestTime = ms;

 				stopat = failat + KBeyondSuccess;		//stop after a few passes after sucsss

 				}

 			else if (ms < bestTime)

 				{

 				if (ms < bestTime/2)

 					stopat = failat + KBeyondSuccess;	// new algorithm has kicked in

 				bestTime = ms;

 				}

 			}

 		CleanupStack::PopAndDestroy(store);

 		}

 	}

 struct TTracker

 	{

 	TStreamId iId;

 	TInt iSize;

 	};

 CFileStore* InitialiseStoreLC(RArray<TTracker>& aStreams, TInt aDataVolume, TInt aAverageSize)

 	{

 	TParsePtrC parse(KFileLocationSpec);	

 	CFileStore* store = CPermanentFileStore::ReplaceLC(TheFs, parse.NameAndExt(), EFileRead|EFileWrite);

 	store->SetTypeL(store->Layout());

 	for (TInt count = Max(1,(aDataVolume + aAverageSize/2)/aAverageSize); count > 0; --count)

 		{

 		TInt size;

 		if (count == 1)

 			size = aDataVolume;

 		else

 			{

 			size = aDataVolume / count;

 			TInt spread = Min(aAverageSize, size);

 			size += Random(spread) - spread/2;

 			}

 		TTracker e;

 		e.iSize = size;

 		e.iId = CreateStreamL(*store, size);

 		User::LeaveIfError(aStreams.Append(e));

 		aDataVolume -= size;

 		}

 	store->CommitL();

 	return store;

 	}

 /**

 @SYMTestCaseID          SYSLIB-STORE-CT-1146

 @SYMTestCaseDesc	    Tests for compaction on store

 @SYMTestPriority 	    High

 @SYMTestActions  	    Tests for CFileStore::CompactL() function

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 void CompactionTestL(const TInt aIterations, const TInt aDataVolume, const TInt aAverageSize, const TInt aCommitFrequency, const TInt aCompactionFrequency)

 	{

 	test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1146 "));

 	TheLog.PrintL("CompactionTest : \n");

 	TheLog.PrintL("\tIterations:\t%d\n",aIterations);

 	TheLog.PrintL("\tDataVolume:\t%d\n",aDataVolume);

 	TheLog.PrintL("\tAverageSize:\t%d\n",aAverageSize);

 	TheLog.PrintL("\tCommitFrequency:\t%d\n",aCommitFrequency);

 	TheLog.PrintL("\tCompactionFrequency:\t%d\n\n",aCompactionFrequency);

 	RArray<TTracker> streams(8);

 	CleanupClosePushL(streams);

 	CFileStore* store = InitialiseStoreLC(streams, aDataVolume, aAverageSize);

 	const TInt maxCount = streams.Count() + (streams.Count() / 5);

 	TInt size = aDataVolume;

 	const TInt span = aDataVolume / 10;		// +- 10%

 	for (TInt i = aIterations ; --i >= 0; )

 		{

 		TInt from = Random(streams.Count());

 		TInt to = Random(maxCount);

 		TInt tfr = to == from ? 0 : Random(streams[from].iSize + 1);

 		TInt adj = Random(span - 1) - span/2;

 		if (size > aDataVolume + span/2)

 			adj -= size - (aDataVolume + span/2);

 		else if (size < aDataVolume - span/2)

 			adj += (aDataVolume - span/2) - size;

 		if (adj < 0)

 			{

 			if (adj < tfr - streams[from].iSize)

 				adj = tfr - streams[from].iSize;

 			}

 		TInt fromSize = streams[from].iSize - tfr;

 		if (adj < 0 || to == from)

 			fromSize += adj;

 		if (fromSize > 0)

 			{

 			RStoreWriteStream s;

 			s.ReplaceLC(*store, streams[from].iId);

 			WriteBytesL(s, fromSize);

 			CleanupStack::PopAndDestroy(&s);

 			streams[from].iSize = fromSize;

 			}

 		if (to != from)

 			{

 			if (to < streams.Count())

 				{

 				TInt toSize = streams[to].iSize + tfr;

 				if (adj > 0)

 					toSize += adj;

 				RStoreWriteStream s;

 				s.ReplaceLC(*store, streams[to].iId);

 				WriteBytesL(s, toSize);

 				CleanupStack::PopAndDestroy(&s);

 				streams[to].iSize = toSize;

 				}

 			else

 				{

 				TInt toSize = tfr;

 				if (adj > 0)

 					toSize += adj;

 				TTracker e;

 				e.iSize = toSize;

 				e.iId = CreateStreamL(*store, toSize);

 				User::LeaveIfError(streams.Append(e));

 				}

 			}

 		if (fromSize <= 0)

 			{

 			store->DeleteL(streams[from].iId);

 			streams.Remove(from);

 			}

 		size += adj;

 //

 		if (Random(aCommitFrequency) == 0)

 			{

 			store->CommitL();

 			if (aCompactionFrequency <= 0)

 				ReclaimCompactL(*store, -aCompactionFrequency);

 			}

 		if (aCompactionFrequency > 0 && Random(aCompactionFrequency) == 0)

 			CompactL(*store);

 		}

 	CleanupStack::PopAndDestroy(store);

 	CleanupStack::PopAndDestroy(&streams);

 	TheLog.PrintL("\nCompactionTestEnd\n\n");

 	}

 void RLog::CreateL(RFs& aFs, const TDesC& aFile)

 	{

 #ifdef __WINS__

 	User::LeaveIfError(iLog.Replace(aFs, aFile, EFileWrite));

 #endif

 	}

 void RLog::Close()

 	{

 	iLog.Close();

 	}

 void RLog::PrintL(const char* aFormat, ...)

 	{

 	VA_LIST list;

 	VA_START(list,aFormat);

 	TBuf8<256> b;

 	b.FormatList(_L8(aFormat),list);

 	VA_END(list);

 #ifdef __WINS__

 	iLog.WriteL(b);

 #endif

 	TBuf<256> b16;

 	b16.Copy(b);

 	test.Printf(_L("%S"),&b16);

 	}

 void GetOpt()

 	{

 	TBuf<256> options;

     User::CommandLine(options);

 	if (options.Length() > 0)

 		{

 		AllTests = EFalse;

 		TLex lex(options);

 		lex.SkipSpace();

 		if (lex.Val(DataVolume) == KErrNone)

 			{

 			lex.SkipSpace();

 			if (lex.Val(Iterations) == KErrNone)

 				{

 				lex.SkipSpace();

 				lex.Val(CompactFrequency);

 				}

 			}

 		}

 	TheResultsFile.Format(KResultsFile,DataVolume);

 	}

 void testCompactL()

 	{

 	GetOpt();

 	TheLog.CreateL(TheFs, TheResultsFile);

 	if (AllTests)

 		{

 		BasicCompactionTestsL();

 		if (AllocationFailure())

 			CompactionAlgorithmTestL();

 		}

 	CompactionTestL(Iterations, DataVolume<<10, 300, 5, CompactFrequency);

 	TheLog.Close();

 	}

 LOCAL_C void setupTestDirectory()

 //

 // Prepare the test directory.

 //

     {

 	TInt r=TheFs.Connect();

 	test(r==KErrNone);

 //

 	TDriveUnit drive(static_cast<TUint>(RFs::GetSystemDrive()));	

 	TParse parse;

 	parse.Set(drive.Name(), &KFileLocationSpec, NULL);

 	r=TheFs.MkDir(parse.DriveAndPath());

 	test(r==KErrNone||r==KErrAlreadyExists);

 	r=TheFs.SetSessionPath(parse.DriveAndPath());

 	test(r==KErrNone);

 	}

 LOCAL_C void setupCleanup()

 //

 // Initialise the cleanup stack.

 //

     {

 	TheTrapCleanup=CTrapCleanup::New();

 	test(TheTrapCleanup!=NULL);

 	TRAPD(r,\

 		{\

 		for (TInt i=KTestCleanupStack;i>0;i--)\

 			CleanupStack::PushL((TAny*)0);\

 		CleanupStack::Pop(KTestCleanupStack);\

 		});

 	test(r==KErrNone);

 	}

 LOCAL_C void DeleteDataFile(const TDesC& aFullName)

 	{

 	RFs fsSession;

 	TInt err = fsSession.Connect();

 	if(err == KErrNone)

 		{

 		TEntry entry;

 		if(fsSession.Entry(aFullName, entry) == KErrNone)

 			{

 			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

 			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

 			if(err != KErrNone)

 				{

 				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

 				}

 			err = fsSession.Delete(aFullName);

 			if(err != KErrNone)

 				{

 				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

 				}

 			}

 		fsSession.Close();

 		}

 	else

 		{

 		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

 		}

 	}

 class CTestStreamStore : public CStreamStore

 	{

 public:

 	static CTestStreamStore* NewL();

 	virtual ~CTestStreamStore();

 private:

 	CTestStreamStore();

 	virtual MStreamBuf* DoReadL(TStreamId anId) const;

 	virtual MStreamBuf* DoCreateL(TStreamId& anId);

 	};

 CTestStreamStore* CTestStreamStore::NewL()

 	{

 	return new (ELeave) CTestStreamStore; 

 	}

 CTestStreamStore::~CTestStreamStore()

 	{

 	}

 CTestStreamStore::CTestStreamStore()

 	{

 	}

 MStreamBuf* CTestStreamStore::DoReadL(TStreamId) const

 	{

 	return NULL;

 	}

 MStreamBuf* CTestStreamStore::DoCreateL(TStreamId&)

 	{

 	return NULL;

 	}

 /**

 @SYMTestCaseID          PDS-STORE-CT-4063

 @SYMTestCaseDesc        CStreamStore tests.

 @SYMTestActions         CStreamStore provides couple of virtual methods in its private section:

                         DoExtendL(), DoDeleteL(), DoReplaceL(), DoReclaimL().

                         They are no-ops and are expected to be overriden in the class derived from

                         CStreamStore. Their implementations leave with KErrNotsupported. 

                         The test uses a class derived from CStreamStore, which class does not implement

                         virtuals mentioned above. These virtuals should leave with KErrNotSupported when called.

 @SYMTestPriority        High

 @SYMTestExpectedResults Test must not fail

 */

 void TestStreamStoreVirtualsL()

 	{

 	CTestStreamStore* store = CTestStreamStore::NewL();

 	TRAPD(err, store->CommitL());

 	test(err == KErrNone);

 	TRAP(err, store->RevertL());

 	test(err == KErrNotSupported);

 	TRAP(err, store->ReclaimL());

 	test(err == KErrNotSupported);

 	TRAP(err, store->CompactL());

 	test(err == KErrNotSupported);

 	TRAP(err, store->DeleteL(TStreamId(1)));

 	test(err == KErrNotSupported);

 	delete store;

 	}

 //

 // Test permanent file store.

 //

 GLDEF_C TInt E32Main()

     {

 	test.Title();

 	setupTestDirectory();

 	setupCleanup();

 	__UHEAP_MARK;

 //

 	test.Start(_L("Test compaction"));

 	TRAPD(r,testCompactL());

 	test(r==KErrNone);

 	test.Next(_L("@SYMTestCaseID:PDS-STORE-CT-4063: Test CStreamStore virtuals"));

 	TRAP(r, TestStreamStoreVirtualsL())

 	test(r==KErrNone);

 	//deletion of data files must be before call to .End() - DEF047652

 	TDriveUnit drive(static_cast<TUint>(RFs::GetSystemDrive()));	

 	TParse parse;

 	parse.Set(drive.Name(), &KFileLocationSpec, NULL);

 	::DeleteDataFile(parse.FullName());

 	test.End();

 //

 	__UHEAP_MARKEND;

 	delete TheTrapCleanup;

 	TheFs.Close();

 	test.Close();

 	return 0;

     }