MCL/sf/os/kernelhwsrv: comparison kerneltest/f32test/filesystem/fat/t

equal deleted inserted replaced

-:a179b74831c9
+:c1f20ce4abcf
 // Nokia Corporation - initial contribution.
 //
 // Contributors:
 //
 // Description:
-// f32test\scndrv\t_tscan32.cpp
+// f32test\filesystem\fat\t_tscan32.cpp
 //
-//
+#define __E32TEST_EXTENSION__
 #include <f32file.h>
 #include <e32test.h>
 #include "t_server.h"
 GLDEF_D TFileName StartupExeName=_L(""); // initialised at run time
 #ifdef _DEBUG
 GLREF_D RTest test;
-GLDEF_D TInt TheFunctionNumber;
+GLDEF_D TInt TheFunctionNumber;	// Indicates which test to run
-GLDEF_D TInt TheOpNumber;
+GLDEF_D TInt TheOpNumber;		// Indicates which file operation to be tested
 GLDEF_D TInt TheFailCount;
 GLDEF_D TBool IsReset;
 GLDEF_D TFileName TestExeName=_L("?:\\T_SCANDR.EXE"); //Renaming it to fit in one root dir entry.
 GLDEF_D TFileName LogFileName=_L("?:\\T_SCANDR.LOG"); //Renaming it to fit in one root dir entry.
 const TInt KControlIoWriteFailOn=0;		// commands to pass into RFs::ControlIo
 const TInt KDirAttrArchive   = 0x20;
 const TInt KDirAttrLongName  = KDirAttrReadOnly | KDirAttrHidden | KDirAttrSystem | KDirAttrVolumeId;
 const TInt KDirAttrLongMask  = KDirAttrLongName | KDirAttrDirectory | KDirAttrArchive;
 const TInt KDirLastLongEntry = 0x40;
-GLDEF_D TInt WriteFailValue;
+GLDEF_D TInt WriteFailValue;	// Indicates what error should return from a write failure
+								// Value assigned in t_scn32dr2 and t_scn32dr3
 LOCAL_C TFatBootSector BootSector;
 LOCAL_D RRawDisk TheRawDisk;
 static TFatType gDiskType = EInvalid;
 LOCAL_D TInt gClusterCount;
 LOCAL_D HBufC8* gFatBuf  = NULL;
 LOCAL_D TInt    gFatAddr = -1;
-enum TFatChain {EChainStd,EChainAlternate,EChainBackwards,EChainForwards};
+enum TFatChain
+	{
+	EChainStd,			// Cluster chain grows contiguously
+	EChainAlternate,	// Cluster chain grows forward but not contiguously
+	EChainBackwards,	// Cluster chain first goes backwards(up to 3.5kb for fat16 file) and then forwards
+	EChainForwards		// Cluster chain first goes forward (upto 3.5kb for fat16 file) and then backwards
+	};
 LOCAL_C TBool IsInternalRam()
 //
 // Returns true if the selected drive is variable size (i.e. RAM drive)
 //
 	{
 	TVolumeInfo v;
 	TInt r=TheFs.Volume(v,gSessionPath[0]-'A');
-	test(r==KErrNone);
+	test_KErrNone(r);
 	return(v.iDrive.iMediaAtt&KMediaAttVariableSize);
 	}
 LOCAL_C void WriteLogFile()
 //
 	test.Printf(_L("Writelogfile()\n"));
 	RFile log;
 	TInt r=log.Open(TheFs,LogFileName,EFileShareExclusive|EFileWrite);
 	if(r!=KErrNone)
 		test.Printf(_L("error=%d\n"),r);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	TInt size;
 	r=log.Size(size);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	TBuf8<16> buf;
 	buf.SetLength(4);
 	buf[0]=(TUint8)TheFunctionNumber;
 	buf[1]=(TUint8)TheOpNumber;
 	buf[2]=(TUint8)TheFailCount;
 	buf[3]='\n';
 	r=log.Write(size,buf,buf.Length());
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test.Printf(_L("Written func=%d,op=%d,fail=%d\n"),TheFunctionNumber,TheOpNumber,TheFailCount);
 	log.Close();
 	}
 LOCAL_C TInt SetWriteFailOn(TInt aFailCount)
 	test.Next(_L("ReadLogFile"));
 	RFile log;
 	TInt r=log.Open(TheFs,LogFileName,EFileShareExclusive);
 	if(r!=KErrNone)
 		test.Printf(_L("error in ReadLogFile()=%d\n"),r);
