// Copyright (c) 2009 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 <e32test.h>
#include <s32file.h>
#include <s32fileiter.h>
#include <s32mem.h>
#include <hal.h>

RTest TheTest(_L("t_storstreamperf"));
RFs TheFs;

TFileName TheTestFile;
TFileName TheTestDir;
TFileName TheTestDictFile;

const TUid KDictFileUid = {19445};
const TUid KDictStrmUid1 = {19446};
const TUid KDictStrmUid2 = {19447};

const TInt KBufSize = 30000;
const TInt KIterCnt = 1000;
const TInt KTestDataLen = KBufSize / KIterCnt;
const TUint8 KTestData[KTestDataLen] = 
	{
	'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
	'P','Q','R','S','T','U','V','W','X','Y','Z','0','1','2','3'
	};
const TPtrC8  KTestDes(KTestData, KTestDataLen);

///////////////////////////////////////////////////////////////////////////////////////

void DestroyTestEnv()
	{
	(void)TheFs.Delete(TheTestDictFile);
	(void)TheFs.Delete(TheTestFile);
	TheFs.Close();
	}

///////////////////////////////////////////////////////////////////////////////////////
//Test macros and functions
void Check(TInt aValue, TInt aLine)
	{
	if(!aValue)
		{
		TheTest.Printf(_L("*** Boolean expression evaluated to false\r\n"));
		DestroyTestEnv();
		TheTest(EFalse, aLine);
		}
	}
void Check(TInt aValue, TInt aExpected, TInt aLine)
	{
	if(aValue != aExpected)
		{
		DestroyTestEnv();
		TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
		TheTest(EFalse, aLine);
		}
	}
#define TEST(arg) ::Check((arg), __LINE__)
#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

///////////////////////////////////////////////////////////////////////////////////////

void CreateTestEnv()
    {
	TInt err = TheFs.Connect();
	TheTest(err == KErrNone);
	
	err = TheFs.MkDirAll(TheTestFile);
	TEST(err == KErrNone || err == KErrAlreadyExists);
	}

///////////////////////////////////////////////////////////////////////////////////////

static TInt TheCounterFreq = -10000000;
const TInt KMicroSecIn1Sec = 1000000;

TUint32 CalcTickDiff(TUint32 aStartTicks, TUint32 aEndTicks)
	{
	TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;
	if(diffTicks < 0)
		{
		diffTicks = KMaxTUint32 + diffTicks + 1;
		}
	return (TUint32)diffTicks;
	}

//Prints aFastCount parameter (converted to us)
void PrintFcDiffAsUs(const TDesC& aFormatStr, TUint32 aFastCount)
	{
	double v = ((double)aFastCount * KMicroSecIn1Sec) / (double)TheCounterFreq;
	TInt v2 = (TInt)v;
	TheTest.Printf(aFormatStr, v2);
	}

///////////////////////////////////////////////////////////////////////////////////////

//Testing RWriteStream performance.
void StreamWriteTestL(RWriteStream& aStream, TUint32& aWriteFc, TUint32& aCommitFc)
	{
	TUint32 fc = User::FastCounter();
	for(TInt i=0;i<KIterCnt;++i)
		{
		aStream.WriteL(KTestDes);
		}
	TUint32 fc2 = User::FastCounter();
	aStream.CommitL();
	TUint32 fc3 = User::FastCounter();
	
	aWriteFc = CalcTickDiff(fc, fc2);
	aCommitFc = CalcTickDiff(fc2, fc3);
	}

void DoStreamWriteTestL(RWriteStream& aStream)
	{
	TUint32 writeFc = 0, commitFc = 0;
	StreamWriteTestL(aStream, writeFc, commitFc);
	PrintFcDiffAsUs(_L("###     RWriteStream::WriteL(),  Time=%d us\r\n"), writeFc);
	PrintFcDiffAsUs(_L("###     RWriteStream::CommitL(), Time=%d us\r\n"), commitFc);
	}

//Testing RReadStream performance.
void StreamReadTestL(RReadStream& aStream, TUint32& aReadFc)
	{
	TBuf8<KTestDataLen> buf;
	TUint32 fc = User::FastCounter();
	for(TInt i=0;i<KIterCnt;++i)
		{
		aStream.ReadL(buf);
		}
	TUint32 fc2 = User::FastCounter();
	TEST(buf == KTestDes);

	aReadFc = CalcTickDiff(fc, fc2);
	}

