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

equal deleted inserted replaced

-:c1f20ce4abcf
+:3e88ff8f41d5
 // Description:
 // f32test\server\t_dspace.cpp
 //
 //
-#define __E32TEST_EXTENSION__
 #include <f32file.h>
 #include <e32test.h>
 #include "t_server.h"
 #include "t_chlffs.h"
 //
 //
 	{
 	TVolumeInfo v;
 	TInt r=TheFs.Volume(v,aDrive);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	return(v.iFree);
 	}
 LOCAL_C TInt64 DiskSize(TInt aDrive)
 //
 //
 //
 	{
 	TVolumeInfo v;
 	TInt r=TheFs.Volume(v,aDrive);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	return(v.iSize);
 	}
 // MinimumFileSize() -
 // Deduces the minimum space occupied by a file by creating a file of one byte
 // in length. This should equal the cluster size on FAT volumes.
 //
 LOCAL_C TInt MinimumFileSize(TInt aDrive)
 	{
 	TInt r = TheFs.Delete(KTestFile1);
-	test_Value(r, r == KErrNone || r==KErrNotFound);
+	test(r==KErrNone || r==KErrNotFound);
 	TInt64 freeSpace = FreeDiskSpace(aDrive);
 	RFile file;
 	r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	r = file.Write(TheBuffer,1);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	file.Close();
 	TInt64 newSpace = FreeDiskSpace(aDrive);
 	r = TheFs.Delete(KTestFile1);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	TInt64 minFileSize = freeSpace - newSpace;
 	test (minFileSize >= 0);
 	minFileSize = Max(minFileSize, 512);
 	test.Printf(_L("inside init++++++++++++++++++++++++++>\n\n\n"));
 	test.Printf(_L("RemovableDrive = %d\n"),RemovableDrive);
 	// initialise removable drive descriptor
 	TChar c;
 	TInt r=RFs::DriveToChar(RemovableDrive,c);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	RemovableDriveBuf[0]=(TText)c;
 	if( !LffsDrive )
 		{
 		// and create the default directory
 		}
 	// better format the default drive as long as not WINS c drive
 	TInt drive;
 	r= RFs::CharToDrive(gSessionPath[0],drive);
-	test_KErrNone(r);
+	test(r==KErrNone);
 #if defined(__WINS__)
 	if(drive!=EDriveC)
 		Format(drive);
 #else
 	Format(drive);
 	Format(EDriveC);
 #endif
 	TheDiskSize=DiskSize(KDefaultDrive);
 	// and set the default directory
 	r=TheFs.MkDirAll(gSessionPath);
-	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
+	test(r==KErrNone || r==KErrAlreadyExists);
 	r=TheFs.Delete(KFileFiller);
-	test_Value(r, r == KErrNone || r==KErrNotFound);
+	test(r==KErrNone || r==KErrNotFound);
 	r=TheFs.Delete(KTestFile1);
-	test_Value(r, r == KErrNone || r==KErrNotFound);
+	test(r==KErrNone || r==KErrNotFound);
 	r=TheFs.Delete(KTestFile2);
-	test_Value(r, r == KErrNone || r==KErrNotFound);
+	test(r==KErrNone || r==KErrNotFound);
 	r=TheFs.RmDir(KTestDir1);
-	test_Value(r, r == KErrNone || r==KErrNotFound);
+	test(r==KErrNone || r==KErrNotFound);
 	r=TheFs.RmDir(KTestDir2);
-	test_Value(r, r == KErrNone || r==KErrNotFound);
+	test(r==KErrNone || r==KErrNotFound);
 	gMinFileSize = MinimumFileSize(drive);
 	}
 LOCAL_C TInt64 FillDisk(RFile& aFile,TInt64 aNewSpace,TInt aDrive)
 		{
 		TInt s=Min(KMaxBufSize, I64INT(space-aNewSpace));
 		TInt r=aFile.Write(TheBuffer,s);
 		if( !LffsDrive )
 			{
-			test_KErrNone(r);
+			test(r==KErrNone);
 			}
 		else
 			{
 			//
 			// LFFS is less predictable than a normal drive because of the logging
 		if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))
 			r = aFile.Flush();
 		if( !LffsDrive )
 			{
-			test_KErrNone(r);
+			test(r==KErrNone);
 			}
 		else
 			{
 			// we can't accurately predict the amount of data we can actually get
 			// on an LFFS drive, so it's posible we could exceed the available
 	TInt r;
 	switch(aTask)
 		{
 		case ETaskMkDir:
 			r=TheFs.RmDir(KTestDir1);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			break;
 		case ETaskRmDir: break;
 		case ETaskDelete: break;
 		case ETaskReplace:
 			r=TheFs.Delete(KTestFile2);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			break;
 		case ETaskFileReplace:
 			r=TheFs.Delete(KTestFile1);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			break;
 		case ETaskFileWrite:
 		case ETaskFileWrite4KB:
 		case ETaskFileWrite64KB:
 		case ETaskFileSetSize:
 	switch(aTask)
 		{
 		case ETaskMkDir:	break;
 		case ETaskRmDir:
 			r=TheFs.MkDir(KTestDir1);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			break;
 		case ETaskDelete:
 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			if( !LffsDrive )
 				{
 				r=file.SetSize(KFileSize1);
-				test_KErrNone(r);
+				test(r==KErrNone);
 				}
 			else
 				{
 				// LFFS supports sparse files, so we have to write real data
 				// into the file to ensure that it uses up disk space
 				}
 			file.Close();
 			break;
 		case ETaskReplace:
 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			if( !LffsDrive )
 				{
 				r=file.SetSize(KFileSize1);
-				test_KErrNone(r);
+				test(r==KErrNone);
 				}
 			else
 				{
 				WriteToFile( file, KFileSize2 );
 				}
 			file.Close();
 			r=file2.Create(TheFs,KTestFile2,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			if( !LffsDrive )
 				{
 				r=file2.SetSize(KFileSize3);
-				test_KErrNone(r);
+				test(r==KErrNone);
 				}
 			else
 				{
 				WriteToFile( file2, gMinFileSize << 4);	// 512 * 16 = 8K
 				}
 			file2.Close();
 			break;
 		case ETaskFileReplace:
 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			if( !LffsDrive )
 				{
 				r=file.SetSize(KFileSize3*2);
 				}
 			else
 				{
 				WriteToFile( file, KFileSize3 );
 				}
-			test_KErrNone(r);
+			test(r==KErrNone);
 			file.Close();
 			break;
 		case ETaskFileWrite:
 		case ETaskFileWrite4KB:
 		case ETaskFileWrite64KB:
 		case ETaskFileSetSize:
 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			file.Close();
 			break;
 		case ETaskNoChange1:
 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			if( !LffsDrive )
 				{
 				r=file.SetSize(KFileSize1);
-				test_KErrNone(r);
+				test(r==KErrNone);
 				}
 			else
 				{
 				WriteToFile( file, KFileSize1 );
 				}
 			file.Close();
 			break;
 		case ETaskNoChange2:
 			r=file.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			file.Close();
 			break;
 		case ETaskFileCreateLffs:
 			r = TheFs.Delete(KTestFile1);
 			break;
 //
 	{
 	RTest test(_L("T_DSPACE_ThreadFunction"));
 	RFs fs;
 	TInt r=fs.Connect();
-	test_KErrNone(r);
+	test(r==KErrNone);
 	r=fs.SetSessionPath(gSessionPath);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	TThreadTask task=*(TThreadTask*)&aThreadTask;
 	RFile file;
 	switch(task)
 		{
 		case ETaskMkDir:
 			r=fs.MkDir(KTestDir1);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			break;
 		case ETaskRmDir:
 			r=fs.RmDir(KTestDir1);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			break;
 		case ETaskDelete:
 			r=fs.Delete(KTestFile1);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			break;
 		case ETaskReplace:
 			r=fs.Replace(KTestFile1,KTestFile2);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			break;
 		case ETaskFileReplace:
 			r=file.Replace(fs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			file.Close();
 			break;
 		case ETaskFileWrite:
 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 #if defined(__WINS__)
 			WriteToFile( file, gMinFileSize << 4);	// 512 * 16 = 8K
 #else
 			WriteToFile( file, gMinFileSize << 1);	// 512 * 2 = 1K
 #endif
 			file.Close();
 			break;
 		case ETaskFileWrite4KB:
 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			WriteToFile(file,gMinFileSize << 3);	// 512 * 2^3 = 512 * 8 = 4K
 			file.Close();
 			break;
 		case ETaskFileWrite64KB:
 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			WriteToFile(file,gMinFileSize<<7);	// 512 * 2^7 = 512 * 128 = 64K
 			file.Close();
 			break;
 		case ETaskFileSetSize:
 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			r=file.SetSize(KFileSize3);
 			file.Close();
 			break;
 		case ETaskFileCreateLffs:
 			r=file.Create(fs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			file.Close();
 			break;
 		case ETaskNoChange1:
 			{
 			r=file.Open(fs,KTestFile1,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			TTime time;
 			time.HomeTime();
 			r=file.SetModified(time);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			file.Close();
 			break;
 			}
 		case ETaskNoChange2:
 			{
 			TEntry e;
 			r=fs.Entry(KTestFile1,e);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			break;
 			}
 		case ETaskSpin:
 			for(;;) {};
 //
 	{
 	// make default directory
 	_LIT(defaultDir,"C:\\F32-TST\\");
 	TInt r=TheFs.MkDirAll(defaultDir);
-	test_Value(r, r == KErrNone||r==KErrAlreadyExists);
+	test(r==KErrNone||r==KErrAlreadyExists);
 	// create the filler file
 	RFile file;
 	TFileName fileName=_L("C:");
 	fileName+=KFileFiller;
 	r=file.Create(TheFs,fileName,EFileShareAny|EFileWrite);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	TInt64 free=FreeDiskSpace(EDriveC);
 	// use up 16KB
 	FillDisk(file,free-16384,EDriveC);
 	// test formatting notifies clients on only specific drive
 	TheFs.NotifyDiskSpace(freeD-1024,RemovableDrive,stat2);
 	test(stat1==KRequestPending && stat2==KRequestPending);
 	RFormat f;
 	TInt count;
 	r=f.Open(TheFs,RemovableDriveBuf,EQuickFormat,count);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	while(count)
 		{
 		r=f.Next(count);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		}
 	f.Close();
 	User::After(1000000);
 	User::WaitForRequest(stat2);
 	test(stat1==KRequestPending && stat2==KErrNone);
 	// and create the test directory for the removable drive
 	TFileName fName=_L("");
 	fName+=RemovableDriveBuf;
 	fName+=_L("F32-TST\\");
 	r=TheFs.MkDirAll(fName);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	// test that a media change notifies clients on all drives
 	test.Next(_L("media change"));
 	freeC=FreeDiskSpace(EDriveC);
 	freeD=FreeDiskSpace(RemovableDrive);
 	// test that scandrive notifies clients on only specific drives
 	test.Next(_L("scandrive"));
 	// first test that scandrive does not find any problems on the removable media
 	r=TheFs.ScanDrive(RemovableDriveBuf);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	// now set up disk space notification
 	freeC=FreeDiskSpace(EDriveC);
 	freeD=FreeDiskSpace(RemovableDrive);
 	test.Printf(_L("free space on drive %d = 0x%x\n"),EDriveC,freeC);
 	test.Printf(_L("free space on drive %d = 0x%x\n"),RemovableDrive,freeD);
 	TheFs.NotifyDiskSpace(freeC+8192,EDriveC,stat1);
 	TheFs.NotifyDiskSpace(freeD-8192,RemovableDrive,stat2);
 	test(stat1==KRequestPending && stat2==KRequestPending);
 	r=TheFs.ScanDrive(RemovableDriveBuf);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	User::After(1000000);
 	User::WaitForRequest(stat2);
 	test(stat1==KRequestPending && stat2==KErrNone);
 	TheFs.NotifyDiskSpaceCancel(stat1);
 	test(stat1==KErrCancel);
 	file.Close();
 	r=TheFs.Delete(fileName);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	if(gSessionPath[0]!=(TText)'C')
 		{
 		r=TheFs.RmDir(defaultDir);
-		test_Value(r, r == KErrNone||r==KErrInUse);
+		test(r==KErrNone||r==KErrInUse);
 		}
 	}
 void TestFunctions()
 	{
 	test.Next(_L("test disk space functions"));
 	// create the filler file
 	RFile file;
 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	TInt64 newSpace = FreeDiskSpace(KDefaultDrive)-8192;
 	FillDisk(file,newSpace,KDefaultDrive);
 	// check file write
 	test.Next(_L("check RFile:Write"));
 	TInt64 threshold=free-200;
 	TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 	test(stat1==KRequestPending);
 	RThread thread;
 	r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	thread.Resume();
 	User::WaitForRequest(stat1);
 	test(stat1==KErrNone);
 	free=FreeDiskSpace(KDefaultDrive);
 	test(free<threshold);
 		free=FreeDiskSpace(KDefaultDrive);
 		threshold=free-100;
 		TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 		test(stat1==KRequestPending);
 		r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		TRequestStatus deathStat;
 		thread.Logon( deathStat );
 		thread.Resume();
 		User::WaitForRequest(stat1);
 		test(stat1==KErrNone);
 	free=FreeDiskSpace(KDefaultDrive);
 	threshold=free+100;
 	TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 	test(stat1==KRequestPending);
 	r=thread.Create(_L("thread3"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	thread.Logon( deathStat );
 	thread.Resume();
 	User::After(1000000);
 	free=FreeDiskSpace(KDefaultDrive);
 	threshold=free+300;
 	TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 	test(stat1==KRequestPending);
 	r=thread.Create(_L("thread4"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	thread.Logon( deathStat );
 	thread.Resume();
 	User::WaitForRequest(stat1);
 	test(stat1==KErrNone);
 	free=FreeDiskSpace(KDefaultDrive);
 	    TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 	    test(stat1==KRequestPending);
 	    r=thread.Create(_L("thread5"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	    test_KErrNone(r);
+	    test(r==KErrNone);
 	    thread.Logon( deathStat );
 	    thread.Resume();
 	    User::After(1000000);
 	    test(stat1==KRequestPending);
 	    free=FreeDiskSpace(KDefaultDrive);
 	    threshold=free+200;
 	    TheFs.NotifyDiskSpace(threshold,KDefaultDrive,stat1);
 	    test(stat1==KRequestPending);
 	    r=thread.Create(_L("thread6"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	    test_KErrNone(r);
+	    test(r==KErrNone);
 	    thread.Logon( deathStat );
 	    thread.Resume();
 	    User::WaitForRequest(stat1);
 	    //User::After(1000000);
 	    test(stat1==KErrNone);
 		_LIT(someFile,"X:\\abcdef");
 #else
 		TBuf<10> someFile=_L("?:\\abcdef");
 		TChar c;
 		TInt r=RFs::DriveToChar(RemovableDrive,c);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		someFile[0]=(TText)c;
 #endif
 		_LIT(someDir,"C:\\1234\\");
 		r=f2.Create(TheFs,someFile,EFileShareAny|EFileWrite);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		r=TheFs.MkDir(someDir);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		TRequestStatus stat2;
 		TInt64 freeC=FreeDiskSpace(EDriveC);
 		TInt64 freeD=FreeDiskSpace(RemovableDrive);
 		TheFs.NotifyDiskSpace(freeC-4097,EDriveC,stat1);
 		TheFs.NotifyDiskSpace(freeD-4097,RemovableDrive,stat2);
 		test(stat1==KRequestPending && stat2==KRequestPending);
 		// before fix this would result in iTheDrive not being updated in next subsession call
 		// therefore this could would not result in a disk space notification
 		r=f2.SetSize(8192);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		User::After(1000000);
 		User::WaitForRequest(stat2);
 		if (stat2!=KErrNone)
 			test.Printf(_L("stat2=%d\n"),stat2.Int());
 		f2.Close();
 		TheFs.NotifyDiskSpaceCancel();
 		test(stat1==KErrCancel);
 		r=TheFs.Delete(someFile);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		r=TheFs.RmDir(someDir);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		}
 	file.Close();
 	r=TheFs.Delete(KFileFiller);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	}
 void TestLffsFunctions()
 	{
 	test.Next(_L("test LFFS disk space functions"));
 	// create the filler file
 	RFile file;
 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	TInt64 newSpace = FreeDiskSpace(KDefaultDrive)-8192;
 	FillDisk(file,newSpace,KDefaultDrive);
 	// check file create
 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 	test(stat1==KRequestPending && stat2==KRequestPending);
 	RThread thread;
 	r=thread.Create(_L("thread7"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	TRequestStatus deathStat;
 	thread.Logon( deathStat );
 	thread.Resume();
 	User::WaitForRequest(stat1);
 	test(stat1==KErrNone);
 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 	TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 	test(stat1==KRequestPending && stat2==KRequestPending && stat3==KRequestPending);
 	r=thread.Create(_L("thread8"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	thread.Logon( deathStat );
 	thread.SetPriority( EPriorityLess );
 	thread.Resume();	// start spinning, blocks background thread
 	// request background thread to notify a daft value
 TPckgBuf<TInt64> cBuf;
 	#define ECioBackgroundNotifyDiskSize 10016
 	r = TheFs.ControlIo(GetDriveLFFS(), ECioBackgroundNotifyDiskSize, cBuf);
 	test( KErrNone==r );
 	// create a  file to force some roll-forward
 	r=file2.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	User::WaitForRequest(stat1);
 	test(stat1==KErrNone);
 	test(stat2==KRequestPending);
 	test(stat3==KRequestPending);
 	// kill the spinner thread to allow the background thread to execute
 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 	TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 	test(stat1==KRequestPending && stat2==KRequestPending && stat3==KRequestPending);
 	r=thread.Create(_L("thread9"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	thread.Logon( deathStat );
 	thread.SetPriority( EPriorityLess );
 	thread.Resume();	// start spinning, blocks background thread
 	// create a  file to force some roll-forward
 	r=file2.Create(TheFs,KTestFile1,EFileShareAny|EFileWrite);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	User::WaitForRequest(stat1);
 	test(stat1==KErrNone);
 	test(stat2==KRequestPending);
 	test(stat3==KRequestPending);
 	// kill the spinner thread to allow the background thread to execute
 	TheFs.Delete( KTestFile1 );
 	file.Close();
 	r=TheFs.Delete(KFileFiller);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	}
 void TestMultiple()
 //
 //
 	{
 	// create the filler file
 	RFile file;
 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	TInt64 free=FreeDiskSpace(KDefaultDrive);
 	TInt64 freeSpaceLeft = gMinFileSize << 4;	// 512 * 2^4 = 512 * 16 = 8K
 	FillDisk(file,free-freeSpaceLeft,KDefaultDrive);
 	TInt size;
 	r=file.Size(size);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	test(size>1024);
 	test.Printf(_L("filler file size=0x%x\n"),size);
 	// test multiple requests
 	test.Next(_L("test multiple requests"));
 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 	TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 	RThread thread;
 	r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	TRequestStatus deathStat;
 	thread.Logon( deathStat );
 	thread.Resume();
 	User::After(1000000);
 	User::WaitForRequest(stat1);
 		TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 		TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 		TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 		test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 		r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		thread.Logon( deathStat );
 		thread.Resume();
 		User::After(10000);
 		User::WaitForRequest(stat3);
 		test(stat3==KErrNone && stat1==KRequestPending && stat2==KRequestPending);
 	// test multiple sessions all notified on disk space change
 	test.Next(_L("test multiple sessions on same drive"));
 	RFs ses2,ses3;
 	r=ses2.Connect();
-	test_KErrNone(r);
+	test(r==KErrNone);
 	r=ses3.Connect();
-	test_KErrNone(r);
+	test(r==KErrNone);
 	r=ses2.SetSessionPath(gSessionPath);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	r=ses3.SetSessionPath(gSessionPath);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	task=ETaskFileReplace;
 	InitialiseForThread(task);
 	free=FreeDiskSpace(KDefaultDrive);
 	test.Printf(_L("free space on default drive = 0x%x\n"),free);
 	threshold1=free+gMinFileSize;			// 512
 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 	ses2.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 	ses3.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 	r=thread.Create(_L("thread3"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	thread.Logon( deathStat );
 	thread.Resume();
 	User::After(1000000);
 	User::WaitForRequest(stat1);
 	User::WaitForRequest(stat2);
 	if( !LffsDrive )
 		{
 		TInt sessionDrive;
 		r=RFs::CharToDrive(gSessionPath[0],sessionDrive);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		if(sessionDrive!=RemovableDrive)
 			{
 			// first create a file on the removable drive
 			RFile file2;
 			TFileName file2name=RemovableDriveBuf;
 			file2name+=_L("F32-TST\\testfile1");
 			TheFs.Delete(file2name);
 			r=file2.Create(TheFs,file2name,EFileShareAny|EFileWrite);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			r=file2.SetSize(KFileSize3);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			// test multiple sessions not notified on disk space change on wrong drive
 			test.Next(_L("test multiple sessions on different drives"));
 			task=ETaskFileReplace;
 			InitialiseForThread(task);
 			TInt64 freeDef=FreeDiskSpace(KDefaultDrive);
 			threshold2=freeRem + (gMinFileSize << 1);	// 1024;
 			TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 			ses2.NotifyDiskSpace(threshold2,RemovableDrive,stat2);
 			test(stat1==KRequestPending&&stat2==KRequestPending);
 			r=thread.Create(_L("thread4"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			thread.Logon( deathStat );
 			thread.Resume();
 			User::After(1000000);
 			User::WaitForRequest(stat1);
 			test(stat1==KErrNone && stat2==KRequestPending);
 			test(stat2==KRequestPending);
 			ses2.NotifyDiskSpaceCancel(stat2);
 			test(stat2==KErrCancel);
 			file2.Close();
 			r=TheFs.Delete(file2name);
-			test_KErrNone(r);
+			test(r==KErrNone);
 			}
 		}
 	ses2.Close();
 	ses3.Close();
 	file.Close();
 	r=TheFs.Delete(KFileFiller);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	}
 void TestLffsMultiple()
 //
 	{
 	// create the filler file
 	RFile file;
 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	TInt64 free=FreeDiskSpace(KDefaultDrive);
 	FillDisk(file,free-8192,KDefaultDrive);
 	TInt size;
 	r=file.Size(size);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	test.Printf(_L("filler file size=0x%x\n"),size);
 	// test multiple requests again
 	test.Next(_L("test multiple requests on LFFS") );
 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 	TheFs.NotifyDiskSpace(threshold3,KDefaultDrive,stat3);
 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 	RThread thread;
 	r=thread.Create(_L("thread10"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	TRequestStatus deathStat;
 	thread.Logon( deathStat );
 //	test.Printf(_L("Resuming other thread"));
 	thread.Resume();
 	User::After(10000);
 	TInt sessionDrive;
 	r=RFs::CharToDrive(gSessionPath[0],sessionDrive);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	if(sessionDrive!=EDriveC)
 		{
 		// test multiple sessions not notified on disk space change on wrong drive
 		test.Next(_L("test multiple sessions on different drives"));
 		RFs ses2,ses3;
 		r=ses2.Connect();
-		test_KErrNone(r);
+		test(r==KErrNone);
 		r=ses3.Connect();
-		test_KErrNone(r);
+		test(r==KErrNone);
 		r=ses2.SetSessionPath(gSessionPath);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		r=ses3.SetSessionPath(gSessionPath);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		// first create a file on the C:\ drive
 		RFile file2;
 		TFileName file2name=_L("C:\\");
 		file2name+=_L("F32-TST\\");
 		r=TheFs.MkDir(file2name);
 		test( KErrNone==r || KErrAlreadyExists==r );
 		file2name+=_L("testfile1");
 		TheFs.Delete(file2name);
 		r=file2.Create(TheFs,file2name,EFileShareAny|EFileWrite);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		WriteToFile( file2, KFileSize3 );
 		task=ETaskFileReplace;
 		InitialiseForThread(task);
 		TInt64 freeLffs=FreeDiskSpace(KDefaultDrive);
 		threshold2=freeD+1024;
 		TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 		ses2.NotifyDiskSpace(threshold2,EDriveC,stat2);
 		test(stat1==KRequestPending&&stat2==KRequestPending);
 		r=thread.Create(_L("thread11"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		thread.Logon( deathStat );
 		thread.Resume();
 		User::After(1000000);
 		User::WaitForRequest(stat1);
 		test(stat1==KErrNone && stat2==KRequestPending);
 		ses2.NotifyDiskSpaceCancel(stat2);
 		User::WaitForRequest( stat2 );
 		test(stat2==KErrCancel);
 		file2.Close();
 		r=TheFs.Delete(file2name);
-		test_KErrNone(r);
+		test(r==KErrNone);
 		ses2.Close();
 		ses3.Close();
 		}
 	file.Close();
 	r=TheFs.Delete(KFileFiller);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	}
 void TestChangeNotification()
 //
 	{
 	// create a filler file
 	RFile file;
 	TInt r=file.Create(TheFs,KFileFiller,EFileShareAny|EFileWrite|EFileWriteDirectIO);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	TInt64 free=FreeDiskSpace(KDefaultDrive);
 	// use 8KB in filler file
 	FillDisk(file,free-8192,KDefaultDrive);
 	// test change notification when no disk space change
 	TheFs.NotifyDiskSpace(threshold2,KDefaultDrive,stat2);
 	TheFs.NotifyChange(ENotifyAll,stat3);
 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 	RThread thread;
 	r=thread.Create(_L("thread1"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	TRequestStatus deathStat;
 	thread.Logon( deathStat );
 	thread.Resume();
 	User::After(1000000);
 	User::WaitForRequest(stat3);
 	// do an operation that will cause the change notification
 	// and disk change notification to be signalled
 	test.Next(_L(" test change notification and disk space notification"));
 	RFs session2,session3;
 	r=session2.Connect();
-	test_KErrNone(r);
+	test(r==KErrNone);
 	r=session3.Connect();
-	test_KErrNone(r);
+	test(r==KErrNone);
 	r=session2.SetSessionPath(gSessionPath);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	r=session3.SetSessionPath(gSessionPath);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	task=ETaskFileWrite;
 	InitialiseForThread(task);
 	free=FreeDiskSpace(KDefaultDrive);
 	threshold1=free-400;
 	TheFs.NotifyDiskSpace(threshold1,KDefaultDrive,stat1);
 	session2.NotifyChange(ENotifyAll,stat2);
 	session3.NotifyChange(ENotifyAll,stat3,KTestFile1);
 	test(stat1==KRequestPending&&stat2==KRequestPending&&stat3==KRequestPending);
 	r=thread.Create(_L("thread2"),ThreadFunction,KStackSize,KHeapSize,KHeapSize,(TAny*)task);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	thread.Logon( deathStat );
 	thread.Resume();
 	User::After(1000000);
 	User::WaitForRequest(stat1);
 	User::WaitForRequest(stat2);
 	session2.Close();
 	session3.Close();
 	file.Close();
 	r=TheFs.Delete(KFileFiller);
-	test_KErrNone(r);
+	test(r==KErrNone);
 	}
 //-------------------------------------------------------------------------------------------------
 // Test the fix for:
 _LIT(KPreModifierPluginFileName,"premodifier_plugin");
 _LIT(KPreModifierPluginName,"PreModifierPlugin");
 const TUint KTestFileSize = KKilo * 100;
-#define SAFETEST_KErrNone(a)        if(a != KErrNone)\
+#define SAFETEST(a)				if(a != KErrNone)\
 {\
 TheFs.DismountPlugin(KPreModifierPluginName);\
 TheFs.RemovePlugin(KPreModifierPluginName);\
-test_KErrNone(a);\
+test(a == KErrNone);\
 }
 TInt PluginTestThreadFunction(TAny*)
 {
 RTest test(_L("PluginTestThreadFunction"));
 RFs fs;
 fs.Connect();
 TInt r = fs.SetSessionPath(gSessionPath);
-test_KErrNone(r);
+test(r == KErrNone);
 RFile file;
 r = file.Create(fs, KTestFile1, EFileShareAny|EFileWrite);
-test_KErrNone(r);
+test(r == KErrNone);
 r = file.SetSize(KTestFileSize);
-test_KErrNone(r);
+test(r == KErrNone);
 file.Close();
 User::After(5000000); // wait for 5 seconds, to ensure first notification received.
 r = fs.Delete(KTestFile1);
-test_KErrNone(r);
+test(r == KErrNone);
 fs.Close();
 return KErrNone;
 }
 {
 test.Next(_L("Test Disk Space Notify With Plugin"));
 TInt drive;
 TInt r = RFs::CharToDrive(gSessionPath[0],drive);
-SAFETEST_KErrNone(r);
+SAFETEST(r);
 Format(drive);
 r = TheFs.MkDirAll(gSessionPath);
-SAFETEST_KErrNone(r);
+SAFETEST(r);
 r = TheFs.AddPlugin(KPreModifierPluginFileName);
-SAFETEST_KErrNone(r);
+SAFETEST(r);
 r = TheFs.MountPlugin(KPreModifierPluginName);
-SAFETEST_KErrNone(r);
+SAFETEST(r);
 TInt64 free = FreeDiskSpace(drive);
 TInt64 threshold = free - KTestFileSize + 1;
 TRequestStatus status;
 TheFs.NotifyDiskSpace(threshold, drive, status);
 RThread thread;
 r = thread.Create(_L("PluginTestThread"), PluginTestThreadFunction, KStackSize, KHeapSize, KHeapSize, NULL);
-SAFETEST_KErrNone(r);
+SAFETEST(r);
 thread.Logon(statusDeath);
 thread.Resume();
 User::WaitForRequest(status);
-SAFETEST_KErrNone(status.Int());
+SAFETEST(status.Int());
 TheFs.NotifyDiskSpace(threshold, drive, status);
 User::WaitForRequest(status);
-SAFETEST_KErrNone(status.Int());
+SAFETEST(status.Int());
 User::WaitForRequest(statusDeath);
-SAFETEST_KErrNone(statusDeath.Int());
+SAFETEST(statusDeath.Int());
 thread.Close();
 r = TheFs.DismountPlugin(KPreModifierPluginName);
-SAFETEST_KErrNone(r);
+SAFETEST(r);
 r = TheFs.RemovePlugin(KPreModifierPluginName);
-SAFETEST_KErrNone(r);
+SAFETEST(r);
 Format(drive);
 }
 GLDEF_C void CallTestsL()
 #endif
 		return;
 		}
 	//Test uses C drive as secondary drive so test can't be tested on that drive
 	r = TheFs.CharToDrive(gSessionPath[0], driveNumber);
-	test_KErrNone(r);
+	test(r == KErrNone);
 	if(driveNumber == EDriveC)
 		{
 		test.Printf(_L("Test uses C drive as secondary drive so test can't be test on C drive, test will exit"));
 		return;
 		}

branch	RCL_3
changeset 44	3e88ff8f41d5
parent 43	c1f20ce4abcf