FCL/sf/os/kernelhwsrv: comparison kerneltest/f32test/server/t

equal deleted inserted replaced

-:a179b74831c9
+:c1f20ce4abcf
 #include <e32svr.h>
 #include <f32dbg.h>
 #include "t_server.h"
 #include <e32twin.h>
 #include <e32cmn.h>
+#include <hal.h>
+#include "tf32testtimer.h"
+#include "f32_test_utils.h"
+using namespace F32_Test_Utils;
 //----------------------------------------------------------------------------------------------
 //! @SYMTestCaseID      PBASE-T_FSCHED-0191
 //! @SYMTestType        CIT
 //! @SYMPREQ            PREQ914
 HBufC8* gBuf = NULL;
 TPtr8 gBufReadPtr(NULL, 0);
 HBufC8* gBufSec = NULL;
 TPtr8 gBufWritePtr(NULL, 0);
-const TInt KuStomS = 1000;
 const TInt KOneK = 1024;
 const TInt KOneMeg = KOneK * 1024;
 const TInt KBigBlockSize = KOneMeg ;
 const TInt KBlockSize = KOneK * 129 ;
 const TInt KWaitRequestsTableSize = 70;
 TTimeIntervalMicroSeconds32 gTimeTakenBigFile(0);
 TTimeIntervalMicroSeconds32 gTimeTakenBigBlock(0);
 TBuf16<45> gSmallFile, gBigFile;
 TInt gNextFile=0;