void DoStreamReadTestL(RReadStream& aStream)
	{
	TUint32 readFc = 0;
	StreamReadTestL(aStream, readFc);
	PrintFcDiffAsUs(_L("###     RReadStream::ReadL(),   Time=%d us\r\n"), readFc);
	}

///////////////////////////////////////////////////////////////////////////////////////

void GetFastCounterFrequency()
	{
	TEST2(HAL::Get(HAL::EFastCounterFrequency, TheCounterFreq), KErrNone);
	TheTest.Printf(_L("Counter frequency=%d Hz\r\n"), TheCounterFreq);
	}

/**
@SYMTestCaseID			PDS-STORE-UT-4053
@SYMTestCaseDesc		Test for DEF141471 - STORE, new stream performance tests.
						PREQ2505 Insturmentation of PDS.
						RDictionaryWriteStream & RDictionaryReadStream performance tests.
@SYMTestPriority		High
@SYMTestActions			Test for DEF141471 - STORE, new stream performance tests.
@SYMTestExpectedResults Test must not fail
@SYMDEF					DEF141471
*/
void DictionaryStreamTestL()
	{
	(void)TheFs.Delete(TheTestDictFile);
	CDictionaryFileStore* store = CDictionaryFileStore::OpenLC(TheFs, TheTestDictFile, KDictFileUid);
	
	//RDictionaryWriteStream::AssignL()
	RDictionaryWriteStream strm1;
	CleanupClosePushL(strm1);
	TUint32 fc = User::FastCounter();
	strm1.AssignL(*store, KDictStrmUid1);
	TUint32 assignFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RDictionaryWriteStream::AssignL(), Time=%d us\r\n"), assignFc);
	DoStreamWriteTestL(strm1);
	CleanupStack::PopAndDestroy(&strm1);
	
	//RDictionaryWriteStream::AssignLC()
	RDictionaryWriteStream strm2;
	fc = User::FastCounter();
	strm2.AssignLC(*store, KDictStrmUid2);
	assignFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RDictionaryWriteStream::AssignLC(), Time=%d us\r\n"), assignFc);
	DoStreamWriteTestL(strm2);
	CleanupStack::PopAndDestroy(&strm2);

	//RDictionaryReadStream::OpenL()
	RDictionaryReadStream strm3;
	CleanupClosePushL(strm3);
	fc = User::FastCounter();
	strm3.OpenL(*store, KDictStrmUid1);
	TUint32 openFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RDictionaryReadStream::OpenL(), Time=%d us\r\n"), openFc);
	DoStreamReadTestL(strm3);
	CleanupStack::PopAndDestroy(&strm3);

	//RDictionaryReadStream::OpenLC()
	RDictionaryReadStream strm4;
	fc = User::FastCounter();
	strm4.OpenLC(*store, KDictStrmUid2);
	openFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RDictionaryReadStream::OpenLC(), Time=%d us\r\n"), openFc);
	DoStreamReadTestL(strm4);
	CleanupStack::PopAndDestroy(&strm4);
	
	CleanupStack::PopAndDestroy(store);
	}

