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

equal deleted inserted replaced

-:a179b74831c9
+:c1f20ce4abcf
 // // .. etc
 //
 //
+#define __E32TEST_EXTENSION__
 #include <f32file.h>
 #include <e32test.h>
 #include <e32svr.h>
 #include "t_server.h"
 #include "t_file64bit.h"
 	TInt r;
 const TUint KBufSize = 256*K1KiloByte;
 RBuf8 buf;
 r = buf.CreateMax(KBufSize);
-test(r == KErrNone);
+test_KErrNone(r);
 RFile64 file;
 	TFileName fileName;
 	fileName.Append(gDriveToTest);
 	fileName.Append(KTestPath);
 	fileName.Append(_L("File4GBMinusOne.txt"));
 	r = file.Replace(TheFs,fileName, EFileWrite);
-	test(r == KErrNone);
+	test_KErrNone(r);
 r = file.SetSize(K4GBMinusOne);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	TInt64 nNumberOfBytesToWrite = 0;
 	TInt64 nNumberOfBytesWritten = 0;
 	for (TInt64 pos = 0; pos < K4GBMinusOne; pos += nNumberOfBytesWritten)
 		{
 nNumberOfBytesWritten = nNumberOfBytesToWrite;
 		}
 	r = file.Flush();
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Printf(_L("\nFile writing is completed!!"));
 	file.Close();
 // Replaces a single file with another
 //
 	{
 	test.Printf(_L("%S File Replaced with %S\n"),&anOldName,&aNewName);\
 	TInt r = TheFs.Replace(anOldName,aNewName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFsTest& RFsTest::ReadFileSection(const TDesC& aName, TInt64 aPos,TDes8& aBuffer,TInt aLen)
 //
 	{
 	test.Printf(_L("Read File Section %S\n"),&aName);
 	TInt r = TheFs.ReadFileSection(aName,aPos,aBuffer,aLen);
 	TInt len = aBuffer.Length();
-	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
+	test_KErrNone(r);
-		{
+	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse && aPos >= K4GB)
-		if(aPos < K4GB)
+		test(len == 0);
-			test(r == KErrNone);
-		else
-			{
-			test(r == KErrNone);
-			test(len == 0);
-			}
-		}
-	else
-		{
-		test (r == KErrNone);
-		}
 	return(*this);
 	}
 RFsTest& RFsTest::GetDir(const TDesC &aName, TUint anEntryAttMask, TUint anEntrySortKey, CDir *&anEntryList)
 // Gets a filtered list of a directory's contents.
 //
 	{
 	test.Printf(_L("Name of the directory for which listing is required %S\n"),&aName);
 	TInt r = TheFs.GetDir(aName,anEntryAttMask,anEntrySortKey,anEntryList);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFsTest& RFsTest::GetDir(const TDesC& aName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,CDir*& aDirList)
 //
 // Gets a filtered list of the directory and the file entries contained in a directory and a
 // list of the directory entries only.
 	{
 	test.Printf(_L("Name of the directory for which directory and file listing is required %S\n"),&aName);
 	TInt r = TheFs.GetDir(aName,anEntryAttMask,anEntrySortKey,anEntryList,aDirList);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFsTest& RFsTest::GetDir(const TDesC& aName,const TUidType& anEntryUid,TUint anEntrySortKey,CDir*& aFileList)
 //
 // Gets a filtered list of directory contents by UID type.
 //
 	{
 	test.Printf(_L("Name of the directory for which listing is required %S\n"),&aName);
 	TInt r = TheFs.GetDir(aName,anEntryUid,anEntrySortKey,aFileList);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFileTest::RFileTest(const TDesC& aName)
 // Creates and opens a new file for writing, if the file already exists an error is returned
 //
 	{
 	test.Printf(_L("%S create %S in %d Mode\n"),&iName,&aName,aFileMode);
 	TInt r = RFile64::Create(TheFs,aName,aFileMode);
-	test(r == KErrNone || r == KErrAlreadyExists);
+	test_Value(r, r == KErrNone || r == KErrAlreadyExists);
 	return(*this);
 	}
 RFileTest& RFileTest::Replace(const TDesC& aName)
 //
 // if it exists or cretaing a new file if it does not exist.
 //
 	{
 	test.Printf(_L("%S replace %S\n"),&iName,&aName);
 	TInt r = RFile64::Replace(TheFs,aName,EFileStream|EFileWrite);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFileTest& RFileTest::Replace(const TDesC& aName, TUint aFileMode)
 //
 // if it exists or cretaing a new file if it does not exist.
 //
 	{
 	test.Printf(_L("%S replace %S in %d Mode\n"),&iName,&aName, aFileMode);
 	TInt r = RFile64::Replace(TheFs,aName,aFileMode);
-	if (r == KErrNone)
+	test_Value(r, r == KErrNone || r == KErrBadName);
-		test(r == KErrNone);
-	else
-		test(r == KErrBadName);
 	return(*this);
 	}
 RFileTest& RFileTest::Open(const TDesC& aName)
 //
 // Open a existing file for reading and writing in shared access mode.
 //
 	{
 	test.Printf(_L("%S open %S\n"),&iName,&aName);
 	TInt r = RFile64::Open(TheFs,aName,EFileWrite|EFileShareAny);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFileTest& RFileTest::Open(const TDesC& aName, TUint aFileMode)
 //
 // Opens an existing file using aFileMode.
 //
 	{
 	test.Printf(_L("%S open %S in %d Mode\n"),&iName,&aName, aFileMode);
 	TInt r = RFile64::Open(TheFs,aName,aFileMode);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFileTest& RFileTest::Temp(const TDesC& aPath,TFileName& aName,TUint aFileMode)
 //
 // Creates and opens a temporary file with a unique name for writing and reading.
 //
 	{
 	test.Printf(_L("%S Temp file %S in %d Mode\n"),&iName,&aName, aFileMode);
 	TInt r = RFile64::Temp(TheFs,aPath,aName,aFileMode);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 void RFileTest::Close()
 //
 // Set a lock on the file. Expected not to fail.
 //
 	{
 	test.Printf(_L("%S lock   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 	TInt r = RFile64::Lock(aPos,aLen);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFileTest& RFileTest::LockE(TInt64 aPos, TInt64 aLen)
 //
 // Set a lock on the file. Expected to fail.
 //
 	{
 	test.Printf(_L("%S lockE  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 	TInt r = RFile64::Lock(aPos,aLen);
-	test(r == KErrLocked);
+	test_Value(r, r == KErrLocked);
 	return(*this);
 	}
 RFileTest& RFileTest::UnLock(TInt64 aPos, TInt64 aLen)
 //
 // Unlock the file. Expected not to fail.
 //
 	{
 	test.Printf(_L("%S ulock  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 	TInt r = RFile64::UnLock(aPos,aLen);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFileTest& RFileTest::UnLockE(TInt64 aPos, TInt64 aLen)
 //
 // Unlock the file. Expected to fail.
 //
 	{
 	test.Printf(_L("%S ulockE 0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 	TInt r = RFile64::UnLock(aPos,aLen);
-	test(r == KErrNotFound);
+	test_Value(r, r == KErrNotFound);
 	return(*this);
 	}
 RFileTest& RFileTest::Write(const TDesC8& aDes)
 //
 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 		{
 		if((seekPos + aDes.Length()) < K4GB)
-			test(r == KErrNone);
+			{
+			test_KErrNone(r);
+			}
 		else
-			test(r == KErrNotSupported);
+			{
+			test_Value(r, r == KErrNotSupported);
+			}
 		}
 	else
 		{
-		test (r == KErrNone);
+		test_KErrNone(r);
 		}
 	return(*this);
 	}
 RFileTest& RFileTest::Write(const TDesC8 &aDes, TRequestStatus &aStatus)
 		User::WaitForRequest(aStatus);
 		}
 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 		{
 		if((seekPos + aDes.Length()) < K4GB)
+			{
 			test(aStatus.Int() == KErrNone);
+			}
 		else
+			{
 			test(aStatus.Int() == KErrNotSupported);
+			}
 		}
 	else
 		{
 		test(aStatus.Int() == KErrNone);
 		}
 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.
 		r = RFile64::Flush();
 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 		{
 		if((seekPos + aLength) < K4GB)
-			test(r == KErrNone);
+			{
+			test_KErrNone(r);
+			}
 		else
-			test(r == KErrNotSupported);
+			{
+			test_Value(r, r == KErrNotSupported);
+			}
 		}
 	else
 		{
-		test(r == KErrNone);
+		test_KErrNone(r);
 		}
 	return(*this);
 	}
 RFileTest& RFileTest::Write(const TDesC8& aDes, TInt aLength, TRequestStatus &aStatus)
 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.
 		r = RFile64::Flush();
 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 		{
 		if ((aPos + aDes.Length()) < K4GB)
-			test(r == KErrNone);
+			{
+			test_KErrNone(r);
+			}
 		else
-			test(r == KErrNotSupported);
+			{
+			test_Value(r, r == KErrNotSupported);
+			}
 		}
 	else
 		{
-		test(r == KErrNone);
+		test_KErrNone(r);
 		}
 	return(*this);
 	}
 RFileTest& RFileTest::WriteU(TUint aPos, const TDesC8& aDes)
 	{
 	test.Printf(_L("%S write  %08x\n"),&iName,aPos);
 	TInt r = RFile64::Write(aPos,aDes);
 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.
 		r = RFile64::Flush();
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFileTest& RFileTest::Write(TInt64 aPos, const TDesC8& aDes, TInt aLen)
 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 		{
 		if ((aPos + aLen) < K4GB)
 			{
 			if (aLen < 0)
-				test(r == KErrArgument);
+				{
+				test_Value(r, r == KErrArgument);
+				}
 			else
-				test(r == KErrNone);
+				{
+				test_KErrNone(r);
+				}
 			}
 		else
-			test(r == KErrNotSupported);
+			{
+			test_Value(r, r == KErrNotSupported);
+			}
 		}
 	else
 		{
 		if (aLen < 0)
-			test(r == KErrArgument);
+			{
+			test_Value(r, r == KErrArgument);
+			}
 		else
-			test(r == KErrNone);
+			{
+			test_KErrNone(r);
+			}
 		}
 	return(*this);
 	}
 RFileTest& RFileTest::WriteU(TUint aPos, const TDesC8& aDes, TInt aLen)
 	{
 	test.Printf(_L("%S write  %08x-%08x\n"),&iName,aPos,aPos+aLen-1);
 	TInt r = RFile64::Write(aPos,aDes,aLen);
 	if( KErrNone == r)	// this is to ensure that the written data is committed and not cached.
 		r = RFile64::Flush();
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFileTest& RFileTest::WriteE(TInt64 aPos, const TDesC8& aDes, TInt aLen)
 // Write to the file. Expected to fail.
 //
 	{
 	test.Printf(_L("%S writeE 0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 	TInt r = RFile64::Write(aPos,aDes,aLen);
-	if (aLen < 0)
+	test_Value(r, r == (aLen < 0) ? KErrArgument : KErrLocked);
-		test(r == KErrArgument);
-	else
-		test(r == KErrLocked);
 	return(*this);
 	}
 RFileTest& RFileTest::Write(TInt64 aPos, const TDesC8& aDes, TInt aLen, TRequestStatus &aStatus)
 //
 // Read from the file. Expected not to fail (Synchronous).
 //
 	{
 	test.Printf(_L("%S read \n"),&iName);
 	TInt r = RFile64::Read(aDes);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFileTest& RFileTest::Read(TDes8& aDes, TRequestStatus& aStatus)
 //
 // Read from the file. Expected not to fail (Synchronous).
 //
 	{
 	test.Printf(_L("%S read 0x%08x bytes\n"),&iName,aLen);
 	TInt r = RFile64::Read(aDes,aLen);
-	if(aLen < 0)
+	test_Value(r, r == (aLen < 0) ? KErrArgument : KErrNone);
-		test(r == KErrArgument);
-	else
-		test(r == KErrNone);
 	return(*this);
 	}
 RFileTest& RFileTest::Read(TInt64 aPos, TDes8& aDes, TInt aLen)
 //
 //
 	{
 	test.Printf(_L("%S read   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 	TInt r = RFile64::Read(aPos,aDes,aLen);
 	TInt len = aDes.Length();
-	if(aLen < 0)
+	test_Value(r, r == (aLen < 0) ? KErrArgument : KErrNone);
-		test(r == KErrArgument);
-	else
-		test(r == KErrNone);
 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 		{
 		if(aPos >= K4GB)
 			test(len == 0);
 		}
 // Reads the specified number of bytes from the file at a specified offset. Expected to fail.
 //
 	{
 	test.Printf(_L("%S readE  0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 	TInt r = RFile64::Read(aPos,aDes,aLen);
-	test(r == KErrLocked);
+	test_Value(r, r == KErrLocked);
 	return(*this);
 	}
 RFileTest& RFileTest::Read(TInt64 aPos, TDes8& aDes, TInt aLen, TRequestStatus& aStatus)
 //
 // Reads from the file at the specfied offset with in the file (Synchronous).
 //
 	{
 	test.Printf(_L("%S read   0x%lx\n"),&iName,aPos);
 	TInt r = RFile64::Read(aPos,aDes);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes)
 //
 // Offset is specified as a TUint value.
 //
 	{
 	test.Printf(_L("%S read   0x%lx\n"),&iName,aPos);
 	TInt r = RFile64::Read(aPos,aDes);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	return(*this);
 	}
 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes,TRequestStatus& aStatus)
 //
 // Offset is specified as a TUint value.
 //
 	{
 	test.Printf(_L("%S read   0x%lx-0x%lx\n"),&iName,aPos,aPos+aLen-1);
 	TInt r = RFile64::Read(aPos,aDes,aLen);
-	if(aLen < 0)
+	test_Value(r, r == (aLen < 0) ? KErrArgument : KErrNone);
-		test(r == KErrArgument);
-	else
-		test(r == KErrNone);
 	return(*this);
 	}
 RFileTest& RFileTest::ReadU(TUint aPos, TDes8& aDes, TInt aLen, TRequestStatus& aStatus)
 //
 	test.Printf(_L("%S size: 0x%lx\n"),&iName,aSize);
 	TInt r = RFile64::SetSize(aSize);
 	if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 		{
 		if(aSize < K4GB)
-			test(r == KErrNone);
+			{
+			test_KErrNone(r);
+			}
 		else
-			test(r == KErrNotSupported);
+			{
+			test_Value(r, r == KErrNotSupported);
+			}
 		}
 	else
 		{
-		test(r == KErrNone);
+		test_KErrNone(r);
 		}
 	return(*this);
 	}
 RFileTest& RFileTest::SetSizeE(TInt64 aSize)
 // Set the size of the file. Expected to fail.
 //
 	{
 	test.Printf(_L("%S sizeE: 0x%lx\n"),&iName,aSize);
 	TInt r = RFile64::SetSize(aSize);
-	test(r == KErrLocked);
+	test_Value(r, r == KErrLocked);
 	return(*this);
 	}
 RFileTest& RFileTest::Size(TInt64& aSize)
 //
 	test.Printf(_L("%S size: 0x%lx\n"),&iName,aSize);
 if(KFileSizeMaxLargerThan4GBMinusOne == EFalse)
 		{
 		if(aSize < K4GB)
-			test(r == KErrNone);
+			{
+			test_KErrNone(r);
+			}
 		else
-			test(r == KErrTooBig);
+			{
+			test_Value(r, r == KErrTooBig);
+			}
 		}
 	else
 		{
-		test(r == KErrNone);
+		test_KErrNone(r);
 		}
 	return(*this);
 	}
 RFileTest& RFileTest::Seek(TSeek aMode, TInt64& aPos)
 // Sets the current file position. Expected not to fail.
 //
 	{
 	test.Printf(_L("Seek to pos %LD in %d Mode\n"),aPos, aMode);
 	TInt r = RFile64::Seek(aMode, aPos);
-	if(aPos < 0)
+	test_Value(r, r == (aPos < 0) ? KErrArgument : KErrNone);
-		test(r == KErrArgument);
-	else
-		test(r == KErrNone);
 	return(*this);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0756
 	TestRFile1.Close();
 	test.Next(_L("2GB File: Open"));
 	TInt r = TheFs.Entry(fileName, entry);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test((TUint) entry.iSize == testSize);
 TestRFile1.Open(fileName, EFileRead);
 	TestRFile1.Size(size);
 	test(size == testSize);
 	TestRFile1.Close();
 	r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0757
 @SYMTestPriority    High
 	TestRFile1.SetSize(testSize);
 	TestRFile1.Close();
 	test.Next(_L("3GB File: Open"));
 	r = TheFs.Entry(fileName, entry);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test((TUint) entry.iSize == testSize);
 	TestRFile1.Open(fileName,EFileRead);
 	TestRFile1.Size(size);
 	test(size == testSize);
 	TestRFile1.Close();
 	r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0758
 @SYMTestPriority    High
 	TestRFile1.SetSize(testSize);
 	TestRFile1.Close();
 	test.Next(_L("4GB-1 File: Open"));
 	r = TheFs.Entry(fileName, entry);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test((TUint) entry.iSize == testSize);
 	TestRFile1.Open(fileName, EFileRead);
 	test(size == testSize);
 	TestRFile1.Close();
 	r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0759
 @SYMTestPriority    High
 	TestRFile1.SetSize(testSize);
 	TestRFile1.Close();
 	test.Next(_L("4GB File: Open"));
 	r = TheFs.Entry(fileName, entry);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	if ((TUint) entry.iSize == testSize)
 		{
 		TestRFile1.Open(fileName, EFileRead);
 		TestRFile1.Size(size);
 		test(size == testSize);
 		TestRFile1.Close();
 		}
 	r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0760
 		}
 	TestRFile1.Close();
 	RFile64 file64;
 	TInt r = file64.Open(TheFs,fileName,EDeleteOnClose);
-	test (r == KErrArgument);
+	test_Value(r, r == KErrArgument);
 	r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0761
 	fileName.Append(KTestPath);
 	fileName.Append(_L("File4GBMinusOne.txt"));
 	test.Start(_L("Test opening a file using RFile and RFile64 in file sharing mode\n"));
 	TInt r = file.Replace(TheFs,fileName,EFileShareAny|EFileWrite);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	TBuf8<100> writeBuf;
 	TBuf8<100> readBuf;
 	writeBuf.Zero();
 	for(count = 0; count < 100; count++)
 		writeBuf.Append(count);
 		}
 	test.Next(_L("Write 100 bytes to the file\n"));
 	r = file.Write(0, writeBuf, 100);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Read 100 bytes from position 0"));
 	r = file.Read(0, readBuf, 100);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Compare the read data to the written data"));
 	test(readBuf == writeBuf);
 	test.Next(_L("Set the file size to 4GB-1\n"));
 	TestRFile1.SetSize(K4GBMinusOne);
 	test.Next(_L("Query the file size using Rfile::Size()\n"));
 	r = file.Size(size);
-	test (r == KErrTooBig);
+	test_Value(r, r == KErrTooBig);
 	test.Next(_L("Seek to the file position using 2GB+5 using RFile::Seek()\n"));
 	TUint seekPos1 = K2GB + 5;
 	TInt seekPos  = (TInt)seekPos1;
 	r = file.Seek(ESeekStart,seekPos);
-	test(r == KErrArgument);
+	test_Value(r, r == KErrArgument);
 	test.Next(_L("Get the file size using RFile64::Size()\n"));
 	TestRFile1.Size(size64);
 	test.Next(_L("Seek to the file position 4GB-10 using RFile64::Seek()\n"));
 	TestRFile1.Close();
 	file.Close();
 	test.Next(_L("Open the file using Rfile::Open()\n"));
 	r = file.Open(TheFs,fileName,EFileShareAny|EFileWrite);
-	test(r == KErrTooBig);
+	test_Value(r, r == KErrTooBig);
 	test.Next(_L("Open the file using Rfile64::Open() and close\n"));
 	TestRFile1.Open(fileName,EFileShareAny|EFileWrite);
 	TestRFile1.Close();
 	r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0762
 @SYMTestPriority    High
 	TFileName testDir;
 	testDir.Append(gDriveToTest);
 	testDir.Append(KTestPath);
 	TInt r = TheFs.MkDir(testDir);
-	test(r == KErrNone || r == KErrAlreadyExists);
+	test_Value(r, r == KErrNone || r == KErrAlreadyExists);
 	TFileName fileName;
 	TestRFile1.Temp(testDir, fileName, EFileWrite|EDeleteOnClose);
 	test.Next(_L("Set the file size to 4GB-1\n"));
 	TestRFile1.Close();
 	test.Next(_L("Delete the temporary file\n"));
 	r = TheFs.Delete(fileName);
-	test(r == KErrNotFound);
+	test_Value(r, r == KErrNotFound);
 	test.Next(_L("Create a temporary file using RFile64::Temp without EDeleteOnClose flag\n"));
 	TestRFile1.Temp(testDir, fileName, EFileWrite);
 	test.Next(_L("Close the file\n"));
 	TestRFile1.Close();
 	test.Next(_L("Delete the temporary the file\n"));
 	r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0763
 	TestRFile1.Create(fileName,EFileWrite);
 	test.Next(_L("create a file with InvalidPath and fileName\n"));
 	RFile64 file64;
 	TInt r = file64.Create(TheFs, _L("C:\\InvalidPathName\\FileName"),EFileWrite);
-	test(r == KErrPathNotFound);
+	test_Value(r, r == KErrPathNotFound);
 	r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0764
 @SYMTestPriority    High
 	TestRFile1.Close();
 	test.Next(_L("Replace a file FileLargeOne.txt with invalid path\n"));
 	RFile64 file64;
 	TInt r = file64.Replace(TheFs,_L("C:\\InvalidPath\\FileLargeOne.Txt"),EFileWrite);
-	test (r == KErrPathNotFound);
+	test_Value(r, r == KErrPathNotFound);
 	r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0765
 @SYMTestPriority    High
 	test(readBuffer == _L8("ABCDEFGHIJ"));
 	test.Next(_L("Close the file and delete\n"));
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileNameReplace);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0766
 @SYMTestPriority    High
 	{
 	test.Next(_L("Tests for checking RFile64::AdoptFromClient()"));
 	RProcess p;
 	TInt r = p.Create(_L("FHServer64Bit.exe"), KNullDesC);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Connect to the File server \n"));
 	RFs fs;
 	r = fs.Connect();
-	test(r == KErrNone);
+	test_KErrNone(r);
 	// Check the number of open file handles
 	TInt resCount = fs.ResourceCount();
 	test(resCount == 0);
 	r = fs.ShareProtected();
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = fs.CreatePrivatePath(gDrive);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = fs.SetSessionToPrivate(gDrive);
 	test.Next(_L("Create a file and set the file size to 4GB-1\n"));
 	RFile64 file1;
 	r = file1.Replace(fs,KClientFileName,EFileWrite);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = file1.SetSize(K4GB-1);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Write few bytes to the location 4GB-10, length = 9bytes\n"));
 	r = file1.Write(K4GB-10,KTestData3(),9);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	file1.Close();
 	r = p.SetParameter(3, gDrive);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	p.Resume();
 	test.Next(_L("Transfer the file handle using TransferToServer() close the file\n"));
 	do
 		{
 		r = handsvr.Connect();
 		}
 	while(r == KErrNotFound);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = handsvr.SetTestDrive(gDrive);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = fs.SetSessionToPrivate(gDrive);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = file1.Open(fs,KClientFileName,EFileRead);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	// pass the file handle to FHServer
 	test.Next(_L("RFile::TransferToServer()"));
 	TIpcArgs ipcArgs;
 	r = file1.TransferToServer(ipcArgs, 0, 1);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Adopt the already open file from a client using RFile64::AdoptFromClient()\n"));
 	r = handsvr.PassFileHandleProcessLargeFileClient(ipcArgs);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	// verify that the original file handle's position is unchanged
 	TInt64 pos = 0;
 	r = file1.Seek(ESeekCurrent, pos);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test(pos == 0);
 	// make sure we can still use it
 	test.Next(_L("Read the file from position 4GB-10 and compare the data\n"));
 	TBuf8<9> rbuf;
 	r = file1.Read(K4GB-10,rbuf);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test (rbuf == KTestData3);
 	// Close the file
 	file1.Close();
 	handsvr.Exit();
 	handsvr.Close();
 	r = fs.MkDir(_L("C:\\mdir"));
-	test(r == KErrNone || r == KErrAlreadyExists);
+	test_Value(r, r == KErrNone || r == KErrAlreadyExists);
 	// Check the number of open file handles
 	resCount = fs.ResourceCount();
 	test(resCount == 0);
 	r = fs.Delete(KClientFileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	fs.Close();
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0767
 	test.Next(_L("Tests for checking RFile64::AdoptFromCreator()"));
 	//create test server
 	test.Next(_L("Create a process named FHServer64Bit.exe\n"));
 	RProcess p;
 	r = p.Create(_L("FHServer64Bit.exe"), KNullDesC);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Connect to the file server\n"));
 	RFs fs;
 	r = fs.Connect();
-	test(r == KErrNone);
+	test_KErrNone(r);
 	// Check the number of open file handles
 	TInt resCount = fs.ResourceCount();
 	test(resCount == 0);
 	r = fs.ShareProtected();
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = fs.CreatePrivatePath(gDrive);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = fs.SetSessionToPrivate(gDrive);
 	test.Next(_L("Create a file and set the file size to 4GB-1\n"));
 	RFile64 file1;
 	r = file1.Replace(fs,KClientFileName,EFileWrite);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = file1.SetSize(K4GB-1);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Write few bytes to the location 4GB-10, length = 3bytes\n"));
 	r = file1.Write(K4GB-10,KTestData2(),3);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	file1.Close();
 	r = file1.Open(fs, KClientFileName, EFileWrite);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	// NB slot 0 is reserved for the command line
 	test.Next(_L("Transfer the file handle using TransferToProcess() close the file"));
 	r = file1.TransferToProcess(p, 1, 2);
 	r = p.SetParameter(3, gDrive);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = fs.SetSessionToPrivate(gDrive);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	// make sure we can still read from the file
 	TBuf8<3> rbuf;
 	r = file1.Read(K4GB-10,rbuf,3);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = rbuf.CompareF(KTestData2());
-	test(r == KErrNone);
+	test_KErrNone(r);
 	file1.Close();
 	r = fs.MkDir(_L("C:\\mdir"));
-	test(r == KErrNone || r == KErrAlreadyExists);
+	test_Value(r, r == KErrNone || r == KErrAlreadyExists);
 	// Check the number of open file handles -
 	// should be 1 (the one duplicated for the other process)
 	resCount = fs.ResourceCount();
 	test(resCount == 1);
 	do
 		{
 		r = handsvr.Connect();
 		}
 	while(r == KErrNotFound);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = handsvr.SetTestDrive(gDrive);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	// wait for server to read the file
 	r = handsvr.PassFileHandleProcessLargeFileCreator();
-	test (r == KErrNone);
+	test_KErrNone(r);
 	// cleanup
 	handsvr.Exit();
 	handsvr.Close();
 	TInt r;
 	test.Next(_L("Connect to the file server\n"));
 	RFs fs;
 	r = fs.Connect();
-	test(r == KErrNone);
+	test_KErrNone(r);
 	// Check the number of open file handles
 	TInt resCount = fs.ResourceCount();
 	test(resCount == 0);
 	r = fs.ShareProtected();
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = fs.CreatePrivatePath(gDrive);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = fs.SetSessionToPrivate(gDrive);
 	test.Next(_L("Create a file and set the file size to 4GB-1\n"));
 	RFile64 file1;
 	r = file1.Replace(fs,KClientFileName,EFileWrite);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = file1.SetSize(K4GB-1);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = file1.Write(K4GB-10,KTestData3(),9);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	file1.Close();
 	r = fs.Delete(KClientFileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	RProcess p;
 	r = p.Create(_L("FHServer64Bit.exe"), KNullDesC);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	// Request an open file (write mode) from the server
 	// using RFile64::AdoptFromServer()
 	test.Next(_L("Adopt an already open file from a server using RFile64::AdoptFromServer()\n"));
 	p.Resume();
 	do
 		{
 		r = handsvr.Connect();
 		}
 	while(r == KErrNotFound);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = handsvr.SetTestDrive(gDrive);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	TInt ssh;
 	TInt fsh = handsvr.GetFileHandleLargeFile2(ssh, EFileWrite);
 	test (fsh >= 0);
 	// adopt the file handle from FHServer
 	test.Next(_L("RFile64::AdoptFromServer()"));
 	RFile64 file;
 	r = file.AdoptFromServer(fsh, ssh);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Read the file from position 4GB-10 and compare the data\n"));
 	TBuf8<9> rbuf;
 	r = file.Read(K4GB-10,rbuf);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	// server should write KTestData1 ("Server!!!") to file
 	test (rbuf == KTestData4);
 	TFileName fileName;
 	r = file.FullName(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	file.Close();
 	//cleanup
 	r = fs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	TFileName sessionPath;
 	r = fs.SessionPath(sessionPath);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = fs.RmDir(sessionPath);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	fs.Close();
 	}
 	TUint 			pos;
 	TBuf8<KBufSize> readBuf1;
 	TBuf8<KBufSize> readBuf2;
 	TUint i;
 	TInt r = GenerateBigFileContents();
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Open & Read Synchronously Large File From Diff Offset:"));
 	TFileName fileName;
 	fileName.Append(gDriveToTest);
 	TestRFile1.Read(pos, readBuf, 0, status7);
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0773
 @SYMTestPriority    High
 		test(readBuffer256.Length() == 0);
 		}
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0774
 @SYMTestPriority    High
 		test(readBuf256.Length() == 0);
 		}
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0775
 @SYMTestPriority    High
 		}
 	TestRFile1.Write(0,wrBuf256,-1);
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0776
 @SYMTestPriority    High
 	TRequestStatus status7 = KRequestPending;
 	TestRFile1.Write(0,wrBuf256,-1,status7);
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0777
 @SYMTestPriority    High
 	}
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0778
 	TestRFile2.UnLock(K4GB, 10);
 	    }
 TestRFile2.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0779
 @SYMTestPriority    High
 	test(seekPos == 512);
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0780
 @SYMTestPriority    High
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 }
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0781
 @SYMTestPriority    High
 	TestRFile1.Read(K4GBMinusTen,testData6,9);
 	test(testData6 == _L8("IJKLMnOPx"));
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0782
 @SYMTestPriority    High
 	fileName.Append(gDriveToTest);
 	fileName.Append(KTestPath);
 	fileName.Append(_L("File4GBMinusOne.txt"));
 	TInt r = file.Replace(TheFs,fileName,EFileWrite);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = file.SetSize(K4GBMinusOne);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	file.Close();
 	test.Next(_L("Read from a big file using RFs::ReadFileSection() from position 3GB-1,52byte lengths of data\n"));
 	TestRFs.ReadFileSection(fileName,K3GBMinusOne,testDes,52);
 		{
 		TestRFs.ReadFileSection(fileName,K4GB,readBuf,52);
 		}
 	r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0783
 @SYMTestPriority    High
 	TestRFile1.Close();
 	test.Next(_L("Get the directory listing, sort by size\n"));
 	RDir dir;
 	TInt r = dir.Open(TheFs, dirName, KEntryAttNormal);
-	test (r == KErrNone);
+	test_KErrNone(r);
 	TEntryArray entryArray;
 	r = dir.Read(entryArray);
-	test (r == KErrEof);
+	test_Value(r, r == KErrEof);
 	test.Next(_L("Check the files count in the directory. Number of files in a directory is 4\n"));
 	test(entryArray.Count() == gFilesInDirectory);
 	test.Next(_L("Get the entry list & Check the files are listed in order of file sizes\n"));
 	dirName.Append(KTestPath);
 	test.Next(_L("Open the directory containing large file, using RDir open()\n"));
 	RDir dir;
 	TInt r = dir.Open(TheFs, dirName, KEntryAttNormal);
-	test (r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Read the directory entry using TEntryArray as parameter\n"));
 	TEntryArray entryArray;
 	r = dir.Read(entryArray);
-	test (r == KErrEof);
+	test_Value(r, r == KErrEof);
 	test.Next(_L("Check the count\n"));
 	test(entryArray.Count() == gFilesInDirectory);
 	test.Next(_L("Close using RDir\n"));
 	TFileName testDir0;
 	testDir0.Append(gDriveToTest);
 	testDir0.Append(_L("F32-TEST"));
 	TInt r = TheFs.MkDir(testDir0);
-	test(r == KErrNone || r == KErrAlreadyExists);
+	test_Value(r, r == KErrNone || r == KErrAlreadyExists);
 	test.Next(_L("Sort with number of entries =0\n"));
 	TestRFs.GetDir(testDir0, KEntryAttMaskSupported, ESortBySize, anEntryList);
 	test(anEntryList->Count() == 0);
 	delete anEntryList;
 	file3GB.Append(gDriveToTest);
 	file3GB.Append(KTestPath);
 	file3GB.Append(_L("File3GB.txt"));
 	TInt r = TheFs.Delete(file4GBMinusOne);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = TheFs.Delete(file2GBMinusOne);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = TheFs.Delete(file2GB);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = TheFs.Delete(file3GB);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0788
 @SYMTestPriority    High
 	RFile64 file64;
 	TInt64 sizeK3GB = K3GB;
 	test.Next(_L("Open test file and get the file size using RFile64::Size() and set the file handle to TFileText object\n"));
 	r = file64.Replace(TheFs,fileName,EFileRead|EFileWrite);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = file64.SetSize(sizeK3GB);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	TFileText fileText;
 	fileText.Set(file64);
 	test.Next(_L("Seek to the file end using TFileText::Seek()\n"));
 	r = fileText.Seek(ESeekEnd);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Get current file position using RFile64::Seek() and verify it is at file end.\n"));
 	TInt64 pos = 0;
 	r = file64.Seek(ESeekCurrent, pos);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test(pos == sizeK3GB);
 	test.Next(_L("Write data to the file using RFile64::Write\n"));
 	HBufC* record = HBufC::NewL(10);
 	record->Des().SetLength(10);
 	record->Des().Fill('A');
 	TPtrC8 bufPtr;
 	bufPtr.Set((TUint8*)record->Ptr(),record->Size()); // Size() returns length in bytes
 	r = file64.Write(pos,bufPtr);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Read data using TFileText::Read\n"));
 	TBuf<20> fileTextReadBuf;
 	file64.Seek(ESeekStart,pos);//seek to the position where the data has been written
 	r = fileText.Read(fileTextReadBuf);
 	test(fileTextReadBuf == _L("AAAAAAAAAA"));
 	test.Next(_L("Seek to the file end using TFileText::Seek(ESeekEnd)\n"));
 	r = fileText.Seek(ESeekEnd);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Write known data using TFileText::Write\n"));
 	TBuf<20> fileTextWriteBuf(_L("AAAAAAAAAA"));
 	pos = 0;
 	r = file64.Seek(ESeekCurrent,pos);
 	r = fileText.Write(fileTextWriteBuf);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Read the data using RFile64::Read\n"));
 	TBuf8<20> file64ReadBuf;
 	file64ReadBuf.Zero();
 	r = file64.Read(pos,file64ReadBuf);
 	r = bufPtr.Compare(file64ReadBuf);
-	test (r == KErrNone);
+	test_KErrNone(r);
 	file64.Close();
 	r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	User::Free(record);
 	}
 /**
 TestRFile2.Close();
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.End();
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-0790
 	fileName1.Append(gDriveToTest);
 	fileName1.Append(KTestPath);
 	fileName1.Append(_L("File2GB.txt"));
 	RFile64 file;
 	TInt r = file.Replace(TheFs, fileName1, EFileWrite);
-	test (r == KErrNone);
+	test_KErrNone(r);
 	file.SetSize(K2GB);
-	test (r == KErrNone);
+	test_KErrNone(r);
 	file.Close();
 	TestRFs.ReadFileSection(fileName1,0,readBuf,100);
 	r = TheFs.Delete(fileName1);
-	test (r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Creating test pattern"));
 	TBuf8<0x63> writeBuf63;
 	TBuf8<0x63> readBuf63;
 	for (TInt count = 0; count < 0x63; count++)
 	TestRFile2.Close();
 	TestRFile1.Close();
 	r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.End();
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-2349
 		}
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.End();
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-2350
 		TestRFile1.Read(readBufx63, status8); // validating the content
 		}
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.End();
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-2351
 		}
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.End();
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-2352
 @SYMTestPriority    High
 		TRequestStatus status8 = KRequestPending;;
 		TestRFile1.Read(readBufx63,99,status8);
 		}
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.End();
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-2353
 @SYMTestPriority    High
 			test(writeBuf == readBuf); // Written data == Read data
 			}
 		}
 	TestRFile1.Close();
 	TInt r = TheFs.Delete(fileName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-2354
 @SYMTestPriority    High
 @SYMTestRequirement REQ9532
 	TestRFile1.Write(_L8("1234567891"));
 	TestRFile1.Close();
 	test.Next(_L("Copy the files from one folder to another using CFileMan::Copy()\n"));
 	TInt r = fileMan->Copy(filePathOld, filePathNew, CFileMan::ERecurse | CFileMan::EOverWrite);
-	test(r == KErrNone || r == KErrTooBig);
+	test_Value(r, r == KErrNone || r == KErrTooBig);
 	test.Next(_L("Get the directory entry and find how many files are copied\n"));
 	// check SMALL and LARGE files have been copied
 	r = dir.Open(TheFs, filePathNew, KEntryAttNormal);
-	test (r == KErrNone);
+	test_KErrNone(r);
 	r = dir.Read(entryArray);
-	test (r == KErrEof);
+	test_Value(r, r == KErrEof);
 	test(entryArray.Count() == gFilesInDirectory);
 	dir.Close();
 	// then delete the new directory
 	r = fileMan->Delete(filePathNew);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.Next(_L("Set file man observer\n"));
 	// attempt to copy to new directory again - this time with an observer
 	fileMan->SetObserver(observer);
 	test.Next(_L("Copy the files from one folder to another, source folder has 3 small files and a large file\n"));
 	r = fileMan->Copy(filePathOld, filePathNew, CFileMan::ERecurse | CFileMan::EOverWrite);
-	test(r == KErrNone || r == KErrTooBig);
+	test_Value(r, r == KErrNone || r == KErrTooBig);
 	test.Next(_L("Check observer for number of successful copy and failed copy\n"));
 	// test that 3 small files and 1 large file were copied
 	// (For 8 GB disk, the 4GB file is missing)
 	test(observer->iNotifyEndedSuccesses == gFilesInDirectory);
 	test(observer->iNotifyEndedFailures == 0);
 	test.Next(_L("Get the directory entry and find how many files copied\n"));
 	// check SMALL files have been copied
 	r = dir.Open(TheFs, filePathNew, KEntryAttNormal);
-	test (r == KErrNone);
+	test_KErrNone(r);
 	r = dir.Read(entryArray);
-	test (r == KErrEof);
+	test_Value(r, r == KErrEof);
 	test(entryArray.Count() == gFilesInDirectory);
 	dir.Close();
 	// then delete the new directory
 	r = fileMan->Delete(filePathNew);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	delete observer;
 	delete fileMan;
 	r = TheFs.Delete(fileSmall1);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = TheFs.Delete(fileSmall2);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = TheFs.Delete(fileSmall3);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = TheFs.Delete(fileLarge1);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}
 /**
 @SYMTestCaseID      PBASE-T_FILE64BIT-2355
 @SYMTestPriority    High
 @SYMTestRequirement REQ9532
 	TestRFile1.Close();
 	// move to new directory
 	TInt r = fileMan->Move(filePathOld, filePathNew, CFileMan::ERecurse | CFileMan::EOverWrite);
-	test(r == KErrNone || r == KErrTooBig);
+	test_Value(r, r == KErrNone || r == KErrTooBig);
 	// check SMALL and LARGE files have been moved
 	RDir dir;
 	r = dir.Open(TheFs, filePathNew, KEntryAttNormal);
-	test (r == KErrNone);
+	test_KErrNone(r);
 	TEntryArray entryArray;
 	r = dir.Read(entryArray);
-	test (r == KErrEof);
+	test_Value(r, r == KErrEof);
 	test(entryArray.Count() == 4);
 	dir.Close();
 	// then delete the new directory
 	r = fileMan->Delete(filePathNew);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	delete fileMan;
 	}
 static void TestOpenFiles()
 static void TestAdoptFiles()
 	{
 	TInt r;
 	RFs fs;
 	r = fs.Connect();
-	test(r == KErrNone);
+	test_KErrNone(r);
 	r = fs.ShareProtected();
-	test(r == KErrNone);
+	test_KErrNone(r);
 	TFileName sessionp;
 	fs.SessionPath(sessionp);
 	r = fs.MkDirAll(sessionp);
-	test(r == KErrNone || r == KErrAlreadyExists);
+	test_Value(r, r == KErrNone || r == KErrAlreadyExists);
 	fs.Close();
 	TestRFile64AdoptFromCreator();
 	TestRFile64AdoptFromClient();
 	TestRFile64AdoptFromServer();
 	}
 	TRequestStatus status1=KRequestPending;
 	TRequestStatus status2=KRequestPending;
 	// If a zero length is passed into the Write function, KErrNone should be returned.
 	r=aFile.Write(aPos,gBuf);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	// If the length is a negative, KErrArgument should be returned.
 	r=aFile.Write(aPos,gBuf,aLen);
-	test(r==KErrArgument);
+	test_Value(r, r == KErrArgument);
 	// Test the asynchronous requests
 	aFile.Write(aPos,gBuf,aLen,status1);
 	aFile.Write(aPos,gBuf,aLen,status2);
 	User::WaitForRequest(status1);
 	User::WaitForRequest(status2);
 	test(status2.Int()==KErrArgument);
 	aFile.Close();
 	r = TheFs.Delete(_L("\\testRFile64NegLen.txt"));
-	test(r == KErrNone);
+	test_KErrNone(r);
 	test.End();
 	}
 //-------------------------------------------------------------------------------------------------------------------
 static TInt PrepareDisk(TInt aDrive)
 //-- decide if we need to test files >= 4G. As soon as there is no appropriate API yet, this way is dodgy..
 if(Is_Fat(TheFs, aDrive))
 {
 KFileSizeMaxLargerThan4GBMinusOne = EFalse; //-- FAT doesn't support >= 4G files
 }
-else if(Is_Win32(TheFs, aDrive))
+else if(Is_SimulatedSystemDrive(TheFs, aDrive))
-{//-- this is the emulator's windows drive. The maximal file size depends on the Windows FS used for this drive.
+{
-//-- if it is NTFS, files >= 4G are supported.
+		 //-- This is the emulator's windows drive or PlatSim's HVFS.
+		 //-- The maximal file size depends on the Windows FS used for this drive.
+//-- If it is NTFS, files >= 4G are supported.
 r = CreateEmptyFile(TheFs, _L("\\test_file"), K4GB);
 KFileSizeMaxLargerThan4GBMinusOne = (r == KErrNone);
 r = TheFs.Delete(_L("\\test_file"));
 void CallTestsL()
 	{
 	TInt r;
 	r = RFs::CharToDrive(gDriveToTest, gDrive);
-	test(r == KErrNone);
+	test_KErrNone(r);
 //-- set up console output
 F32_Test_Utils::SetConsole(test.Console());
 PrintDrvInfo(TheFs, gDrive);
 	// Delete the test directory
 	TFileName dirName;
 	dirName.Append(gDriveToTest);
 	dirName.Append(KTestPath);
 	r = TheFs.RmDir(dirName);
-	test(r == KErrNone);
+	test_KErrNone(r);
 	}

branch	RCL_3
changeset 43	c1f20ce4abcf
parent 0	a41df078684a
child 44	3e88ff8f41d5