--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/store/TSTRM/t_storstreamperf.cpp Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,637 @@
+// 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;
+ }