/**
@SYMTestCaseID			PDS-STORE-UT-4054
@SYMTestCaseDesc		Test for DEF141471 - STORE, new stream performance tests.
						PREQ2505 Insturmentation of PDS.
						RFileWriteStream & RFileReadStream performance tests.
@SYMTestPriority		High
@SYMTestActions			Test for DEF141471 - STORE, new stream performance tests.
@SYMTestExpectedResults Test must not fail
@SYMDEF					DEF141471
*/
void FileStreamTestL()
	{
	(void)TheFs.Delete(TheTestFile);
	
	//RFileWriteStream::Create()
	RFileWriteStream strm1;
	TUint32 fc = User::FastCounter();
	TInt err = strm1.Create(TheFs, TheTestFile, EFileWrite | EFileRead);
	TUint32 createFc = CalcTickDiff(fc, User::FastCounter());
	TEST2(err, KErrNone);
	PrintFcDiffAsUs(_L("###  RFileWriteStream::Create(), Time=%d us\r\n"), createFc);
	strm1.Close();
	
	//RFileWriteStream::Replace()
	RFileWriteStream strm2;
	fc = User::FastCounter();
	err = strm2.Replace(TheFs, TheTestFile, EFileWrite | EFileRead);
	TUint32 replaceFc = CalcTickDiff(fc, User::FastCounter());
	TEST2(err, KErrNone);
	PrintFcDiffAsUs(_L("###  RFileWriteStream::Replace(), Time=%d us\r\n"), replaceFc);
	strm2.Close();
	
	//RFileWriteStream::Open()
	RFileWriteStream strm3;
	fc = User::FastCounter();
	err = strm3.Open(TheFs, TheTestFile, EFileWrite | EFileRead);
	TUint32 openFc = CalcTickDiff(fc, User::FastCounter());
	TEST2(err, KErrNone);
	PrintFcDiffAsUs(_L("###  RFileWriteStream::Open(), Time=%d us\r\n"), openFc);
	strm3.Close();
	
	//RFileWriteStream::Attach()
	RFile file;
	err = file.Open(TheFs, TheTestFile, EFileWrite | EFileRead);
	TEST2(err, KErrNone);
	RFileWriteStream strm4;
	CleanupClosePushL(strm4);
	fc = User::FastCounter();
	strm4.Attach(file);
	TUint32 attachFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RFileWriteStream::Attach(), Time=%d us\r\n"), attachFc);
	DoStreamWriteTestL(strm4);
	CleanupStack::PopAndDestroy(&strm4);
	
	//RFileWriteStream::Temp()
	RFileWriteStream strm5;
	CleanupClosePushL(strm5);
	TFileName fname;
	fc = User::FastCounter();
	err = strm5.Temp(TheFs, TheTestDir, fname, EFileWrite | EFileRead);
	TUint32 tempFc = CalcTickDiff(fc, User::FastCounter());
	TEST2(err, KErrNone);
	PrintFcDiffAsUs(_L("###  RFileWriteStream::Temp(), Time=%d us\r\n"), tempFc);
	DoStreamWriteTestL(strm5);
	CleanupStack::PopAndDestroy(&strm5);
	err = TheFs.Delete(fname);
	TEST2(err, KErrNone);
	
	//RFileReadStream::Open()
	RFileReadStream strm6;
	fc = User::FastCounter();
	err = strm6.Open(TheFs, TheTestFile, EFileRead);
	openFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RFileReadStream::Open(), Time=%d us\r\n"), openFc);
	strm6.Close();

	//RFileReadStream::Attach()
	err = file.Open(TheFs, TheTestFile, EFileRead);
	TEST2(err, KErrNone);
	RFileReadStream strm7;
	fc = User::FastCounter();
	strm7.Attach(file);
	attachFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RFileReadStream::Attach(), Time=%d us\r\n"), attachFc);
	strm7.Close();

	//RFileReadStream::RFileReadStream(RFile&)
	err = file.Open(TheFs, TheTestFile, EFileRead);
	TEST2(err, KErrNone);
	fc = User::FastCounter();
	RFileReadStream strm8(file);
	TUint32 constrFc = CalcTickDiff(fc, User::FastCounter());
	CleanupClosePushL(strm8);
	PrintFcDiffAsUs(_L("###  RFileReadStream::RFileReadStream(RFile&), Time=%d us\r\n"), constrFc);
	DoStreamReadTestL(strm8);
	CleanupStack::PopAndDestroy(&strm8);
	}

/**
@SYMTestCaseID			PDS-STORE-UT-4055
@SYMTestCaseDesc		Test for DEF141471 - STORE, new stream performance tests.
						PREQ2505 Insturmentation of PDS.
						RMemWriteStream & RMemReadStream performance tests.
@SYMTestPriority		High
@SYMTestActions			Test for DEF141471 - STORE, new stream performance tests.
@SYMTestExpectedResults Test must not fail
@SYMDEF					DEF141471
*/
void MemStreamTestL()
	{
	HBufC8* buf = HBufC8::NewLC(KBufSize);
	TPtr8 bufPtr = buf->Des();

	//RMemWriteStream::Open()	
	RMemWriteStream strm1;
	TUint32 fc = User::FastCounter();
	strm1.Open(const_cast <TUint8*> (bufPtr.Ptr()), KBufSize);
	TUint32 openFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RMemWriteStream::Open(), Time=%d us\r\n"), openFc);
	strm1.Close();
	
	//RMemWriteStream::RMemWriteStream(TAny*,...)	
	fc = User::FastCounter();
	RMemWriteStream strm2(const_cast <TUint8*> (bufPtr.Ptr()), KBufSize);
	TUint32 constrFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RMemWriteStream::RMemWriteStream(TAny*,...), Time=%d us\r\n"), constrFc);
	CleanupClosePushL(strm2);
	DoStreamWriteTestL(strm2);
	CleanupStack::PopAndDestroy(&strm2);
	
	//RMemReadStream::Open()
	RMemReadStream strm3;
	fc = User::FastCounter();
	strm3.Open(bufPtr.Ptr(), KBufSize);
	openFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RMemReadStream::Open(), Time=%d us\r\n"), openFc);
	strm3.Close();

	//RMemReadStream::RMemReadStream(TAny*,...)	
	fc = User::FastCounter();
	RMemReadStream strm4(bufPtr.Ptr(), KBufSize);
	constrFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RMemReadStream::RMemReadStream(TAny*,...), Time=%d us\r\n"), openFc);
	CleanupClosePushL(strm4);
	DoStreamReadTestL(strm4);
	CleanupStack::PopAndDestroy(&strm4);
	
	CleanupStack::PopAndDestroy(buf);
	}

