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

equal deleted inserted replaced

-:ef2a444a7410
+:b3a1d9898418
 // Contributors:
 //
 // Description:
 //
+#define __E32TEST_EXTENSION__
 #include <f32file.h>
 #include <e32test.h>
 #include <e32svr.h>
 #include <e32math.h>
 nRes = FormatFatDrive(TheFs, gTestDrive, ETrue);
 #endif
-test(nRes == KErrNone);
+test_KErrNone(nRes);
 }
 void SynchronousClose(RFs &aSession)
 	{
 	TRequestStatus s;
 //
 	{
 	test.Start(_L("Fill disk to capacity"));
 	TInt r=TheFs.MkDirAll(KBasePath);
-	test(r==KErrNone || r==KErrAlreadyExists);
+	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 	gCount=0;
 	TFileName sessionPath;
 	r=TheFs.SessionPath(sessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	TBuf<128> fileName=KBaseName();
 	TInt64 freespace=0;
 	TInt64 freespaceBeforeScanDrive = 0;
 	TInt64 freespaceAfterScanDrive = 0;
 				if(fillfilesize <= 2)
 					break;
 				else
 					fillfilesize=fillfilesize/2;
 				}
-			test(r==KErrNone || r==KErrDiskFull);
+			test_Value(r, r == KErrNone || r==KErrDiskFull);
 			if(r==KErrNone)
 				gCount++;
 			}
 		r=TheFs.CheckDisk(fileName);
 //
 	{
 	TVolumeInfo v;
 	TInt r=TheFs.Volume(v,gTestDrive);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	aFree=v.iFree;
 	}
 static void Test1()
 	TInt64 free2;
 	TInt64 free1;
 	TInt64 diff;
 	r=TheFs.GetReserveAccess(gTestDrive);
-	test(r==KErrPermissionDenied);
+	test_Value(r, r == KErrPermissionDenied);
 	//make sure nothing odd happens if we didnt already have access
 	r=TheFs.ReleaseReserveAccess(gTestDrive);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	GetFreeDiskSpace(free2);
 	r=TheFs.ReserveDriveSpace(gTestDrive,0x1000);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	GetFreeDiskSpace(free1);
 	diff = free2 - free1;
 	test(I64INT(diff) > 0xfe0 && I64INT(diff) < 0x1100);
 	r=TheFs.GetReserveAccess(gTestDrive);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	GetFreeDiskSpace(free1);
 	TInt64 temp = free2-free1;
 	test(I64INT(temp)>(-0x90) && I64INT(temp)<0x90);
 	r=TheFs.ReleaseReserveAccess(gTestDrive);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	GetFreeDiskSpace(free1);
 	diff = free2 - free1;
 	test(I64INT(diff) > 0xfe0 && I64INT(diff) < 0x1100);
 	//test reallocation of reserved space is possible
 	r=TheFs.ReserveDriveSpace(gTestDrive,0x2000);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	//test upper limit of reserved space
 	r=TheFs.ReserveDriveSpace(gTestDrive,0x2000000);
-	test(r==KErrArgument);
+	test_Value(r, r == KErrArgument);
 	r=TheFs.ReserveDriveSpace(gTestDrive,0);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.GetReserveAccess(gTestDrive);
-	test(r==KErrPermissionDenied);
+	test_Value(r, r == KErrPermissionDenied);
 	//make sure nothing odd happens if we didnt already have access
 	r=TheFs.ReleaseReserveAccess(gTestDrive);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.ReserveDriveSpace(gTestDrive,-45);
-	test(r==KErrArgument);
+	test_Value(r, r == KErrArgument);
 	}
 static void Test2()
 //
 	//Connect Sessions
 	for(i=0; i<17; i++)
 		{
 		r = sessions[i].Connect();
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	test.Next(_L("Test breaching sesson reserve limit"));
 	r=sessions[0].ReserveDriveSpace(gTestDrive,0x10001);
-	test(r==KErrArgument);
+	test_Value(r, r == KErrArgument);
 	//Get Volume Free Space
 	r = sessions[0].Volume(v, gTestDrive);
 	if(v.iFree > 0x100000)
 		test.Next(_L("Test breaching drive reserve limit"));
 		for (i=0; i<16; i++)
 			{
 			r=sessions[i].ReserveDriveSpace(gTestDrive,0x10000);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			}
 		//The straw
 		r=sessions[16].ReserveDriveSpace(gTestDrive,0x10);
-		test(r==KErrTooBig);
+		test_Value(r, r == KErrTooBig);
 		}
 	else
 		{
 		test.Printf(_L("Drive too small: breaching drive reserve limit test skipped\n"));
 		test.Next(_L("Testing exhausting available drive free space instead"));
 		for(i=0; (v.iFree -= 0x10000) >= 0; i++)
 			{
 			r=sessions[i].ReserveDriveSpace(gTestDrive,0x10000);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			}
 		//The straw
 		r=sessions[i].ReserveDriveSpace(gTestDrive,0x10000);
-		test(r==KErrDiskFull);
+		test_Value(r, r == KErrDiskFull);
 		}
 	//Close Sessions
 	for(i=0; i<17; i++)
 		{
 	TInt64 free1(0);
 	TInt64 diff(0);
 	TInt r=0;
 	r = fs1.Connect();
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r = fs2.Connect();
-	test(r==KErrNone);
+	test_KErrNone(r);
 	GetFreeDiskSpace(free1);
 	r=fs1.ReserveDriveSpace(gTestDrive,0x10000);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=fs2.ReserveDriveSpace(gTestDrive,0x10000);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	GetFreeDiskSpace(free2);
 	diff = free1 - free2;
 	test(I64INT(diff)>0x1FBD0 && I64INT(diff)<0x21000);
 	GetFreeDiskSpace(free2);
 	diff = free1-free2;
 	test(I64INT(diff)>0xFA00 && I64INT(diff)<0x103C4);
 	r = fs1.Connect();
-	test(r==KErrNone);
+	test_KErrNone(r);
 	GetFreeDiskSpace(free1);
 	diff= free1-free2;
 	test(I64INT(diff)== 0 || I64INT(diff)<0xFA0 );
 	r=fs1.ReserveDriveSpace(gTestDrive,0x10000);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	GetFreeDiskSpace(free2);
 	diff = free1 - free2;
 	test(I64INT(diff)>0xFA00 && I64INT(diff)<0x103C4);
 	// Make sure no reserve space is allocated
 	r=fs1.ReserveDriveSpace(gTestDrive,0);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=fs2.ReserveDriveSpace(gTestDrive,0);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	// Now fill up the disk
 	FillUpDisk();
 	// Should fail as there is no space
 	r=fs1.ReserveDriveSpace(gTestDrive,0x10000);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	SynchronousClose(fs1);
 	SynchronousClose(fs2);
 	}
 FormatDrive();
 	RFs fs;
 	TInt r=fs.Connect();
