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

equal deleted inserted replaced

-:4a8fed1c0ef6
+:597aaf25e343
 // Contributors:
 //
 // Description:
 //
+#define __E32TEST_EXTENSION__
 #include <f32file.h>
 #include <e32test.h>
 #include <hal.h>
 #include "t_server.h"
 #include "t_chlffs.h"
 	if (lastError!=KErrNone && lastError!=KErrBadName)
 		{
 		TFileName fileName=iFileMan->CurrentEntry().iName;
 		if (gAsynch==EFalse)
 			test.Printf(_L("CurrentEntry is %S\n"),&fileName);
-		test(lastError==KErrAlreadyExists);
+		test_Equal(KErrAlreadyExists, lastError);
-		test(fileName.MatchF(_L("PIPE1.PLP"))!=KErrNotFound || fileName.MatchF(_L("FOUR"))!=KErrNotFound || fileName.MatchF(_L("File*.TXT"))!=KErrNotFound  || fileName.MatchF(_L("ah"))!=KErrNotFound || fileName.MatchF(_L("a"))!=KErrNotFound);
+		test_Value(KErrNotFound, fileName.MatchF(_L("PIPE1.PLP"))!=KErrNotFound || fileName.MatchF(_L("FOUR"))!=KErrNotFound || fileName.MatchF(_L("File*.TXT"))!=KErrNotFound  || fileName.MatchF(_L("ah"))!=KErrNotFound || fileName.MatchF(_L("a"))!=KErrNotFound);
 		}
 	return(MFileManObserver::EContinue);
 	}
 LOCAL_C void WaitForSuccess()
 //
 // Wait for gStat to complete with aResult
 //
 	{
 	User::WaitForRequest(gStat);
-	test(gStat==aResult);
+	test_Value(aResult, gStat==aResult);
 	}
 LOCAL_C void TestResult(TInt aReturnVal, TInt aExpectedAsynchReturnStatus=KErrNone, TInt aExpectedSynchReturn=KErrNone)
 //
 // Test the result, wait for an asynchronous call
 //
 	{
 	if (!gAsynch)
-		test(aReturnVal==aExpectedAsynchReturnStatus);
+		{
-	else
+		test_Equal(aExpectedAsynchReturnStatus, aReturnVal);
-		{
+		}
-		test(aReturnVal==aExpectedSynchReturn);
+	else
+		{
+		test_Equal(aExpectedSynchReturn, aReturnVal);
 		WaitForResult(aExpectedAsynchReturnStatus);
 		}
 	}
 LOCAL_C void RmDir(const TDesC& aDirName)
 // Remove a directory
 //
 	{
 	gFileMan->Attribs(aDirName, 0, KEntryAttReadOnly, 0, CFileMan::ERecurse);
 	TInt r=gFileMan->RmDir(aDirName);
-	test(r==KErrNone || r==KErrNotFound || r==KErrPathNotFound);
+	test_Value(r, r==KErrNone || r==KErrNotFound || r==KErrPathNotFound);
 	}
 LOCAL_C void Compare(const TDesC& aDir1,const TDesC& aDir2)
 //
 // Test that the contents of two directories are identical
 		*aDestOtherDrive = gSessionPath[0] == 'C' ? _L("D:\\F32-TST\\TFMAN\\dest\\") : _L("C:\\F32-TST\\TFMAN\\dest\\");
 #else
 		*aDestOtherDrive = gSessionPath[0] == 'C' ? _L("Y:\\F32-TST\\TFMAN\\dest\\") : _L("C:\\F32-TST\\TFMAN\\dest\\");
 #endif
 		err = TheFs.MkDirAll(*aDestOtherDrive);
-		test(err == KErrNone || err == KErrAlreadyExists);
+		test_Value(err, err == KErrNone || err == KErrAlreadyExists);
 		}
 	err = TheFs.MkDirAll(sourceName);
-	test(err == KErrNone || err == KErrAlreadyExists);
+	test_Value(err, err == KErrNone || err == KErrAlreadyExists);
 	err = TheFs.MkDirAll(sourceCompare);
-	test(err == KErrNone || err == KErrAlreadyExists);
+	test_Value(err, err == KErrNone || err == KErrAlreadyExists);
 	err = TheFs.MkDirAll(destSameDrive);
