FCL/sf/os/kernelhwsrv: comparison kerneltest/f32test/filesystem/fat/b

equal deleted inserted replaced

-:ef2a444a7410
+:b3a1d9898418
 // Description:
 // f32test\server\b_fat32.cpp
 //
 //
+#define	__E32TEST_EXTENSION__
 #include <f32file.h>
 #include <e32test.h>
 #include <e32math.h>
 #include "fat_utils.h"
 ptr = (TUint8*)aFat + pos;
 else
 {
 pos += TheBootSector.ReservedSectors() * TheBootSector.BytesPerSector();
 TInt r=TheDisk.Open(TheFs,gSessionPath[0]-'A');
-test(r==KErrNone);
+test_KErrNone(r);
 TPtr8 buf(&data[0], 4);
 r=TheDisk.Read(pos, buf);
-test(r==KErrNone);
+test_KErrNone(r);
 TheDisk.Close();
 }
 TUint32 val = 0;
 switch (gDiskType)
 {
 TInt pos = PosInBytes(aIndex);
 pos += TheBootSector.ReservedSectors() * TheBootSector.BytesPerSector();
 TInt r=TheDisk.Open(TheFs,gSessionPath[0]-'A');
-test(r==KErrNone);
+test_KErrNone(r);
 TUint8  data[4];
 TPtr8 buf(&data[0], 4);
 r=TheDisk.Read(pos, buf);
-test(r==KErrNone);
+test_KErrNone(r);
 data[3] &= 0x0F;
 data[3] |= 0xA0;
 r=TheDisk.Write(pos, buf);
-test(r==KErrNone);
+test_KErrNone(r);
 TheDisk.Close();
 }
 void DumpBootSector()
 //
 {
 HBufC8* buf=HBufC8::New(gBytesPerCluster);
 test(buf!=NULL);
 TPtr8 ptr=buf->Des();
 TInt r=TheDisk.Open(TheFs,gSessionPath[0]-'A');
-test(r==KErrNone);
+test_KErrNone(r);
 r=TheDisk.Read(ClusterToByte(cluster), ptr);
-test(r==KErrNone);
+test_KErrNone(r);
 TheDisk.Close();
 RDebug::Print(_L("Cluster %d @ 0x%08X:"), cluster, ClusterToByte(cluster));
 DumpDirCluster(ptr.Ptr());
 delete buf;
 }
 TInt ent = 0;
 HBufC8* buf=HBufC8::New(KSizeOfFatDirEntry);
 test(buf!=NULL);
 TPtr8 ptr=buf->Des();
 TInt r=TheDisk.Open(TheFs,gSessionPath[0]-'A');
-test(r==KErrNone);
+test_KErrNone(r);
 RDebug::Print(_L("--------------- ROOT DIR ------------------"));
 for (TInt i = 0; i < num; i++)
 {
 r=TheDisk.Read(pos, ptr);
-test(r==KErrNone);
+test_KErrNone(r);
 if (!DumpDirEntry(ent, ptr.Ptr()))
 break;
 pos += KSizeOfFatDirEntry;
 }
 RDebug::Print(_L("-------------------------------------------"));
 default:
 test(0);
 }
 TInt r=TheDisk.Open(TheFs,CurrentDrive());
-test(r==KErrNone);
+test_KErrNone(r);
 test(ReadWriteDWord(pos,mask,aValue)==KErrNone);
 TheDisk.Close();
 }
 static  void TestRwWord(TInt64 aPos,TInt anErr)
 FatWrite(clust,gEndOfChain);
 if ((r=TheFs.Delete(_L("\\LOOPED1.TMP")))!=KErrNone)
 Error(_L("Error deleting file"),r);
 RDebug::Print(_L("File removed"));
 r=TheFs.CheckDisk(gSessionPath);
-test(r==KErrNone);
+test_KErrNone(r);
 }
 static  void TestFatEntry(TUint16 aFileSize,TInt aCorruptFatCluster)
 //
 // Test fat entry
 TInt r;
 test.Printf(_L("File size=%d, cluster value=0x%x\n"),aFileSize,aCorruptFatCluster);
 FormatPack();
 r=TheFile.Replace(TheFs,_L("\\CORRUPT2.TMP"),EFileRead|EFileWrite);