-	test(r==KErrNone);
+	test_KErrNone(r);
 	TInt64 freeA(0);
 	TInt64 freeB(0);
 	RFile file;
 									//start with known amount of space
 	TBuf<20> buf;
 	buf=KTestFile;
 	buf[0]=(TUint16)gCh;
 	r=file.Replace(fs, buf, EFileWrite);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=file.Write(KTestData());
-	test(r==KErrNone);
+	test_KErrNone(r);
 	file.Close();
 	r=fs.ReserveDriveSpace(gTestDrive,0x10000);		//reserve some disk space
-	test(r==KErrNone);
+	test_KErrNone(r);
 	FillUpDisk();									//fill up the disk
 	TVolumeInfo v;									//get disk space
 	r=fs.Volume(v,gTestDrive);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	freeA=v.iFree;
 	r=fs.GetReserveAccess(gTestDrive);				//get access to reserve space
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=fs.Volume(v,gTestDrive);						//get disk space
-	test(r==KErrNone);
+	test_KErrNone(r);
 	freeB=v.iFree;
 	r=fs.ReleaseReserveAccess(gTestDrive);			//release reserve space
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(freeA == (freeB - 0x10000));				//test difference in space is equal to the amount reserved
 	r=fs.Volume(v,gTestDrive);						//get disk space
-	test(r==KErrNone);
+	test_KErrNone(r);
 	freeB=v.iFree;
 	test(freeA == freeB);							//check reading is still correct
 	TBuf <20> dir = KDir();
 	dir[0]=(TUint16)gCh;
 	r=fs.MkDir(dir);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=fs.MkDirAll(dir);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	TFileName temp;
 	TBuf<5> drv = KDrv();
 	drv[0]=(TUint16)gCh;
 	r=file.Temp(fs, drv, temp, EFileWrite);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=file.Replace(fs, buf, EFileWrite);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=file.Create(fs, buf, EFileWrite);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=file.Open(fs, buf, EFileWrite);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=file.Write(128, KTestData());
 	if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))
 		r = file.Flush();
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=file.SetSize(0x1000);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=file.SetAtt(KEntryAttHidden,0);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	TTime dtime;
 	r=file.SetModified(dtime);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=file.Set(dtime,KEntryAttHidden,0);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=file.Rename(buf);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	file.Close();
 	// Test that we can create a temporary file & write to it after acquiring reserved access,
 	r=fs.GetReserveAccess(gTestDrive);				//get access to reserve space
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=fs.Volume(v,gTestDrive);						//get disk space
-	test(r==KErrNone);
+	test_KErrNone(r);
 	freeA = v.iFree;
 	r=file.Temp(fs, drv, temp, EFileWrite);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r = file.Write(KTestData());