/**
@SYMTestCaseID			PDS-STORE-UT-4056
@SYMTestCaseDesc		Test for DEF141471 - STORE, new stream performance tests.
						PREQ2505 Insturmentation of PDS.
						RBufWriteStream & RBufReadStream performance tests.
@SYMTestPriority		High
@SYMTestActions			Test for DEF141471 - STORE, new stream performance tests.
@SYMTestExpectedResults Test must not fail
@SYMDEF					DEF141471
*/
void BufStreamTestL()
	{
	CBufFlat* bufFlat = CBufFlat::NewL(KTestDataLen);
	CleanupStack::PushL(bufFlat);
	
	//RBufWriteStream::Open()
	RBufWriteStream strm1;
	CleanupClosePushL(strm1);
	TUint32 fc = User::FastCounter();
	strm1.Open(*bufFlat);
	TUint32 openFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RBufWriteStream::Open(), Time=%d us\r\n"), openFc);
	DoStreamWriteTestL(strm1);
	CleanupStack::PopAndDestroy(&strm1);
	TheTest.Printf(_L("       Buffer size=%d\r\n"), bufFlat->Size());

	//RBufWriteStream::Append()
	RBufWriteStream strm2;
	CleanupClosePushL(strm2);
	fc = User::FastCounter();
	strm2.Append(*bufFlat);
	TUint32 appendFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RBufWriteStream::Append(), Time=%d us\r\n"), appendFc);
	DoStreamWriteTestL(strm2);
	CleanupStack::PopAndDestroy(&strm2);
	TheTest.Printf(_L("       Buffer size=%d\r\n"), bufFlat->Size());
	
	//RBufWriteStream::Insert()
	RBufWriteStream strm3;
	CleanupClosePushL(strm3);
	fc = User::FastCounter();
	strm3.Insert(*bufFlat, KBufSize);
	TUint32 insertFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RBufWriteStream::Insert(), Time=%d us\r\n"), insertFc);
	DoStreamWriteTestL(strm3);
	CleanupStack::PopAndDestroy(&strm3);
	TheTest.Printf(_L("       Buffer size=%d\r\n"), bufFlat->Size());
	
	//RBufWriteStream::Truncate()
	RBufWriteStream strm4;
	CleanupClosePushL(strm4);
	fc = User::FastCounter();
	strm4.Truncate(*bufFlat);
	TUint32 truncateFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RBufWriteStream::Truncate(), Time=%d us\r\n"), truncateFc);
	DoStreamWriteTestL(strm4);
	CleanupStack::PopAndDestroy(&strm4);
	TheTest.Printf(_L("       Buffer size=%d\r\n"), bufFlat->Size());
	
	RBufReadStream strm5;
	CleanupClosePushL(strm5);
	fc = User::FastCounter();
	strm5.Open(*bufFlat);
	openFc = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  RBufReadStream::Open(), Time=%d us\r\n"), openFc);
	DoStreamReadTestL(strm5);
	CleanupStack::PopAndDestroy(&strm5);
	
	CleanupStack::PopAndDestroy(bufFlat);
	}