-test(r==KErrNone);
+test_KErrNone(r);
 TheBuffer.SetLength(aFileSize);
 Mem::Fill(&TheBuffer[0],aFileSize,'A');
 r=TheFile.Write(TheBuffer);
-test(r==KErrNone);
+test_KErrNone(r);
 TheFile.Close();
 FatWrite(gFirstDataCluster,aCorruptFatCluster);
 TInt pos=0;
 r=TheFile.Open(TheFs,_L("\\CORRUPT2.TMP"),EFileRead|EFileWrite);
-test(r==KErrNone || r==KErrCorrupt);
+test_Value(r, r == KErrNone || r==KErrCorrupt);
 if (r==KErrNone)
 {
 r=TheFile.Seek(ESeekStart,pos);
-test(r==KErrNone);
+test_KErrNone(r);
 r=TheFile.Write(TheBuffer);
 if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))
 r = TheFile.Flush();
 FatWrite(gFirstDataCluster,gEndOfChain);
 pos=0;
 r=TheFile.Open(TheFs,_L("\\CORRUPT2.TMP"),EFileRead|EFileWrite);
-test(r==KErrNone);
+test_KErrNone(r);
 r=TheFile.Seek(ESeekStart,pos);
-test(r==KErrNone);
+test_KErrNone(r);
 r=TheFile.Write(TheBuffer);
 if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))
 r = TheFile.Flush();
 test(TheFile.Create(TheFs,_L("\\CORRUPT1.TMP"),EFileRead|EFileWrite)==KErrNone);
 TheBuffer.SetLength(anInitialSize);
 Mem::Fill(&TheBuffer[0],anInitialSize,'A');
 r=TheFile.Write(TheBuffer);
-test(r==KErrNone);
+test_KErrNone(r);
 TheFile.Close();
 r=TheDisk.Open(TheFs,CurrentDrive());
-test(r==KErrNone);
+test_KErrNone(r);
 TPtr8 sectorBuf((TUint8*)pBuffer1->Ptr(),TheBootSector.BytesPerSector());
 TInt pos = gRootDirStart;
 r=TheDisk.Read(pos,sectorBuf);
-test(r==KErrNone);
+test_KErrNone(r);
 TFatDirEntry* pE=(TFatDirEntry*)pBuffer1->Ptr();
 while (pE->IsVFatEntry())   //  UNICODE entries are VFat by definition
 pE++;
 pE->SetStartCluster(aCorruptStartCluster);
 //-- a small hack to avoid problems with the fact that FAT[1] entry
 //-- is now used for marking volume as clean.  TheDisk.Close() cause volume remout and
 //-- the data
 TheDisk.Close();
 r=TheDisk.Open(TheFs,CurrentDrive());
-test(r==KErrNone);
+test_KErrNone(r);
 pos=0;
 TPtr8 buffer1(pBuffer1->Des());
 r=TheDisk.Read(pos,buffer1);
-test(r==KErrNone);
+test_KErrNone(r);
 TheDisk.Close();
 r=TheFs.Entry(_L("\\CORRUPT1.TMP"),TheEntry);
-test(r==KErrNone || r==KErrCorrupt);
+test_Value(r, r == KErrNone || r==KErrCorrupt);
 TTime saveTime=TheEntry.iModified;
 if (r!=KErrNone)
 saveTime.HomeTime();
 r=TheFile.Open(TheFs,_L("\\CORRUPT1.TMP"),EFileRead|EFileWrite);
 }
 TheFile.Close();
 }
 r=TheDisk.Open(TheFs,CurrentDrive());
-test(r==KErrNone);
+test_KErrNone(r);
 pos=0;
 TPtr8 buffer2(pBuffer2->Des());
 r=TheDisk.Read(pos,buffer2);
-test(r==KErrNone);
+test_KErrNone(r);
 //-- this bit is dodgy. The buffers may differ because of volume finalisation stuff
 //-- FAT[1] and FSInfo sectors
 test(buffer1==buffer2);
 TheDisk.Close();
 r=TheFs.SetModified(_L("\\CORRUPT1.TMP"),saveTime);