-	test (r == KErrNone);
+	test_KErrNone(r);
 	// If write caching is enabled, call RFs::Entry() to flush the file "anonymously"
 	if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))
 		{
 		r = file.Flush();
-		test (r == KErrNone);
+		test_KErrNone(r);
 		}
 	r=fs.Volume(v,gTestDrive);						//get disk space
-	test(r==KErrNone);
+	test_KErrNone(r);
 	freeB = v.iFree;
 	test (freeB < freeA);
 	file.Close();
 	r=fs.ReleaseReserveAccess(gTestDrive);			//release reserve space
-	test(r==KErrNone);
+	test_KErrNone(r);
 	TBuf<20> newname =KNewName();
 	newname[0]=(TUint16)gCh;
 	r=fs.Rename(buf, newname);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=fs.Replace(buf, newname);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=fs.SetEntry(buf, dtime, KEntryAttHidden, 0);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=fs.CreatePrivatePath(gTestDrive);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=fs.SetVolumeLabel(_L("Moooo"), gTestDrive);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=fs.SetModified(buf, dtime);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	SynchronousClose(fs);
 	}
 	RFs fs1;
 	RFs fs2;
 	TInt r=KErrNone;
 	r=fs1.Connect();
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=fs2.Connect();
-	test(r==KErrNone);
+	test_KErrNone(r);
 	FormatDrive();
 	r=fs1.ReserveDriveSpace(gTestDrive,0x10000);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=fs2.ReserveDriveSpace(gTestDrive,0x10000);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	FillUpDisk();
 	r=fs1.GetReserveAccess(gTestDrive);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	TBuf<20> dir = KDir();
 	dir[0]=(TUint16)gCh;
 	r=fs2.MkDir(dir);
-	test(r==KErrDiskFull);
+	test_Value(r, r == KErrDiskFull);
 	r=fs1.ReserveDriveSpace(gTestDrive,0); //can not release reserve space while you have reserve access
-	test(r==KErrInUse);
+	test_Value(r, r == KErrInUse);
 	r=fs1.ReleaseReserveAccess(gTestDrive);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=fs1.ReserveDriveSpace(gTestDrive,0);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=fs2.MkDir(dir);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	SynchronousClose(fs1);
 	SynchronousClose(fs2);
 	}
 	TInt64 diff(0);
 	RThread t[KNumberThreads];
 	TRequestStatus tStat[KNumberThreads];
 	r=fsess.Connect();
-	test(r==KErrNone);
+	test_KErrNone(r);
 	FormatDrive();
 	r= fsess.ShareAuto();
-	test(r==KErrNone);
+	test_KErrNone(r);
 	GetFreeDiskSpace(free1);
 	fsess.ReserveDriveSpace(gTestDrive,0x1000);
 	r = t[0].Create(_L("Sub_Thread1"),RsrvSpaceThread,KDefaultStackSize,KHeapSize,KHeapSize,&fsess);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	t[0].Rendezvous(tStat[0]);
 	t[0].Resume();
 	User::WaitForRequest(tStat[0]);
 	t[0].Close();
 	test(tStat[0]==KErrNone);
 	r = t[1].Create(_L("Sub_Thread2"),SessCloseThread,KDefaultStackSize,KHeapSize,KHeapSize,&fsess);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	t[1].Rendezvous(tStat[1]);
 	t[1].Resume();
 	User::WaitForRequest(tStat[1]);
 	TBuf<25> fileName;
 	fileName = KFileFiller;
 	fileName[0] = (TUint16)gCh;
 	err = theTestSession.Connect();
-	test(err == KErrNone);
+	test_KErrNone(err);
 	// determine the cluster size
 	RFile theFile;
 	err=theFile.Replace(theTestSession, fileName, EFileShareAny | EFileWrite);
-	test(err==KErrNone);
+	test_KErrNone(err);
 	// Neither notifier should be triggered here
 	err = theFile.SetSize(1);
 	test(KErrNone == err);
 	theFile.Close();
 	// Main part of the test starts here.
 	// First we create a new file, then we increase its size to cause the
 	// "Normal" notifier to trigger but not the "Reserved" notifier
 	//
 	err=theFile.Replace(theTestSession, fileName, EFileShareAny | EFileWrite);
