diff -r 000000000000 -r a41df078684a kerneltest/f32test/server/t_format.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/f32test/server/t_format.cpp Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,900 @@ +// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of the License "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// f32test\server\t_format.cpp +// +// + +#define __E32TEST_EXTENSION__ + +#include +#include +#include +#include "t_server.h" +#include "t_chlffs.h" + +#include "f32_test_utils.h" + +using namespace F32_Test_Utils; + + +GLREF_D TFileName gSessionPath; + + +void GenerateMediaChange() + { + TBuf<2> b; + b.SetLength(2); + b[0]=gSessionPath[0]; + b[1]=':'; + RFormat format; + TInt count; + TInt r=format.Open(TheFs,b,EHighDensity,count); + test(r==KErrNone); + format.Close(); + } + +RTest test(_L("T_FORMAT")); +RSemaphore gSleepThread; +TRequestStatus gThreadLogon; + +static TInt gDrive=-1; +static const TInt KSectorSize=512; +static const TInt KHeapSize=0x200; + +enum TTestCode{ETest3,ETest5}; + + +//------------------------------------------------------------------- +TInt DoFormatSteps(RFormat& aFormat, TInt& aFmtCnt) +{ + TInt nRes = KErrNone; + + while(aFmtCnt) + { + nRes = aFormat.Next(aFmtCnt); + if(nRes != KErrNone) + { + test.Printf(_L("RFormat::Next() failed! code:%d\n"), nRes); + break; + } + } + + return nRes; +} + +static void WaitForMedia() +// +// Wait until the media change is serviced +// + { + + FOREVER + { + TInt r=TheFs.MkDir(_L("\\")); + if (r!=KErrNotReady) + break; + User::After(100000); + } + } + +static TInt ThreadEntryPoint(TAny* aTestCode) +// +// Thread entry point +// + { + + RFs fs; + TInt ret=fs.Connect(); + test(ret==KErrNone); + ret=fs.SetSessionPath(gSessionPath); + test(ret==KErrNone); + TTestCode testCode=*(TTestCode*)&aTestCode; + TInt count; + RFormat format; + switch (testCode) + { + case ETest3: + { + ret=format.Open(fs,gSessionPath,EQuickFormat,count); + test(ret==KErrNone); + + ret = DoFormatSteps(format, count); + test(ret==KErrNone); + + format.Close(); + break; + } + case ETest5: + { + ret=format.Open(fs,gSessionPath,EFullFormat,count); + test(ret==KErrNone); + gSleepThread.Signal(); + User::After(100000000); + break; + } + default: + break; + } + return(KErrNone); + } + +//------------------------------------------------------------------- +static void CorruptCurrentDrive() +// +// Corrupt the current drive +// + { + test.Printf(_L("CorruptCurrentDrive() %c:"), 'A'+CurrentDrive()); + + RRawDisk raw; + TInt r=raw.Open(TheFs,CurrentDrive()); + test(r==KErrNone); + if (!Is_Lffs(TheFs, gDrive)) + { + TBuf8 zeroBuf(KSectorSize); + Mem::FillZ((TAny*)zeroBuf.Ptr(),zeroBuf.MaxSize()); + + //-- for FAT32 we need to corrupt a backup BOOT sector as well, + //-- otherwise it can be used and some tests will fail.. + const TInt KMaxSectors = 25; //-- how many sectors to corrupt + for(TInt i=0; i zeroBuf(32); + for (TInt j=0;j<32;++j) + zeroBuf[j]=(TUint8)j; //Not actuall zero buf for lffs + // For LFFS, the media may not exhibit a contiguous region of sufficient length + // to support a continuous sequence of writes. This is the case if the + // Control Mode Size is non-zero + TInt cntlModeSize=GetLFFSControlModeSize(); + if(cntlModeSize==0) + { + //test.Printf(_L("CorruptCurrentDrive() - Control mode size is zero\n"),r); + for (TInt writePos=0;writePos<0x20200;writePos+=32) + { + r=raw.Write(writePos,zeroBuf); + // The device driver most likely fails when writing a random + // buffer due to read back checks. Since we're writing + // aligned 32-byte blocks, we don't need to bother that much. + // The device driver writes the block but fails when reading + // it back. + // test(r==KErrNone); + } + } + else if(cntlModeSize>0) + { + //test.Printf(_L("CorruptCurrentDrive() - Control mode = 0x%x\n"),r); + // For devices which have a non-zero control mode size, the writes may + // require segmentation. + TInt cmBase=0; + TInt cmOffset=0; + TInt bufOffset=0; + TInt bytesWritten=0; + TPtrC8 writeBuf; + while(bytesWritten < 0x20200) + { + TInt bufLeft = 32 - bufOffset; // 32 from size of zeroBuf + TInt spaceLeft = cntlModeSize - cmOffset; + TInt writeLen=(bufLeft>spaceLeft)? spaceLeft : bufLeft; + writeBuf.Set(&(zeroBuf[bufOffset]),writeLen); + TInt writePos = cmBase + cmOffset; + r=raw.Write(writePos,writeBuf); + bytesWritten += writeLen; + if(bufLeft < spaceLeft) + { + bufOffset = 0; + cmOffset += bufLeft; + } + else if(bufLeft == spaceLeft) + { + bufOffset = 0; + cmOffset = 0; + cmBase += (2*cntlModeSize); + } + else + { // bufRemaining>spaceRemaining + bufOffset += spaceLeft; + cmOffset = 0; + cmBase += (2*cntlModeSize); + } + } + } + else + { + // Negative value (error code) returned from GetLFFSControlModeSize() + test.Printf(_L("CorruptCurrentDrive() - Control mode = %d (ERROR!) \n"),cntlModeSize); + test(0); + } + } + raw.Close(); + } + + +//------------------------------------------------------------------- +static void Test1() +// +// Format disk +// + { + + test.Next(_L("Test EFullFormat")); + TInt count; + RFormat format; + + TInt r=format.Open(TheFs,gSessionPath,EFullFormat,count); + test(r==KErrNone); + + r = DoFormatSteps(format, count); + test(r==KErrNone); + + format.Close(); + + TVolumeInfo volInfo; + r=TheFs.Volume(volInfo); + test(r==KErrNone); + + if (volInfo.iSize-volInfo.iFree!=0) + { + test.Printf(_L("Memory 'in use' after a full format = %ld\n"),(volInfo.iSize-volInfo.iFree)); + test.Printf(_L("volInfo.iSize = %ld\n"),volInfo.iSize); + test.Printf(_L("volInfo.iFree = %ld\n"),volInfo.iFree); + } + + test.Next(_L("Test EQuickFormat")); + r=format.Open(TheFs,gSessionPath,EQuickFormat,count); + test(r==KErrNone); + + r = DoFormatSteps(format, count); + test(r==KErrNone); + + format.Close(); + + r=TheFs.Volume(volInfo); + test(r==KErrNone); + + if (volInfo.iSize-volInfo.iFree!=0) + { + test.Printf(_L("Memory 'in use' after a quick format = %ld\n"),(volInfo.iSize-volInfo.iFree)); + test.Printf(_L("volInfo.iSize = %ld\n"),volInfo.iSize); + test.Printf(_L("volInfo.iFree = %ld\n"),volInfo.iFree); + return; + } + + } + +//------------------------------------------------------------------- +static void Test2() +// +// Test access controls +// + { + + test.Next(_L("Test disk cannot be formatted while a file is open")); + RFile f; + TInt r=f.Replace(TheFs,_L("BLARGME.BLARG"),EFileStream); + test(r==KErrNone); + + TInt count; + RFormat format; + r=format.Open(TheFs,gSessionPath,EFullFormat,count); + test(r==KErrInUse); + + f.Close(); + r=format.Open(TheFs,gSessionPath,EFullFormat,count); + test(r==KErrNone); + format.Close(); + + CheckFileExists(_L("BLARGME.BLARG"),KErrNone); + } + +//------------------------------------------------------------------- +static void Test3() +// +// Test notification +// + { + + test.Next(_L("Test successful format triggers notifier")); + MakeFile(_L("\\BLARG_BLARG_BLARG.BLG")); + TRequestStatus reqStat; + TheFs.NotifyChange(ENotifyEntry,reqStat); + + RThread clientThread; + TInt r=clientThread.Create(_L("ClientThread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest3); + test.Printf(_L("Created helper thread #1, res=%d\n"),r); + test(r==KErrNone); + + clientThread.Logon(gThreadLogon); + clientThread.Resume(); + clientThread.Close(); + + User::WaitForRequest(reqStat); + test.Printf(_L("Notifier triggered #1, res=%d\n"),reqStat.Int()); + + User::WaitForRequest(gThreadLogon); + test.Printf(_L("Helper thread exited #1, res=%d\n"),gThreadLogon.Int()); + + CheckFileExists(_L("BLARG_BLARG_BLARG.BLG"),KErrNotFound); + MakeFile(_L("\\BLARG_BLARG_BLARG.BLG")); + + TheFs.NotifyChange(ENotifyAll,reqStat); + r=clientThread.Create(_L("ClientThread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest3); + test.Printf(_L("Created helper thread #2, res=%d\n"),r); + test(r==KErrNone); + + + clientThread.Logon(gThreadLogon); + clientThread.Resume(); + clientThread.Close(); + + User::WaitForRequest(reqStat); + test.Printf(_L("Notifier triggered #2, res=%d\n"),reqStat.Int()); + + User::WaitForRequest(gThreadLogon); + test.Printf(_L("Helper thread exited #2, res=%d\n"),gThreadLogon.Int()); + + CheckFileExists(_L("BLARG_BLARG_BLARG.BLG"),KErrNotFound); + } + +//------------------------------------------------------------------- +static void Test4() +// +// Test partially completed formats +// + { + test.Next(_L("Test partially completed formats")); + + if(Is_Automounter(TheFs, gDrive)) + {//-- if we have automounter FS installed, formatting of the corrupted media is not straightforward + //-- The automounter might not be able to decide which of the child file systems shall be used; This issue is covered in a specific test. + test.Printf(_L("This step is skipped for Automounter File System\n")); + return; + } + + MakeFile(_L("\\FORMAT\\DIR1\\BLARG_BLARG_BLARG.BLG")); + TInt count; + CorruptCurrentDrive(); + + test.Printf(_L("Formatting the drive...\n")); + + RFormat format; + TInt r=format.Open(TheFs,gSessionPath,EFullFormat,count); + test(r==KErrNone); + + while(count) + { + RDir dir; + r=dir.Open(TheFs,_L("\\*.*"),KEntryAttNormal); + test(r==KErrInUse); + r=format.Next(count); + test(r==KErrNone); + } + format.Close(); + + CheckFileExists(_L("\\FORMAT\\DIR1\\BLARG_BLARG_BLARG.BLG"),KErrPathNotFound); + } + +//------------------------------------------------------------------- +static void Test5() +// +// Test panic formatting thread +// + { + + test.Next(_L("Test panic formatting thread")); + + if(Is_Automounter(TheFs, gDrive)) + {//-- if we have automounter FS installed, formatting of the corrupted media is not straightforward + //-- The automounter might not be able to decide which of the child file systems shall be used; This issue is covered in a specific test. + test.Printf(_L("This step is skipped for Automounter File System\n")); + return; + } + + CorruptCurrentDrive(); + if (!(IsTestingLFFS() && GetDriveLFFS()==EDriveC)) // ??? Remove after ER5U + { +// UserSvr::ForceRemountMedia(ERemovableMedia0); // Generate media change + GenerateMediaChange(); + WaitForMedia(); + } + + gSleepThread.CreateLocal(0); + RThread clientThread; + TInt r=clientThread.Create(_L("ClientThread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest5); + test.Printf(_L("Created helper thread #1, res=%d\n"),r); + test(r==KErrNone); + + test.Printf(_L("Panicing formatting thread #1\n")); + clientThread.Resume(); + gSleepThread.Wait(); + test.Printf(_L("Panicing formatting thread #2\n")); + User::SetJustInTime(EFalse); + clientThread.Panic(_L("Panic formatting thread"),KErrGeneral); + User::SetJustInTime(ETrue); + User::After(200000); // to let panic take effect + test.Printf(_L("Panicing formatting thread #3\n")); + + RDir dir; + r=dir.Open(TheFs,_L("\\*.*"),KEntryAttNormal); +// if(IsTestingLFFS() && (r==KErrNone)) +// { +// dir.Close(); +// } +// else +// { + test(r==KErrCorrupt); +// } + + test.Printf(_L("Formatting the drive...\n")); + + TInt count; + RFormat format; + r=format.Open(TheFs,gSessionPath,EQuickFormat,count); + test(r==KErrNone); + + r = DoFormatSteps(format, count); + test(r==KErrNone); + + format.Close(); + + MakeFile(_L("BLARGOID.BLARG")); + CheckFileExists(_L("BLARGOID.BLARG"),KErrNone); + clientThread.Close(); + gSleepThread.Close(); + } + +//------------------------------------------------------------------- +static void Test6() +// +// Test ramdrive is shrunk after formatting +// + { + + test.Next(_L("Test ramdrive shrinks after formatting")); + TVolumeInfo volInfo; + TInt r=TheFs.Volume(volInfo); + test(r==KErrNone); + if ((volInfo.iDrive.iMediaAtt&KMediaAttVariableSize)==0) + return; + + TInt64 used=volInfo.iSize-volInfo.iFree; + RFile f; + r=f.Replace(TheFs,_L("BIGFILE.SIZE"),EFileRead|EFileWrite); + test(r==KErrNone); + f.SetSize(0x100000); // 1MB + f.Close(); + + r=TheFs.Volume(volInfo); + test(r==KErrNone); + TInt64 used2=volInfo.iSize-volInfo.iFree; + test(used=used2); + } + +static void Test7() +// +// Generate media change before formatting. +// + { + + test.Next(_L("Generate Media change before formatting")); + + if(Is_Automounter(TheFs, gDrive)) + {//-- if we have automounter FS installed, formatting of the corrupted media is not straightforward + //-- The automounter might not be able to decide which of the child file systems shall be used; This issue is covered in a specific test. + test.Printf(_L("This step is skipped for Automounter File System\n")); + return; + } + + TVolumeInfo volInfo; + TInt r=TheFs.Volume(volInfo); + test(r==KErrNone); + + if (volInfo.iDrive.iMediaAtt&KMediaAttVariableSize) + return; // Don't bother on internal disk + + if (Is_Lffs(TheFs, gDrive)) + return; // Don't bother on LFFS + + CorruptCurrentDrive(); +// UserSvr::ForceRemountMedia(ERemovableMedia0); // Generate media change + GenerateMediaChange(); + WaitForMedia(); + TInt count; + RFormat format; + r=format.Open(TheFs,gSessionPath,EQuickFormat,count); + test(r==KErrNone); + + r = DoFormatSteps(format, count); + test(r==KErrNone); + + format.Close(); + } + +//------------------------------------------------------------------- +static void Test8() +// +// Test incomplete format +// + { + + test.Next(_L("Test incomplete format")); + + if(Is_Automounter(TheFs, gDrive)) + {//-- if we have automounter FS installed, formatting of the corrupted media is not straightforward + //-- The automounter might not be able to decide which of the child file systems shall be used; This issue is covered in a specific test. + test.Printf(_L("This step is skipped for Automounter File System\n")); + return; + } + + CorruptCurrentDrive(); + + if (!(IsTestingLFFS() && GetDriveLFFS()==EDriveC)) // ??? Remove after ER5U + { +// UserSvr::ForceRemountMedia(ERemovableMedia0); // Generate media change + GenerateMediaChange(); + WaitForMedia(); + } + + TVolumeInfo volInfo; + TInt r=TheFs.Volume(volInfo); +// test(r==KErrCorrupt); + TInt count; + RFormat format; + r=format.Open(TheFs,gSessionPath,EQuickFormat,count); + r=TheFs.Volume(volInfo); + test(r==KErrInUse); + r=format.Next(count); + test(r==KErrNone); + TDriveList driveList; + r=TheFs.DriveList(driveList); + test(r==KErrNone); + + if(gDrive == EDriveC) + { + r=TheFs.Volume(volInfo, gDrive); + test(r==KErrInUse); + } + else + { + r=TheFs.Volume(volInfo,EDriveC); + test(r==KErrNone); + + r=TheFs.Volume(volInfo,gDrive); + test(r==KErrInUse); + + r=TheFs.Volume(volInfo,gDrive); + test(r==KErrInUse); + } + + + format.Close(); + Format(CurrentDrive()); + } + + +//------------------------------------------------------------------- +/** + Test an API that allows force media formatting with the files or other objects opened on the volume +*/ +void TestFormat_ForceDismount() +{ + test.Next(_L("Test format with forced media dismounting")); + + if(Is_Lffs(TheFs, gDrive)) + {//-- forced FS dismounting with files/directories opened damages LFFS structure for unknown reason. + //-- this is a problem of LFFS, anyway, it is not supported. + test.Next(_L("This test can't be performed on LFFS, Skipping.")); + return; + } + + TInt nRes; + RFormat format; + TUint fmtMode = EQuickFormat; + TInt fmtCnt; + TBuf<10> drivePath; + drivePath.Format(_L("%C:\\"), gDrive+'A'); + + + RBuf8 buf8; + RFile file1; + RDir dir; + + const TInt KBufLen = 128*K1KiloByte; + nRes = buf8.CreateMax(KBufLen); + test_KErrNone(nRes); + + _LIT(KFname, "\\file1"); + + + + //--------------------------------------------------------------------------------- + //-- 1.1 open a file, try to format in normal mode; this shall fail with KErrInUse + test.Printf(_L("Test normal format with normal opened objects\n")); + nRes = file1.Replace(TheFs, KFname, EFileWrite); + test_KErrNone(nRes); + + fmtMode = EQuickFormat; + + nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); + test(nRes == KErrInUse); + format.Close(); + + buf8.SetLength(22); + nRes = file1.Write(buf8); + test_KErrNone(nRes); + + file1.Close(); + + //-- 1.2 open a directory, try to format in normal mode; this shall fail with KErrInUse + nRes = dir.Open(TheFs,_L("\\*.*"),KEntryAttNormal); + test_KErrNone(nRes); + + fmtMode = EQuickFormat; + nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); + test(nRes == KErrInUse); + format.Close(); + + dir.Close(); + + + //--------------------------------------------------------------------------------- + //-- 2.1 forced quick formatting + test.Printf(_L("Test forced quick formatting\n")); + nRes = file1.Replace(TheFs, KFname, EFileWrite); //-- open a file + test_KErrNone(nRes); + + nRes = dir.Open(TheFs,_L("\\*.*"),KEntryAttNormal); //-- open a directory + test_KErrNone(nRes); + + //-- this will mark the current Mount as "Dismounted" and will instantiate another CMountCB for formatting + fmtMode = EQuickFormat | EForceFormat; + + nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); + test_KErrNone(nRes); + + nRes = DoFormatSteps(format, fmtCnt); + test_KErrNone(nRes); + + format.Close(); + + + nRes=TheFs.CheckDisk(gSessionPath); + test(nRes==KErrNone||nRes==KErrNotSupported); + + buf8.SetLength(22); + nRes = file1.Write(buf8); + test(nRes == KErrDisMounted); + file1.Close(); //-- this will make the previously "Dismounted" mount die. + dir.Close(); + + + //--------------------------------------------------------------------------------- + //-- 2.2 forced full formatting + test.Printf(_L("Test forced full formatting\n")); + nRes = file1.Replace(TheFs, KFname, EFileWrite); + test_KErrNone(nRes); + + //-- this will mark the current Mount as "Dismounted" and will instantiate another CMountCB for formatting + fmtMode = EFullFormat | EForceFormat; + + nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); + test_KErrNone(nRes); + + nRes = DoFormatSteps(format, fmtCnt); + test_KErrNone(nRes); + + format.Close(); + + nRes=TheFs.CheckDisk(gSessionPath); + test(nRes==KErrNone||nRes==KErrNotSupported); + + buf8.SetLength(22); + nRes = file1.Write(buf8); + test(nRes == KErrDisMounted); + file1.Close(); //-- this will make the previously "Dismounted" mount die. + + //--------------------------------------------------------------------------------- + //-- 3. check that forced formatting will complete NotifyDismount + test.Printf(_L("Test forced formatting completes NotifyDismount\n")); + TRequestStatus stat1; + + nRes = file1.Replace(TheFs, KFname, EFileWrite); + test_KErrNone(nRes); + + TheFs.NotifyDismount(gDrive, stat1, EFsDismountRegisterClient); + test(stat1.Int() == KRequestPending); + + fmtMode = EQuickFormat; + nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); + test(nRes == KErrInUse); + format.Close(); + + test(stat1.Int() == KRequestPending); + + fmtMode = EQuickFormat | EForceFormat; + nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); + test_KErrNone(nRes); + format.Close(); + + User::WaitForRequest(stat1); + test(stat1.Int() == KErrNone); + + buf8.SetLength(22); + nRes = file1.Write(buf8); + test(nRes == KErrDisMounted); + file1.Close(); + + //--------------------------------------------------------------------------------- + //-- 4.1 check that forced formatting will succeed with dirty file cache + test.Printf(_L("Test forced formatting will succeed with dirty file cache\n")); + + nRes = file1.Replace(TheFs, KFname, EFileWrite | EFileWriteBuffered); //-- enable write caching + test_KErrNone(nRes); + + buf8.SetLength(KBufLen); + nRes = file1.Write(buf8); //-- this will hopefully get via file write cache + test_KErrNone(nRes); + + fmtMode = EQuickFormat | EForceFormat; + nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); + test_KErrNone(nRes); + format.Close(); + + nRes = file1.Write(buf8); + test(nRes == KErrDisMounted); + file1.Close(); + + + //--------------------------------------------------------------------------------- + + test.Printf(_L("Test forced formatting with disk access objects opened\n")); + + //-- 5.1 check that forced formatting will fail when there are "disk access" objects opened RFormat + RFormat format1; + + nRes = format1.Open(TheFs, drivePath, fmtMode, fmtCnt); + test(nRes == KErrNone); + + fmtMode = EQuickFormat | EForceFormat; + nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); + test(nRes == KErrInUse); + format.Close(); + + format1.Close(); + + //-- 5.1 check that forced formatting will fail when there are "disk access" objects opened RRawDisk + RRawDisk rawDisk; + nRes = rawDisk.Open(TheFs, gDrive); + test(nRes == KErrNone); + + fmtMode = EQuickFormat | EForceFormat; + nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); + test(nRes == KErrInUse); + format.Close(); + + rawDisk.Close(); + + + //--------------------------------------------------------------------------------- + //-- 6. Try forced formatting with clamped files, this shall fail with KErrInuse + test.Printf(_L("Test forced formatting and clamps on the volume\n")); + + nRes = file1.Replace(TheFs, KFname, EFileWrite); + test_KErrNone(nRes); + + buf8.SetLength(KBufLen); + nRes = file1.Write(buf8); //-- this will hopefully get via file write cache + test_KErrNone(nRes); + file1.Flush(); + + //-- Clamp file + RFileClamp handle; + + nRes=handle.Clamp(file1); + if(nRes != KErrNone) + { + test.Printf(_L("file clamps on this drive are not supported\n")); + } + else + { + fmtMode = EQuickFormat | EForceFormat; + nRes = format.Open(TheFs, drivePath, fmtMode, fmtCnt); + test(nRes == KErrInUse); + format.Close(); + } + + handle.Close(TheFs); + + file1.Close(); + + buf8.Close(); +} + + +void CallTestsL() +// +// Call tests that may leave +// + { + + TInt r; + r = TheFs.CharToDrive(gDriveToTest, gDrive); + test(r == KErrNone); + + //-- set up console output + F32_Test_Utils::SetConsole(test.Console()); + + TInt nRes=TheFs.CharToDrive(gDriveToTest, gDrive); + test(nRes==KErrNone); + + PrintDrvInfo(TheFs, gDrive); + + if(Is_Win32(TheFs, gDrive)) + return; //-- emulator drive c: + + + SetSessionPath(_L("\\")); + + Test1(); + Test2(); + Test3(); + Test4(); + Test5(); + Test6(); + Test7(); + Test8(); + TestFormat_ForceDismount(); + + r=TheFs.CheckDisk(gSessionPath); + test(r==KErrNone||r==KErrNotSupported); + } + +