-test(r==KErrNone || r==KErrCorrupt);
+test_Value(r, r == KErrNone || r==KErrCorrupt);
 r=TheFs.Entry(_L("\\CORRUPT1.TMP"),TheEntry);
-test(r==KErrNone || r==KErrCorrupt);
+test_Value(r, r == KErrNone || r==KErrCorrupt);
 }
 static  void TestBounds()
 //
 // Test reading/writing past the end of a drive
 {
 test.Next(_L("Test read/write past boundaries"));
 test(TheFs.Volume(TheVolumeInfo,CurrentDrive())==KErrNone);
 TInt64 size=TheVolumeInfo.iSize;
 TInt r=TheDisk.Open(TheFs,CurrentDrive());
-test(r==KErrNone);
+test_KErrNone(r);
 TPtr8 buffer(pBuffer1->Des());
 TInt64 pos=size - 2*buffer.MaxLength();
 TInt inc=buffer.MaxLength();
 FOREVER
 {
 TPtr8 tempbuf((TUint8*)pBuffer1->Ptr(),inc);
 r=TheDisk.Read(pos,tempbuf);
 test.Printf(_L("Read %08X:%08X len %d r %d\r"), I64HIGH(pos),I64LOW(pos), inc, r);
-test(r==KErrNone || r==KErrCorrupt);
+test_Value(r, r == KErrNone || r==KErrCorrupt);
 if (r==KErrNone)
 pos+=inc;
 else
 {
 inc>>=1;
 {
 TPtr8 temp((TUint8*) (pBuffer1->Ptr()), (TInt) bsize);
 TInt expect = (lpos+bsize-1 < maxpos ? KErrNone : KErrCorrupt);
 r=TheDisk.Read(lpos, temp);
 RDebug::Print(_L("Read %08X:%08X result %d     \r"), I64HIGH(lpos), I64LOW(lpos), r);
-test(r==expect);
+test_Value(r, r == expect);
 }
 }
 }
 RDebug::Print(_L("\n"));
 RFile f;
 TInt r;
 r=f.Replace(TheFs,_L("\\GOBLIN.TMP"),EFileRead|EFileWrite);
-test(r==KErrNone);
+test_KErrNone(r);
 f.SetSize(4*gBytesPerCluster); // 4 Clusters
 f.Close();
 r=f.Replace(TheFs,_L("\\WIZARD.TMP"),EFileRead|EFileWrite);
-test(r==KErrNone);
+test_KErrNone(r);
 f.SetSize(5*gBytesPerCluster); // 5 Clusters
 f.Close();
 r=f.Replace(TheFs,_L("\\TROLL.TMP"),EFileRead|EFileWrite);
-test(r==KErrNone);
+test_KErrNone(r);
 f.SetSize(3*gBytesPerCluster); // 3 Clusters
 f.Close();
 r=f.Replace(TheFs,_L("\\GNOME.TMP"),EFileRead|EFileWrite);
-test(r==KErrNone);
+test_KErrNone(r);
 f.SetSize(10*gBytesPerCluster); // 10 Clusters
 f.Close();
 r=f.Replace(TheFs,_L("\\CYCLOPS.TMP"),EFileRead|EFileWrite);
-test(r==KErrNone);
+test_KErrNone(r);
 f.SetSize(gBytesPerCluster); // 1 Cluster
 f.Close();
 r=f.Replace(TheFs,_L("\\PIXIE.TMP"),EFileRead|EFileWrite);
-test(r==KErrNone);
+test_KErrNone(r);
 f.SetSize(gBytesPerCluster); // 1 Cluster
 f.Close();
 r=TheDisk.Open(TheFs,CurrentDrive());
-test(r==KErrNone);
+test_KErrNone(r);
 TPtr8 sectorBuf((TUint8*)pBuffer1->Ptr(),TheBootSector.BytesPerSector());
 TInt pos = gRootDirStart;
 test(TheDisk.Read(pos,sectorBuf)==KErrNone);
 TheDisk.Close();
 test((pE->StartCluster()-cluster)==1);
 name=pE->Name();
 test(name==_L8("PIXIE   TMP"));
 r=TheFs.Delete(_L("\\GOBLIN.TMP"));
-test(r==KErrNone);
+test_KErrNone(r);
 r=TheFs.Delete(_L("\\WIZARD.TMP"));
-test(r==KErrNone);
+test_KErrNone(r);
 r=TheFs.Delete(_L("\\TROLL.TMP"));
-test(r==KErrNone);
+test_KErrNone(r);
 r=TheFs.Delete(_L("\\GNOME.TMP"));
-test(r==KErrNone);
+test_KErrNone(r);
 r=TheFs.Delete(_L("\\CYCLOPS.TMP"));
-test(r==KErrNone);
+test_KErrNone(r);
 r=TheFs.Delete(_L("\\PIXIE.TMP"));
-test(r==KErrNone);
+test_KErrNone(r);
 FormatPack();
 }
 //
 {
 test.Printf(_L("Checking cluster %02d, parent %d: \"%S\"\n"), aNewClust, aParentClust, &aName);
 TInt r=TheFs.MkDir(aName);
-test(r==KErrNone || r==KErrAlreadyExists);
+test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 TInt pos=ClusterToByte(aNewClust);
 TPtr8 sectorBuf((TUint8*)pBuffer1->Ptr(),gBytesPerCluster);
 r=TheDisk.Open(TheFs,CurrentDrive());
 CreateFatEntry(_L("\\"), EFalse);
 }
 r = f.Create(TheFs, _L("\\123456.78"), EFileRead|EFileWrite);
