Symaptic: os/persistentdata/persistentstorage/store/TSTRM/t

     1 // Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include <e32test.h>

    17 #include <s32file.h>

    18 #include <s32fileiter.h>

    19 #include <s32mem.h>

    20 #include <hal.h>

    22 RTest TheTest(_L("t_storstreamperf"));

    23 RFs TheFs;

    25 TFileName TheTestFile;

    26 TFileName TheTestDir;

    27 TFileName TheTestDictFile;

    29 const TUid KDictFileUid = {19445};

    30 const TUid KDictStrmUid1 = {19446};

    31 const TUid KDictStrmUid2 = {19447};

    33 const TInt KBufSize = 30000;

    34 const TInt KIterCnt = 1000;

    35 const TInt KTestDataLen = KBufSize / KIterCnt;

    36 const TUint8 KTestData[KTestDataLen] =

    37 	{

    38 	'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',

    39 	'P','Q','R','S','T','U','V','W','X','Y','Z','0','1','2','3'

    40 	};

    41 const TPtrC8  KTestDes(KTestData, KTestDataLen);

    43 ///////////////////////////////////////////////////////////////////////////////////////

    45 void DestroyTestEnv()

    46 	{

    47 	(void)TheFs.Delete(TheTestDictFile);

    48 	(void)TheFs.Delete(TheTestFile);

    49 	TheFs.Close();

    50 	}

    52 ///////////////////////////////////////////////////////////////////////////////////////

    53 //Test macros and functions

    54 void Check(TInt aValue, TInt aLine)

    55 	{

    56 	if(!aValue)

    57 		{

    58 		TheTest.Printf(_L("*** Boolean expression evaluated to false\r\n"));

    59 		DestroyTestEnv();

    60 		TheTest(EFalse, aLine);

    61 		}

    62 	}

    63 void Check(TInt aValue, TInt aExpected, TInt aLine)

    64 	{

    65 	if(aValue != aExpected)

    66 		{

    67 		DestroyTestEnv();

    68 		TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

    69 		TheTest(EFalse, aLine);

    70 		}

    71 	}

    72 #define TEST(arg) ::Check((arg), __LINE__)

    73 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

    75 ///////////////////////////////////////////////////////////////////////////////////////

    77 void CreateTestEnv()

    78     {

    79 	TInt err = TheFs.Connect();

    80 	TheTest(err == KErrNone);

    82 	err = TheFs.MkDirAll(TheTestFile);

    83 	TEST(err == KErrNone || err == KErrAlreadyExists);

    84 	}

    86 ///////////////////////////////////////////////////////////////////////////////////////

    88 static TInt TheCounterFreq = -10000000;

    89 const TInt KMicroSecIn1Sec = 1000000;

    91 TUint32 CalcTickDiff(TUint32 aStartTicks, TUint32 aEndTicks)

    92 	{

    93 	TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;

    94 	if(diffTicks < 0)

    95 		{

    96 		diffTicks = KMaxTUint32 + diffTicks + 1;

    97 		}

    98 	return (TUint32)diffTicks;

    99 	}

   101 //Prints aFastCount parameter (converted to us)

   102 void PrintFcDiffAsUs(const TDesC& aFormatStr, TUint32 aFastCount)

   103 	{

   104 	double v = ((double)aFastCount * KMicroSecIn1Sec) / (double)TheCounterFreq;

   105 	TInt v2 = (TInt)v;

   106 	TheTest.Printf(aFormatStr, v2);

   107 	}

   109 ///////////////////////////////////////////////////////////////////////////////////////

   111 //Testing RWriteStream performance.

   112 void StreamWriteTestL(RWriteStream& aStream, TUint32& aWriteFc, TUint32& aCommitFc)

   113 	{

   114 	TUint32 fc = User::FastCounter();

   115 	for(TInt i=0;i<KIterCnt;++i)

   116 		{

   117 		aStream.WriteL(KTestDes);

   118 		}

   119 	TUint32 fc2 = User::FastCounter();

   120 	aStream.CommitL();

   121 	TUint32 fc3 = User::FastCounter();

   123 	aWriteFc = CalcTickDiff(fc, fc2);

   124 	aCommitFc = CalcTickDiff(fc2, fc3);

   125 	}

   127 void DoStreamWriteTestL(RWriteStream& aStream)

   128 	{

   129 	TUint32 writeFc = 0, commitFc = 0;

   130 	StreamWriteTestL(aStream, writeFc, commitFc);

   131 	PrintFcDiffAsUs(_L("###     RWriteStream::WriteL(),  Time=%d us\r\n"), writeFc);

   132 	PrintFcDiffAsUs(_L("###     RWriteStream::CommitL(), Time=%d us\r\n"), commitFc);

   133 	}

   135 //Testing RReadStream performance.

   136 void StreamReadTestL(RReadStream& aStream, TUint32& aReadFc)

   137 	{

   138 	TBuf8<KTestDataLen> buf;

   139 	TUint32 fc = User::FastCounter();

   140 	for(TInt i=0;i<KIterCnt;++i)

   141 		{

   142 		aStream.ReadL(buf);

   143 		}

   144 	TUint32 fc2 = User::FastCounter();

   145 	TEST(buf == KTestDes);

   147 	aReadFc = CalcTickDiff(fc, fc2);

   148 	}

   150 void DoStreamReadTestL(RReadStream& aStream)

   151 	{

   152 	TUint32 readFc = 0;

   153 	StreamReadTestL(aStream, readFc);

   154 	PrintFcDiffAsUs(_L("###     RReadStream::ReadL(),   Time=%d us\r\n"), readFc);

   155 	}

   157 ///////////////////////////////////////////////////////////////////////////////////////

   159 void GetFastCounterFrequency()

   160 	{

   161 	TEST2(HAL::Get(HAL::EFastCounterFrequency, TheCounterFreq), KErrNone);

   162 	TheTest.Printf(_L("Counter frequency=%d Hz\r\n"), TheCounterFreq);

   163 	}

   165 /**

   166 @SYMTestCaseID			PDS-STORE-UT-4053

   167 @SYMTestCaseDesc		Test for DEF141471 - STORE, new stream performance tests.

   168 						PREQ2505 Insturmentation of PDS.

   169 						RDictionaryWriteStream & RDictionaryReadStream performance tests.

   170 @SYMTestPriority		High

   171 @SYMTestActions			Test for DEF141471 - STORE, new stream performance tests.

   172 @SYMTestExpectedResults Test must not fail

   173 @SYMDEF					DEF141471

   174 */

   175 void DictionaryStreamTestL()

   176 	{

   177 	(void)TheFs.Delete(TheTestDictFile);

   178 	CDictionaryFileStore* store = CDictionaryFileStore::OpenLC(TheFs, TheTestDictFile, KDictFileUid);

   180 	//RDictionaryWriteStream::AssignL()

   181 	RDictionaryWriteStream strm1;

   182 	CleanupClosePushL(strm1);

   183 	TUint32 fc = User::FastCounter();

   184 	strm1.AssignL(*store, KDictStrmUid1);

   185 	TUint32 assignFc = CalcTickDiff(fc, User::FastCounter());

   186 	PrintFcDiffAsUs(_L("###  RDictionaryWriteStream::AssignL(), Time=%d us\r\n"), assignFc);

   187 	DoStreamWriteTestL(strm1);

   188 	CleanupStack::PopAndDestroy(&strm1);

   190 	//RDictionaryWriteStream::AssignLC()

   191 	RDictionaryWriteStream strm2;

   192 	fc = User::FastCounter();

   193 	strm2.AssignLC(*store, KDictStrmUid2);

   194 	assignFc = CalcTickDiff(fc, User::FastCounter());

   195 	PrintFcDiffAsUs(_L("###  RDictionaryWriteStream::AssignLC(), Time=%d us\r\n"), assignFc);

   196 	DoStreamWriteTestL(strm2);

   197 	CleanupStack::PopAndDestroy(&strm2);

   199 	//RDictionaryReadStream::OpenL()

   200 	RDictionaryReadStream strm3;

   201 	CleanupClosePushL(strm3);

   202 	fc = User::FastCounter();

   203 	strm3.OpenL(*store, KDictStrmUid1);

   204 	TUint32 openFc = CalcTickDiff(fc, User::FastCounter());

   205 	PrintFcDiffAsUs(_L("###  RDictionaryReadStream::OpenL(), Time=%d us\r\n"), openFc);

   206 	DoStreamReadTestL(strm3);

   207 	CleanupStack::PopAndDestroy(&strm3);

   209 	//RDictionaryReadStream::OpenLC()

   210 	RDictionaryReadStream strm4;

   211 	fc = User::FastCounter();

   212 	strm4.OpenLC(*store, KDictStrmUid2);

   213 	openFc = CalcTickDiff(fc, User::FastCounter());

   214 	PrintFcDiffAsUs(_L("###  RDictionaryReadStream::OpenLC(), Time=%d us\r\n"), openFc);

   215 	DoStreamReadTestL(strm4);

   216 	CleanupStack::PopAndDestroy(&strm4);

   218 	CleanupStack::PopAndDestroy(store);

   219 	}

   221 /**

   222 @SYMTestCaseID			PDS-STORE-UT-4054

   223 @SYMTestCaseDesc		Test for DEF141471 - STORE, new stream performance tests.

   224 						PREQ2505 Insturmentation of PDS.

   225 						RFileWriteStream & RFileReadStream performance tests.

   226 @SYMTestPriority		High

   227 @SYMTestActions			Test for DEF141471 - STORE, new stream performance tests.

   228 @SYMTestExpectedResults Test must not fail

   229 @SYMDEF					DEF141471

   230 */

   231 void FileStreamTestL()

   232 	{

   233 	(void)TheFs.Delete(TheTestFile);

   235 	//RFileWriteStream::Create()

   236 	RFileWriteStream strm1;

   237 	TUint32 fc = User::FastCounter();

   238 	TInt err = strm1.Create(TheFs, TheTestFile, EFileWrite | EFileRead);

   239 	TUint32 createFc = CalcTickDiff(fc, User::FastCounter());

   240 	TEST2(err, KErrNone);

   241 	PrintFcDiffAsUs(_L("###  RFileWriteStream::Create(), Time=%d us\r\n"), createFc);

   242 	strm1.Close();

   244 	//RFileWriteStream::Replace()

   245 	RFileWriteStream strm2;

   246 	fc = User::FastCounter();

   247 	err = strm2.Replace(TheFs, TheTestFile, EFileWrite | EFileRead);

   248 	TUint32 replaceFc = CalcTickDiff(fc, User::FastCounter());

   249 	TEST2(err, KErrNone);

   250 	PrintFcDiffAsUs(_L("###  RFileWriteStream::Replace(), Time=%d us\r\n"), replaceFc);

   251 	strm2.Close();

   253 	//RFileWriteStream::Open()

   254 	RFileWriteStream strm3;

   255 	fc = User::FastCounter();

   256 	err = strm3.Open(TheFs, TheTestFile, EFileWrite | EFileRead);

   257 	TUint32 openFc = CalcTickDiff(fc, User::FastCounter());

   258 	TEST2(err, KErrNone);

   259 	PrintFcDiffAsUs(_L("###  RFileWriteStream::Open(), Time=%d us\r\n"), openFc);

   260 	strm3.Close();

   262 	//RFileWriteStream::Attach()

   263 	RFile file;

   264 	err = file.Open(TheFs, TheTestFile, EFileWrite | EFileRead);

   265 	TEST2(err, KErrNone);

   266 	RFileWriteStream strm4;

   267 	CleanupClosePushL(strm4);

   268 	fc = User::FastCounter();

   269 	strm4.Attach(file);

   270 	TUint32 attachFc = CalcTickDiff(fc, User::FastCounter());

   271 	PrintFcDiffAsUs(_L("###  RFileWriteStream::Attach(), Time=%d us\r\n"), attachFc);

   272 	DoStreamWriteTestL(strm4);

   273 	CleanupStack::PopAndDestroy(&strm4);

   275 	//RFileWriteStream::Temp()

   276 	RFileWriteStream strm5;

   277 	CleanupClosePushL(strm5);

   278 	TFileName fname;

   279 	fc = User::FastCounter();

   280 	err = strm5.Temp(TheFs, TheTestDir, fname, EFileWrite | EFileRead);

   281 	TUint32 tempFc = CalcTickDiff(fc, User::FastCounter());

   282 	TEST2(err, KErrNone);

   283 	PrintFcDiffAsUs(_L("###  RFileWriteStream::Temp(), Time=%d us\r\n"), tempFc);

   284 	DoStreamWriteTestL(strm5);

   285 	CleanupStack::PopAndDestroy(&strm5);

   286 	err = TheFs.Delete(fname);

   287 	TEST2(err, KErrNone);

   289 	//RFileReadStream::Open()

   290 	RFileReadStream strm6;

   291 	fc = User::FastCounter();

   292 	err = strm6.Open(TheFs, TheTestFile, EFileRead);

   293 	openFc = CalcTickDiff(fc, User::FastCounter());

   294 	PrintFcDiffAsUs(_L("###  RFileReadStream::Open(), Time=%d us\r\n"), openFc);

   295 	strm6.Close();

   297 	//RFileReadStream::Attach()

   298 	err = file.Open(TheFs, TheTestFile, EFileRead);

   299 	TEST2(err, KErrNone);

   300 	RFileReadStream strm7;

   301 	fc = User::FastCounter();

   302 	strm7.Attach(file);

   303 	attachFc = CalcTickDiff(fc, User::FastCounter());

   304 	PrintFcDiffAsUs(_L("###  RFileReadStream::Attach(), Time=%d us\r\n"), attachFc);

   305 	strm7.Close();

   307 	//RFileReadStream::RFileReadStream(RFile&)

   308 	err = file.Open(TheFs, TheTestFile, EFileRead);

   309 	TEST2(err, KErrNone);

   310 	fc = User::FastCounter();

   311 	RFileReadStream strm8(file);

   312 	TUint32 constrFc = CalcTickDiff(fc, User::FastCounter());

   313 	CleanupClosePushL(strm8);

   314 	PrintFcDiffAsUs(_L("###  RFileReadStream::RFileReadStream(RFile&), Time=%d us\r\n"), constrFc);

   315 	DoStreamReadTestL(strm8);

   316 	CleanupStack::PopAndDestroy(&strm8);

   317 	}

   319 /**

   320 @SYMTestCaseID			PDS-STORE-UT-4055

   321 @SYMTestCaseDesc		Test for DEF141471 - STORE, new stream performance tests.

   322 						PREQ2505 Insturmentation of PDS.

   323 						RMemWriteStream & RMemReadStream performance tests.

   324 @SYMTestPriority		High

   325 @SYMTestActions			Test for DEF141471 - STORE, new stream performance tests.

   326 @SYMTestExpectedResults Test must not fail

   327 @SYMDEF					DEF141471

   328 */

   329 void MemStreamTestL()

   330 	{

   331 	HBufC8* buf = HBufC8::NewLC(KBufSize);

   332 	TPtr8 bufPtr = buf->Des();

   334 	//RMemWriteStream::Open()

   335 	RMemWriteStream strm1;

   336 	TUint32 fc = User::FastCounter();

   337 	strm1.Open(const_cast <TUint8*> (bufPtr.Ptr()), KBufSize);

   338 	TUint32 openFc = CalcTickDiff(fc, User::FastCounter());

   339 	PrintFcDiffAsUs(_L("###  RMemWriteStream::Open(), Time=%d us\r\n"), openFc);

   340 	strm1.Close();

   342 	//RMemWriteStream::RMemWriteStream(TAny*,...)

   343 	fc = User::FastCounter();

   344 	RMemWriteStream strm2(const_cast <TUint8*> (bufPtr.Ptr()), KBufSize);

   345 	TUint32 constrFc = CalcTickDiff(fc, User::FastCounter());

   346 	PrintFcDiffAsUs(_L("###  RMemWriteStream::RMemWriteStream(TAny*,...), Time=%d us\r\n"), constrFc);

   347 	CleanupClosePushL(strm2);

   348 	DoStreamWriteTestL(strm2);

   349 	CleanupStack::PopAndDestroy(&strm2);

   351 	//RMemReadStream::Open()

   352 	RMemReadStream strm3;

   353 	fc = User::FastCounter();

   354 	strm3.Open(bufPtr.Ptr(), KBufSize);

   355 	openFc = CalcTickDiff(fc, User::FastCounter());

   356 	PrintFcDiffAsUs(_L("###  RMemReadStream::Open(), Time=%d us\r\n"), openFc);

   357 	strm3.Close();

   359 	//RMemReadStream::RMemReadStream(TAny*,...)

   360 	fc = User::FastCounter();

   361 	RMemReadStream strm4(bufPtr.Ptr(), KBufSize);

   362 	constrFc = CalcTickDiff(fc, User::FastCounter());

   363 	PrintFcDiffAsUs(_L("###  RMemReadStream::RMemReadStream(TAny*,...), Time=%d us\r\n"), openFc);

   364 	CleanupClosePushL(strm4);

   365 	DoStreamReadTestL(strm4);

   366 	CleanupStack::PopAndDestroy(&strm4);

   368 	CleanupStack::PopAndDestroy(buf);

   369 	}

   371 /**

   372 @SYMTestCaseID			PDS-STORE-UT-4056

   373 @SYMTestCaseDesc		Test for DEF141471 - STORE, new stream performance tests.

   374 						PREQ2505 Insturmentation of PDS.

   375 						RBufWriteStream & RBufReadStream performance tests.

   376 @SYMTestPriority		High

   377 @SYMTestActions			Test for DEF141471 - STORE, new stream performance tests.

   378 @SYMTestExpectedResults Test must not fail

   379 @SYMDEF					DEF141471

   380 */

   381 void BufStreamTestL()

   382 	{

   383 	CBufFlat* bufFlat = CBufFlat::NewL(KTestDataLen);

   384 	CleanupStack::PushL(bufFlat);

   386 	//RBufWriteStream::Open()

   387 	RBufWriteStream strm1;

   388 	CleanupClosePushL(strm1);

   389 	TUint32 fc = User::FastCounter();

   390 	strm1.Open(*bufFlat);

   391 	TUint32 openFc = CalcTickDiff(fc, User::FastCounter());

   392 	PrintFcDiffAsUs(_L("###  RBufWriteStream::Open(), Time=%d us\r\n"), openFc);

   393 	DoStreamWriteTestL(strm1);

   394 	CleanupStack::PopAndDestroy(&strm1);

   395 	TheTest.Printf(_L("       Buffer size=%d\r\n"), bufFlat->Size());

   397 	//RBufWriteStream::Append()

   398 	RBufWriteStream strm2;

   399 	CleanupClosePushL(strm2);

   400 	fc = User::FastCounter();

   401 	strm2.Append(*bufFlat);

   402 	TUint32 appendFc = CalcTickDiff(fc, User::FastCounter());

   403 	PrintFcDiffAsUs(_L("###  RBufWriteStream::Append(), Time=%d us\r\n"), appendFc);

   404 	DoStreamWriteTestL(strm2);

   405 	CleanupStack::PopAndDestroy(&strm2);

   406 	TheTest.Printf(_L("       Buffer size=%d\r\n"), bufFlat->Size());

   408 	//RBufWriteStream::Insert()

   409 	RBufWriteStream strm3;

   410 	CleanupClosePushL(strm3);

   411 	fc = User::FastCounter();

   412 	strm3.Insert(*bufFlat, KBufSize);

   413 	TUint32 insertFc = CalcTickDiff(fc, User::FastCounter());

   414 	PrintFcDiffAsUs(_L("###  RBufWriteStream::Insert(), Time=%d us\r\n"), insertFc);

   415 	DoStreamWriteTestL(strm3);

   416 	CleanupStack::PopAndDestroy(&strm3);

   417 	TheTest.Printf(_L("       Buffer size=%d\r\n"), bufFlat->Size());

   419 	//RBufWriteStream::Truncate()

   420 	RBufWriteStream strm4;

   421 	CleanupClosePushL(strm4);

   422 	fc = User::FastCounter();

   423 	strm4.Truncate(*bufFlat);

   424 	TUint32 truncateFc = CalcTickDiff(fc, User::FastCounter());

   425 	PrintFcDiffAsUs(_L("###  RBufWriteStream::Truncate(), Time=%d us\r\n"), truncateFc);

   426 	DoStreamWriteTestL(strm4);

   427 	CleanupStack::PopAndDestroy(&strm4);

   428 	TheTest.Printf(_L("       Buffer size=%d\r\n"), bufFlat->Size());

   430 	RBufReadStream strm5;

   431 	CleanupClosePushL(strm5);

   432 	fc = User::FastCounter();

   433 	strm5.Open(*bufFlat);

   434 	openFc = CalcTickDiff(fc, User::FastCounter());

   435 	PrintFcDiffAsUs(_L("###  RBufReadStream::Open(), Time=%d us\r\n"), openFc);

   436 	DoStreamReadTestL(strm5);

   437 	CleanupStack::PopAndDestroy(&strm5);

   439 	CleanupStack::PopAndDestroy(bufFlat);

   440 	}

   442 /**

   443 @SYMTestCaseID			PDS-STORE-UT-4057

   444 @SYMTestCaseDesc		Test for DEF141471 - STORE, new stream performance tests.

   445 						PREQ2505 Insturmentation of PDS.

   446 						RPermanentFileStoreIter performance tests.

   447 @SYMTestPriority		High

   448 @SYMTestActions			Test for DEF141471 - STORE, new stream performance tests.

   449 @SYMTestExpectedResults Test must not fail

   450 @SYMDEF					DEF141471

   451 */

   452 void PermanentFileStoreIterTestL()

   453 	{

   454 	(void)TheFs.Delete(TheTestFile);

   456 	CPermanentFileStore* store = CPermanentFileStore::ReplaceLC(TheFs, TheTestFile, EFileWrite | EFileRead);

   457 	store->SetTypeL(KPermanentFileStoreLayoutUid);

   459 	//Create streams

   460 	const TInt KStreamCnt = 10;

   461 	TStreamId streamId[KStreamCnt] = {0};

   462 	TheTest.Printf(_L("###  CPermanentFileStore, create %d streams\r\n"), KStreamCnt);

   463 	for(TInt i=0;i<KStreamCnt;i++)

   464 		{

   465 		RStoreWriteStream out;

   466 		streamId[i] = out.CreateLC(*store);

   467 		TheTest.Printf(_L("###    Stream##%02d, streamId=%08X\r\n"), i + 1, streamId[i].Value());

   468 		DoStreamWriteTestL(out);

   469 		CleanupStack::PopAndDestroy(&out);

   470 		}

   471 	TUint32 fc = User::FastCounter();

   472 	store->CommitL();

   473 	TUint32 commitFc = CalcTickDiff(fc, User::FastCounter());

   474 	CleanupStack::PopAndDestroy(store);

   475 	PrintFcDiffAsUs(_L("###  RPermanentFileStoreIter::CommitL(), Time=%d us\r\n"), commitFc);

   477 	//RPermanentFileStoreIter::ResetL()

   478 	store = CPermanentFileStore::OpenLC(TheFs, TheTestFile, EFileWrite | EFileRead);

   479 	RPermanentFileStoreIter it1;

   480 	CleanupClosePushL(it1);

   481 	fc = User::FastCounter();

   482 	it1.ResetL(*store);

   483 	TUint32 resetFc = CalcTickDiff(fc, User::FastCounter());

   484 	CleanupStack::PopAndDestroy(&it1);

   485 	CleanupStack::PopAndDestroy(store);

   486 	PrintFcDiffAsUs(_L("###  RPermanentFileStoreIter::ResetL(), Time=%d us\r\n"), resetFc);

   488 	//RPermanentFileStoreIter::ResetLC()

   489 	store = CPermanentFileStore::OpenLC(TheFs, TheTestFile, EFileWrite | EFileRead);

   490 	RPermanentFileStoreIter it2;

   491 	fc = User::FastCounter();

   492 	it2.ResetLC(*store);

   493 	resetFc = CalcTickDiff(fc, User::FastCounter());

   494 	CleanupStack::PopAndDestroy(&it2);

   495 	CleanupStack::PopAndDestroy(store);

   496 	PrintFcDiffAsUs(_L("###  RPermanentFileStoreIter::ResetLC(), Time=%d us\r\n"), resetFc);

   498 	//RPermanentFileStoreIter - construction & destruction

   499 	store = CPermanentFileStore::OpenLC(TheFs, TheTestFile, EFileWrite | EFileRead);

   500 	fc = User::FastCounter();

   501 	RPermanentFileStoreIter it3;

   502 	CleanupClosePushL(it3);

   503 	it3.ResetL(*store);

   504 	CleanupStack::PopAndDestroy(&it3);

   505 	TUint32 fc2 = CalcTickDiff(fc, User::FastCounter());

   506 	CleanupStack::PopAndDestroy(store);

   507 	PrintFcDiffAsUs(_L("###  RPermanentFileStoreIter - construction & destruction, Time=%d us\r\n"), fc2);

   509 	//RPermanentFileStoreIter::NextL()

   510 	store = CPermanentFileStore::OpenLC(TheFs, TheTestFile, EFileWrite | EFileRead);

   511 	RPermanentFileStoreIter it4;

   512 	it4.ResetLC(*store);

   513 	TStreamId id(KNullStreamIdValue);

   514 	TInt cnt = 0;

   515 	fc = User::FastCounter();

   516 	while((id = it4.NextL()) != KNullStreamIdValue)

   517 		{

   518 		++cnt;

   519 		}

   520 	TUint32 nextFc = CalcTickDiff(fc, User::FastCounter());

   521 	CleanupStack::PopAndDestroy(&it4);

   522 	CleanupStack::PopAndDestroy(store);

   523 	TEST2(cnt, KStreamCnt);

   524 	PrintFcDiffAsUs(_L("###  RPermanentFileStoreIter::NextL(), Time=%d us\r\n"), nextFc);

   525 	}

   527 /**

   528 @SYMTestCaseID          SYSLIB-STORE-CT-4007

   529 @SYMTestCaseDesc	    CDirectFileStore::ReplaceLC() and SetTypeL() performance test

   530 @SYMTestPriority 	    High

   531 @SYMTestActions  	    Creates new CDirectFileStore object and measures the time of the operation.

   532 @SYMTestExpectedResults Tests set type time

   533 @SYMCR                  ATHE-7CQP8H

   534 */

   535 void CreateDirectFileStoreTestL()

   536 	{

   537 	(void)TheFs.Delete(TheTestFile);

   539     TUint32 fc = User::FastCounter();

   540 	CFileStore* store = CDirectFileStore::ReplaceLC(TheFs, TheTestFile, EFileWrite | EFileRead);

   541 	// Must say what kind of file store

   542 	// SetTypeL() calls RFileBuf::EndL() which used to call RFile::Size()

   543 	store->SetTypeL(KDirectFileStoreLayoutUid);

   544 	TUint32 time = CalcTickDiff(fc, User::FastCounter());

   545 	CleanupStack::PopAndDestroy(store);

   546 	PrintFcDiffAsUs(_L("###  CDirectFileStore::ReplaceLC() & SetTypeL(), Time=%d us\r\n"), time);

   547 	}

   549 /**

   550 @SYMTestCaseID          SYSLIB-STORE-CT-4008

   551 @SYMTestCaseDesc	    Tests performance when calling CFileStore::Destruct()

   552 @SYMTestPriority 	    High

   553 @SYMTestActions  	    Creates and deletes a File Store

   554 @SYMTestExpectedResults Tests deletion time

   555 @SYMCR                  ATHE-7CQP8H

   556 */

   557 void DirectFileStoreTestL()

   558 	{

   559 	(void)TheFs.Delete(TheTestFile);

   561     TUint32 fc = User::FastCounter();

   562 	CFileStore* store = CDirectFileStore::ReplaceLC(TheFs, TheTestFile, EFileWrite | EFileRead);

   563 	//then delete it. this calls CFileStore::Destruct(), which used to call Revert()

   564 	CleanupStack::PopAndDestroy(store);

   565 	TUint32 time = CalcTickDiff(fc, User::FastCounter());

   566 	PrintFcDiffAsUs(_L("###  CDirectFileStore construction & destruction, Time=%d us\r\n"), time);

   567 	}

   569 void DoTestsL()

   570 	{

   571 	TheTest.Start(_L("Get fast counter frequency"));

   572 	GetFastCounterFrequency();

   574 	TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4053 RDictionaryWriteStream & RDictionaryReadStream - performance test"));

   575 	DictionaryStreamTestL();

   577 	TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4054 RFileWriteStream & RFileReadStream - performance test"));

   578 	FileStreamTestL();

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

   581 	MemStreamTestL();

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

   584 	BufStreamTestL();

   586 	TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4057 RPermanentFileStoreIter - performance test"));

   587 	PermanentFileStoreIterTestL();

   589 	TheTest.Next(_L(" @SYMTestCaseID SYSLIB-STORE-CT-4007 CDirectFileStore::ReplaceLC() & SetTypeL() performance test"));

   590 	CreateDirectFileStoreTestL();

   592 	TheTest.Next(_L(" @SYMTestCaseID SYSLIB-STORE-CT-4008 CDirectFileStore construction & destruction performance test"));

   593 	DirectFileStoreTestL();

   594 	}

   596 //Usage: "t_streamperf [<drive letter>:]]"

   597 TInt E32Main()

   598 	{

   599 	TheTest.Title();

   601 	CTrapCleanup* tc = CTrapCleanup::New();

   602 	TheTest(tc != NULL);

   604 	TBuf<256> cmdline;

   605 	User::CommandLine(cmdline);

   607 	TParse parse;

   609 	_LIT(KTestFile, "c:\\stor-tst\\t_streamperf.dat");

   610 	parse.Set(cmdline, &KTestFile, 0);

   611 	TheTestFile.Copy(parse.FullName());

   613 	_LIT(KTestPath, "c:\\stor-tst\\");

   614 	parse.Set(cmdline, &KTestPath, 0);

   615 	TheTestDir.Copy(parse.FullName());

   617 	_LIT(KDictFile, "c:\\stor-tst\\dicfile.ini");

   618 	parse.Set(cmdline, &KDictFile, 0);

   619 	TheTestDictFile.Copy(parse.FullName());

   621 	__UHEAP_MARK;

   623 	CreateTestEnv();

   624 	TRAPD(err, DoTestsL());

   625 	TEST2(err, KErrNone);

   626 	DestroyTestEnv();

   628 	__UHEAP_MARKEND;

   630 	TheTest.End();

   631 	TheTest.Close();

   633 	delete tc;

   635 	User::Heap().Check();

   636 	return KErrNone;

   637 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--