Symaptic: os/kernelhwsrv/kerneltest/f32test/bench/t

     1 // Copyright (c) 2006-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 the License "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 // f32test\bench\t_fsropen.cpp

    15 //

    16 //

    18 #include <f32file.h>

    19 #include <e32test.h>

    20 #include "t_select.h"

    21 #include "..\server\t_server.h"

    22 #include "t_benchmain.h"

    24 GLDEF_D RTest test(_L("File Server Benchmarks, Open File"));

    26 //----------------------------------------------------------------------------------------------

    27 //! @SYMTestCaseID      PBASE-T_FSROPEN-0275

    28 //! @SYMTestType        CIT

    29 //! @SYMPREQ            PREQ000

    30 //! @SYMTestCaseDesc    This test case is measuring performance of the FAT implementation

    31 //! @SYMTestActions     0.  Expects the files to exist in order to successful execution

    32 //!						1.	Time the opening and read of 4 Kb of last.txt file in each directory

    33 //!						2.	Time the opening and read of 4 Kb of last.txt file in each directory

    34 //!							with two  clients accessing the directory

    35 //!						3.	Time the opening and read of 4 Kb of last.txt file in each directory

    36 //!							with two clients accessing different directories

    37 //!

    38 //! @SYMTestExpectedResults Finishes if the system behaves as expected, panics otherwise

    39 //! @SYMTestPriority        High

    40 //! @SYMTestStatus          Implemented

    41 //----------------------------------------------------------------------------------------------

    44 LOCAL_D RSemaphore client;

    45 LOCAL_D const TInt KHeapSize=0x6000;

    46 LOCAL_D TBuf8<4096> buf;

    48 LOCAL_D TDriveList gDriveList;

    49 LOCAL_D TFileName gFindEntryDir;

    50 LOCAL_D TBuf<100> gFindDir;

    52 LOCAL_D TFileName gFindEntryDir2;

    53 LOCAL_D TBuf<100> gFindDir2;

    55 // Concurrent thread

    56 RThread gSpeedy;

    57 RThread gSpeedyII;

    59 LOCAL_D TInt ThreadCount=0;

    61 _LIT(KDirMultipleName2, "dir%d_%d\\");

    63 /** Find entry in directory

    65 */

    66 LOCAL_C TInt FindEntryAccess2(TAny*)

    67 	{

    68 	RFs fs;

    69 	TInt r = fs.Connect();

    70 	RTest test(_L("test 2"));

    72 	r = fs.SetSessionPath(gSessionPath);

    74 	client.Signal();

    76 	FOREVER

    77 		{

    78 		TEntry entry;

    80 		r = fs.Entry(gFindEntryDir2, entry);

    81 		FailIfError(r);

    82 		test.Printf(_L("1"));

    83 		r=fs.Entry(gFindDir2, entry);

    84 		FailIfError(r);

    85 		}

    86 	}

    88 /** Starts two concurrent client sessions in the same directory

    90 */

    91 LOCAL_C void DoTest(TThreadFunction aFunction)

    92 	{

    93 	TBuf<50> buf = _L("Speedy");

    94 	buf.AppendNum(ThreadCount++);

    95 	TInt r = gSpeedy.Create(buf, aFunction, KDefaultStackSize, KHeapSize, KHeapSize, NULL);

    96 	FailIfError(r);

    98 	buf = _L("Speedy");

    99 	buf.AppendNum(ThreadCount++);

   100 	r = gSpeedyII.Create(buf, aFunction, KDefaultStackSize, KHeapSize, KHeapSize, NULL);

   101 	FailIfError(r);

   103 	gSpeedy.SetPriority(EPriorityLess);

   104     gSpeedyII.SetPriority(EPriorityLess);

   106 	gSpeedy.Resume();

   107 	gSpeedyII.Resume();

   109 	client.Wait();

   110 	client.Wait();

   111 	}

   113 /** Starts two concurrent client sessions in different directories

   115 */

   116 LOCAL_C void DoTest2(TThreadFunction aFunction)

   117 	{

   118 	TBuf<50> buf=_L("Speedy");

   119 	buf.AppendNum(ThreadCount++);

   120 	TInt r = gSpeedy.Create(buf, aFunction, KDefaultStackSize, KHeapSize, KHeapSize, NULL);

   121 	FailIfError(r);

   123 	buf = _L("Speedy");

   124 	buf.AppendNum(ThreadCount++);

   125 	r = gSpeedyII.Create(buf, FindEntryAccess2, KDefaultStackSize, KHeapSize, KHeapSize, NULL);

   126 	FailIfError(r);

   128  	gSpeedy.SetPriority(EPriorityLess);

   129     gSpeedyII.SetPriority(EPriorityLess);

   131 	gSpeedy.Resume();

   132 	gSpeedyII.Resume();

   134 	client.Wait();

   135 	client.Wait();

   136 	}

   138 /** Kills the concurrent session

   140 */

   141 LOCAL_C void DoTestKill()

   142 	{

   143 	gSpeedy.Kill(KErrNone);

   144 	gSpeedy.Close();

   146 	gSpeedyII.Kill(KErrNone);

   147 	gSpeedyII.Close();

   148 	}

   150 /** Find entry in directory

   152 */

   153 LOCAL_C TInt FindEntryAccess(TAny*)

   154 	{

   155 	RFs fs;

   156 	TInt r = fs.Connect();

   157 	RTest test(_L("test 2"));

   159 	fs.SetSessionPath(gSessionPath);

   161 	client.Signal();

   163 	FOREVER

   164 		{

   165 		TEntry entry;

   167 		r = fs.Entry(gFindEntryDir, entry);

   168 		FailIfError(r);

   170 		r = fs.Entry(gFindDir,entry);

   171 		FailIfError(r);

   172 		}

   173 	}

   175 /** Find last.txt by opening it and with two threads accessing the current directory

   176 	and looking for the same file

   178 	@param aN 		Number of files in the directory

   179 	@param aStep 	Test step

   180 */

   181 LOCAL_C void FindFileM2(TInt aN, TInt aStep)

   182 	{

   183 	TBuf16<100> dir1;

   184 	TBuf16<100> dir2;

   185 	TBuf16<100> dir3;

   186 	TBuf16<100> dirtemp;

   188 	TInt r = 0;

   190 	TTime startTime;

   191 	TTime endTime;

   192 	TTimeIntervalMicroSeconds timeTaken(0);

   193 	RFile file;

   194 	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;

   196 	if(aN <= gFilesLimit)

   197 		{

   198 		dir1 = gSessionPath;

   199 		dir2 = gSessionPath;

   200 		dir3 = gSessionPath;

   202 		dirtemp.Format(KDirMultipleName2, 1, aN);

   203 		dir1.Append(dirtemp);

   204 		gFindDir = dir1;

   206 		dirtemp.Format(KDirMultipleName2, 2, aN);

   207 		dir2.Append(dirtemp);

   209 		dirtemp.Format(KDirMultipleName2, 3, aN);

   210 		dir3.Append(dirtemp);

   212 		dir1.Append(KCommonFile);

   214 		if(gTypes >= 1)

   215 			{

   216 			gFindEntryDir = dir1;

   217 			DoTest(FindEntryAccess);

   219 			User::After(200);

   220 			startTime.HomeTime();

   222 			r = file.Open(TheFs, dir1, EFileShareAny|EFileWrite);

   223 			FailIfError(r);

   225 			endTime.HomeTime();

   227 			DoTestKill();

   228 			file.Close();

   230 			timeTaken = endTime.MicroSecondsFrom(startTime);

   231 			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit);

   232 			}

   234 		if(gTypes >= 2)

   235 			{

   236 			gFindDir = dir2;

   237 			dir2.Append(KCommonFile);

   238 			gFindEntryDir = dir2;

   240 			DoTest(FindEntryAccess);

   241 			User::After(200);

   242 			startTime.HomeTime();

   244 			r = file.Open(TheFs, dir2, EFileShareAny|EFileWrite);

   245 			FailIfError(r);

   247 			endTime.HomeTime();

   249 			DoTestKill();

   250 			file.Close();

   252 			timeTaken = endTime.MicroSecondsFrom(startTime);

   253 			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit);

   254 			}

   256 		if(gTypes >= 3)

   257 			{

   258 			gFindDir = dir3;

   259 			dir3.Append(KCommonFile);

   261 			gFindEntryDir = dir3;

   262 			DoTest(FindEntryAccess);

   264 			User::After(200);

   265 			startTime.HomeTime();

   267 			r=file.Open(TheFs, dir3, EFileShareAny|EFileWrite);

   268 			FailIfError(r);

   270 			endTime.HomeTime();

   271 			DoTestKill();

   272 			file.Close();

   274 			timeTaken = endTime.MicroSecondsFrom(startTime);

   275 			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit);

   277 			}

   278 		}

   280 	PrintResult(aStep, 1, aN);

   281 	PrintResultTime(aStep, 2, timeTaken1);

   282 	PrintResultTime(aStep, 3, timeTaken2);

   283 	PrintResultTime(aStep, 4, timeTaken3);

   284 	}

   286 /** Find last.txt by opening it and without any other process

   288 	@param aN 		Number of files in the directory

   289 	@param aStep 	Test step

   290 */

   291 LOCAL_C void OpenFile(TInt aN, TInt aStep)

   292 	{

   293 	TBuf16<100> dir1;

   294 	TBuf16<100> dir2;

   295 	TBuf16<100> dir3;

   296 	TBuf16<100> dirtemp;

   298 	TInt r = 0;

   299 	TInt pos = 0;

   300 	TTime startTime;

   301 	TTime endTime;

   302 	TTimeIntervalMicroSeconds timeTaken(0);

   303 	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;

   304 	RFile file;

   306 	if(aN <= gFilesLimit)

   307 		{

   308 		dir1 = gSessionPath;

   309 		dir2 = gSessionPath;

   310 		dir3 = gSessionPath;

   312 		dirtemp.Format(KDirMultipleName, 1, aN);

   313 		dir1.Append(dirtemp);

   315 		dirtemp.Format(KDirMultipleName, 2, aN);

   316 		dir2.Append(dirtemp);

   318 		dirtemp.Format(KDirMultipleName, 3, aN);

   319 		dir3.Append(dirtemp);

   321 		dir1.Append(KCommonFile);

   322 		dir2.Append(KCommonFile);

   323 		dir3.Append(KCommonFile);

   325 		if(gTypes >= 1)

   326 			{

   327 			startTime.HomeTime();

   329 			r = file.Open(TheFs, dir1, EFileShareAny|EFileRead);

   330 			FailIfError(r);

   331 			r = file.Seek(ESeekStart, pos);

   332 			FailIfError(r);

   333 			r = file.Read(buf);

   334 			FailIfError(r);

   336 			endTime.HomeTime();

   337 			file.Close();

   339 			timeTaken = endTime.MicroSecondsFrom(startTime);

   340 			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit);

   342 			}

   344 		if(gTypes >= 2)

   345 			{

   346 			startTime.HomeTime();

   348 			r = file.Open(TheFs, dir2, EFileShareAny|EFileRead);

   349 			FailIfError(r);

   350 			r = file.Seek(ESeekStart,pos);

   351 			FailIfError(r);

   352 			r = file.Read(buf);

   353 			FailIfError(r);

   355 			endTime.HomeTime();

   357 			file.Close();

   359 			timeTaken = endTime.MicroSecondsFrom(startTime);

   360 			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit);

   361 			}

   363 		if(gTypes >= 3)

   364 			{

   365 			startTime.HomeTime();

   367 			r = file.Open(TheFs, dir3, EFileShareAny|EFileRead);

   368 			FailIfError(r);

   369 			r = file.Seek(ESeekStart, pos);

   370 			FailIfError(r);

   371 			r = file.Read(buf);

   372 			FailIfError(r);

   374 			endTime.HomeTime();

   375 			file.Close();

   377 			timeTaken=endTime.MicroSecondsFrom(startTime);

   378 			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit);

   379 			}

   380 		}

   382 	PrintResult(aStep, 1, aN);

   383 	PrintResultTime(aStep, 2, timeTaken1);

   384 	PrintResultTime(aStep, 3, timeTaken2);

   385 	PrintResultTime(aStep, 4, timeTaken3);

   387 	}

   389 /** Find last.txt with TFindFile and with two threads accessing the current directory and other one

   391 	@param aN 		Number of files in the directory

   392 	@param aStep 	Test step

   393 */

   394 LOCAL_C void FindFileMD1(TInt aN, TInt aStep)

   395 	{

   396 	TBuf16<100> dir1;

   397 	TBuf16<100> dir2;

   398 	TBuf16<100> dir3;

   399     TBuf16<100> dir4;

   400     TBuf16<100> dirtemp;

   402 	TInt r = 0;

   403 	TFindFile find(TheFs);

   404 	TTime startTime;

   405 	TTime endTime;

   406 	TTimeIntervalMicroSeconds timeTaken(0);

   407 	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;

   409 	if(aN <= gFilesLimit)

   410 		{

   411 		dir1 = gSessionPath;

   412 		dir2 = gSessionPath;

   413 		dir3 = gSessionPath;

   415 		dirtemp.Format(KDirMultipleName2,1,aN);

   416 		dir1.Append(dirtemp);

   418 		gFindDir = dir1;

   419 		dirtemp.Format(KDirMultipleName, 2, aN);

   420 		dir2.Append(dirtemp);

   422 		dirtemp.Format(KDirMultipleName, 3, aN);

   423 		dir3.Append(dirtemp);

   425 		dir4=gSessionPath;

   426 		dirtemp.Format(KDirMultipleName, 3, 300);

   428 		dir4.Append(dirtemp);

   429 		gFindDir2 = dir4;

   431 		dir1.Append(KCommonFile);

   432 		dir2.Append(KCommonFile);

   433 		dir3.Append(KCommonFile);

   434 		dir4.Append(KCommonFile);

   435 		gFindEntryDir2 = dir4;

   437 		if(gTypes >= 1)

   438 			{

   440 			gFindEntryDir = dir1;

   442 			dir4.Format(KDirMultipleName, 1, aN);

   444 			DoTest2(FindEntryAccess);

   445 			startTime.HomeTime();

   447 			r = find.FindByPath(dir1, &dir4);

   448 			FailIfError(r);

   450 			endTime.HomeTime();

   451 			DoTestKill();

   453 			timeTaken = endTime.MicroSecondsFrom(startTime);

   454 			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit);

   455 			}

   457 		if(gTypes >= 2)

   458 			{

   459 			dir4.Format(KDirMultipleName, 2, aN);

   461 			gFindEntryDir=dir2;

   463 			DoTest2(FindEntryAccess);

   465 			startTime.HomeTime();

   467 			r = find.FindByPath(dir2,&dir4);

   468 			FailIfError(r);

   470 			endTime.HomeTime();

   471 			timeTaken = endTime.MicroSecondsFrom(startTime);

   473 			DoTestKill();

   475 			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit);

   476 			}

   478 		if(gTypes >= 3)

   479 			{

   480 			dir4.Format(KDirMultipleName, 3, aN);

   481 			gFindEntryDir = dir3;

   483 			DoTest2(FindEntryAccess);

   485 			startTime.HomeTime();

   487 			r = find.FindByPath(dir3,&dir4);

   488 			FailIfError(r);

   490 			endTime.HomeTime();

   491 			DoTestKill();

   493 			timeTaken = endTime.MicroSecondsFrom(startTime);

   494 			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit);

   495 			}

   496 		}

   498 	PrintResult(aStep, 1, aN);

   499 	PrintResultTime(aStep, 2, timeTaken1);

   500 	PrintResultTime(aStep, 3, timeTaken2);

   501 	PrintResultTime(aStep, 4, timeTaken3);

   502 	}

   505 /** Find last.txt by opening the file and with two threads accessing the current directory and other one

   507 	@param aN 		Number of files in the directory

   508 	@param aStep 	Test step

   509 */

   510 LOCAL_C void FindFileMD2(TInt aN, TInt aStep)

   511 	{

   512 	TBuf16<100> dir1;

   513 	TBuf16<100> dir2;

   514 	TBuf16<100> dir3;

   515 	TBuf16<100> dir4;

   516 	TBuf16<100> dirtemp;

   518 	TInt r = 0;

   520 	TTime startTime;

   521 	TTime endTime;

   522 	TTimeIntervalMicroSeconds timeTaken(0);

   523 	TInt timeTaken1 = -1, timeTaken2 = -1, timeTaken3 = -1;

   525 	RFile file;

   527 	if(aN <= gFilesLimit)

   528 		{

   529 		dir1 = gSessionPath;

   530 		dir2 = gSessionPath;

   531 		dir3 = gSessionPath;

   532 		dir4 = gSessionPath;

   534 		dirtemp.Format(KDirMultipleName2, 1, aN);

   535 		dir1.Append(dirtemp);

   536 		gFindDir = dir1;

   538 		dirtemp.Format(KDirMultipleName2, 2, aN);

   539 		dir2.Append(dirtemp);

   541 		dirtemp.Format(KDirMultipleName2, 3, aN);

   542 		dir3.Append(dirtemp);

   544 		dir1.Append(KCommonFile);

   545 		gFindEntryDir = dir1;

   547 		dirtemp.Format(KDirMultipleName, 3, 300);

   548 		dir4.Append(dirtemp);

   549 		gFindDir2 = dir4;

   550 		dir4.Append(KCommonFile);

   551 		gFindEntryDir2 = dir4;

   553 		if(gTypes >= 1)

   554 			{

   555 			DoTest2(FindEntryAccess);

   556 			User::After(200);

   558 			startTime.HomeTime();

   560 			r = file.Open(TheFs,dir1,EFileShareAny|EFileWrite);

   561 			FailIfError(r);

   563 			endTime.HomeTime();

   565 			DoTestKill();

   566 			file.Close();

   568 			timeTaken = endTime.MicroSecondsFrom(startTime);

   569 			timeTaken1 = I64LOW(timeTaken.Int64() / gTimeUnit);

   570 			}

   572 		if(gTypes >= 2)

   573 			{

   574 			gFindDir = dir2;

   575 			dir2.Append(KCommonFile);

   576 			gFindEntryDir = dir2;

   578 	 		DoTest2(FindEntryAccess);

   579 			User::After(200);

   581 			startTime.HomeTime();

   583 			r = file.Open(TheFs, dir2, EFileShareAny|EFileWrite);

   584 			FailIfError(r);

   586 			endTime.HomeTime();

   588 			DoTestKill();

   589 			file.Close();

   591 			timeTaken = endTime.MicroSecondsFrom(startTime);

   592 			timeTaken2 = I64LOW(timeTaken.Int64() / gTimeUnit);

   593 			}

   595 		if(gTypes >= 3)

   596 			{

   597 			gFindDir = dir3;

   598 			dir3.Append(KCommonFile);

   599 			gFindEntryDir = dir3;

   600 			DoTest2(FindEntryAccess);

   602 			User::After(200);

   603 			startTime.HomeTime();

   605 			r = file.Open(TheFs, dir3, EFileShareAny|EFileWrite);

   606 			FailIfError(r);

   608 			endTime.HomeTime();

   609 			DoTestKill();

   610 			file.Close();

   612 			timeTaken = endTime.MicroSecondsFrom(startTime);

   613 			timeTaken3 = I64LOW(timeTaken.Int64() / gTimeUnit);

   614 			}

   615 		}

   617 	PrintResult(aStep, 1, aN);

   618 	PrintResultTime(aStep, 2, timeTaken1);

   619 	PrintResultTime(aStep, 3, timeTaken2);

   620 	PrintResultTime(aStep, 4, timeTaken3);

   621 	}

   623 /** Times the system when opening a file with multiple clients accessing the directory

   624 	Precondition: This test expects the drive already filled with files

   626 	@param aSelector Configuration in case of manual execution

   627 */

   628 LOCAL_C TInt TestOpenEntry(TAny* aSelector)

   629 	{

   630 	TInt i = 100, r = 0;

   631 	TInt testStep = 1;

   632 	TTime startTime;

   633 	TTime endTime;

   634 	TTimeIntervalSeconds timeTaken;

   636 	Validate(aSelector);

   638 	test.Printf(_L("#~TS_Title_%d,%d: Open and read 4 Kb entry last.txt, RFile::Open \n"), gTestHarness, gTestCase);

   639 	startTime.HomeTime();

   641 	while(i <= KMaxFiles)

   642 		{

   643 		if(i == 100 || i == 1000 || i == 5000 || i == 10000)

   644 			OpenFile(i, testStep++);

   645 		i += 100;

   646 		}

   648 	gTestCase++;

   650 	endTime.HomeTime();

   651 	r = endTime.SecondsFrom(startTime, timeTaken);

   652 	FailIfError(r);

   653 	test.Printf(_L("#~TS_Timing_%d,%d=%d\n"), gTestHarness, gTestCase, timeTaken.Int());

   655 	return(KErrNone);

   656 	}

   658 /** Times the system when opening a file with multiple clients accessing the directory

   659 	Precondition: This test expects the drive already filled with files

   661 	@param aSelector Configuration in case of manual execution

   662 */

   663 LOCAL_C TInt TestOpenEntryMultipleClients(TAny* aSelector)

   664 	{

   665 	TInt i = 100, r = 0;

   666 	TInt testStep;

   667 	TTime startTime;

   668 	TTime endTime;

   669 	TTimeIntervalSeconds timeTaken;

   671 	Validate(aSelector);

   673 	test.Printf(_L("#~TS_Title_%d,%d: Find entry mult clients accessing same directory, RFile::Open \n"), gTestHarness, gTestCase);

   674 	startTime.HomeTime();

   676 	i = 100;

   677 	testStep = 1;

   678 	while(i <= KMaxFiles)

   679 		{

   680 		if(i == 100 || i == 1000 || i == 5000 || i == 10000)

   681 			FindFileM2(i, testStep++);

   682 		i += 100;

   683 		}

   685 	gTestCase++;

   687 	endTime.HomeTime();

   688 	r = endTime.SecondsFrom(startTime, timeTaken);

   689 	FailIfError(r);

   690 	test.Printf(_L("#~TS_Timing_%d,%d=%d\n"), gTestHarness, gTestCase, timeTaken.Int());

   692 	return(KErrNone);

   693 	}

   695 /** Times the system when opening a file with multiple clients accessing dif directory

   696 	Precondition: This test expects the drive already filled with files

   698 	@param aSelector Configuration in case of manual execution

   699 */

   700 LOCAL_C TInt TestOpenEntryMultipleClientsDD(TAny* aSelector)

   701 	{

   702 	TInt i = 100, r = 0;

   703 	TInt testStep;

   704 	TTime startTime;

   705 	TTime endTime;

   706 	TTimeIntervalSeconds timeTaken;

   708 	Validate(aSelector);

   710 	test.Printf(_L("#~TS_Title_%d,%d: Find entry mult clients accessing dif directory, TFindFile\n"), gTestHarness, gTestCase);

   711 	startTime.HomeTime();

   713 	testStep = 1;

   714 	while(i <= KMaxFiles)

   715 		{

   716 		if(i == 100 || i == 1000 || i == 5000 || i == 10000)

   717 			FindFileMD1(i, testStep++);

   718 		i += 100;

   719 		}

   721 	gTestCase++;

   723 	endTime.HomeTime();

   724 	r = endTime.SecondsFrom(startTime, timeTaken);

   725 	FailIfError(r);

   726 	test.Printf(_L("#~TS_Timing_%d,%d=%d\n"), gTestHarness, gTestCase, timeTaken.Int());

   729 	test.Printf(_L("#~TS_Title_%d,%d: Find entry mult clients accessing dif directory, RFile::Open \n"), gTestHarness, gTestCase);

   730 	startTime.HomeTime();

   732 	i = 100;

   733 	testStep = 1;

   734 	while(i <= KMaxFiles)

   735 		{

   736 		if(i == 100 || i == 1000 || i == 5000 || i == 10000)

   737 			FindFileMD2(i, testStep++);

   738 		i += 100;

   739 		}

   741 	gTestCase++;

   743 	endTime.HomeTime();

   744 	r = endTime.SecondsFrom(startTime, timeTaken);

   745 	FailIfError(r);

   746 	test.Printf(_L("#~TS_Timing_%d,%d=%d\n"), gTestHarness, gTestCase, timeTaken.Int());

   748 	return(KErrNone);

   749 	}

   751 /** It goes automatically through all the options

   753 	@param aSelector Configuration in case of manual execution

   754 */

   755 LOCAL_C TInt TestAll(TAny* aSelector)

   756 	{

   757 	Validate(aSelector);

   759 	TestOpenEntry(aSelector);

   760 	TestOpenEntryMultipleClients(aSelector);

   761 	TestOpenEntryMultipleClientsDD(aSelector);

   763 	return(KErrNone);

   764 	}

   766 /** Call all tests

   768 */

   769 GLDEF_C void CallTestsL()

   770 	{

   771 	TInt r = client.CreateLocal(0);

   772 	FailIfError(r);

   774 	CSelectionBox* TheSelector = CSelectionBox::NewL(test.Console());

   776 	gFileSize = 8;

   778 	// Each test case of the suite has an identifyer for parsing purposes of the results

   779 	gTestHarness = 4;

   780 	gTestCase = 1;

   782 	CreateDirWithNFiles(300, 3);

   783 	PrintHeaders(1, _L("t_fsropen. File Open"));

   785 	if(gMode == 0)

   786 		{ // Manual

   787 		gSessionPath=_L("?:\\");

   788 		TCallBack createFiles(TestFileCreate, TheSelector);

   789 		TCallBack openFile(TestOpenEntry, TheSelector);

   790 		TCallBack openFileMC(TestOpenEntryMultipleClients, TheSelector);

   791 		TCallBack openFileMCDD(TestOpenEntryMultipleClientsDD, TheSelector);

   792 		TCallBack allOpen(TestAll,TheSelector);

   793 		TheSelector->AddDriveSelectorL(TheFs);

   794 		TheSelector->AddLineL(_L("Create all files"), createFiles);

   795 		TheSelector->AddLineL(_L("Open random file"), openFile);

   796 		TheSelector->AddLineL(_L("With mult clients same directory"), openFileMC);

   797 		TheSelector->AddLineL(_L("With mult clients dif large directories"), openFileMCDD);

   798 		TheSelector->AddLineL(_L("All options"), allOpen);

   799 		TheSelector->Run();

   800 		}

   801 	else

   802 		{ // Automatic

   803 		TestAll(TheSelector);

   804 		}

   806 	client.Close();

   807 	test.Printf(_L("#~TestEnd_%d\n"), gTestHarness);

   808 	delete TheSelector;

   809 	}

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