-test(r==KErrDirFull);
+test_Value(r, r == KErrDirFull);
 f.Close();
 TInt i=0;
 for (i=0;i<KMaxFiles;i++)
 {
 r=TheFs.Delete(fileName[i]);
-test(r==KErrNone);
+test_KErrNone(r);
 }
 r=TheFs.SetSessionPath(_L("\\"));
-test(r==KErrNone);
+test_KErrNone(r);
 TInt nameLength=(KMaxFiles-1)*13;   // -1 for zero terminator
 CreateLongName(tempName,gSeed,nameLength*2);
 r=f.Create(TheFs,tempName,0);       //  Needs 9 free entries - there are only 5 available
-test(r==KErrDirFull);
+test_Value(r, r == KErrDirFull);
 tempName.SetLength(nameLength+1);
 r=f.Create(TheFs,tempName,0);       //  Needs 6 free entries - there are only 5 available
-test(r==KErrDirFull);
+test_Value(r, r == KErrDirFull);
 tempName.SetLength(nameLength);
 r=f.Create(TheFs,tempName,0);       //  Needs 5 free entries - there are 5 available
-test(r==KErrNone);
+test_KErrNone(r);
 f.Close();
 #if 0       // This is the old test that assumed UNICODE builds
 // which created VFAT entries even for uppercase 8.3 file names
 TInt i=0;
 for (i=0;i<KMaxFiles-2;i++)
 {
 r=TheFs.Delete(fileName[i]);    //  UNICODE build - free 6 entries (delete 3 files)
-test(r==KErrNone);
+test_KErrNone(r);
 }
 r=TheFs.SetSessionPath(_L("\\"));
-test(r==KErrNone);
+test_KErrNone(r);
 TInt vFatUnitNameSize=13;
 TInt nameLength=(KMaxFiles-1)*vFatUnitNameSize-1;   //
 CreateLongName(tempName,gSeed,nameLength*2);
 r=f.Create(TheFs,tempName,0);                       //  Needs 9 free entries
-test(r==KErrDirFull);
+test_Value(r, r == KErrDirFull);
 nameLength=(KMaxFiles)*vFatUnitNameSize;
 tempName.SetLength(nameLength+1);
 r=f.Create(TheFs,tempName,0);                       //  Needs 7 free entries
-test(r==KErrDirFull);
+test_Value(r, r == KErrDirFull);
 tempName.SetLength(nameLength);
 r=f.Create(TheFs,tempName,0);                       //  Needs 6 free entries
-test(r==KErrNone);
+test_KErrNone(r);
 f.Close();
 #endif
 TheFs.Delete(tempName);
 tempName.SetLength(nameLength-7);
 r=f.Create(TheFs,tempName,0);
