// 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(KNullStreamIdValue);

	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;

	}