Fix for bug 2283 (RVCT 4.0 support is missing from PDK 3.0.h)
Have multiple extension sections in the bld.inf, one for each version
of the compiler. The RVCT version building the tools will build the
runtime libraries for its version, but make sure we extract all the other
versions from zip archives. Also add the archive for RVCT4.
// 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 <f32file.h>
#include <e32test.h>
#include <e32svr.h>
#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<KSectorSize> 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<KMaxSectors; ++i)
{
r=raw.Write(i*KSectorSize, zeroBuf);
test(r==KErrNone);
}
}
else
{
TBuf8<32> 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);
r=TheFs.Delete(_L("BIGFILE.SIZE"));
test(r==KErrNone);
r=TheFs.Volume(volInfo);
test(r==KErrNone);
used2=volInfo.iSize-volInfo.iFree;
test(used==used2);
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);
used2=volInfo.iSize-volInfo.iFree;
test(used<used2);
TInt count;
RFormat format;
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);
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);
}