-	test(r==KErrNone);
+	test_KErrNone(r);
-	test(r==KErrNone);
 	TInt fileSize;
 	r=log.Size(fileSize);
 	if(fileSize==0)
 		{
 		TheFunctionNumber=0;
 /**
 Fill media with zeroes from aStartPos to aEndPos
 */
 static void DoZeroFillMedia(TInt64 aStartPos, TInt64 aEndPos, RRawDisk& aWriter)
 {
-test(aStartPos >=0 && aEndPos >=0 && aStartPos < aEndPos);
+	test(aStartPos >=0 && aEndPos >=0 && aStartPos < aEndPos);
 if(aStartPos == aEndPos)
 return;
 RBuf8 buf;
 TInt  nRes;
 const TUint32 KBufSz=65536*2; //-- buffer with zeroes
 nRes = buf.CreateMax(KBufSz);
-test(nRes == KErrNone);
+test_KErrNone(nRes);
 buf.FillZ();
 TUint32 rem = (TUint32)(aEndPos - aStartPos);
 while(rem)
 {
 const TUint32 bytesToWrite=Min(rem, KBufSz);
 TPtrC8 ptr(buf.Ptr(), bytesToWrite);
 nRes = aWriter.Write(aStartPos, ptr);
-test(nRes == KErrNone || nRes == KErrDiskFull);
+test_Value(nRes, nRes == KErrNone || nRes == KErrDiskFull);
 aStartPos+=bytesToWrite;
 rem-=bytesToWrite;
 }
 //
 LOCAL_C void ClearDiskData()
 	{
 	TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');
-	test(r==KErrNone);
+	test_KErrNone(r);
 	TUint32 startPos = gDataStartBytes;
 	if (gDiskType == EFat32)
 		startPos += gBytesPerCluster;
 static void DoReadBootSector()
 	{
 TInt nRes = ReadBootSector(TheFs, CurrentDrive(), KBootSectorNum<<KDefaultSectorLog2, BootSector);
-test(nRes == KErrNone);
+test_KErrNone(nRes);
 if(!BootSector.IsValid())
 {
 test.Printf(_L("Wrong bootsector! Dump:\n"));
 BootSector.PrintDebugInfo();
 	if (!gFatBuf)
 		{
 		gFatBuf=HBufC8::New(gBytesPerCluster);
-		test(gFatBuf!=NULL);
+		test_NotNull(gFatBuf);
 		gFatAddr = -1;
 		}
 	const TUint8* ptr;
 		{
 		TInt pos = PosInBytes(aIndex) + gFatStartBytes;
 		if (gFatAddr < 0 || pos < gFatAddr || pos >= gFatAddr + gBytesPerCluster)
 			{
 			TPtr8 ptr=gFatBuf->Des();
-		TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');
+			TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=TheRawDisk.Read(pos, ptr);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			TheRawDisk.Close();
 			gFatAddr = pos;
 			}
 		ptr = gFatBuf->Ptr() + pos-gFatAddr;
 		}
 	for (TInt cluster = aStart; cluster < aEnd; cluster++)
 		{
 		if (GetFatEntry(cluster, aFat) != 0)
 			{
 			HBufC8* buf=HBufC8::New(gBytesPerCluster);
-			test(buf!=NULL);
+			test_NotNull(buf);
 			TPtr8 ptr=buf->Des();
 			TInt r=TheRawDisk.Open(TheFs,gSessionPath[0]-'A');
-			test(r==KErrNone);
+			test_KErrNone(r);
 			r=TheRawDisk.Read(ClusterToByte(cluster), ptr);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			TheRawDisk.Close();
 			RDebug::Print(_L("Cluster %d @ 0x%08X:"), cluster, ClusterToByte(cluster));
 			DumpDirCluster(ptr.Ptr());
 			delete buf;
 			}
 	while(entriesSoFar<maxRootEntries)
 		{
 		dir[1]=TUint16(count/26+'a');
 		dir[2]=TUint16(count%26+'a');
 		r=TheFs.MkDir(dir);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		entriesSoFar+=2;
 		++count;
 		}
 	}
 	while(entriesSoFar>existing)
 		{
 		dir[1]=TUint16(count/26+'a');
 		dir[2]=TUint16(count%26+'a');
 		r=TheFs.RmDir(dir);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		entriesSoFar-=2;
 		++count;
 		}
 	}
 // Returns ETrue if aName is found
 //
 	{
 	TEntry entry;
 	TInt r=TheFs.Entry(aName,entry);
-	test(r==KErrNone||r==KErrNotFound);
+	test_Value(r, r==KErrNone||r==KErrNotFound);
 	return(r==KErrNone?(TBool)ETrue:(TBool)EFalse);
 	}
 LOCAL_C TInt EntriesPerFatSector()
 //
 //
 // returns entry details for the entry with aName
 //
 	{
 	TInt r=TheFs.Entry(aName,aEntry);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	}
 LOCAL_C TBool IsSameEntryDetails(TEntry aOldEntry,TEntry aNewEntry)
 //
 //
 	TInt entries=EntriesPerFatSector();
 	RFile file1,file2;
 	TInt size1,size2;
 	size1=size2=0;
 	TInt r=file1.Create(TheFs,aNameOne,EFileShareAny);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=file2.Create(TheFs,aNameTwo,EFileShareAny);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	// one entry for file1 for every 40 entries for file2
 	// if file 1 subseqently deleted then 7 entries available
 	// in that fat sector - ~3.5kb file size - for fat16
 	TInt ratio=40;
 	TBool first=ETrue;
 		{
 		if(first)
 			{
 			size1+=gBytesPerCluster;
 			r=file1.SetSize(size1);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			first=EFalse;
 			--entries;
 			}
 		else
 			{
 			size2+=gBytesPerCluster*ratio;
-			r=file1.SetSize(size1);
+			r=file2.SetSize(size2);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			first=ETrue;
 			entries-=ratio;
 			}
 		}
 	file1.Close();
 		while (fn.Length() < maxFileNameLen)
 			fn.Append('0');
 		TFileName fullName(aName);
 		fullName.Append(fn);
 		TInt r = TheFs.Delete(fullName);
-		test(r == KErrNone);
+		test_KErrNone(r);
 		entry += 1 + (fn.Length() + 12) / 13;
 		}
 	RDebug::Print(_L("CleanDirectory(%S, %d)"), &aName, aClusters);
 	}
 			fn.Append('0');
 		TFileName fullName(aName);
 		fullName.Append(fn);
 		RFile file;
 		TInt r = file.Create(TheFs,fullName,EFileShareAny);
-		test(r == KErrNone);
+		test_KErrNone(r);
 		file.Close();
 		entry += 1 + (fn.Length() + 12) / 13;
 		}
 	// to leave a directory expanded by aClusters but with no additional entries
 	RDebug::Print(_L("ExpandDirectory(%S, %d)"), &aName, aClusters);
 //
 // Deletes entry aName and corresponding entries created for EChainAlternate
 //
 	{
 	TInt r=TheFs.Delete(_L("\\fat\\file2"));
-	test(r==KErrNone||KErrNotFound);
+	test_Value(r, r==KErrNone||r==KErrNotFound);
 	if(aIsDir)
 		return(TheFs.RmDir(aName));
 	else
 		return(TheFs.Delete(aName));
 	}
 // Creates entry with aName where cluster chain grows forward but not contiguously.
 // Assumes that no holes in fat clusters.
 //
 	{
 	TInt r=DeleteAlternateEntry(aName,aIsDir);
-	test(r==KErrNone||r==KErrNotFound);
+	test_Value(r, r==KErrNone||r==KErrNotFound);
 	RFile file;
 	if(aIsDir)
 		{
 		r=TheFs.MkDir(aName);
 		if(r!=KErrNone)
 		{
 		r=file.Create(TheFs,aName,EFileShareAny);
 		if(r!=KErrNone)
 			return(r);
 		r=file.SetSize(1); //ensure file allocated a start cluster
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	CreateAlternate(_L("\\fat\\file1"),_L("\\fat\\file2"));
 	r=TheFs.Delete(_L("\\fat\\file1"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	if(aIsDir)
 		ExpandDirectory(aName,aSize);
 	else
 		{
 		r=file.SetSize(aSize);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		file.Close();
 		}
 	return(KErrNone);
 	}
 //
 // Deletes entry with aName and corresponding entries created for EChainForward
 //
 	{
 	TInt r=TheFs.Delete(_L("\\fat\\file2"));
-	test(r==KErrNone||r==KErrNotFound);
+	test_Value(r, r==KErrNone||r==KErrNotFound);
 	r=TheFs.Delete(_L("\\fat\\file4"));
-	test(r==KErrNone||r==KErrNotFound);
+	test_Value(r, r==KErrNone||r==KErrNotFound);
 	r=TheFs.Delete(_L("\\fat\\file5"));
-	test(r==KErrNone||r==KErrNotFound);
+	test_Value(r, r==KErrNone||r==KErrNotFound);
 	if(aIsDir)
 		r=TheFs.RmDir(aName);
 	else
 		r=TheFs.Delete(aName);
 	return r;
 // Creates an entry whose cluster chain first goes forward (upto 3.5kb for fat16 file)
 // and then backwards
 //
 	{
 	TInt r=DeleteForwardEntry(aName,aIsDir);
-	test(r==KErrNone||r==KErrNotFound);
+	test_Value(r, r==KErrNone||r==KErrNotFound);
 	RFile file1,file2,entry;
 	r=file1.Create(TheFs,_L("\\fat\\file1"),EFileShareAny);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=file1.SetSize(EntriesPerFatSector()*gBytesPerCluster);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=file2.Create(TheFs,_L("\\fat\\file2"),EFileShareAny);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=file2.SetSize(EntriesPerFatSector()*gBytesPerCluster);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	if(aIsDir)
 		{
 		r=TheFs.MkDir(aName);
 		if(r!=KErrNone)
 			return(r);
 		{
 		r=entry.Create(TheFs,aName,EFileShareAny);
 		if(r!=KErrNone)
 			return(r);
 		r=entry.SetSize(1);	// ensure entry has start cluster allocated
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	CreateAlternate(_L("\\fat\\file3"),_L("\\fat\\file4"));
 	RFile file5;
 	r=file5.Create(TheFs,_L("\\fat\\file5"),EFileShareAny);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=file5.SetSize(EntriesPerFatSector()*gBytesPerCluster*2);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	file1.Close();
 	file2.Close();
 	file5.Close();
 	r=TheFs.Delete(_L("\\fat\\file1"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.Delete(_L("\\fat\\file3"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	if(aIsDir)
 		ExpandDirectory(aName,aSize);
 	else
 		{
 		r=entry.SetSize(aSize);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		entry.Close();
 		}
 	return(KErrNone);
 	}
 //
 // Deletes entry with aName and corresponding entries created for EChainBackwards
 //
 	{
 	TInt r=TheFs.Delete(_L("\\fat\\file2"));
-	test(r==KErrNone||r==KErrNotFound);
+	test_Value(r, r==KErrNone||r==KErrNotFound);
 	r=TheFs.Delete(_L("\\fat\\file3"));
-	test(r==KErrNone||r==KErrNotFound);
+	test_Value(r, r==KErrNone||r==KErrNotFound);
 	if(aIsDir)
 		r=TheFs.RmDir(aName);
 	else
 		r=TheFs.Delete(aName);
 	return r;
 // Creates an entry whose fat cluster chain first goes backwards(upto 3.5kb for fat16 file)
 // and then forwards
 //
 	{
 	TInt r=DeleteBackwardEntry(aName,aIsDir);
-	test(r==KErrNone||r==KErrNotFound);
+	test_Value(r, r==KErrNone||r==KErrNotFound);
 	CreateAlternate(_L("\\fat\\file1"),_L("\\fat\\file2"));
 	RFile entry;
 	if(aIsDir)
 		{
 		r=TheFs.MkDir(aName);
 		{
 		r=entry.Create(TheFs,aName,EFileShareAny);
 		if(r!=KErrNone)
 			return(r);
 		r=entry.SetSize(1);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		}
 	RFile file3;
 	r=file3.Create(TheFs,_L("\\fat\\file3"),EFileShareAny);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=file3.SetSize(EntriesPerFatSector()*gBytesPerCluster);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.Delete(_L("\\fat\\file1"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	file3.Close();
 	if(aIsDir)
 		ExpandDirectory(aName,aSize);
 	else
 		{
 		r=entry.SetSize(aSize);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		entry.Close();
 		}
 	return(KErrNone);
 	}
 //
 // Creates entry with aName where the cluster chain grows contiguously
 //
 	{
 	TInt r=DeleteStdEntry(aName,aIsDir);
-	test(r==KErrNone||r==KErrNotFound);
+	test_Value(r, r==KErrNone||r==KErrNotFound);
 	if(aIsDir)
 		{
 		r=TheFs.MkDir(aName);
 		if(r==KErrNone)
 			ExpandDirectory(aName,aSize);
 		RFile file;
 		r=file.Create(TheFs,aName,EFileShareAny);
 		if(r==KErrNone)
 			{
 			r=file.SetSize(aSize);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			}
 		else if(r==KErrAlreadyExists)
 			{
 			TInt res =file.Open(TheFs,aName,EFileShareAny);
-			test(res==KErrNone);
+			test_KErrNone(res);
 			}
 		else
 			return(r);
 		file.Close();
 		return(r);
 	test.Start(_L("TestRFsDelete"));
 	FOREVER
 		{
 		test.Printf(_L("failCount=%d\n"),failCount);
 		r=CreateEntry(aName,EFalse,aChain,aFileSize);
-		test(r==KErrNone||r==KErrAlreadyExists);
+		test_Value(r, r==KErrNone||r==KErrAlreadyExists);
 		if(IsReset)
 			{
 			++TheFailCount;
 			WriteLogFile();
 			}
 		r=SetWriteFailOn(failCount);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.Delete(aName);
 		if(r==KErrNone)
 			break;
-		test(r==WriteFailValue);
+		test_Equal(WriteFailValue,r);
 		r=TheFs.ScanDrive(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.CheckDisk(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		++failCount;
 		}
 	r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.CheckDisk(gSessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(!EntryExists(aName));
 	++TheOpNumber;
 	TheFailCount=0;
 	}
 		}
 	FOREVER
 		{
 		test.Printf(_L("failCount=%d\n"),failCount);
 		r=CreateEntry(aName,ETrue,aChain,aDirSize);
-		test(r==KErrNone||r==KErrAlreadyExists);
+		test_Value(r, r==KErrNone||r==KErrAlreadyExists);
 		if(IsReset)
 			{
 			++TheFailCount;
 			WriteLogFile();
 			}
 		r=SetWriteFailOn(failCount);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.RmDir(aName);
 		if(r==KErrNone)
 			break;
-		test(r==WriteFailValue);
+		test_Equal(WriteFailValue,r);
 		r=TheFs.ScanDrive(gSessionPath);
 		RDebug::Print(_L("%6d: ScanDrive = %d"), __LINE__, r);
 		if (r != KErrNone)
 		{
 			RDebug::Print(_L("ScanDrive fail %d"), r);
 			DumpFat();
 			DumpData(NULL, 0, 200);
 		}
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.CheckDisk(gSessionPath);
 		RDebug::Print(_L("%6d: CheckDisk = %d"), __LINE__, r);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		++failCount;
 		}
 	r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.CheckDisk(gSessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(!EntryExists(aName));
 	++TheOpNumber;
 	TheFailCount=0;
 	}
 	test.Next(_L("TestRFsMkDir"));
 	FOREVER
 		{
 		test.Printf(_L("failCount=%d\n"),failCount);
 		r=DeleteEntry(aName,ETrue,EChainStd);
-		test(r==KErrNone||r==KErrNotFound);
+		test_Value(r, r==KErrNone||r==KErrNotFound);
 		if(IsReset)
 			{
 			++TheFailCount;
 			WriteLogFile();
 			}
 		r=SetWriteFailOn(failCount);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.MkDir(aName);
 		if(r==KErrNone)
 			break;
-		test(r==WriteFailValue);
+		test_Equal(WriteFailValue,r);
 		r=TheFs.ScanDrive(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.CheckDisk(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		++failCount;
 		}
 	r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.CheckDisk(gSessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(EntryExists(aName));
 	r=DeleteEntry(aName,ETrue,EChainStd);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	++TheOpNumber;
 	TheFailCount=0;
 	}
 LOCAL_C void TestRFsRename(const TDesC& aOldName,const TDesC& aNewName,TBool aIsDir,TFatChain aChain,TInt aSize)
 	TEntry oldEntryInfo,newEntryInfo;
 	FOREVER
 		{
 		test.Printf(_L("failCount=%d\n"),failCount);
 		r=CreateEntry(aOldName,aIsDir,aChain,aSize);
-		test(r==KErrNone||r==KErrAlreadyExists);
+		test_Value(r, r==KErrNone||r==KErrAlreadyExists);
 		r=DeleteEntry(aNewName,aIsDir,aChain);
-		test(r==KErrNone||r==KErrNotFound);
+		test_Value(r, r==KErrNone||r==KErrNotFound);
 		GetEntryDetails(aOldName,oldEntryInfo);
 		if(IsReset)
 			{
 			++TheFailCount;
 			WriteLogFile();
 			}
 		r=SetWriteFailOn(failCount);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.Rename(aOldName,aNewName);
 		if(r==KErrNone)
 			break;
-		if(r!=WriteFailValue)
+		test_Equal(WriteFailValue,r);
-			{
-			test.Printf(_L("r=%d\n"),r);
-			test(EFalse);
-			}
-		test(r==WriteFailValue);
 		r=TheFs.ScanDrive(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.CheckDisk(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		// no start cluster if aSize==0
 		if(aSize!=0)
 			test(OneEntryExists(aOldName,aNewName));
 		++failCount;
 		}
 	r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.CheckDisk(gSessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(EntryExists(aNewName) && !EntryExists(aOldName));
 	GetEntryDetails(aNewName,newEntryInfo);
 	test(IsSameEntryDetails(oldEntryInfo,newEntryInfo));
 	r=DeleteEntry(aNewName,aIsDir,aChain);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	++TheOpNumber;
 	TheFailCount=0;
 	}
 LOCAL_C void TestRFsReplace(const TDesC& aOldName, const TDesC& aNewName,TBool aBothExist,TFatChain aChain,TInt aFileSize)
 	TEntry oldEntryInfo,newEntryInfo;
 	FOREVER
 		{
 		test.Printf(_L("failCount=%d\n"),failCount);
 		r=CreateEntry(aOldName,EFalse,aChain,aFileSize);
-		test(r==KErrNone||r==KErrAlreadyExists);
+		test_Value(r, r==KErrNone||r==KErrAlreadyExists);
 		if(aBothExist)
 			{
 			r=CreateEntry(aNewName,EFalse,aChain,aFileSize);
-			test(r==KErrNone||r==KErrAlreadyExists);
+			test_Value(r, r==KErrNone||r==KErrAlreadyExists);
 			}
 		else
 			{
 			r=DeleteEntry(aNewName,EFalse,aChain);
-			test(r==KErrNone||r==KErrNotFound);
+			test_Value(r, r==KErrNone||r==KErrNotFound);
 			}
 		GetEntryDetails(aOldName,oldEntryInfo);
 		if(IsReset)
 			{
 			++TheFailCount;
 			WriteLogFile();
 			}
 		r=SetWriteFailOn(failCount);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.Replace(aOldName,aNewName);
 		if(r==KErrNone)
 			break;
-		test(r==WriteFailValue);
+		test_Equal(WriteFailValue,r);
 		r=TheFs.ScanDrive(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.CheckDisk(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		if(!aBothExist && aFileSize!=0)
 			test(OneEntryExists(aOldName,aNewName));
 		else if(aBothExist)
 			test(EntryExists(aOldName)||EntryExists(aNewName));
 		++failCount;
 		}
 	r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.CheckDisk(gSessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(EntryExists(aNewName) && !EntryExists(aOldName));
 	GetEntryDetails(aNewName,newEntryInfo);
 	test(IsSameEntryDetails(oldEntryInfo,newEntryInfo));
 	r=DeleteEntry(aNewName,EFalse,aChain);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	++TheOpNumber;
 	TheFailCount=0;
 	}
 LOCAL_C void TestRFileCreate(const TDesC& aName)
 	test.Next(_L("TestRFileCreate"));
 	FOREVER
 		{
 		test.Printf(_L("failCount=%d\n"),failCount);
 		r=DeleteEntry(aName,EFalse,EChainStd);
-		test(r==KErrNone||r==KErrNotFound);
+		test_Value(r, r==KErrNone||r==KErrNotFound);
 		if(IsReset)
 			{
 			++TheFailCount;
 			WriteLogFile();
 			}
 		r=SetWriteFailOn(failCount);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		RFile file;
 		r=file.Create(TheFs,aName,EFileShareAny);
 		if(r==KErrNone)
 			{
 			r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			file.Close();
 			break;
 			}
-		test(r==WriteFailValue);
+		test_Equal(WriteFailValue,r);
 		r=TheFs.ScanDrive(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.CheckDisk(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		++failCount;
 		}
 	r=TheFs.CheckDisk(gSessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(EntryExists(aName));
 	r=DeleteEntry(aName,EFalse,EChainStd);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	++TheOpNumber;
 	TheFailCount=0;
 	}
 LOCAL_C void TestRFileTemp(const TDesC& aPath)
 			{
 			++TheFailCount;
 			WriteLogFile();
 			}
 		r=SetWriteFailOn(failCount);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		RFile file;
 		r=file.Temp(TheFs,aPath,temp,EFileShareAny);
 		if(r==KErrNone)
 			{
 			r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			file.Close();
 			break;
 			}
 		test(r==WriteFailValue);
 		r=TheFs.ScanDrive(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.CheckDisk(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		++failCount;
 		}
 	r=TheFs.CheckDisk(gSessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(EntryExists(temp));
 	r=DeleteEntry(temp,EFalse,EChainStd);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	++TheOpNumber;
 	TheFailCount=0;
 	}
 LOCAL_C void TestRFileRename(const TDesC& aOldName, const TDesC& aNewName,TFatChain aChain,TInt aFileSize)
 	TEntry oldEntryInfo,newEntryInfo;
 	FOREVER
 		{
 		test.Printf(_L("failCount=%d\n"),failCount);
 		r=CreateEntry(aOldName,EFalse,aChain,aFileSize);
-		test(r==KErrNone||r==KErrAlreadyExists);
+		test_Value(r, r==KErrNone||r==KErrAlreadyExists);
 		r=DeleteEntry(aNewName,EFalse,aChain);
-		test(r==KErrNone||r==KErrNotFound);
+		test_Value(r, r==KErrNone||r==KErrNotFound);
 		GetEntryDetails(aOldName,oldEntryInfo);
 		if(IsReset)
 			{
 			++TheFailCount;
 			WriteLogFile();
 			}
 		RFile file;
 		r=file.Open(TheFs,aOldName,EFileShareExclusive|EFileWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=SetWriteFailOn(failCount);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=file.Rename(aNewName);
 		if(r==KErrNone)
 			{
 			r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			file.Close();
 			break;
 			}
-		test(r==WriteFailValue);
+		test_Equal(WriteFailValue,r);
 		file.Close();
 		r=TheFs.ScanDrive(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.CheckDisk(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		if(aFileSize)
 			test(OneEntryExists(aOldName,aNewName));
 		++failCount;
 		}
 	r=TheFs.CheckDisk(gSessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(EntryExists(aNewName) && !EntryExists(aOldName));
 	GetEntryDetails(aNewName,newEntryInfo);
 	test(IsSameEntryDetails(oldEntryInfo,newEntryInfo));
 	r=DeleteEntry(aNewName,EFalse,aChain);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	++TheOpNumber;
 	TheFailCount=0;
 	}
 LOCAL_C void TestRFileReplace(const TDesC& aName,TBool aAlreadyExists,TFatChain aChain,TInt aFileSize)
 		{
 		test.Printf(_L("failCount=%d\n"),failCount);
 		if(aAlreadyExists)
 			{
 			r=CreateEntry(aName,EFalse,aChain,aFileSize);
-			test(r==KErrNone||r==KErrAlreadyExists);
+			test_Value(r, r==KErrNone||r==KErrAlreadyExists);
 			}
 		else
 			{
 			r=DeleteEntry(aName,EFalse,aChain);
-			test(r==KErrNone||r==KErrNotFound);
+			test_Value(r, r==KErrNone||r==KErrNotFound);
 			}
 		if(IsReset)
 			{
 			++TheFailCount;
 			WriteLogFile();
 			}
 		r=SetWriteFailOn(failCount);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		RFile file;
 		r=file.Replace(TheFs,aName,EFileShareAny);
 		if(r==KErrNone)
 			{
 			r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			file.Close();
 			break;
 			}
-		test(r==WriteFailValue);
+		test_Equal(WriteFailValue,r);
 		r=TheFs.ScanDrive(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.CheckDisk(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		++failCount;
 		}
 	r=TheFs.CheckDisk(gSessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	test(EntryExists(aName));
 	r=DeleteEntry(aName,EFalse,aChain);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	if(!aAlreadyExists)
 		{
 		++TheOpNumber;
 		TheFailCount=0;
 		}
 	test.Printf(_L("old size=%d new size=%d\n"),aOldFileSize,aNewFileSize);
 	FOREVER
 		{
 		test.Printf(_L("failCount=%d\n"),failCount);
 		r=CreateEntry(aName,EFalse,aChain,aOldFileSize);
-		test(r==KErrNone||r==KErrAlreadyExists);
+		test_Value(r, r==KErrNone||r==KErrAlreadyExists);
 		if(IsReset)
 			{
 			++TheFailCount;
 			WriteLogFile();
 			}
 		r=SetWriteFailOn(failCount);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		RFile file;
 		r=file.Open(TheFs,aName,EFileShareAny|EFileWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=file.SetSize(aNewFileSize);
 		// close the file before testing the return value!
 		file.Close();
 		if(r==KErrNone)
 			{
 			r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			file.Close();
 			break;
 			}
 		file.Close();
-		test(r==WriteFailValue);
+		test_Equal(WriteFailValue,r);
 		r=TheFs.ScanDrive(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.CheckDisk(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=file.Open(TheFs,aName,EFileShareAny|EFileWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		TInt size;
 		r=file.Size(size);
-		test(r==KErrNone);
+		test_KErrNone(r);
-		test(size==aNewFileSize||size==aOldFileSize);
+		test_Value(size, size==aNewFileSize||size==aOldFileSize);
 		file.Close();
 		++failCount;
 		}
 	r=TheFs.CheckDisk(gSessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	RFile file;
 	r=file.Open(TheFs,aName,EFileShareAny);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	TInt fileSize;
 	r=file.Size(fileSize);
-	test(r==KErrNone);
+	test_KErrNone(r);
-	test(aNewFileSize==fileSize);
+	test_Equal(aNewFileSize,fileSize);
 	file.Close();
 	r=DeleteEntry(aName,EFalse,aChain);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	++TheFunctionNumber;
 	TheFailCount=0;
 	}
 LOCAL_C void TestRFileWrite(const TDesC& aName,TFatChain aChain,TInt aFileSize,TInt aPos,TInt aLength)
 	test.Next(_L("TestRFileWrite"));
 	test.Printf(_L("aFileSize=%d,aPos=%d,aLength=%d\n"),aFileSize,aPos,aLength);
 	TInt newSize=(aFileSize>=aPos+aLength)?aFileSize:aPos+aLength;
 	HBufC8* desPtr;
 	desPtr=HBufC8::New(aLength);
-	test(desPtr!=NULL);
+	test_NotNull(desPtr);
 	TPtr8 des=desPtr->Des();
 	des.SetLength(aLength);
 	InitialiseWriteBuffer(des);
 	FOREVER
 		{
 		test.Printf(_L("failCount=%d\n"),failCount);
 		r=CreateEntry(aName,EFalse,aChain,aFileSize);
-		test(r==KErrNone||r==KErrAlreadyExists);
+		test_Value(r, r==KErrNone||r==KErrAlreadyExists);
 		if(IsReset)
 			{
 			++TheFailCount;
 			WriteLogFile();
 			}
 		r=SetWriteFailOn(failCount);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		RFile file;
 		r=file.Open(TheFs,aName,EFileShareAny|EFileWrite);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=file.Write(aPos,des,aLength);
 		if(r==KErrNone)
 			{
 			r=TheFs.ControlIo(gSessionPath[0]-'A',KControlIoWriteFailOff);
-			test(r==KErrNone);
+			test_KErrNone(r);
 			file.Close();
 			break;
 			}
-		test(r==WriteFailValue);
+		test_Equal(WriteFailValue,r);
 		file.Close();
 		r=TheFs.ScanDrive(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		r=TheFs.CheckDisk(gSessionPath);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		file.Open(TheFs,aName,EFileShareAny);
-		test(r==KErrNone);
+		test_KErrNone(r);
 		TInt fileSize;
 		r=file.Size(fileSize);
 		// with fair scheduling enabled it's possible for the file
 		// size to grow even if the write appears to have failed...
-//		test(fileSize==aFileSize||fileSize==newSize);
+//		test_Value(fileSize, fileSize==aFileSize||fileSize==newSize);
-		test(fileSize>=aFileSize && fileSize <= newSize);
+		test_Value(fileSize, fileSize>=aFileSize && fileSize <= newSize);
 		file.Close();
 		++failCount;
 		}
 	r=TheFs.CheckDisk(gSessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	RFile file;
 	r=file.Open(TheFs,aName,EFileShareAny);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	TInt fileSize;
 	r=file.Size(fileSize);
-	test(r==KErrNone);
+	test_KErrNone(r);
-	test(newSize==fileSize);
+	test_Equal(newSize,fileSize);
 	HBufC8* desPtr2;
 	desPtr2=HBufC8::New(aLength);
-	test(desPtr2!=NULL);
+	test_NotNull(desPtr2);
 	TPtr8 des2=desPtr2->Des();
 	des2.SetLength(aLength);
 	r=file.Read(aPos,des2,des2.Length());
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=des2.Compare(des);
-	test(r==0);
+	test_KErrNone(r);
 	file.Close();
 	r=DeleteEntry(aName,EFalse,aChain);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	delete desPtr;
 	delete desPtr2;
 	++TheFunctionNumber;
 	TheFailCount=0;
 	}
 	DoReadBootSector();
 	DumpBootSector();
 	ClearDiskData();
 	r=TheFs.SetSessionPath(gSessionPath);
-	test(r==KErrNone);
+	test_KErrNone(r);
 	switch(TheFunctionNumber)
 		{
 		case(0):TestOperation0();
 		case(1):{
 				TestOperation1();
 				r=TheFs.MkDir(_L("\\fat\\"));
-				test(r==KErrNone);
+				test_KErrNone(r);
 				r=TheFs.MkDir(_L("\\test\\"));
-				test(r==KErrNone);
+				test_KErrNone(r);
 				r=TheFs.MkDir(_L("\\ANother\\"));
-				test(r==KErrNone);
+				test_KErrNone(r);
 				r=TheFs.MkDir(_L("\\test\\subdir1\\"));
-				test(r==KErrNone);
+				test_KErrNone(r);
 				r=TheFs.MkDir(_L("\\test\\subdir2\\"));
-				test(r==KErrNone);}
+				test_KErrNone(r);}
 		case(2):{
 				TestOperation2();
 				// add some filler files
 				CreateEntry(_L("\\test\\subdir1\\FillerOne"),EFalse,EChainStd,512);
 				CreateEntry(_L("\\test\\subdir1\\FillerTwo"),EFalse,EChainStd,1024);}
 	DeleteEntry(_L("\\test\\subdir1\\FillerFour"),EFalse,EChainStd);
 	DeleteEntry(_L("\\ANother\\FillerThree"),EFalse,EChainStd);
 	DeleteEntry(_L("\\test\\subdir1\\FillerTwo"),EFalse,EChainStd);
 	DeleteEntry(_L("\\test\\subdir1\\FillerOne"),EFalse,EChainStd);
 	r=TheFs.RmDir(_L("\\test\\subdir2\\"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.RmDir(_L("\\test\\subdir1\\"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.RmDir(_L("\\ANother\\"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.RmDir(_L("\\test\\"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	r=TheFs.RmDir(_L("\\fat\\"));
-	test(r==KErrNone);
+	test_KErrNone(r);
 	if (gFatBuf)
 		{
 		delete gFatBuf;
 		gFatBuf = NULL;
 		}

branch	RCL_3
changeset 43	c1f20ce4abcf
parent 42	a179b74831c9
child 44	3e88ff8f41d5