--- /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 <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);
+ }
+
+