/** 
@SYMTestCaseID			PDS-STORE-UT-4057
@SYMTestCaseDesc		Test for DEF141471 - STORE, new stream performance tests.
						PREQ2505 Insturmentation of PDS.
						RPermanentFileStoreIter performance tests.
@SYMTestPriority		High
@SYMTestActions			Test for DEF141471 - STORE, new stream performance tests.
@SYMTestExpectedResults Test must not fail
@SYMDEF					DEF141471
*/
void PermanentFileStoreIterTestL()
	{
	(void)TheFs.Delete(TheTestFile);

	CPermanentFileStore* store = CPermanentFileStore::ReplaceLC(TheFs, TheTestFile, EFileWrite | EFileRead);
	store->SetTypeL(KPermanentFileStoreLayoutUid);
	
	//Create streams
	const TInt KStreamCnt = 10;
	TStreamId streamId[KStreamCnt] = {0}; 	
	TheTest.Printf(_L("###  CPermanentFileStore, create %d streams\r\n"), KStreamCnt);
	for(TInt i=0;i<KStreamCnt;i++)
		{
		RStoreWriteStream out;
		streamId[i] = out.CreateLC(*store);
		TheTest.Printf(_L("###    Stream##%02d, streamId=%08X\r\n"), i + 1, streamId[i].Value());
		DoStreamWriteTestL(out);
		CleanupStack::PopAndDestroy(&out);
		}
	TUint32 fc = User::FastCounter();
	store->CommitL();
	TUint32 commitFc = CalcTickDiff(fc, User::FastCounter());
	CleanupStack::PopAndDestroy(store);
	PrintFcDiffAsUs(_L("###  RPermanentFileStoreIter::CommitL(), Time=%d us\r\n"), commitFc);
	
	//RPermanentFileStoreIter::ResetL()
	store = CPermanentFileStore::OpenLC(TheFs, TheTestFile, EFileWrite | EFileRead);
	RPermanentFileStoreIter it1;
	CleanupClosePushL(it1);
	fc = User::FastCounter();
	it1.ResetL(*store);
	TUint32 resetFc = CalcTickDiff(fc, User::FastCounter());
	CleanupStack::PopAndDestroy(&it1);
	CleanupStack::PopAndDestroy(store);
	PrintFcDiffAsUs(_L("###  RPermanentFileStoreIter::ResetL(), Time=%d us\r\n"), resetFc);

	//RPermanentFileStoreIter::ResetLC()
	store = CPermanentFileStore::OpenLC(TheFs, TheTestFile, EFileWrite | EFileRead);
	RPermanentFileStoreIter it2;
	fc = User::FastCounter();
	it2.ResetLC(*store);
	resetFc = CalcTickDiff(fc, User::FastCounter());
	CleanupStack::PopAndDestroy(&it2);
	CleanupStack::PopAndDestroy(store);
	PrintFcDiffAsUs(_L("###  RPermanentFileStoreIter::ResetLC(), Time=%d us\r\n"), resetFc);

	//RPermanentFileStoreIter - construction & destruction
	store = CPermanentFileStore::OpenLC(TheFs, TheTestFile, EFileWrite | EFileRead);
	fc = User::FastCounter();
	RPermanentFileStoreIter it3;
	CleanupClosePushL(it3);
	it3.ResetL(*store);
	CleanupStack::PopAndDestroy(&it3);
	TUint32 fc2 = CalcTickDiff(fc, User::FastCounter());
	CleanupStack::PopAndDestroy(store);
	PrintFcDiffAsUs(_L("###  RPermanentFileStoreIter - construction & destruction, Time=%d us\r\n"), fc2);

	//RPermanentFileStoreIter::NextL()
	store = CPermanentFileStore::OpenLC(TheFs, TheTestFile, EFileWrite | EFileRead);
	RPermanentFileStoreIter it4;
	it4.ResetLC(*store);
	TStreamId id;
	TInt cnt = 0;
	fc = User::FastCounter();
	while((id = it4.NextL()) != KNullStreamIdValue)
		{
		++cnt;
		}
	TUint32 nextFc = CalcTickDiff(fc, User::FastCounter());
	CleanupStack::PopAndDestroy(&it4);
	CleanupStack::PopAndDestroy(store);
	TEST2(cnt, KStreamCnt);
	PrintFcDiffAsUs(_L("###  RPermanentFileStoreIter::NextL(), Time=%d us\r\n"), nextFc);
	}