-test(r==KErrNone);
+test_KErrNone(r);
 f.Close();
 r=f.Create(TheFs,_L("ASDF"),0);
-test(r==KErrDirFull);
+test_Value(r, r == KErrDirFull);
 TheFs.Delete(tempName);
 tempName.SetLength(nameLength-15);
 r=f.Create(TheFs,tempName,0);
-test(r==KErrNone);
+test_KErrNone(r);
 f.Close();
 tempName=_L("testname");
 r=f.Create(TheFs,tempName,0);
-test(r==KErrDirFull);
+test_Value(r, r == KErrDirFull);
 tempName.UpperCase();
 r=f.Create(TheFs,tempName,0);
-test(r==KErrNone);
+test_KErrNone(r);
 f.Close();
 r=TheFs.SetSessionPath(gSessionPath);
-test(r==KErrNone);
+test_KErrNone(r);
 }
 static  void TestVolumeSize()
 //
 // Test the volume size is zero when empty
 test.Next(_L("Test the volume size"));
 FormatPack();
 TVolumeInfo volInfo;
 TInt r=TheFs.Volume(volInfo);
-test(r==KErrNone);
+test_KErrNone(r);
 TInt64 calcsize = MAKE_TINT64(0, gClusterCount)*gBytesPerCluster;
 if (volInfo.iSize > calcsize)
 {
 test.Printf(_L("volInfo.iSize = %ld\n"), volInfo.iSize);
 test.Printf(_L("volInfo.iFree = %ld\n"), volInfo.iFree);
 for (i=0;i<KMaxFiles;i++)
 {
 fileName=_L("\\File");
 fileName.AppendNum(i);
 r=f[i].Create(TheFs,fileName,0);
-test(r==KErrNone);
+test_KErrNone(r);
 }
 TInt maxTotalSize=1048576;
 TInt maxFileSize=maxTotalSize/KMaxFiles;
 TInt maxIterations=20;
 {
 for (i=0;i<KMaxFiles;i++)
 {
 TInt randSize=Math::Rand(gSeed)%maxFileSize;
 r=f[i].SetSize(randSize);
-test(r==KErrNone);
+test_KErrNone(r);
 }
 test.Printf(_L("Countdown .. %d   \r"),maxIterations);
 }
 test.Printf(_L("\n"));
 for (i=0;i<KMaxFiles;i++)
 {
 TInt size=0;
 r=f[i].Size(size);
-test(r==KErrNone);
+test_KErrNone(r);
 totalSize+=((size+gBytesPerCluster-1)/gBytesPerCluster)*gBytesPerCluster;
 }
 r=TheFs.Volume(volInfo);
-test(r==KErrNone);
+test_KErrNone(r);
 if (gDiskType == EFat32)
 volInfo.iSize -= gBytesPerCluster; // root dir is part of the 'size'
 if (volInfo.iSize-volInfo.iFree!=totalSize)
 {
 test.Printf(_L("volInfo.iSize = %ld\n"), volInfo.iSize);
 for (i=0;i<KMaxFiles;i++)
 {
 fileName=_L("\\File");
 fileName.AppendNum(i);
 r=TheFs.Delete(fileName);
-test(r==KErrNone);
+test_KErrNone(r);
 }
 r=TheFs.Volume(volInfo);
 if (gDiskType == EFat32)
 volInfo.iSize -= gBytesPerCluster; // root dir is part of the 'size'
-test(r==KErrNone);
+test_KErrNone(r);
 test(volInfo.iSize-volInfo.iFree==0);
 MakeDir(gSessionPath);
 TInt entries=(gBytesPerCluster/KSizeOfFatDirEntry)*5-2;
 CreateFatEntry(gSessionPath, EFalse);
 }
 r=TheFs.Volume(volInfo);
-test(r==KErrNone);
+test_KErrNone(r);
 if (gDiskType == EFat32)
 volInfo.iSize -= gBytesPerCluster; // root dir is part of the 'size'
 test.Printf(_L("volInfo.iSize = %ld\n"), volInfo.iSize);
 test.Printf(_L("volInfo.iFree = %ld\n"), volInfo.iFree);
 if (volInfo.iSize-volInfo.iFree!=clusters*gBytesPerCluster)
 //-- create 1 FAT dir. entry
 CreateFatEntry(gSessionPath, EFalse);
 r=TheFs.Volume(volInfo);
-test(r==KErrNone);
+test_KErrNone(r);
 if (gDiskType == EFat32)
 volInfo.iSize -= gBytesPerCluster; // root dir is part of the 'size'
 test.Printf(_L("volInfo.iSize = %ld\n"), volInfo.iSize);
 test.Printf(_L("volInfo.iFree = %ld\n"), volInfo.iFree);
 if (volInfo.iSize-volInfo.iFree!=(clusters+1)*gBytesPerCluster)
 }
 test(volInfo.iSize-volInfo.iFree==(clusters+1)*gBytesPerCluster);
 CFileMan* fMan=CFileMan::NewL(TheFs);
 r=fMan->RmDir(gSessionPath);