-	test(err == KErrNone || err == KErrAlreadyExists);
+	test_Value(err, err == KErrNone || err == KErrAlreadyExists);
 	if(aCreateFiles)
 		{
 		err = TheFs.MkDirAll(sourceNameSubDir);
-		test(err == KErrNone || err == KErrAlreadyExists);
+		test_Value(err, err == KErrNone || err == KErrAlreadyExists);
 		err = TheFs.MkDirAll(sourceCompareSubDir);
-		test(err == KErrNone || err == KErrAlreadyExists);
+		test_Value(err, err == KErrNone || err == KErrAlreadyExists);
 		for(TInt i=0; i<5; i++)
 			{
 			// Create a test file to be copied
 			TFileName name = sourceName;
 			name.AppendNum(i);
 			name.Append(_L(".TXT"));
 			RFile file;
 			err = file.Create(TheFs,name,EFileRead|EFileWrite);
-			test(err == KErrNone || err == KErrAlreadyExists);
+			test_Value(err, err == KErrNone || err == KErrAlreadyExists);
 			file.Close();
 			// ...and another to compare against
 			name = sourceCompare;
 			name.Append(_L("File"));
 			name.AppendNum(i);
 			name.Append(_L(".TXT"));
 			err = file.Create(TheFs,name,EFileRead|EFileWrite);
-			test(err == KErrNone || err == KErrAlreadyExists);
+			test_Value(err, err == KErrNone || err == KErrAlreadyExists);
 			file.Close();
 			}
 		}
 	}
 	if(err == KErrNone)
 		{
 		buf.Insert(0, _L("\\"));
 		buf.Append(_L("\\file"));
 		err = TheFs.Delete(buf);
-		test(err == KErrNone);
+		test_KErrNone(err);
 		ret = ETrue;
 		}
 	RmDir(_L("\\longname1\\"));
 	return ret;
 	}
 		MakeDir(_L("\\TEST\\LONG\\NAME\\ABCDE\\DIRECTORY1DIRECTORY2DIRECTORY3DIRECTORY4\\"));
 		MakeFile(_L("\\TEST\\LONG\\NAME\\ABCDE\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04"));
 		MakeFile(_L("\\TEST\\LONG\\NAME\\ABCDE\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04"));
 		TFileName name1(KLongName1);
 		r=gFileMan->Rename(_L("\\TEST\\LONG"),name1,CFileMan::EOverWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 	//	Two long directory names - makes paths invalid
 		MakeDir(_L("\\TEST\\LONG\\NAME\\FGHIJ"));
 		MakeDir(_L("\\TEST\\LONG\\NAME\\FGHIJ\\DIRECTORY1DIRECTORY2DIRECTORY3DIRECTORY4\\"));
 		MakeFile(_L("\\TEST\\LONG\\NAME\\FGHIJ\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04"));
 		MakeFile(_L("\\TEST\\LONG\\NAME\\FGHIJ\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04"));
 		// Testing invalid long file name (i.e. >256)
 		r=gFileMan->Rename(_L("\\TEST\\LONG"),KInvalidLongName,CFileMan::EOverWrite);
-		test(r==KErrBadName);
+		test_Equal(KErrBadName, r);
 		// Testing invalid long path (i.e. >256)
 		r=gFileMan->Rename(_L("\\TEST\\LONG"),KInvalidLongPath,CFileMan::EOverWrite);
-		test(r==KErrBadName);
+		test_Equal(KErrBadName, r);
 		r=gFileMan->Rename(_L("\\TEST\\LONG"),_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds"),CFileMan::EOverWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	//testing invalid source path at the beginning:
 	if (!gAsynch)
 		{
 		if (testingInvalidPathLengths)
 			{
 			TFileName name1(KLongName1);
 			name1+=_L("\\NAME\\ABCDE\\*.*");
 			r=gFileMan->Delete(name1);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->Delete(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds\\NAME\\FGHIJ\\*.*"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			}
 		}
 	else
 		{
 		gFileMan->Delete(_L("\\F32-TST\\TFMAN\\DELDIR\\*.TXT"),0,gStat);
 			{
 			TFileName name1(KLongName1);
 			name1+=_L("\\NAME\\ABCDE\\*.*");
 			r=gFileMan->Delete(name1,0,gStat);
 			WaitForSuccess();
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->Delete(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds\\NAME\\FGHIJ\\*.*"),0,gStat);
 			WaitForSuccess();
-			test(r==KErrNone);
+			test_KErrNone(r);
 			}
 		}
 	test.Next(_L("Check files are deleted"));
 	RmDir(_L("\\F32-TST\\TFMAN\\After\\"));
 	Compare(_L("\\F32-TST\\TFMAN\\DELDIR\\*"),_L("\\F32-TST\\TFMAN\\AFTER\\DELDIR\\*"));
 	if (testingInvalidPathLengths)
 		{
 		r=gFileMan->RmDir(_L("\\TEST\\"));
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	/**
 	Test wild card matching in short file names
 	Note this test is only run on FAT file systems as 'short file names' are only
 		supported by FAT.
 	DEF130113: TTG:<Wild card characters cannot be handled in the short file names>
 	*/
 	TInt theDrive;
 	r=TheFs.CharToDrive(gDriveToTest,theDrive);
-	test(r==KErrNone);
+	test_KErrNone(r);
 TFSName f;
 	r = TheFs.FileSystemName(f, theDrive);
-	test(r == KErrNone || r == KErrNotFound);
+	test_Value(r, r == KErrNone || r == KErrNotFound);
 if (f.FindF(_L("Fat")) == 0 )
 	{
 		test.Next(_L("Test wild card matching in short file names"));
 	MakeFile(_L("abcdefghi.txt"));
 	TInt err = gFileMan->Delete(_L("ABCDEF~*"));
-	test(err == KErrNone);
+	test_KErrNone(err);
 	MakeFile(_L("abcdefghi.txt"));
 	err = gFileMan->Delete(_L("ABCDEF~*.TXT"));
-	test(err == KErrNone);
+	test_KErrNone(err);
 	MakeFile(_L("abcdefghi.txt"));
 	err = gFileMan->Delete(_L("ABCDEF~*.?XT"));
-	test(err == KErrNone);
+	test_KErrNone(err);
 	MakeFile(_L("abcdefghi.txt"));
 	err = gFileMan->Delete(_L("ABCDEF~1.*"));
-	test(err == KErrNone);
+	test_KErrNone(err);
 	}
 	}
 LOCAL_C void TestCopy()
 //
 		MakeFile(_L("\\START\\LONG\\ABCDEFGH01ABCDEFGH01ABCDEFGH01ABCDEFGH01.txt"));
 		MakeFile(_L("\\START\\LONG\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04.txt"));
 		MakeFile(_L("\\START\\LONG\\DINOSAUR01DINOSAUR02DINOSAUR03DINOSAUR04.txt"));
 		MakeFile(_L("\\START\\LONG\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04.txt"));
 		r=gFileMan->Rename(_L("\\START\\LONG"),_L("\\START\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff"),CFileMan::EOverWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		MakeDir(_L("\\START\\ASDFFDSA\\"));
 		}
 	//testing invalid source path at the beginning:
 	if (!gAsynch)
 	TestResult(r,KErrAlreadyExists);
 	if (!gAsynch)
 		{
 		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\*.TXT"),_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
-		test(r==KErrNone);
+		test_KErrNone(r);
 		if (testingInvalidPathLengths)
 			{
 			test.Next(_L("Test invalid length paths"));
 			r=gFileMan->Copy(_L("\\START\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\*.*"),_L("\\FINISH\\"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->RmDir(_L("\\START\\"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->RmDir(_L("\\FINISH\\"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			}
 		}
 	else
 		{
 		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\DELDIR\\*.TXT"),_L("\\F32-TST\\TFMAN\\COPYDIR\\"),0,gStat);
 		WaitForSuccess();
-		test(r==KErrNone);
+		test_KErrNone(r);
 		if (testingInvalidPathLengths)
 			{
 			test.Next(_L("Test invalid length paths (Asynch)"));
 			r=gFileMan->Copy(_L("\\START\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\*.*"),_L("\\FINISH\\"),0,gStat);
 			WaitForSuccess();
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->RmDir(_L("\\START\\"),gStat);
 			WaitForSuccess();
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->RmDir(_L("\\FINISH\\"),gStat);
 			WaitForSuccess();
-			test(r==KErrNone);
+			test_KErrNone(r);
 			}
 		}
 	if (!gAsynch)
 		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\NewDir\\*.*"),_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
 		r=gFileMan->Copy(fn,_L("\\F32-TST\\TFMAN\\COPYDIR\\"),0,gStat);
 	TestResult(KErrNone);
 	TEntry entry;
 	r=TheFs.Entry(_L("\\F32-TST\\TFMAN\\COPYDIR\\T_FSRV.CPP"),entry);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(entry.iName.MatchF(_L("T_FSRV.CPP"))!=KErrNotFound);
 #if defined (__WINS__)
-	test(entry.iAtt==KEntryAttArchive);
+	test_Equal(KEntryAttArchive, entry.iAtt);
 #else
 	if (!IsTestingLFFS())
-		test(entry.iAtt==KEntryAttReadOnly);
+		{
-	else
+	    test_Equal(KEntryAttReadOnly, entry.iAtt);
+		}
+	else
+		{
 		test(entry.iAtt&KEntryAttReadOnly); // ???
+		}
 #endif
 	r=TheFs.SetAtt(_L("\\F32-TST\\TFMAN\\COPYDIR\\T_FSRV.CPP"),0,KEntryAttReadOnly);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\AFTER\\RUMBA?.TXT"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\DELDIR\\RUMBA?.TXT"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	}
 LOCAL_C void TestDEF121663_Setup(TFileName& aSrcPath)
 	{
 	RmDir(aSrcPath);
 		MakeFile(_L("\\START\\LONG\\ABCDEFGH01ABCDEFGH01ABCDEFGH01ABCDEFGH01.txt"));
 		MakeFile(_L("\\START\\LONG\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04.txt"));
 		MakeFile(_L("\\START\\LONG\\DINOSAUR01DINOSAUR02DINOSAUR03DINOSAUR04.txt"));
 		MakeFile(_L("\\START\\LONG\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04.txt"));
 		r=gFileMan->Rename(_L("\\START\\LONG"),_L("\\START\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff"),CFileMan::EOverWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		//	Two long directory names - makes paths invalid
 		MakeDir(_L("\\TEST\\LONG\\NAME\\FGHIJ"));
 		MakeDir(_L("\\TEST\\LONG\\NAME\\FGHIJ\\DIRECTORY1DIRECTORY2DIRECTORY3DIRECTORY4\\"));
 		MakeFile(_L("\\TEST\\LONG\\NAME\\FGHIJ\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04"));
 		MakeFile(_L("\\TEST\\LONG\\NAME\\FGHIJ\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04"));
 		r=gFileMan->Rename(_L("\\TEST\\LONG"),_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds"),CFileMan::EOverWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		MakeDir(_L("\\START\\ASDFFDSA\\"));
 		}
 	//testing invalid source path at the beginning:
 	TestResult(r,KErrNone);
 	if ((!gAsynch)&&(testingInvalidPathLengths))
 		{
 		r=gFileMan->Move(_L("\\START\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\*.*"),_L("\\FINISH\\"));
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=gFileMan->Move(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds\\*.*"),_L("\\FINISH\\"), CFileMan::EOverWrite | CFileMan::ERecurse);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=gFileMan->RmDir(_L("\\START\\"));
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=gFileMan->RmDir(_L("\\FINISH\\"));
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	if ((gAsynch)&&(testingInvalidPathLengths))
 		{
 		r=gFileMan->Move(_L("\\START\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\*.*"),_L("\\FINISH\\"),CFileMan::EOverWrite,gStat);
 		User::WaitForRequest(gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=gFileMan->Move(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds\\*.*"),_L("\\FINISH\\"), CFileMan::EOverWrite | CFileMan::ERecurse,gStat);
 		User::WaitForRequest(gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=gFileMan->RmDir(_L("\\START\\"),gStat);
 		WaitForSuccess();
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=gFileMan->RmDir(_L("\\FINISH\\"),gStat);
 		WaitForSuccess();
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	if (!gAsynch)
 		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"),_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
 	else
 		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"),_L("\\F32-TST\\TFMAN\\MoveDIR\\FILE1.TXT"),0);
 	else
 		r=gFileMan->Move(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"),_L("\\F32-TST\\TFMAN\\MoveDIR\\FILE1.TXT"),0,gStat);
 	TestResult(r,KErrAlreadyExists);
 	r=TheFs.Delete(_L("\\F32-TST\\TFMAN\\DELDIR\\FILE1.TXT"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Check files have been moved"));
 	RmDir(_L("\\F32-TST\\TFMAN\\AFTER\\*"));
 	MakeDir(_L("\\F32-TST\\TFMAN\\AFTER\\DELTEST\\EMPTY\\"));
 	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\DELTEST\\FILE4.TXT"));
 	Compare(_L("\\F32-TST\\TFMAN\\AFTER\\*"),_L("\\F32-TST\\TFMAN\\MOVEDIR\\*"));
 	if (testingInvalidPathLengths)
 		{
 		r=gFileMan->RmDir(_L("\\TEST\\"));
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	TestDEF121663(); // Test moving directory to its subdirectory
 	TestDEF123575(); // Test moving directories where src and trg have matching subdirectory structures
 	TestDEF125570(); // Test move when trg has at least one of the src dirs
 	MakeFile(_L("\\F32-TST\\TFMAN\\FMAN2\\PETER.TXT"));
 	CFileMan* fman=CFileMan::NewL(TheFs);
 	TRequestStatus stat1;
 	TInt r=fman->Delete(_L("\\F32-TST\\TFMAN\\FMAN1\\*.*"),0,stat1);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\FMAN2\\*.TXT"),_L("\\F32-TST\\TFMAN\\FMAN2\\*.EXT"),0,gStat);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	FOREVER
 		{
 		if (stat1!=KRequestPending && gStat!=KRequestPending)
 			break;
 		User::WaitForAnyRequest();
 	test.Next(_L("Test wildcards are replaced with letters from the matched file (DEF092084)"));
 	MakeDir(_L("\\DEF092084"));
 	MakeFile(_L("\\DEF092084\\FILE1.TXT"));
 	TInt r = gFileMan->Rename(_L("\\DEF092084\\*.TXT"),_L("\\DEF092084\\*.DDB"), CFileMan::EOverWrite);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	CheckFileExists(_L("\\DEF092084\\FILE1.DDB"), KErrNone);
 	r = gFileMan->Rename(_L("\\DEF092084\\?*.DD?"),_L("\\DEF092084\\?*.TXT"), CFileMan::EOverWrite);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	CheckFileExists(_L("\\DEF092084\\FILE1.TXT"), KErrNone);
 	RmDir(_L("\\DEF092084\\"));
 	}
 	_LIT(KTestFile, "\\TESTFILE.TXT");
 	test.Printf(_L("1: Create Test File\n"));
 	RFile testFile;
 	r = testFile.Create(TheFs, KTestFile, EFileRead | EFileWrite);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Printf(_L("2: Populate testFile1 Data\n"));
 	r = testFile.Write(_L8("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Printf(_L("3: Get Initial Attributes\n"));
 	TUint atts = 0;
 	r = testFile.Att(atts);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Printf(_L("   Attributes: %08x"), atts);
 	test.Printf(_L("4: Set KEntryAttHidden Attribute\n"));
 	r = testFile.SetAtt(KEntryAttHidden, 0);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Printf(_L("5: Verify KEntryAttHidden Attribute is set for testFile1\n"));
 	r = testFile.Att(atts);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test(atts & KEntryAttHidden);
 	test.Printf(_L("6: Read Data from beginning of file testFile1\n"));
 	TBuf8<4> data;
 	r = testFile.Read(0, data);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Printf(_L("7: Close all the testFiles\n"));
 	testFile.Close();
 	test.Printf(_L("8: Verify KEntryAttHidden is present\n"));
 	r = TheFs.Att(KTestFile, atts);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Printf(_L("  Finally, attributes are : %08x\n"), atts);
 	test(atts & KEntryAttHidden);
 	test.Printf(_L("9: Delete Test File\n"));
 	r = TheFs.Delete(KTestFile);
-	test(r == KErrNone || r == KErrNotFound);
+	test_Value(r, r == KErrNone || r == KErrNotFound);
 	}
 LOCAL_C void TestDEF113299()
 	{
 	test.Next(_L("Test invalid file rename (DEF113299)"));
 		MakeDir(_L("\\LONGNAME\\DIRECTORY1DIRECTORY2DIRECTORY3DIRECTORY4\\"));
 		MakeFile(_L("\\LONGNAME\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04.txt"));
 		MakeFile(_L("\\LONGNAME\\DINOSAUR01DINOSAUR02DINOSAUR03DINOSAUR04.txt"));
 		MakeFile(_L("\\LONGNAME\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04.bin"));
 		r=gFileMan->Rename(_L("\\LONGNAME"),_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff"),CFileMan::EOverWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 	//	Two long directory names - makes paths invalid
 		MakeDir(_L("\\TEST\\LONG\\NAME\\FGHIJ"));
 		MakeDir(_L("\\TEST\\LONG\\NAME\\FGHIJ\\DIRECTORY1DIRECTORY2DIRECTORY3DIRECTORY4\\"));
 		MakeFile(_L("\\TEST\\LONG\\NAME\\FGHIJ\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT.txt"));
 		MakeFile(_L("\\TEST\\LONG\\NAME\\FGHIJ\\FILEFILE01FILEFILE02FILEFILE03FILEFILE.txt"));
 		r=gFileMan->Rename(_L("\\TEST\\LONG"),_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds"),CFileMan::EOverWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	//testing invalid source path at the beginning:
 	if (!gAsynch)
 		{
 		TestResult(r,KErrBadName,KErrNone);
 	if (!gAsynch)
 		{
 		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\*.TXT"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		if (testingInvalidPathLengths)
 			{
 			r=gFileMan->Rename(_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\elephant01elephant02elephant03elephant04.txt"),_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\elephant01elephant02elephant03elephant04.bin"));
-			test(r==KErrBadName);
+			test_Equal(KErrBadName, r);
 			r=gFileMan->Rename(_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff"),_L("\\Shortened"),CFileMan::EOverWrite);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->Rename(_L("\\Shortened\\*.txt"),_L("\\Shortened\\*.cat"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->RmDir(_L("\\Shortened\\"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->Rename(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds"),_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\NotSoShortened"),CFileMan::EOverWrite);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->Rename(_L("\\TEST"),_L("\\OXO!"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->Rename(_L("\\OXO!\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as"),_L("\\OXO!\\Shorter"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->Rename(_L("\\OXO!\\Shorter\\NotSoShortened\\NAME\\FGHIJ\\*.txt"),_L("\\TEST\\Shorter\\NotSoShortened\\NAME\\FGHIJ\\*.cat"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->RmDir(_L("\\OXO!\\"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			}
 		}
 	else
 		{
 		r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\RENAME\\SRC\\*.TXT"),_L("\\F32-TST\\TFMAN\\RENAME\\DEST\\*.DDB"),CFileMan::EOverWrite,gStat);
 		WaitForSuccess();
 		if (testingInvalidPathLengths)
 			{
 			r=gFileMan->Rename(_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\elephant01elephant02elephant03elephant04.txt"),_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\elephant01elephant02elephant03elephant04.bin"));
-			test(r==KErrBadName);
+			test_Equal(KErrBadName, r);
 			r=gFileMan->Rename(_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff"),_L("\\Shortened"),CFileMan::EOverWrite,gStat);
 			WaitForSuccess();
 			r=gFileMan->Rename(_L("\\Shortened\\*.txt"),_L("\\Shortened\\*.bin"),0,gStat);
 			WaitForSuccess();
 			r=gFileMan->RmDir(_L("\\Shortened\\"),gStat);
 			WaitForSuccess();
 			r=gFileMan->Rename(_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\fdsa21asdffds"),_L("\\TEST\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as\\NotSoShortened"),CFileMan::EOverWrite,gStat);
 			WaitForSuccess();
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->Rename(_L("\\TEST"),_L("\\OXO!"),CFileMan::EOverWrite,gStat);
 			WaitForSuccess();
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->Rename(_L("\\OXO!\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20as"),_L("\\OXO!\\Shorter"),CFileMan::EOverWrite,gStat);
 			WaitForSuccess();
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->Rename(_L("\\OXO!\\Shorter\\NotSoShortened\\NAME\\FGHIJ\\*.txt"),_L("\\TEST\\Shorter\\NotSoShortened\\NAME\\FGHIJ\\*.cat"),CFileMan::EOverWrite,gStat);
 			WaitForSuccess();
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->RmDir(_L("\\OXO!\\"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=gFileMan->RmDir(_L("\\TEST\\"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			}
 		}
 	RmDir(_L("\\F32-TST\\TFMAN\\after\\"));
 	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\abcDEF.DDB"));
 	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\abxx.DDB"));
 	// Test behaviour for omitted parameters
 	// For this, default should be session path
 	TFileName sessionPath;
 	TInt err=TheFs.SessionPath(sessionPath);
-	test(err==KErrNone);
+	test_KErrNone(err);
 	SetupDirectories(ETrue, NULL);
 	err=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\dest\\"));
-	test(err == KErrNone);
+	test_KErrNone(err);
 	err = gFileMan->Rename(_L("\\F32-TST\\TFMAN\\source"), _L(""));
-	test(err == KErrNone);
+	test_KErrNone(err);
 	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\source\\*"));
 	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));
 	RmDir(_L("\\F32-TST\\TFMAN\\source\\"));
 	SetupDirectories(ETrue, NULL);
 	err=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\source\\"));
-	test(err == KErrNone);
+	test_KErrNone(err);
 	err = gFileMan->Rename(_L(""), _L("\\F32-TST\\TFMAN\\dest\\"));
-	test(err == KErrNone);
+	test_KErrNone(err);
 	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\*"));
 	err=TheFs.SetSessionPath(sessionPath);
-	test(err==KErrNone);
+	test_KErrNone(err);
 	TestINC109754(); // Test empty source directory should exist after contents being renamed
 	TestDEF092084(); // Test wildcards are replaced with letters from the matched file
 	TestDEF113299(); // Test invalid file rename
 	}
 	TUint setMask=KEntryAttReadOnly;
 	TUint clearMask=KEntryAttHidden|KEntryAttArchive;
 	if (!gAsynch)
 		{
 		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\ATTRIBS\\AT*.AT"),setMask,clearMask,TTime(0));
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	else
 		{
 		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\ATTRIBS\\AT*.AT"),setMask,clearMask,TTime(0),0,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForSuccess();
 		}
 	CDirScan* scan=CDirScan::NewL(TheFs);
 	scan->SetScanDataL(_L("\\F32-TST\\TFMAN\\ATTRIBS\\*"),KEntryAttMaskSupported,ESortByName);
 	CDir* entryList;
 	scan->NextL(entryList);
 	TInt count=entryList->Count();
-	test(count==2);
+	test_Equal(2, count);
 	TEntry entry=(*entryList)[0];
 	test(entry.iName.MatchF(_L("attrib1.AT"))!=KErrNotFound);
-	test(entry.iAtt==KEntryAttReadOnly);
+	test_Equal(KEntryAttReadOnly, entry.iAtt);
 	entry=(*entryList)[1];
 	test(entry.iName.MatchF(_L("attrib2.AT"))!=KErrNotFound);
-	test(entry.iAtt==KEntryAttReadOnly);
+	test_Equal(KEntryAttReadOnly, entry.iAtt);
 	delete entryList;
 	TDateTime dateTime(1990,ENovember,20,9,5,0,0);
 	TTime time(dateTime); // FAT loses microseconds if try to convert HomeTime()
 	if (!gAsynch)
 		{
 		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\ATTRIBS\\AT*.AT"),0,legalAttMask,time);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	else
 		{
 		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\ATTRIBS\\AT*.AT"),0,legalAttMask,time,0,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForSuccess();
 		}
 	scan->SetScanDataL(_L("\\F32-TST\\TFMAN\\ATTRIBS\\*"),KEntryAttMaskSupported,ESortByName);
 	scan->NextL(entryList);
 	count=entryList->Count();
-	test(count==2);
+	test_Equal(2, count);
 	entry=(*entryList)[0];
 	test(entry.iName.MatchF(_L("attrib1.AT"))!=KErrNotFound);
-	test(entry.iAtt==0);
+	test_Equal(0, entry.iAtt);
 	TDateTime dt=(entry.iModified).DateTime();
 	test(dt.Year()==dateTime.Year());
 	test(dt.Month()==dateTime.Month());
 	test(dt.Day()==dateTime.Day());
 	test(dt.Hour()==dateTime.Hour());
 	test(dt.Minute()==dateTime.Minute());
 	test(dt.Second()==dateTime.Second());
 	test(entry.iModified==time);
 	entry=(*entryList)[1];
 	test(entry.iName.MatchF(_L("attrib2.AT"))!=KErrNotFound);
-	test(entry.iAtt==0);
+	test_Equal(0, entry.iAtt);
 	test(entry.iModified==time);
 	delete entryList;
 	delete scan;
 	TestINC111038(); // Test example of incorrect attribute flushing
 		ret = TheFs.Replace(oldname, longname);
 		}
 	if(oldname.Length() >= KMaxFileName-5) // if not, it means that we won't be calling ShrinkNames !!
 		{
 		TInt r = gFileMan->Rename(_L("\\12345678\\Book\\12345678"),_L("\\INC091841\\Book\\012-235-abcd"),0);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		CDir* dir;
 		r = TheFs.GetDir(_L("\\INC091841\\Book\\012-235-abcd\\"), KEntryAttNormal, ESortNone, dir);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r = KErrNotFound;
 		TInt dirlen = sizeof("\\INC091841\\Book\\012-235-abcd\\");
 		for(TInt i=0; r==KErrNotFound && i<dir->Count(); i++)
 			{
 			if((*dir)[i].iName.Length() + dirlen > oldname.Length())
 				{
 				r = KErrNone;
 				}
 			}
 		delete dir;
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r = gFileMan->RmDir(_L("\\INC091841\\"));
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	RmDir(_L("\\12345678\\"));
 	}
 LOCAL_C void TestRmDir()
 		MakeDir(_L("\\LONGNAMETEST\\"));
 		MakeDir(_L("\\LONGNAMETEST\\DIRECTORY1DIRECTORY2DIRECTORY3DIRECTORY4\\"));
 		MakeFile(_L("\\LONGNAMETEST\\ELEPHANT01ELEPHANT02ELEPHANT03ELEPHANT04"));
 		MakeFile(_L("\\LONGNAMETEST\\FILEFILE01FILEFILE02FILEFILE03FILEFILE04"));
 		r=gFileMan->Rename(_L("\\LONGNAMETEST"),_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff"),CFileMan::EOverWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	//testing invalid source path at the beginning:
 	if (!gAsynch)
 		{
 	TestResult(r,KErrNone,KErrNone);
 	if (!gAsynch)
 		{
 		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\RMDIR\\*.AT"));
-		test(r==KErrNone);
+		test_KErrNone(r);
 			if (testingInvalidPathLengths)
 			{
 			r=gFileMan->RmDir(_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\"));
-			test(r==KErrNone);
+			test_KErrNone(r);
 			}
 		}
 	else
 		{
 		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\RMDIR\\*.AT"),gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForSuccess();
 		if (testingInvalidPathLengths)
 			{
 			r=gFileMan->RmDir(_L("\\asdffdsa01asdffdsa02asdffdsa03asdffdsa04asdffdsa05asdffdsa06asdffdsa07asdffdsa08asdffdsa09asdffdsa10asdffdsa11asdffdsa12asdffdsa13asdffdsa14asdffdsa15asdffdsa16asdffdsa17asdffdsa18asdffdsa19asdffdsa20asdffdsa21asdffdsa22asdff\\"),gStat);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			WaitForSuccess();
 			}
 		}
 	TEntry entry;
 	r=TheFs.Entry(_L("\\F32-TST\\TFMAN\\RMDIR"),entry);
-	test(r==KErrNotFound);
+	test_Equal(KErrNotFound, r);
 	MakeDir(_L("\\F32-TST\\TFMAN\\READONLY\\"));
 	r=TheFs.SetAtt(_L("\\F32-TST\\TFMAN\\READONLY\\"),KEntryAttReadOnly,0);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	if (!gAsynch)
 		{
 		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\READONLY\\"));
-		test(r==KErrAccessDenied);
+		test_Equal(KErrAccessDenied, r);
 		}
 	else
 		{
 		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\READONLY\\"),gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrAccessDenied);
 		}
 	r=TheFs.SetAtt(_L("\\F32-TST\\TFMAN\\READONLY\\"),0,KEntryAttReadOnly);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\READONLY\\"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	// Test behaviour for omitted parameters
 	// For this, default should be session path
 	TFileName sessionPath;
 	r=TheFs.SessionPath(sessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	SetupDirectories(ETrue, NULL);
 	r=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\source\\"));
 	// Default removal of session path
 	r=gFileMan->RmDir(_L(""));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.SetSessionPath(sessionPath);
 	r = gFileMan->Rename(_L("\\F32-TST\\TFMAN\\source\\subdir"), _L("\\F32-TST\\TFMAN\\source\\tofail"), CFileMan::ERecurse);
-	test(r == KErrPathNotFound);
+	test_Equal(KErrPathNotFound, r);
 	r = gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	MakeDir(_L("\\F32-TST\\TFMAN\\"));
 	if(testingInvalidPathLengths)
 		{
 		TestINC091841(); // Test delete long fullnames
 	MakeDir(_L("\\F32-TST\\TFMAN\\OPENFILE\\"));
 	MakeFile(_L("\\F32-TST\\TFMAN\\OPENFILE\\FILE.TXT"));
 	RFile file;
 	r = file.Open(TheFs,_L("\\F32-TST\\TFMAN\\OPENFILE\\FILE.TXT"), EFileRead | EFileShareExclusive);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	if (!gAsynch)
 		{
 		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\OPENFILE\\"));
-		test(r==KErrInUse);
+		test_Equal(KErrInUse, r);
 		file.Close();
 		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\OPENFILE\\"));
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	else
 		{
 		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\OPENFILE\\"), gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrInUse);
 		file.Close();
 		r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\OPENFILE\\"), gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrNone);
 		}
 	gFileMan->SetObserver(gObserver);
 	}
 	// Test behaviour for omitted parameters
 	// For this, default should be session path
 	TFileName sessionPath;
 	r=TheFs.SessionPath(sessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	RmDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
 	MakeDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
 	r=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
 	Compare(_L("\\F32-TST\\TFMAN\\DELDIR\\*"),_L("\\F32-TST\\TFMAN\\COPYDIR\\*"));
 	RmDir(_L("\\F32-TST\\TFMAN\\COPYDIR\\"));
 	RmDir(_L("\\F32-TST\\TFMAN\\DELDIR\\"));
 	r=TheFs.SetSessionPath(sessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	}
 LOCAL_C void TestRecursiveAttribs()
 //
 // Test set attribs recursively
 	MakeFile(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\SUBDIR\\ATFILE.TXT"));
 	if (!gAsynch)
 		{
 		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\"),KEntryAttReadOnly,0,TTime(0),CFileMan::ERecurse);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	else
 		{
 		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\"),KEntryAttReadOnly,0,TTime(0),CFileMan::ERecurse,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForSuccess();
 		}
 	CDir* entryList;
 	CDirScan* scan=CDirScan::NewL(TheFs);
 	scan->SetScanDataL(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\*"),KEntryAttMaskSupported,ESortByName);
 	scan->NextL(entryList);
 	TInt count=entryList->Count();
-	test(count==3);
+	test_Equal(3, count);
 	TEntry entry=(*entryList)[0];
 	test(entry.iName.MatchF(_L("ATTRIB1.AT"))!=KErrNotFound);
 	if (!IsTestingLFFS())
-		test(entry.iAtt==(KEntryAttReadOnly|KEntryAttArchive));
+		{
-	else
+		test_Equal((KEntryAttReadOnly|KEntryAttArchive), entry.iAtt);
+		}
+	else
+		{
 		test(entry.iAtt&KEntryAttReadOnly); // ???
+		}
 	entry=(*entryList)[1];
 	test(entry.iName.MatchF(_L("ATTRIB2.AT"))!=KErrNotFound);
 	if (!IsTestingLFFS())
-		test(entry.iAtt==(KEntryAttReadOnly|KEntryAttArchive));
+		{
-	else
+		test_Equal((KEntryAttReadOnly|KEntryAttArchive), entry.iAtt);
+		}
+	else
+		{
 		test(entry.iAtt&KEntryAttReadOnly); // ???
+		}
 	entry=(*entryList)[2];
 	test(entry.iName.MatchF(_L("SUBDIR"))!=KErrNotFound);
 	delete entryList;
 	scan->NextL(entryList);
 	count=entryList->Count();
-	test(count==1);
+	test_Equal(1, count);
 	entry=(*entryList)[0];
 	test(entry.iName.MatchF(_L("ATFILE.TXT"))!=KErrNotFound);
 	if (!IsTestingLFFS())
-		test(entry.iAtt==(KEntryAttReadOnly|KEntryAttArchive));
+		{
-	else
+		test_Equal((KEntryAttReadOnly|KEntryAttArchive), entry.iAtt);
+		}
+	else
+		{
 		test(entry.iAtt&KEntryAttReadOnly); // ???
+		}
 	delete entryList;
 	scan->NextL(entryList);
 	test(entryList==NULL);
 	if (!gAsynch)
 		{
 		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\"),0,KEntryAttReadOnly|KEntryAttArchive,TTime(0),CFileMan::ERecurse);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	else
 		{
 		TInt r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\"),0,KEntryAttReadOnly|KEntryAttArchive,TTime(0),CFileMan::ERecurse,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForSuccess();
 		}
 	scan->SetScanDataL(_L("\\F32-TST\\TFMAN\\RECATTRIBS\\*"),KEntryAttMaskSupported,ESortByName);
 	scan->NextL(entryList);
 	count=entryList->Count();
-	test(count==3);
+	test_Equal(3, count);
 	entry=(*entryList)[0];
 	test(entry.iName.MatchF(_L("ATTRIB1.AT"))!=KErrNotFound);
-	test(entry.iAtt==KEntryAttNormal);
+	test_Equal(KEntryAttNormal, entry.iAtt);
 	entry=(*entryList)[1];
 	test(entry.iName.MatchF(_L("ATTRIB2.AT"))!=KErrNotFound);
-	test(entry.iAtt==KEntryAttNormal);
+	test_Equal(KEntryAttNormal, entry.iAtt);
 	entry=(*entryList)[2];
 	test(entry.iName.MatchF(_L("SUBDIR"))!=KErrNotFound);
 	delete entryList;
 	scan->NextL(entryList);
 	count=entryList->Count();
-	test(count==1);
+	test_Equal(1, count);
 	entry=(*entryList)[0];
 	test(entry.iName.MatchF(_L("ATFILE.TXT"))!=KErrNotFound);
-	test(entry.iAtt==KEntryAttNormal);
+	test_Equal(KEntryAttNormal, entry.iAtt);
 	delete entryList;
 	scan->NextL(entryList);
 	test(entryList==NULL);
 	delete scan;
 	MakeFile(_L("\\F32-TST\\TFMAN\\RECDELETE\\FILE1.TXT"));
 	if (!gAsynch)
 		{
 		TInt r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\RECDELETE\\*.PLP"),CFileMan::ERecurse);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	else
 		{
 		TInt r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\RECDELETE\\*.PLP"),CFileMan::ERecurse,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForSuccess();
 		}
 	RmDir(_L("\\F32-TST\\TFMAN\\after\\"));
 	MakeFile(_L("\\F32-TST\\TFMAN\\AFTER\\FULL\\GRAPE.TXT"));
 		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), 0);
 	else // Asynchronously
 		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), 0, gStat);
 	test.Next(_L("Test INC108401 : SAME DRIVE with 0"));
 	TestResult(err);
-	// test(err==KErrNone);
+	// test_KErrNone(err);
 	RmDir(_L("\\F32-TST\\TFMAN\\INC108401\\"));
 	// case for gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), CFileMan::EOverWrite);
 	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\subDirC\\"));
 	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\dest\\"));
 		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), CFileMan::EOverWrite);
 	else // Asynchronously
 		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), CFileMan::EOverWrite, gStat);
 	test.Next(_L("Test INC108401 : SAME DRIVE with CFileMan::EOverWrite"));
 	TestResult(err);
-	// test(err==KErrNone);
+	// test_KErrNone(err);
 	RmDir(_L("\\F32-TST\\TFMAN\\INC108401\\"));
 	// case for gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), CFileMan::EOverWrite|CFileMan::ERecurse);
 	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\src\\subDirA\\subDirB\\subDirC\\"));
 	MakeDir(_L("\\F32-TST\\TFMAN\\INC108401\\dest\\"));
 		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), CFileMan::ERecurse|CFileMan::EOverWrite);
 	else // Asynchronously
 		err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\INC108401\\src"), _L("\\F32-TST\\TFMAN\\INC108401\\dest\\"), CFileMan::ERecurse|CFileMan::EOverWrite, gStat);
 	test.Next(_L("Test INC108401 : SAME DRIVES with CFileMan::ERecurse|CFileMan::EOverWrite"));
 	TestResult(err);
-	// test(err==KErrNone);
+	// test_KErrNone(err);
 	RmDir(_L("\\F32-TST\\TFMAN\\INC108401\\"));
 	// cleanup for the current drive
 	RmDir(trgPath);
 	RmDir(_L("\\F32-TST\\"));
 	MakeFile(_L("\\INC089638\\source\\subdir1\\file3"));
 	MakeFile(_L("\\INC089638\\source\\subdir1\\file4"));
 	MakeFile(_L("\\INC089638\\source\\subdir2\\file5"));
 	MakeFile(_L("\\INC089638\\source\\subdir2\\file6"));
 	MakeDir(_L("\\INC089638\\dest\\"));
-	test(TheFs.SetAtt(_L("\\INC089638\\source\\subdir1"), KEntryAttHidden, 0) == KErrNone);
+	test_KErrNone(TheFs.SetAtt(_L("\\INC089638\\source\\subdir1"), KEntryAttHidden, 0));
-	test(TheFs.SetAtt(_L("\\INC089638\\source\\subdir2"), KEntryAttReadOnly, 0) == KErrNone);
+	test_KErrNone(TheFs.SetAtt(_L("\\INC089638\\source\\subdir2"), KEntryAttReadOnly, 0));
 	TInt r = gFileMan->Move(_L("\\INC089638\\source\\"), _L("\\INC089638\\dest\\"), CFileMan::ERecurse);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r = TheFs.RmDir(_L("\\INC089638\\source\\"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	RmDir(_L("\\INC089638\\"));
 }
 void TestINC101379()
 	gFileMan->SetObserver(NULL);
 	if (!gAsynch)
 		err = gFileMan->Move(KSourceDir, dest, CFileMan::ERecurse|CFileMan::EOverWrite);
 	else
 		err = gFileMan->Move(KSourceDir, dest, CFileMan::ERecurse|CFileMan::EOverWrite, gStat);
-	test(err==KErrInUse); // Recursive move prohibited
+	test_Equal(KErrInUse, err); // Recursive move prohibited
 	if (gAsynch)
 		WaitForResult(KErrInUse);
 	CheckFileContents(KFile1, _L8("qwerty"));
 	CheckFileContents(KFile2, _L8("abc"));
 	CheckFileContents(KFile3, _L8("qwerty"));
 	dst.Append(_L("ahsx\\"));
 	MakeDir(dst);
 	TEntry entry;
 	r = gFileMan->Move(src, KDest, 0); // ahsx\ah
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = TheFs.Entry(src, entry);
-	test(r == KErrNotFound);
+	test_Equal(KErrNotFound, r);
 	src.SetLength(src.Length()-1); // ahsx\a
 	r = gFileMan->Move(src, KDest, 0);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = TheFs.Entry(src, entry);
-	test(r == KErrNotFound);
+	test_Equal(KErrNotFound, r);
 	src.SetLength(src.Length()-3); // ahs
 	r = gFileMan->Move(src, KDest, 0);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = TheFs.Entry(src, entry);
-	test(r == KErrNotFound);
+	test_Equal(KErrNotFound, r);
 	src.SetLength(src.Length()-1); // ah
 	r = gFileMan->Move(src, KDest, 0);
-	test(r == KErrAlreadyExists);
+	test_Equal(KErrAlreadyExists, r);
 	r = TheFs.Entry(src, entry);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = gFileMan->Move(src, KDest, CFileMan::EOverWrite); // ah
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = TheFs.Entry(src, entry);
-	test(r == KErrNotFound);
+	test_Equal(KErrNotFound, r);
 	src.SetLength(src.Length()-1); // a
 	r = gFileMan->Move(src, KDest, 0);
-	test(r == KErrAlreadyExists);
+	test_Equal(KErrAlreadyExists, r);
 	r = TheFs.Entry(src, entry);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = gFileMan->Move(src, KDest, CFileMan::EOverWrite); // a
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = TheFs.Entry(src, entry);
-	test(r == KErrNotFound);
+	test_Equal(KErrNotFound, r);
 	RmDir(source);
 	RmDir(KDest);
 	}
 	test.Next(_L("Test moving empty directories"));
 	SetupDirectories(EFalse, NULL);
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse);
-	test(err == KErrNotFound);	// Expected - directory is empty
+	test_Equal(KErrNotFound, err);	// Expected - directory is empty
 	// Test that all directories are still present
 	TEntry entry;
 	err = TheFs.Entry(_L("\\F32-TST\\TFMAN\\source\\"), entry);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	err = TheFs.Entry(_L("\\F32-TST\\TFMAN\\dest\\"), entry);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	SetupDirectories(EFalse, NULL);
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source"), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse);
-	test(err == KErrNone);		// Expected - should move (or rename) directory
+	test_KErrNone(err);		// Expected - should move (or rename) directory
 	// Test directory has been moved
 	err = TheFs.Entry(_L("\\F32-TST\\TFMAN\\dest\\source\\"), entry);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	err = TheFs.Entry(_L("\\F32-TST\\TFMAN\\source\\"), entry);
-	test(err == KErrNotFound);
+	test_Equal(KErrNotFound, err);
 	RmDir(_L("\\F32-TST\\TFMAN\\dest\\source\\"));
 	//
 	// Test moving when the source directory contains subdirectories (INC074828, INC078800)
 	//
 	test.Next(_L("Test moving a directory containing subdirectories"));
 	SetupDirectories(ETrue, NULL);
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse | CFileMan::EOverWrite);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\*"));
 	//---------------------------------------------
 	//! @SYMTestCaseID			PBASE-T_FMAN-0160
 	SetupDirectories(ETrue, NULL);
 	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\*"));
 	SetupDirectories(ETrue, NULL);
 	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), _L("\\F32-TST\\TFMAN\\dest"), CFileMan::ERecurse);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\*"));
 	SetupDirectories(ETrue, NULL);
 	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source"), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	MakeDir(_L("\\F32-TST\\TFMAN\\compare\\subdir\\"));
 	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\source\\*"));
 	RmDir(_L("\\F32-TST\\TFMAN\\compare\\subdir\\"));
 	SetupDirectories(ETrue, NULL);
 	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\File1.TXT"), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	CheckFileExists(_L("\\F32-TST\\TFMAN\\source\\File1.TXT"), KErrNotFound, ETrue);
 	CheckFileExists(_L("\\F32-TST\\TFMAN\\dest\\File1.TXT"),   KErrNone,     ETrue);
 	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));
 	// Test behaviour for omitted parameters
 	// For this, default should be session path
 	TFileName sessionPath;
 	err=TheFs.SessionPath(sessionPath);
-	test(err==KErrNone);
+	test_KErrNone(err);
 	SetupDirectories(ETrue, NULL);
 	err=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\dest\\"));
-	test(err == KErrNone);
+	test_KErrNone(err);
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source"), _L(""), CFileMan::ERecurse);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\source\\*"));
 	RmDir(_L("\\F32-TST\\TFMAN\\dest\\"));
 	RmDir(_L("\\F32-TST\\TFMAN\\source\\"));
 	SetupDirectories(ETrue, NULL);
 	err=TheFs.SetSessionPath(_L("\\F32-TST\\TFMAN\\source\\"));
-	test(err == KErrNone);
+	test_KErrNone(err);
 	err = gFileMan->Move(_L(""), _L("\\F32-TST\\TFMAN\\dest\\"), CFileMan::ERecurse);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), _L("\\F32-TST\\TFMAN\\dest\\*"));
 	err=TheFs.SetSessionPath(sessionPath);
-	test(err==KErrNone);
+	test_KErrNone(err);
 	//---------------------------------------------
 	//! @SYMTestCaseID			PBASE-T_FMAN-0520
 	//! @SYMTestType			UT
 	//! @SYMREQ					INC106735
 	TFileName destOtherDrive;
 	SetupDirectories(EFalse, &destOtherDrive);
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), destOtherDrive, CFileMan::ERecurse);
-	test(err == KErrNotFound);	// Expected - directory is empty
+	test_Equal(KErrNotFound, err);	// Expected - directory is empty
 	// Test that all directories are still present
 	TEntry entry;
 	err = TheFs.Entry(_L("\\F32-TST\\TFMAN\\source\\"), entry);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	err = TheFs.Entry(destOtherDrive, entry);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	//---------------------------------------------
 	//! @SYMTestCaseID			PBASE-T_FMAN-0571
 	//! @SYMTestType			UT
 	//! @SYMREQ					INC108401
 	//
 	test.Next(_L("Test moving a directory containing subdirectories"));
 	SetupDirectories(ETrue, &destOtherDrive);
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), destOtherDrive, CFileMan::ERecurse | CFileMan::EOverWrite);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	destOtherDrive.Append(_L("*"));
 	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), destOtherDrive);
 	//---------------------------------------------
 	SetupDirectories(ETrue, &destOtherDrive);
 	RmDir(destOtherDrive);
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\"), destOtherDrive, CFileMan::ERecurse);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), destOtherDrive);
 	SetupDirectories(ETrue, &destOtherDrive);
 	RmDir(destOtherDrive);
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source"), destOtherDrive, CFileMan::ERecurse);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	MakeDir(_L("\\F32-TST\\TFMAN\\compare\\subdir\\"));
 	destOtherDrive.Append(_L("source\\"));
 	Compare(_L("\\F32-TST\\TFMAN\\compare\\*"), destOtherDrive);
 	RmDir(_L("\\F32-TST\\TFMAN\\compare\\subdir\\"));
 	SetupDirectories(ETrue, &destOtherDrive);
 	RmDir(destOtherDrive);
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\source\\File1.TXT"), destOtherDrive, CFileMan::ERecurse);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	CheckFileExists(_L("\\F32-TST\\TFMAN\\source\\File1.TXT"), KErrNotFound, ETrue);
 	destOtherDrive.Append(_L("File1.TXT"));
 	CheckFileExists(destOtherDrive, KErrNone, ETrue);
 	// Set up the test directory
 	TInt level = 0;
 	for(level=0; level < KNumFiles; level++)
 		{
 		err = TheFs.MkDirAll(complexFile[level]);
-		test(err == KErrNone || err == KErrAlreadyExists);
+		test_Value(err, err == KErrNone || err == KErrAlreadyExists);
 		RFile file;
 		err = file.Create(TheFs, complexFile[level], EFileRead | EFileWrite);
-		test(err == KErrNone || err == KErrAlreadyExists || err == KErrBadName);
+		test_Value(err, err == KErrNone || err == KErrAlreadyExists || err == KErrBadName);
 		file.Close();
 		}
 	//
 	// Move directory 'dir1' into 'dir12' *without* overwrite flag set
 	//  - This should fail, as 'dir12' already contains a directory called 'dir1'
 	//  - No directories should be modified
 	//
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\complex\\dir1"), _L("\\F32-TST\\TFMAN\\complex\\dir12\\"), CFileMan::ERecurse);
-	test(err == KErrAlreadyExists);
+	test_Equal(KErrAlreadyExists, err);
 	for(level=0; level < KNumFilesResult1; level++)
 		{
 		err = TheFs.MkDirAll(complexResult1[level]);
-		test(err == KErrNone || err == KErrAlreadyExists);
+		test_Value(err, err == KErrNone || err == KErrAlreadyExists);
 		RFile file;
 		err = file.Create(TheFs, complexResult1[level], EFileRead | EFileWrite);
-		test(err == KErrNone || err == KErrAlreadyExists || err == KErrBadName);
+		test_Value(err, err == KErrNone || err == KErrAlreadyExists || err == KErrBadName);
 		file.Close();
 		}
 	Compare(_L("\\F32-TST\\TFMAN\\complex_result1\\*"), _L("\\F32-TST\\TFMAN\\complex\\*"));
 	//
 	// Move directory 'dir1' into 'dir12' *with* overwrite flag set
 	//
 	err = gFileMan->Move(_L("\\F32-TST\\TFMAN\\complex\\dir1"), _L("\\F32-TST\\TFMAN\\complex\\dir12\\"), CFileMan::ERecurse | CFileMan::EOverWrite);
-	test(err == KErrNone);
+	test_KErrNone(err);
 	for(level=0; level < KNumFilesResult2; level++)
 		{
 		err = TheFs.MkDirAll(complexResult2[level]);
-		test(err == KErrNone || err == KErrAlreadyExists);
+		test_Value(err, err == KErrNone || err == KErrAlreadyExists);
 		RFile file;
 		err = file.Create(TheFs, complexResult2[level], EFileRead | EFileWrite);
-		test(err == KErrNone || err == KErrAlreadyExists || err == KErrBadName);
+		test_Value(err, err == KErrNone || err == KErrAlreadyExists || err == KErrBadName);
 		file.Close();
 		}
 	Compare(_L("\\F32-TST\\TFMAN\\complex_result2\\*"), _L("\\F32-TST\\TFMAN\\complex\\*"));
 //
 	{
 	TInt lastError=iFileMan->GetLastError();
 	if (lastError!=KErrNone)
 		{
-		test(lastError==KErrAlreadyExists);
+		test_Equal(KErrAlreadyExists, lastError);
 		if (gAsynch==EFalse)
 			{
 			TFileName fileName=iFileMan->CurrentEntry().iName;
 			test.Printf(_L("     %S already exists\n"),&fileName);
 			}
 	MakeFile(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC\\FILE2.TXT"),contentsFile2);
 	if (!gAsynch)
 		{
 		TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG"),0);
-		test(r==KErrAlreadyExists);
+		test_Equal(KErrAlreadyExists, r);
 		}
 	else
 		{
 		TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG"),0,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrAlreadyExists);
 		}
 	RFile f;
 	TInt r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE1.TXT"),EFileRead);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	TBuf8<128> data;
 	r=f.Read(data);
-	test(r==KErrNone);
+	test_KErrNone(r);
-	test(data.Length()==0);
+	test_Equal(0, data.Length());
 	f.Close();
 	if (!gAsynch)
 		{
 		TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG"),CFileMan::EOverWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	else
 		{
 		TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG"),CFileMan::EOverWrite,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForSuccess();
 		}
 	r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE1.TXT"),EFileRead);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=f.Read(data);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(data==contentsFile1);
 	f.Close();
 	RmDir(_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\"));
 	MakeFile(_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE1.TXT"));
 	MakeFile(_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE2.TXT"));
 	if (!gAsynch)
 		{
 	TInt r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC\\*"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\*"),0);
-		test(r==KErrAlreadyExists);
+		test_Equal(KErrAlreadyExists, r);
 		}
 	else
 		{
 		TInt r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC\\*"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\*"),0,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrAlreadyExists);
 		}
 	r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE2.TXT"),EFileRead);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=f.Read(data);
-	test(r==KErrNone);
+	test_KErrNone(r);
-	test(data.Length()==0);
+	test_Equal(0, data.Length());
 	f.Close();
 	if (!gAsynch)
 		{
 		TInt r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC\\*"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\*"),CFileMan::EOverWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	else
 		{
 		TInt r=gFileMan->Rename(_L("\\F32-TST\\TFMAN\\OVERWRITE\\SRC\\*"),_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\*"),CFileMan::EOverWrite,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForSuccess();
 		}
 	r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\OVERWRITE\\TRG\\FILE2.TXT"),EFileRead);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=f.Read(data);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(data==contentsFile2);
 	f.Close();
 	gFileMan->SetObserver(gObserver);
 	CleanupStack::PopAndDestroy();
 	}
 	{
 	test.Next(_L("Test error handling"));
 	if (!gAsynch)
 		{
 		TInt r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\BADPATH\\*"));
-		test(r==KErrPathNotFound);
+		test_Equal(KErrPathNotFound, r);
 		}
 	else
 		{
 		TInt r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\BADPATH\\*"),0,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrPathNotFound);
 		}
 	CFileMan* fMan=CFileMan::NewL(TheFs);
 	TInt r;
 			// found a non-extant drive, test it...
 			_LIT(KBad,"?:\\BADPATH\\*");
 			TBuf<16> bad(KBad);
 			bad[0] = TUint16('A'+drvNum);
 			TInt r=fMan->Delete(bad);
-			test(r==KErrNotReady);
+			test_Equal(KErrNotReady, r);
 			break;
 			}
 		}
 	}
 	delete fMan;
 	test.Next(_L("Test cyclic copy"));
 	if (!gAsynch)
 		r=gFileMan->Copy(_L("\\ONE\\TWO\\*"),_L("\\ONE\\TWO\\THREE\\"),CFileMan::ERecurse);
 	else
 		r=gFileMan->Copy(_L("\\ONE\\TWO\\*"),_L("\\ONE\\TWO\\THREE\\"),CFileMan::ERecurse,gStat);
-	test(r==KErrArgument);
+	test_Equal(KErrArgument, r);
 	test.Next(_L("Test src name == trg name"));
 	if (!gAsynch)
 		{
 		r=gFileMan->Copy(_L("\\ONE\\TWO\\FOUR"),_L("\\ONE\\TWO\\FOUR")); // default aSwitch=EOverWrite
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=gFileMan->Copy(_L("\\ONE\\TWO\\FOUR"),_L("\\ONE\\TWO\\FOUR"), 0);
-		test(r==KErrAlreadyExists);
+		test_Equal(KErrAlreadyExists, r);
 		r=gFileMan->Copy(_L("\\ONE\\TWO\\FOUR"),_L("\\ONE\\TWO\\FOUR"),CFileMan::ERecurse);
-		test(r==KErrAlreadyExists);
+		test_Equal(KErrAlreadyExists, r);
 		r=gFileMan->Copy(_L("\\ONE\\TWO\\F*R"),_L("\\ONE\\TWO\\FOUR"),CFileMan::ERecurse);
-		test(r==KErrAlreadyExists);
+		test_Equal(KErrAlreadyExists, r);
 		}
 	else
 		{
 		r=gFileMan->Copy(_L("\\ONE\\TWO\\*.TXT"),_L("\\ONE\\TWO\\*.TXT"),0,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrAlreadyExists);
 		r=gFileMan->Copy(_L("\\ONE\\TWO\\FOUR"),_L("\\ONE\\TWO\\F*R"),CFileMan::ERecurse,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
-		WaitForResult(KErrNone);
+WaitForResult(KErrNone);
 		}
 	RmDir(_L("\\ONE\\"));
 	test.Next(_L("Test copy missing source and path"));
 	if (!gAsynch)
 		{
 		r=gFileMan->Copy(_L("\\ONE\\TWO\\XXXYYY"),_L("\\ONE\\TWO\\asdfsadf"));
-		test(r==KErrPathNotFound);
+		test_Equal(KErrPathNotFound, r);
 		r=gFileMan->Copy(_L("\\ONE\\TWO\\XXXYYY"),_L("\\ONE\\TWO\\asdfsadf"),CFileMan::ERecurse);
-		test(r==KErrPathNotFound);
+		test_Equal(KErrPathNotFound, r);
 		}
 	else
 		{
 		r=gFileMan->Copy(_L("\\ONE\\TWO\\*.TXT"),_L("\\ONE\\TWO\\*.YYY"),0,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrPathNotFound);
 		r=gFileMan->Copy(_L("\\ONE\\TWO\\XXXYYY"),_L("\\ONE\\TWO\\asdfsadf"),CFileMan::ERecurse,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrPathNotFound);
 		}
 	test.Next(_L("Test copy missing source"));
 	if (!gAsynch)
 		{
 		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\*.LPQ"),_L("\\ONE\\TWO\\*.YYY"));
-		test(r==KErrNotFound);
+		test_Equal(KErrNotFound, r);
 		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\XXXYYY"),_L("\\ONE\\TWO\\asdfsadf"),CFileMan::ERecurse);
-		test(r==KErrNotFound);
+		test_Equal(KErrNotFound, r);
 		}
 	else
 		{
 		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\XXXYYY"),_L("\\ONE\\TWO\\asdfsadf"),0,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrNotFound);
 		r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\XXXYYY"),_L("\\ONE\\TWO\\asdfsadf"),CFileMan::ERecurse,gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrNotFound);
 		}
 	RmDir(_L("\\EMPTYSRC\\"));
 	MakeDir(_L("\\EMPTYSRC\\"));
 	MakeDir(_L("\\EMPTYTRG\\"));
 	test.Next(_L("Test copy empty source directory"));
 	if (!gAsynch)
 		{
 		r=gFileMan->Copy(_L("\\EMPTYSRC\\"),_L("\\EMPTYTRG\\"));
-		test(r==KErrNotFound);
+		test_Equal(KErrNotFound, r);
 		r=gFileMan->Copy(_L("\\EMPTYSRC\\"),_L("\\EMPTYTRG\\"), CFileMan::ERecurse);
-		test(r==KErrNotFound);
+		test_Equal(KErrNotFound, r);
 		r=gFileMan->Copy(_L("\\EMPTYSRC"),_L("\\EMPTYTRG\\"));
-		test(r==KErrNotFound);
+		test_Equal(KErrNotFound, r);
 		r=gFileMan->Copy(_L("\\EMPTYSRC"),_L("\\EMPTYTRG\\"), CFileMan::ERecurse);
-		test(r==KErrNotFound);
+		test_Equal(KErrNotFound, r);
 		}
 	else
 		{
 		r=gFileMan->Copy(_L("\\EMPTYSRC\\"),_L("\\EMPTYTRG\\"), 0, gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrNotFound);
 		r=gFileMan->Copy(_L("\\EMPTYSRC\\"),_L("\\EMPTYTRG\\"), CFileMan::ERecurse, gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrNotFound);
 		r=gFileMan->Copy(_L("\\EMPTYSRC"),_L("\\EMPTYTRG\\"), 0, gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrNotFound);
 		r=gFileMan->Copy(_L("\\EMPTYSRC"),_L("\\EMPTYTRG\\"), CFileMan::ERecurse, gStat);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		WaitForResult(KErrNotFound);
 		}
 	RmDir(_L("\\EMPTYSRC\\"));
 	RmDir(_L("\\EMPTYTRG\\"));
 	MakeFile(_L("Dummyfile"));
 	test.Next(_L("Test illegal names"));
 	r=gFileMan->Attribs(_L(":C:"),0,0,TTime(0),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Copy(_L(":C:"),_L("newname"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Copy(_L("Dummyfile"),_L(":C:"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Delete(_L(":C:"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Move(_L(":C:"),_L("newname"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Move(_L("dummyFile"),_L(":C:"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Rename(_L(":C:"),_L("newname"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Rename(_L("DummyFile"),_L(":C:"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->RmDir(_L("\\:C:\\"));
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Attribs(_L("::C:"),0,0,TTime(0),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Copy(_L("::C:"),_L("newname"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Copy(_L("Dummyfile"),_L("::C:"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Delete(_L("::C:"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Move(_L("::C:"),_L("newname"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Move(_L("dummyFile"),_L("::C:"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Rename(_L("::C:"),_L("newname"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->Rename(_L("DummyFile"),_L("::C:"),0);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=gFileMan->RmDir(_L("::C:"));
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=TheFs.Delete(_L("DummyFile"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	// test copying two files with identical names that do not exist
 	_LIT(KNonExistent,"\\azzzz.txt");
 	r=gFileMan->Copy(KNonExistent,KNonExistent,0);
-	test(r==KErrNotFound);
+	test_Equal(KErrNotFound, r);
 	}
 LOCAL_C void TestNameMangling()
 //
 // Synchronous test of name mangling
 	MakeFile(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\zyx.abcdefghijk.def"));
 	MakeFile(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\zyx.abc.defgh"));
 	MakeFile(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\zyx.abcdefghijk.defgh"));
 	TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\*.*"),_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\TRG\\*.*"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	Compare(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\SRC\\*"),_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\TRG\\*"));
 	r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\NAMEMANGLER\\TRG\\*.*"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	}
 LOCAL_C void TestLongNames()
 //
 // Synchronous test of name mangling
 	longFileNameA.Fill('A',longFileLength);
 	TFileName longRootDirNameA=_L("\\");
 	longRootDirNameA+=longFileNameA;
 	longRootDirNameA+=_L("\\");
 	TInt r=TheFs.MkDir(longRootDirNameA);
-	test(r==KErrNone || r==KErrAlreadyExists);
+	test_Value(r, r==KErrNone || r==KErrAlreadyExists);
 	// Second folder
 	TFileName longFileNameB;
 	longFileNameB.SetLength(longFileLength);
 	longFileNameB.Fill('B',longFileLength);
 	TFileName longRootDirNameB=_L("\\");
 	longRootDirNameB+=longFileNameB;
 	longRootDirNameB+=_L("\\");
 	r=TheFs.MkDir(longRootDirNameB);
-	test(r==KErrNone || r==KErrAlreadyExists);
+	test_Value(r, r==KErrNone || r==KErrAlreadyExists);
 	TInt longFilePtrLength = KMaxFileName-3; // We do not want the trailing backslash
 	TPtrC ptrLongFileA(longRootDirNameA.Ptr(),longFilePtrLength);
 	TPtrC ptrLongFileB(longRootDirNameB.Ptr(),longFilePtrLength);
 	// TInt CFileMan::Move(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);
 	// Tries to move a folder with a long name into another
 	// This test will return KErrGeneral because the new path will exceed the maximum length
 	// See KMaxFileName
 	r=gFileMan->Move(ptrLongFileA,ptrLongFileB);
-	test(r==KErrGeneral);
+	test_Equal(KErrGeneral, r);
 	r=gFileMan->RmDir(longRootDirNameA);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=gFileMan->Rename(ptrLongFileB,ptrLongFileA);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=gFileMan->RmDir(longRootDirNameB);
-	test(r==KErrPathNotFound);
+	test_Equal(KErrPathNotFound, r);
 	r=gFileMan->RmDir(longRootDirNameA);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	TFileName longSubDirName=_L("\\Files\\");
 	TPtrC longSubDirFileName(longFileNameA.Ptr(),longFilePtrLength-longSubDirName.Length());
 	longSubDirName+=longSubDirFileName;
 	longSubDirName+=_L("\\");
 	r=TheFs.MkDirAll(longSubDirName);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	CDir* dirList;
 	r=TheFs.GetDir(longSubDirName,KEntryAttMaskSupported,0,dirList);
-	test(r==KErrNone);
+	test_KErrNone(r);
-	test(dirList->Count()==0);
+	test_Equal(0, dirList->Count());
 	delete dirList;
 	TPtrC ptrLongSubDirSrc(longSubDirName.Ptr(),longSubDirName.Length()-1);
 	TPtrC ptrLongSubDirTrg(longRootDirNameA.Ptr(),longRootDirNameA.Length()-1);
 	r=gFileMan->Copy(ptrLongSubDirSrc,ptrLongSubDirTrg);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.MkDir(longRootDirNameB);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=gFileMan->Move(ptrLongSubDirSrc,longRootDirNameB);
-	test(r==KErrBadName);
+	test_Equal(KErrBadName, r);
 	r=TheFs.RmDir(longRootDirNameB);
-	test(r==KErrNone);
+	test_KErrNone(r);
-	test(TheFs.RmDir(longSubDirName) == KErrNone);
+	test_KErrNone(TheFs.RmDir(longSubDirName));
-	test(TheFs.RmDir(_L("\\Files\\")) == KErrNone);
+	test_KErrNone(TheFs.RmDir(_L("\\Files\\")));
 	gFileMan->SetObserver(gObserver);
 	}
 LOCAL_C void TestFileAttributes()
 //
 	MakeFile(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\readonlyhidden.def"),KEntryAttReadOnly|KEntryAttHidden);
 	MakeFile(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\hiddensystem.def"),KEntryAttHidden|KEntryAttSystem);
 	MakeFile(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\systemarchive.def"),KEntryAttArchive|KEntryAttSystem);
 	TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\*.*"),_L("\\F32-TST\\TFMAN\\FILEATT\\TRG\\*.*"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	Compare(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\*.*"),_L("\\F32-TST\\TFMAN\\FILEATT\\TRG\\*"));
 	r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\FILEATT\\SRC\\*"),0,KEntryAttReadOnly,TTime(0));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=gFileMan->Attribs(_L("\\F32-TST\\TFMAN\\FILEATT\\TRG\\*"),0,KEntryAttReadOnly,TTime(0));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\FILEATT\\"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	}
 class CFileManObserverContinue : public CBase, public MFileManObserver
 	{
 public:
 	bufPtr.Set((TUint8*)contents.Ptr(),contents.Size());
 	MakeFile(_L("\\F32-TST\\TFMAN\\FILECOPY\\asdf.asdf"),bufPtr);
 	RFile f;
 	TInt r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\FILECOPY\\asdf.asdf"),EFileRead|EFileShareReadersOnly);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\FILECOPY\\asdf.asdf"),_L("\\F32-TST\\TFMAN\\FILECOPY\\xxxx.xxxx"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	f.Close();
 	r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\FILECOPY\\xxxx.xxxx"),EFileRead);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	TBuf8<256*sizeof(TText)> temp;
 	r=f.Read(temp);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(temp==bufPtr);
 	r=f.Read(temp);
-	test(r==KErrNone);
+	test_KErrNone(r);
-	test(temp.Length()==0);
+	test_Equal(0, temp.Length());
 	f.Close();
 	r=f.Open(TheFs,_L("\\F32-TST\\TFMAN\\FILECOPY\\asdf.asdf"),EFileRead);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\FILECOPY\\asdf.asdf"),_L("\\F32-TST\\TFMAN\\FILECOPY\\xxxx.xxxx"));
-	test(r==KErrInUse);
+	test_Equal(KErrInUse, r);
 	f.Close();
 	gFileMan->SetObserver(gObserver);
 	r=gFileMan->RmDir(_L("\\F32-TST\\TFMAN\\FILECOPY\\"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	delete fManObserver;
 	}
 void TestINC101844()
 	{
 	src.Append(_L("subdir1"));
 	TheFs.SetAtt(src, KEntryAttSystem | KEntryAttHidden, KEntryAttArchive);
 	// Move directory containing files and subdirs with different attributes
 	r = gFileMan->Move(source, KDest, 0);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	// Check that the files and subdirs have moved and have the correct attributes
 	TEntry entry;
 	src = KDest;
 	src.Append(_L("file1"));
 	r = TheFs.Entry(src, entry);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test(entry.iAtt&KEntryAttReadOnly);
 	src = KDest;
 	src.Append(_L("file2"));
 	r = TheFs.Entry(src, entry);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test(entry.iAtt&KEntryAttHidden);
 	src = KDest;
 	src.Append(_L("file3"));
 	r = TheFs.Entry(src, entry);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test(entry.iAtt&KEntryAttSystem);
 	src = source;
 	src.Append(_L("subdir1\\"));
 	r = gFileMan->Move(src, source, 0);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = TheFs.RmDir(src);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	src = source;
 	src.Append(_L("file4"));
 	r = TheFs.Delete(src);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r = TheFs.RmDir(source);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	RmDir(KDest);
 	}
 LOCAL_C void TestMoveAcrossDrives()
 //
 	CheckFileExists(_L("C:\\F32-TST\\TFMAN\\DRIVEMOVE\\Sketch"),KErrPathNotFound);
 	// Check Sketch exists on target drive
 	CheckFileExists(trgDirFile,KErrNone);
 	RmDir(trgDir);
-	test(TheFs.Delete(trgFile) == KErrNone);
+	test_KErrNone(TheFs.Delete(trgFile));
 	TestINC101844(); // Test move files and subdirs with different attributes
 	}
 class CFileManObserverCopyAbort : public CBase, public MFileManObserver
 //
 // Observer for testoverwrite tests
 //
 	{
 	TInt lastError = iFileMan->GetLastError();
-	test(lastError == KErrNone);
+	test_KErrNone(lastError);
 	TFileName srcfile;
 	iFileMan->GetCurrentSource(srcfile);
 	TInt action = iFileMan->CurrentAction();
-	test(action == CFileMan::EMove   ||
+	test_Value(action,  action == CFileMan::EMove   ||
-		 action == CFileMan::EDelete ||
+action == CFileMan::EDelete ||
-		 action == CFileMan::ERmDir);
+action == CFileMan::ERmDir);
 	iCurrentStep--;
 	return(iCurrentStep ? MFileManObserver::EContinue : MFileManObserver::EAbort);
 	}
 	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\TWO.TXT"));
 	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\TWO.GOD"));
 	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\TWO.BAD"));
 	TInt r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\TWO.*"), _L("\\F32-TST\\TFMAN\\THREE.*"), CFileMan::ERecurse);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE.TXT"), KErrNone);
 	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE.GOD"), KErrNone);
 	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE.BAD"), KErrNone);
 	r=gFileMan->Delete(_L("\\F32-TST\\TFMAN\\CPMV\\THREE.*"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2\\TWO__1.TXT"));
 	MakeFile(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2\\TWO__2.TXT"));
 	// copy and rename dir
 	r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2"), _L("\\F32-TST\\TFMAN\\CPMV\\THREE"), CFileMan::ERecurse);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	Compare(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2\\*"), _L("\\F32-TST\\TFMAN\\CPMV\\THREE\\*"));
 	// copy and move into another dir
 	r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2"), _L("\\F32-TST\\TFMAN\\CPMV\\THREE\\TWO"), CFileMan::ERecurse);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	Compare(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2\\*"), _L("\\F32-TST\\TFMAN\\CPMV\\THREE\\TWO\\*"));
 	// copy and rename files and dirs in current dir
 	r=gFileMan->Copy(_L("\\F32-TST\\TFMAN\\CPMV\\TWO*"), _L("\\F32-TST\\TFMAN\\CPMV\\THREE*"), CFileMan::ERecurse);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	//	Compare(_L("\\F32-TST\\TFMAN\\CPMV\\TWO2\\*"), _L("\\F32-TST\\TFMAN\\CPMV\\THREE2\\*"));
 	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\ONE\\THREEO.TWO"), KErrNone);
 	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE\\TWO__1.TXT"), KErrNone);
 	CheckFileExists(_L("\\F32-TST\\TFMAN\\CPMV\\THREE\\TWO__2.TXT"), KErrNone);
 	test.Printf(_L("Level:%d Available:%d\n"), aLevel, available);
 	gFileMan->SetObserver(NULL);
 	// Attribs
 	r = gFileMan->Attribs(KDir, 0, 0, 0, CFileMan::ERecurse);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	// Move
 	r = gFileMan->Move(KFile1, KFile2, CFileMan::ERecurse);
-	test(r==KErrAlreadyExists);
+	test_Equal(KErrAlreadyExists, r);
 	r = gFileMan->Move(KFile1, KFile2, CFileMan::ERecurse | CFileMan::EOverWrite);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	// Copy
 	r = gFileMan->Copy(KFile2, KFile1, CFileMan::ERecurse);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	// Rename
 	r = gFileMan->Rename(KFile1, KFile2, 0);
-	test(r==KErrAlreadyExists);
+	test_Equal(KErrAlreadyExists, r);
 	r = gFileMan->Rename(KFile1, KFile2, CFileMan::EOverWrite);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	// Delete
 	r = gFileMan->Delete(KFile2, CFileMan::ERecurse);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	// RmDir
 	r = gFileMan->RmDir(KDir);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	gFileMan->SetObserver(gObserver);
 	}
 LOCAL_C void InitialiseL()
 	TestResult(err);
 	// Verify src contents after move operation
 	CDir *dir = NULL;
 	err = TheFs.GetDir(srcPath, KEntryAttMaskSupported, ESortNone, dir);
-	test(6 == dir->Count());
+	test_Equal(6, dir->Count());
 	delete dir;
 	// Verify dest contents after move operation
 	err = TheFs.GetDir(trgPath, KEntryAttMaskSupported, ESortNone, dir);
-	test(3 == dir->Count());
+	test_Equal(3, dir->Count());
 	delete dir;
 	// Recursive move with "\\" at the end of srcPath
 	// clean up before execution
 	RmDir(srcPath);
 		err = gFileMan->Move(srcPath, trgPath, CFileMan::ERecurse, gStat);
 	TestResult(err);
 	// Verify src has no content
 	err = TheFs.GetDir(srcPath, KEntryAttMaskSupported, ESortNone, dir);
-	test(0 == dir->Count());
+	test_Equal(0, dir->Count());
 	delete dir;
 	// Verify dest contents after move operation
 	err = TheFs.GetDir(trgPath, KEntryAttMaskSupported, ESortNone, dir);
-	test(9 == dir->Count());
+	test_Equal(9, dir->Count());
 	delete dir;
 	// Recursive move without "\\" at the end of srcPath
 	// clean up before execution
 	RmDir(srcPath);
 	// Add the "\\" at the end of srcPath for verification
 	srcPath.Append(KPathDelimiter);
 	// Verify src doesnt not exist
 	err = gFileMan->RmDir(srcPath);
-	test(err==KErrPathNotFound); // KErrPathNotFound expected as src has been moved to dest
+	test_Equal(KErrPathNotFound, err); // KErrPathNotFound expected as src has been moved to dest
 	// Verify dest after move operation
 	err = TheFs.GetDir(trgPath, KEntryAttMaskSupported, ESortNone, dir);
-	test(1 == dir->Count());
+	test_Equal(1, dir->Count());
 	delete dir;
 	// clean up before leaving
 	RmDir(srcPath);
 	RmDir(trgPath);
 	gAsynch=ETrue;
 	test.Next(_L("Asynchronous tests ..."));
 	TheFs.SetAllocFailure(gAllocFailOff);
 	TInt uid;
-	test(HAL::Get(HAL::EMachineUid,uid)==KErrNone);
+	test_KErrNone(HAL::Get(HAL::EMachineUid,uid));
 	TBool doTargetTests =  (!IsTestingLFFS() &&
 							uid!=HAL::EMachineUid_Cogent &&
 							uid!=HAL::EMachineUid_IQ80310 &&
 							uid!=HAL::EMachineUid_X86PC);
 	TestDEF130678(); // Test CFileMan::Move does not leak any memory
 #ifndef __WINS__
 	RThread t;
 	TThreadStackInfo stack;
-	test(t.StackInfo(stack)==KErrNone);
+	test_KErrNone(t.StackInfo(stack));
 	TestStackUsage(0, stack);
 #endif
 	Cleanup();
 	DeleteTestDirectory();
-	test(TheFs.RmDir(_L("\\F32-TST\\")) == KErrNone);
+	test_KErrNone(TheFs.RmDir(_L("\\F32-TST\\")));
 	}

branch	RCL_3
changeset 80	597aaf25e343
parent 31	56f325a607ea
child 109	b3a1d9898418
child 189	a5496987b1da
child 249	a179b74831c9