-	test(err==KErrNone);
+	test_KErrNone(err);
 	test((statNrm == KRequestPending) && (statRes == KRequestPending));
 	// Neither notifier should be triggered here
 	err = theFile.SetSize(resSpace);
 	test(KErrNone == err);
 	test((statNrm == KRequestPending) && (statRes == KRequestPending));
 	err = theTestSession.ReserveDriveSpace(gTestDrive, resSpace * 3);
 	if (err != KErrArgument)	// will have exceeded limit if resSpace = 32K
 		{
-		test(err == KErrNone);
+		test_KErrNone(err);
 		test((statNrm == KErrNone) && (statRes == KRequestPending));
 		}
 	//
 	// All done - tidy up.
 TUint att;
 TTime time;
 RFs fs;
 TInt err = fs.Connect();
-test(err == KErrNone);
+test_KErrNone(err);
 RFile file;
 TBuf<20> fileName;
 fileName = KTestFile;
 fileName[0] = (TUint16)gCh;
 err = fs.ReserveDriveSpace(gTestDrive,0x10000);
-test(err == KErrNone);
+test_KErrNone(err);
 err = file.Replace(fs, fileName, EFileWrite);
-test(err == KErrNone);
+test_KErrNone(err);
 err = file.Write(KTestData);
-test(err == KErrNone);
+test_KErrNone(err);
 err = file.Flush();
-test(err == KErrNone);
+test_KErrNone(err);
 file.Close();
 err = file.Open(fs, fileName, EFileRead);
-test(err == KErrNone);
+test_KErrNone(err);
 err = file.Att(att);
-test(err == KErrNone);
+test_KErrNone(err);
 err = file.Modified(time);
-test(err == KErrNone);
+test_KErrNone(err);
 file.Close();
 FillUpDisk();
 err = file.Open(fs, fileName, EFileRead);
-test(err == KErrNone);
+test_KErrNone(err);
 TUint att1;
 err = file.Att(att1);
-test(err == KErrNone);
+test_KErrNone(err);
 test(att1 == att);
 TTime time1;
 err = file.Modified(time1);
-test(err == KErrNone);
+test_KErrNone(err);
 test(time1 == time);
 file.Close();
 fs.Close();
 		}
 TVolumeInfo volInfo;
 	TInt nRes = TheFs.Volume(volInfo,gTestDrive);
-	test(nRes == KErrNone);
+	test_KErrNone(nRes);
 if(volInfo.iSize < K4Gig+K1MegaByte)
 		{
 		test.Printf(_L("This test requires volume > 4G. Skipping.\n"));
 		return;
 FormatDrive();
 //-- find out media position of the data region start
 TFatBootSector bootSector;
 nRes = ReadBootSector(TheFs, gTestDrive, 0, bootSector);
-test(nRes == KErrNone);
+test_KErrNone(nRes);
 test(bootSector.IsValid());
 const TInt64 dataStartPos = bootSector.FirstDataSector() << KDefaultSectorLog2;
 const TInt64 lowRegion = K4Gig - dataStartPos - K1MegaByte;
 const TUint32 DummyFileLen = (TUint32)(lowRegion / MaxDummyFiles);
 	TInt i;
 for(i=0; i<MaxDummyFiles; ++i)
 		{
 nRes = CreateFileX(KBaseFN, i, DummyFileLen);
-test(nRes == KErrNone);
+test_KErrNone(nRes);
 		}
 //-- 3. create a real file that crosses 4G boundary
 nRes = CreateCheckableStuffedFile(TheFs, KBaseFN, 5*K1MegaByte);
-test(nRes == KErrNone);
+test_KErrNone(nRes);
 test.Printf(_L("Verifying the file that crosses 4G boundary.\n"));
 nRes = VerifyCheckableFile(TheFs, KBaseFN);
-test(nRes == KErrNone);
+test_KErrNone(nRes);
 	nRes = TheFs.Delete(KBaseFN);
-	test(nRes == KErrNone);
+	test_KErrNone(nRes);
 for(i=0; i<MaxDummyFiles; ++i)
 	    {
 nRes = DeleteFileX(KBaseFN, i);
-test(nRes == KErrNone);
+test_KErrNone(nRes);
 		}
 	}
 //-----------------------------------------------------------------------------
 			}
 	//get the number of the drive we are currently testing
 	TInt r=0;
 	r=RFs::CharToDrive(gSessionPath[0],gTestDrive);
-test(r==KErrNone);
+test_KErrNone(r);
 	r=RFs::DriveToChar(gTestDrive,gCh);
-	test(r==KErrNone);
+	test_KErrNone(r);
 TDriveInfo drv;
 r = TheFs.Drive(drv, gTestDrive);
-test(r == KErrNone);
+test_KErrNone(r);
 if (Is_Win32(TheFs, gTestDrive))
 {
 test.Printf(_L("Skipping on emulator %C: drive\n"), gSessionPath[0]);
 return;

changeset 109	b3a1d9898418
parent 90	947f0dc9f7a8
child 139	95f71bcdcdb7