/**
@SYMTestCaseID          SYSLIB-STORE-CT-4007
@SYMTestCaseDesc	    CDirectFileStore::ReplaceLC() and SetTypeL() performance test
@SYMTestPriority 	    High
@SYMTestActions  	    Creates new CDirectFileStore object and measures the time of the operation. 
@SYMTestExpectedResults Tests set type time 
@SYMCR                  ATHE-7CQP8H
*/
void CreateDirectFileStoreTestL()
	{	
	(void)TheFs.Delete(TheTestFile);
	    
    TUint32 fc = User::FastCounter();
	CFileStore* store = CDirectFileStore::ReplaceLC(TheFs, TheTestFile, EFileWrite | EFileRead);
	// Must say what kind of file store
	// SetTypeL() calls RFileBuf::EndL() which used to call RFile::Size()
	store->SetTypeL(KDirectFileStoreLayoutUid);
	TUint32 time = CalcTickDiff(fc, User::FastCounter());
	CleanupStack::PopAndDestroy(store);
	PrintFcDiffAsUs(_L("###  CDirectFileStore::ReplaceLC() & SetTypeL(), Time=%d us\r\n"), time);
	}

/**
@SYMTestCaseID          SYSLIB-STORE-CT-4008
@SYMTestCaseDesc	    Tests performance when calling CFileStore::Destruct()
@SYMTestPriority 	    High
@SYMTestActions  	    Creates and deletes a File Store 
@SYMTestExpectedResults Tests deletion time 
@SYMCR                  ATHE-7CQP8H
*/
void DirectFileStoreTestL()
	{	
	(void)TheFs.Delete(TheTestFile);
	
    TUint32 fc = User::FastCounter();
	CFileStore* store = CDirectFileStore::ReplaceLC(TheFs, TheTestFile, EFileWrite | EFileRead);
	//then delete it. this calls CFileStore::Destruct(), which used to call Revert()
	CleanupStack::PopAndDestroy(store);
	TUint32 time = CalcTickDiff(fc, User::FastCounter());
	PrintFcDiffAsUs(_L("###  CDirectFileStore construction & destruction, Time=%d us\r\n"), time);
	}

void DoTestsL()
	{
	TheTest.Start(_L("Get fast counter frequency"));
	GetFastCounterFrequency();
	
	TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4053 RDictionaryWriteStream & RDictionaryReadStream - performance test"));
	DictionaryStreamTestL();
	
	TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4054 RFileWriteStream & RFileReadStream - performance test"));
	FileStreamTestL();

	TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4055 RMemWriteStream & RMemReadStream - performance test"));
	MemStreamTestL();

	TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4056 RBufWriteStream & RBufReadStream - performance test"));
	BufStreamTestL();

	TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4057 RPermanentFileStoreIter - performance test"));
	PermanentFileStoreIterTestL();
	
	TheTest.Next(_L(" @SYMTestCaseID SYSLIB-STORE-CT-4007 CDirectFileStore::ReplaceLC() & SetTypeL() performance test"));
	CreateDirectFileStoreTestL();
	
	TheTest.Next(_L(" @SYMTestCaseID SYSLIB-STORE-CT-4008 CDirectFileStore construction & destruction performance test"));
	DirectFileStoreTestL();
	}

//Usage: "t_streamperf [<drive letter>:]]"
TInt E32Main()
	{
	TheTest.Title();

	CTrapCleanup* tc = CTrapCleanup::New();
	TheTest(tc != NULL);
		
	TBuf<256> cmdline;
	User::CommandLine(cmdline);

	TParse parse;

	_LIT(KTestFile, "c:\\stor-tst\\t_streamperf.dat");
	parse.Set(cmdline, &KTestFile, 0);
	TheTestFile.Copy(parse.FullName());

	_LIT(KTestPath, "c:\\stor-tst\\");
	parse.Set(cmdline, &KTestPath, 0);
	TheTestDir.Copy(parse.FullName());
	
	_LIT(KDictFile, "c:\\stor-tst\\dicfile.ini");
	parse.Set(cmdline, &KDictFile, 0);
	TheTestDictFile.Copy(parse.FullName());

	__UHEAP_MARK;

	CreateTestEnv();
	TRAPD(err, DoTestsL());
	TEST2(err, KErrNone);
	DestroyTestEnv();

	__UHEAP_MARKEND;

	TheTest.End();
	TheTest.Close();

	delete tc;

	User::Heap().Check();
	return KErrNone;
	}