-TTime gTime1;
-TTime gTime2;
+TF32TestTimer gTestTimer;
 RSemaphore gSync;
 // Concurrent Threads
 RThread gBig;
 	{
 	EThreadWait,
 	EThreadSignal,
 	ENoThreads
 	};
 /** Generates a file name of the form FFFFF*<aPos>.TXT (aLong.3)
 	@param aBuffer The filename will be returned here
 	@param aLong   Defines the longitude of the file name
 	r = aFs.Delete(fileName2);
 	TEST(r == KErrNone);
 	}
 /** Measure the time taken for a big block to be written synchronously
 */
 void TimeTakenToWriteBigBlock()
 {
-	TTime startTime;
-	TTime endTime;
 	RFile fileWrite;
 	TInt r = fileWrite.Replace(TheFs,gBigFile,EFileShareAny|EFileWrite|EFileWriteDirectIO);
 	TESTERROR(r);
 	// Calculate how long it takes to write a big block to be able to issue at the right time the concurrent writes
-	startTime.HomeTime();
+TF32TestTimer timer;
+	timer.Start();
 	r = fileWrite.Write(gBufWritePtr, KBigBlockSize);
-	endTime.HomeTime();
+timer.Stop();
 	fileWrite.Close();
 	TESTERROR(r);
-	gTimeTakenBigBlock = I64LOW(endTime.MicroSecondsFrom(startTime).Int64()/3);
+	gTimeTakenBigBlock = timer.TimeInMicroSeconds()/3;
-	test.Printf(_L("\nTime spent to write the big block in isolation: %d ms\n"), gTimeTakenBigBlock.Int() / KuStomS);
+	test.Printf(_L("\nTime spent to write the big block in isolation: %d ms\n"), TF32TestTimer::TimeInMilliSeconds(gTimeTakenBigBlock));
 }
 /** Measure the time taken for this file to be written synchronously
 */
 void TimeTakenToWriteBigFile(TInt aPos)
 {
-	TTime startTime;
-	TTime endTime;
 	test((aPos >= 0) && (aPos <= 1));
-	startTime.HomeTime();
+TF32TestTimer timer;
+timer.Start();
 	WriteFile(TheFs,gBigFile, gBigFileSize, KBigBlockSize, ENoThreads);
-	endTime.HomeTime();
+	timer.Stop();
-	gTimeTakenBigFile = I64LOW(endTime.MicroSecondsFrom(startTime).Int64());
+	gTimeTakenBigFile = timer.Time32();
+	test.Printf(_L("\nTime spent to write the big file in isolation: %d ms\n"), TF32TestTimer::TimeInMilliSeconds(gTimeTakenBigFile));
-	test.Printf(_L("\nTime spent to write the big file in isolation: %d ms\n"), gTimeTakenBigFile.Int() / KuStomS);
+	gTotalTimeSync[aPos] = Max(TF32TestTimer::TimeInMilliSeconds(gTimeTakenBigFile), gTotalTimeSync[aPos]) ;
-	gTotalTimeSync[aPos] = Max((gTimeTakenBigFile.Int()/KuStomS), gTotalTimeSync[aPos]) ;
 }
 /** Measure the time taken for this file to be written asynchronously
 */
 void TimeTakenToWriteBigFileAsync(TInt aPos)
 {
-	TTime startTime;
-	TTime endTime;
-	TTime endTime2;
 	TRequestStatus status[KWaitRequestsTableSize];
 	RFile bigFile;
 	test((aPos >= 0) && (aPos <= 1));
-	startTime.HomeTime();
+TF32TestTimer2 timer;
+	timer.Start();
 	WriteFileAsync(TheFs, bigFile, gBigFile, gBigFileSize,KBigBlockSize,status);
-	endTime.HomeTime();
+	timer.Stop();
 	WaitForAll(status, gBigFileSize, KBigBlockSize);
+	timer.Stop2();
-	endTime2.HomeTime();
+	gTimeTakenBigFile = timer.Time32();
-	gTimeTakenBigFile=I64LOW(endTime.MicroSecondsFrom(startTime).Int64());
 	bigFile.Close();
-	test.Printf(_L("\nTime to queue the blocks in isolation asynchronously: %d ms, "), gTimeTakenBigFile.Int() / KuStomS);
+	test.Printf(_L("\nTime to queue the blocks in isolation asynchronously: %d ms, "), timer.TimeInMilliSeconds());
-	gTimeTakenBigFile=I64LOW(endTime2.MicroSecondsFrom(startTime).Int64());
+	gTimeTakenBigFile = timer.Time2();
-	test.Printf(_L("to actually write it: %d ms\n"),gTimeTakenBigFile.Int() / KuStomS);
+	test.Printf(_L("to actually write it: %d ms\n"), TF32TestTimer::TimeInMilliSeconds(gTimeTakenBigFile));
-	gTotalTimeAsync[aPos] = Max((gTimeTakenBigFile.Int() / KuStomS), gTotalTimeAsync[aPos]) ;
+	gTotalTimeAsync[aPos] = Max(TF32TestTimer::TimeInMilliSeconds(gTimeTakenBigFile), gTotalTimeAsync[aPos]) ;
 }
 /**  Delete content of directory
 	@param aDir	Target directory
 	r = fs.SetSessionPath(gSessionPath);
 	TESTERROR(r);
 	ReadFile(fs,gSmallFile,KBlockSize, EThreadWait);
-	gTime2.HomeTime();
+	gTestTimer.Start();
 	client.Signal();
 	fs.Close();
 	test.Close();
 	r=fs.SetSessionPath(gSessionPath);
 	TESTERROR(r);
 	ReadFile(fs,gBigFile,KBlockSize, EThreadWait);
-	gTime2.HomeTime();
+	gTestTimer.Stop();
 	client.Signal();
 	fs.Close();
 	test.Close();
 	r=fs.SetSessionPath(gSessionPath);
 	TESTERROR(r);
 	WriteFile(fs,gSmallFile,gSmallFileSize, KBlockSize, EThreadWait);
-	gTime2.HomeTime();
+	gTestTimer.Start();
 	client.Signal();
 	fs.Close();
 	test.Close();
 	r=fs.SetSessionPath(gSessionPath);
 	TESTERROR(r);
 	WriteFile(fs, gBigFile, gBigFileSize, KBigBlockSize, EThreadSignal);
-	gTime1.HomeTime();
+	gTestTimer.Stop();
 	client.Signal();
 	fs.Close();
 	test.Close();
 	r = fs.SetSessionPath(gSessionPath);
 	TESTERROR(r);
 	WriteFile(fs, gSmallFile, gBigFileSize, KBigBlockSize, EThreadWait);
-	gTime2.HomeTime();
+	gTestTimer.Stop();
 	client.Signal();
 	fs.Close();
 	test.Close();
 /**  Reads a small file while writing a big one
 */
 void TestReadingWhileWriting()
 {
-	TInt r = 0;
-	TTime time1;
-	TTime time2;
-	time1.HomeTime();
 	// Write the small file and take the appropriate measures
 	WriteFile(TheFs,gSmallFile,KBlockSize, KBlockSize, ENoThreads);
 	// Sync test
 	TBuf<20> buf=_L("Big Write");
-	r = gBig.Create(buf, WriteBigFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL);
+	TInt r = gBig.Create(buf, WriteBigFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL);
 	TEST(r == KErrNone);
 	buf = _L("Small Read");
 	r = gSmall.Create(buf, ReadSmallFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL);
 	TEST(r == KErrNone);
 	CLIENTWAIT();
 	gBig.Close();
 	gSmall.Close();
+	TTimeIntervalMicroSeconds timeTaken = gTestTimer.Time();
-	TTimeIntervalMicroSeconds timeTaken = gTime1.MicroSecondsFrom(gTime2);
+	test.Printf(_L("\nSync read done %d ms before the write ended\n"), TF32TestTimer::TimeInMilliSeconds(timeTaken));
-	test.Printf(_L("\nSync read done %d ms before the write ended\n"),I64LOW(timeTaken.Int64() / KuStomS));
-	TReal time=I64LOW(timeTaken.Int64() / KuStomS);
 	#if !defined(__WINS__)
-	// If this condition fails, means that writing the sync file while fairscheduling a small sync read takes too long
+		// If this condition fails, it means that writing the sync file while
-		test.Printf(_L("time: %f\n"), time);
+// fairscheduling a small sync read takes too long. Reading small file
-//		test((time > 0) && (((gTotalTimeSync[0]-time)>0) || ((gTotalTimeSync[1]-time)>0)) );
+// should complete first.
-		test(time > 0);
+		test(timeTaken > 0);
 	#endif
 	// Async test
 	TRequestStatus status[KWaitRequestsTableSize];
 	TRequestStatus status2[2];
 	WriteFileAsync(TheFs, bigFile, gBigFile, gBigFileSize,  KBigBlockSize ,status);
 	ReadFileAsync(TheFs, smallFile, gSmallFile, KBlockSize, status2 );
 	WaitForAll(status2,KBlockSize , KBlockSize );
-	time1.HomeTime();
+TF32TestTimer timer;
+	timer.Start();
 	WaitForAll(status,gBigFileSize, KBigBlockSize);
-	time2.HomeTime();
+	timer.Stop();
 	bigFile.Close();
 	smallFile.Close();
-	timeTaken = time2.MicroSecondsFrom(time1);
+	timeTaken = timer.Time();
-	test.Printf(_L("\nAsync read done %d ms before the write ended\n"),I64LOW(timeTaken.Int64() / KuStomS));
+	test.Printf(_L("\nAsync read done %d ms before the write ended\n"), timer.TimeInMilliSeconds());
-	time = I64LOW(timeTaken.Int64() / KuStomS);
 	#if !defined(__WINS__)
-	// If this condition fails, means that writing the async file while fairscheduling a small async read takes too long
+	if (!Is_HVFS(TheFs, gDrive))
-		test.Printf(_L("time: %f\n"), time);
+		{
+		// If this condition fails, it means that writing the async file while fairscheduling a small async read takes too long
 		test.Printf(_L("gTotalTimeAsync[0] = %d , gTotalTimeAsync[1] = %d\n"),gTotalTimeAsync[0],gTotalTimeAsync[1] );
-//		test((time > 0) && (((gTotalTimeAsync[0]-time)>0) || ((gTotalTimeAsync[1]-time)>0)) );
+		test(timeTaken > 0);
-		test(time > 0);
+		}
 	#endif
 }
 /** Writes a small file while writing a big one
 */
 void TestWritingWhileWriting()
 {
 	TInt r = 0;
-	TTime time1;
-	TTime time2;
 	// Sync test
 	TBuf<20> buf = _L("Big Write II");
 	r = gBig.Create(buf, WriteBigFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL);
 	TEST(r == KErrNone);
 	CLIENTWAIT();
 	gBig.Close();
 	gSmall.Close();
-	TTimeIntervalMicroSeconds timeTaken = gTime1.MicroSecondsFrom(gTime2);
+	TTimeIntervalMicroSeconds timeTaken = gTestTimer.Time();
-	test.Printf(_L("\nSync write done %d ms before the big write ended\n"),I64LOW(timeTaken.Int64() / KuStomS));
+	test.Printf(_L("\nSync write done %d ms before the big write ended\n"), gTestTimer.TimeInMilliSeconds());
-	TReal time=I64LOW(timeTaken.Int64() / KuStomS);
 	#if !defined(__WINS__)
-	// If this condition fails, means that writing the sync file while fairscheduling a small sync write takes too long
+		// If this condition fails, it means that writing the sync file while
-		test.Printf(_L("time: %f\n"), time);
+// fairscheduling a small sync write takes too long
-// 		test((time > 0) && (((gTotalTimeSync[0]-time)>0) || ((gTotalTimeSync[1]-time)>0)) );
+		test(timeTaken > 0);
-		test(time > 0);
 	#endif
 	// Async test
 	TRequestStatus status[KWaitRequestsTableSize];
 	TRequestStatus status2[1];
 	RFile bigFile, smallFile;
 	WriteFileAsync(TheFs, bigFile, gBigFile, gBigFileSize, KBigBlockSize, status);
 	WriteFileAsync(TheFs,smallFile, gSmallFile,gSmallFileSize,KBlockSize,status2);
 	WaitForAll(status2,gSmallFileSize, KBlockSize);
-	time1.HomeTime();
+TF32TestTimer timer;
+	timer.Start();
 	WaitForAll(status, gBigFileSize, KBigBlockSize);
-	time2.HomeTime();
+	timer.Stop();
-	timeTaken = time2.MicroSecondsFrom(time1);
+	timeTaken = timer.Time();
-	test.Printf(_L("\nAsync write done %d ms before the big write ended\n"),I64LOW(timeTaken.Int64() / KuStomS));
+	test.Printf(_L("\nAsync write done %d ms before the big write ended\n"),timer.TimeInMilliSeconds());
-	time=I64LOW(timeTaken.Int64() / KuStomS);
 	#if !defined(__WINS__)
-	// If this condition fails, means that writing the async file while fairscheduling a small async write takes too long
+	if (!Is_HVFS(TheFs, gDrive))
-		test.Printf(_L("time: %f\n"), time);
+		{
+		// If this condition fails, it means that writing the async file while fairscheduling a small async write takes too long
 		test.Printf(_L("gTotalTimeAsync[0] = %d , gTotalTimeAsync[1] = %d\n"),gTotalTimeAsync[0],gTotalTimeAsync[1] );
-//		test((time > 0) && (((gTotalTimeAsync[0]-time)>0) || ((gTotalTimeAsync[1]-time)>0)) );
+		test(timeTaken > 0);
-		test(time > 0);
+		}
 	#endif
 	bigFile.Close();
 	smallFile.Close();
 }
 */
 void TestTwoBigOnes()
 {
 	TInt r = 0;
-	TTime time1;
-	TTime time2;
 	// Sync test
 	TBuf<20> buf = _L("Big Write IIII");
 	r = gBig.Create(buf, WriteBigFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL);
 	TEST(r == KErrNone);
 	CLIENTWAIT();
 	gBig.Close();
 	gSmall.Close();
-	TTimeIntervalMicroSeconds timeTaken = gTime2.MicroSecondsFrom(gTime1);
+	TTimeIntervalMicroSeconds timeTaken = gTestTimer.Time();
-	test.Printf(_L("\nSync first write ended %d ms before the second write ended (same file size)\n"),I64LOW(timeTaken.Int64() / KuStomS));
+	test.Printf(_L("\nSync first write ended %d ms before the second write ended (same file size)\n"),TF32TestTimer::TimeInMilliSeconds(timeTaken));
 	// Async test
 	TRequestStatus status[KWaitRequestsTableSize];
 	TRequestStatus status2[KWaitRequestsTableSize];
 	RFile bigFile, bigFile2;
 	WriteFileAsync(TheFs, bigFile, gBigFile, gBigFileSize, KBigBlockSize, status);
 	WriteFileAsync(TheFs, bigFile2, gSmallFile, gBigFileSize, KBigBlockSize, status2);
 	WaitForAll(status, gBigFileSize, KBigBlockSize);
-	time1.HomeTime();
+TF32TestTimer timer;
+	timer.Start();
 	WaitForAll(status2, gBigFileSize, KBigBlockSize);
-	time2.HomeTime();
+	timer.Stop();
-	timeTaken = time2.MicroSecondsFrom(time1);
+	timeTaken = timer.Time();
-	test.Printf(_L("\nAsync first write ended %d ms before the second write ended (same file size)\n"),I64LOW(timeTaken.Int64() / KuStomS));
+	test.Printf(_L("\nAsync first write ended %d ms before the second write ended (same file size)\n"),TF32TestTimer::TimeInMilliSeconds(timeTaken));
 	bigFile.Close();
 	bigFile2.Close();
 }
 /**  Reads the file that is being written
 */
 void TestReadingWhileWritingSameFile()
 {
 	TInt r = 0;
-	TTime time1;
+	TF32TestTimer timer;
-	time1.HomeTime();
+	timer.Start();
 	// Sync test
 	TBuf<20> buf = _L("Big Write IV");
 	r = gBig.Create(buf, WriteBigFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL);
 	TEST(r == KErrNone);
 	CLIENTWAIT();
 	CLOSE_AND_WAIT(gBig);
 	CLOSE_AND_WAIT(gSmall);
-	TTimeIntervalMicroSeconds timeTaken = gTime2.MicroSecondsFrom(gTime1);
+	TTimeIntervalMicroSeconds timeTaken = gTestTimer.Time();
-	test.Printf(_L("\nSync write finished %d ms before the read ended\n"),I64LOW(timeTaken.Int64() / KuStomS));
+	test.Printf(_L("\nSync write finished %d ms before the read ended\n"),TF32TestTimer::TimeInMilliSeconds(timeTaken));
 }
 /** Client dying uncleanly before the operation is finished
 	test.Printf(_L("Disabling Lock Fail simulation ...\n"));
 	// turn OFF lock failure mode (if cache is enabled)
 	TBool simulatelockFailureMode = EFalse;
 	r = controlIo(TheFs, gDrive, KControlIoSimulateLockFailureMode, simulatelockFailureMode);
-	test (r == KErrNone  ||  r == KErrNotSupported);
+	test_Value(r, r == KErrNone  ||  r == KErrNotSupported);
 #endif
 	// FileNames/File generation
 	test.Start(_L("Preparing the environment\n"));
 	test.Next(_L("Ensure write order is preserved\n"));
 	TestWriteOrder();
 	// Format the drive to make sure no blocks are left to be erased in LFFS
-	#if !defined(__WINS__)
+	if (!Is_Win32(TheFs, gDrive))
 		Format(gDrive);
-	#endif
 	r = TheFs.MkDirAll(gSessionPath);
 	TimeTakenToWriteBigFile(1);
 	TimeTakenToWriteBigFileAsync(1);
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 	// turn lock failure mode back ON (if cache is enabled)
 	simulatelockFailureMode = ETrue;
 	r = controlIo(TheFs, gDrive, KControlIoSimulateLockFailureMode, simulatelockFailureMode);
-test (r == KErrNone  ||  r == KErrNotSupported);
+test_Value(r, r == KErrNone  ||  r == KErrNotSupported);
 #endif
 	test.End();
 	}
 {
 	TVolumeInfo volInfo;
 	TInt r = TheFs.Volume(volInfo, gDrive);
 	TESTERROR(r);
-	gMediaSize = volInfo.iSize;
+	gMediaSize = volInfo.iFree;
 	gSmallFileSize = KBlockSize;
 	gBigFileSize = KBlockSize*20;
 	while(((2*gBigFileSize)+KOneMeg) > gMediaSize )
 		{
 	else if (r == KErrCorrupt)
 		{
 		test.Printf(_L("%c: Media corruption; previous test may have aborted; else, check hardware\n"), (TUint)gDrive + 'A');
 		}
 	TESTERROR(r);
-#if !defined(__WINS__)
-	if ((volInfo.iDrive.iMediaAtt & KMediaAttFormattable))
+	if (!Is_Win32(TheFs, gDrive) && (volInfo.iDrive.iMediaAtt & KMediaAttFormattable))
 		Format(gDrive);
-#endif
 	if(CheckForDiskSize())
 		{
 		DoTests();
 		}

branch	RCL_3
changeset 256	c1f20ce4abcf
parent 0	a41df078684a
child 257	3e88ff8f41d5