-test(r==KErrNone);
+test_KErrNone(r);
 delete fMan;
 r=TheFs.Volume(volInfo);
-test(r==KErrNone);
+test_KErrNone(r);
 if (gDiskType == EFat32)
 volInfo.iSize -= gBytesPerCluster; // root dir is part of the 'size'
 if (volInfo.iSize-volInfo.iFree!=0)
 {
 DumpFat();
 buffer.SetLength(KDirEntrySize);
 buffer.FillZ();
 buffer.Replace(0,11,_L8("TEST1      "));
 TInt r=TheDisk.Open(TheFs,CurrentDrive());
-test(r==KErrNone);
+test_KErrNone(r);
 r=TheDisk.Write(pos,buffer);
-test(r==KErrNone);
+test_KErrNone(r);
 TheDisk.Close();
 r=TheDir.Open(TheFs,_L("\\"),KEntryAttMaskSupported);
-test(r==KErrNone);
+test_KErrNone(r);
 r=TheDir.Read(TheEntry);
-test(r==KErrNone);
+test_KErrNone(r);
 test(TheEntry.iName==_L("TEST1"));
 r=TheDir.Read(TheEntry);
-test(r==KErrEof);
+test_Value(r, r == KErrEof);
 TheDir.Close();
 r=TheFs.SetSessionPath(_L("\\"));
-test(r==KErrNone);
+test_KErrNone(r);
 TEntry e;
 r=TheFs.Entry(_L("TEST1"),e);
 if(e.iName!=_L("TEST1"))
 {
 test.Printf(_L("e.iName = %S\n"),&e.iName);
 HBufC8 *infop = HBufC8::NewL(seclen);
 TPtr8   info((TUint8*)bootp, seclen);
 TInt r=TheDisk.Open(TheFs,CurrentDrive());
 if (r != KErrNone)
 test.Printf(_L("Error %d opening on %C"), r, (TUint)gDriveToTest);
-test(r==KErrNone);
+test_KErrNone(r);
 r=TheDisk.Read(0, boot);
-test(r==KErrNone);
+test_KErrNone(r);
 TUint32 val = GetValue(boot, 510, 2);
 RDebug::Print(_L("BPB magic number = 0x%X\n"), val);
 test(aTestOnly || val == 0xAA55);
 switch (boot[0])
 {
 Mem::Fill(&TheBuffer[0],2048,'X');
 for(i=0; i<=20; i++)
 {
 r = TheFile.Write(TheBuffer);
-test(r==KErrNone);
+test_KErrNone(r);
 }
 TheFile.Close();
 for (i=8; i <=15; i++)
 testVal.iNumberOfFats,
 testVal.iMaxDiskSectors,
 testVal.iSectorsPerCluster,
 testVal.iRootDirEntries);
 TInt r = fatAlignment.AdjustFirstDataSectorAlignment(testVal.iBlockSize);
-test (r == KErrNone);
+test_KErrNone(r);
 fatAlignment.Display();
 }
 const TInt64 KOneMByte = 1024*1024;
 const TInt64 KOneGByte = 1024*KOneMByte;
 TInt r;
 TVolumeInfo volInfo;
 r=TheFs.Volume(volInfo);
-test(r==KErrNone);
+test_KErrNone(r);
 TInt64 spaceToUse = volInfo.iFree - gBytesPerCluster; // whole disk except 1 cluster
 test.Printf(_L("spaceToUse %ld gClusterCount %d gBytesPerCluster %d\n"), spaceToUse, gClusterCount, gBytesPerCluster);
 test.Printf(_L("Before fill, volInfo.iSize %ld volInfo.iFree %ld\n"), volInfo.iSize, volInfo.iFree);
 TInt tempfiles = 0;
 while (spaceToUse > K1GigaByte)
 {
 TFileName tempName;
 r=f.Temp(TheFs,_L("\\"),tempName,EFileRead|EFileWrite);
-test(r==KErrNone);
+test_KErrNone(r);
 r=f.SetSize(K1GigaByte);
-test(r==KErrNone);
+test_KErrNone(r);
 f.Close();
 spaceToUse -= K1GigaByte;
 tempfiles++;
 }
 r=f.Replace(TheFs,_L("\\USESPACE.TMP"),EFileRead|EFileWrite);
-test(r==KErrNone);
+test_KErrNone(r);
 r=f.SetSize((TInt)spaceToUse);
-test(r==KErrNone);
+test_KErrNone(r);
 f.Close();
 r=TheFs.Volume(volInfo);
-test(r==KErrNone);
+test_KErrNone(r);
 test.Printf(_L("After fill, volInfo.iSize %ld volInfo.iFree %ld\n"), volInfo.iSize, volInfo.iFree);
 test(volInfo.iFree==gBytesPerCluster); // check we have 1 cluster free
 r=f.Replace(TheFs,_L("\\FILE.TMP"),EFileRead|EFileWrite);
-test(r==KErrNone);
+test_KErrNone(r);
 r=f.SetSize(2*gBytesPerCluster); // 2 clusters (will fail since there's not space)
-test(r==KErrDiskFull);
+test_Value(r, r == KErrDiskFull);
 f.Close();
 r=TheFs.Volume(volInfo);
-test(r==KErrNone);
+test_KErrNone(r);
 test(volInfo.iFree==gBytesPerCluster); // check we still have 1 cluster free
 r=f.Replace(TheFs,_L("\\USESPACE.TMP"),EFileRead|EFileWrite); // truncate file to 0
-test(r==KErrNone);
+test_KErrNone(r);
 f.Close();
 r=TheFs.Volume(volInfo);
-test(r==KErrNone);
+test_KErrNone(r);
 test(volInfo.iFree==(spaceToUse+gBytesPerCluster)); // check we've freed up the space from USESPACE plus one cluster
 test(TheBootSector.IsValid()); //-- TheBootSector is read after formatting
 TInt64 rootDirpos = gRootDirStart;
 //-- read 1 sector of the root dir.
 r = MediaRawRead(TheFs, CurrentDrive(), rootDirpos, TheBootSector.BytesPerSector(), TheBuffer);
-test(r == KErrNone);
+test_KErrNone(r);
 const TFatDirEntry* pE=(TFatDirEntry*)TheBuffer.Ptr();
 while (tempfiles-- > 0)
 {
 while (pE->IsVFatEntry())
 TInt drvNum;
 TInt r=TheFs.CharToDrive(gDriveToTest,drvNum);
-test(r==KErrNone);
+test_KErrNone(r);
 if (!Is_Fat(TheFs,drvNum))
 {
 test.Printf(_L("CallTestsL: Skipped: test requires FAT filesystem\n"));
 return;
 PrintDrvInfo(TheFs, drvNum);
 // check this is not the internal ram drive
 TVolumeInfo v;
 r=TheFs.Volume(v, drvNum);
-test(r==KErrNone);
+test_KErrNone(r);
 TBool isRamDrive = v.iDrive.iMediaAtt&KMediaAttVariableSize;
 gSessionPath[0] = (TText)gDriveToTest;
 // verify that the drive is large enough for proper testing
 if (v.iSize<512*1024)

changeset 109	b3a1d9898418
parent 90	947f0dc9f7a8
child 210	b592f7984442
child 257	3e88ff8f41d5