--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/server/t_falsespace.cpp Thu Dec 17 09:24:54 2009 +0200
@@ -0,0 +1,1108 @@
+// 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:
+//
+
+#include <f32file.h>
+#include <e32test.h>
+#include <e32math.h>
+
+#include "fat_utils.h"
+#include "t_server.h"
+#include "t_chlffs.h"
+
+using namespace Fat_Test_Utils;
+
+RTest test(_L("t_falsespace"));
+
+const TInt KNumberThreads=2;
+const TInt KHeapSize=0x2000;
+
+static TInt RsrvSpaceThread(TAny* aArg);
+static TInt SessCloseThread(TAny* aArg);
+static void GetFreeDiskSpace(TInt64 &aFree);
+
+
+TInt gCount; //count of files used to fill up the disk
+TInt gTestDrive; //drive number of the drive currently being tested
+
+TChar gCh;
+
+_LIT(KBasePath,"\\F32-TST\\FILLDIR\\");
+_LIT(KBaseName,"\\F32-TST\\FILLDIR\\FILE");
+
+_LIT(KTestFile,"?:\\test.txt");
+_LIT8(KTestData, "12345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678123456781234567812345678");
+_LIT(KDir, "?:\\adodgydir\\");
+_LIT(KDrv,"?:\\");
+_LIT(KNewName,"?:\\newname.txt");
+
+
+void FormatDrive()
+{
+ TInt nRes;
+
+
+ #if 0
+ //-- FAT32 SPC:1; for the FAT32 testing on the emulator
+ TFatFormatParam fp;
+ fp.iFatType = EFat32;
+ fp.iSecPerCluster = 1;
+
+ nRes = FormatFatDrive(TheFs, gTestDrive, ETrue, &fp);
+ #else
+
+ nRes = FormatFatDrive(TheFs, gTestDrive, ETrue);
+
+ #endif
+
+ test(nRes == KErrNone);
+}
+
+void SynchronousClose(RFs &aSession)
+ {
+ TRequestStatus s;
+ aSession.NotifyDestruction(s);
+ test(s.Int()==KRequestPending);
+ aSession.Close();
+ User::WaitForRequest(s);
+ }
+
+
+static TInt CreateFileX(const TDesC& aBaseName,TInt aX, TInt aFileSize)
+//
+// Create a large file. Return KErrEof or KErrNone
+//
+ {
+
+ TBuf<128> fileName=aBaseName;
+ fileName.AppendNum(aX);
+ RFile file;
+
+ TInt r=file.Replace(TheFs,fileName,EFileWrite);
+ if (r==KErrDiskFull)
+ return(r);
+ if (r!=KErrNone)
+ {
+ test.Printf(_L("ERROR:: Replace returned %d\n"),r);
+ test(0);
+ return(KErrDiskFull);
+ }
+
+ if (!IsTestingLFFS())
+ r=file.SetSize(aFileSize);
+ else
+ {
+ TBuf8<1024> testdata(1024);
+ TInt count=(aFileSize/testdata.Length());
+ r=KErrNone;
+ while (count-- && r==KErrNone)
+ r=file.Write(testdata);
+ }
+ if (r==KErrDiskFull)
+ {
+ file.Close();
+ return(r);
+ }
+ if (r!=KErrNone)
+ {
+ test.Printf(_L("ERROR:: SetSize/Write returned %d\n"),r);
+ test(0);
+ //test.Getch();
+ file.Close();
+ return(KErrDiskFull);
+ }
+
+ file.Close();
+
+ test.Printf(_L("Created file %d size %d\n"),aX,aFileSize);
+ return(KErrNone);
+ }
+
+LOCAL_C TInt DeleteFileX(const TDesC& aBaseName,TInt aX)
+//
+// Delete a large file
+//
+ {
+ TBuf<128> fileName=aBaseName;
+ fileName.AppendNum(aX);
+ return TheFs.Delete(fileName);
+ }
+
+
+static void FillUpDisk()
+//
+// Test that a full disk is ok
+//
+ {
+
+ test.Start(_L("Fill disk to capacity"));
+ TInt r=TheFs.MkDirAll(KBasePath);
+ test(r==KErrNone || r==KErrAlreadyExists);
+ gCount=0;
+ TFileName sessionPath;
+ r=TheFs.SessionPath(sessionPath);
+ test(r==KErrNone);
+ TBuf<128> fileName=KBaseName();
+
+ TInt64 freespace=0;
+ TInt64 freespaceBeforeScanDrive = 0;
+ TInt64 freespaceAfterScanDrive = 0;
+
+ do
+ {
+ GetFreeDiskSpace(freespace);
+ TInt fillfilesize=0;
+ if (I64HIGH(freespace))
+ fillfilesize=KMaxTInt;
+ else
+ fillfilesize=I64LOW(freespace)* 7/8;
+
+ FOREVER
+ {
+ TInt r=CreateFileX(fileName,gCount,fillfilesize);
+ if (r==KErrDiskFull)
+ {
+ if(fillfilesize <= 2)
+ break;
+ else
+ fillfilesize=fillfilesize/2;
+ }
+ test(r==KErrNone || r==KErrDiskFull);
+ if(r==KErrNone)
+ gCount++;
+ }
+
+ r=TheFs.CheckDisk(fileName);
+ if (r!=KErrNone && r!=KErrNotSupported)
+ {
+ test.Printf(_L("ERROR:: CheckDisk returned %d\n"),r);
+ test(0);
+
+ }
+
+ // Test that scan drive passes on a full disk
+ // DEF071696 - KErrCorrupt on Scan Drive
+ GetFreeDiskSpace(freespaceBeforeScanDrive);
+ test.Printf(_L("Before ScanDrive freeSpace = %08X:%08X\n"),
+ I64HIGH(freespaceBeforeScanDrive), I64LOW(freespaceBeforeScanDrive));
+ r = TheFs.ScanDrive(fileName);
+ if (r!=KErrNone && r!=KErrNotSupported)
+ {
+ test.Printf(_L("ScanDrive returned %d\n"), r);
+ test(0);
+ }
+ GetFreeDiskSpace(freespaceAfterScanDrive);
+ test.Printf(_L("After ScanDrive freeSpace = %08X:%08X\n"),
+ I64HIGH(freespaceAfterScanDrive), I64LOW(freespaceAfterScanDrive));
+ }
+ while (freespaceBeforeScanDrive != freespaceAfterScanDrive );
+
+ gCount--;
+
+ test.End();
+ }
+
+static void GetFreeDiskSpace(TInt64 &aFree)
+//
+// Get free disk space
+//
+ {
+ TVolumeInfo v;
+
+ TInt r=TheFs.Volume(v,gTestDrive);
+ test(r==KErrNone);
+ aFree=v.iFree;
+ }
+
+
+static void Test1()
+//
+// Test the API fundamentaly works for one session
+//
+ {
+ test.Next(_L("Test Disk Space reserve APIs"));
+ TInt r=0;
+
+ FormatDrive();
+
+ TInt64 free2;
+ TInt64 free1;
+ TInt64 diff;
+
+ r=TheFs.GetReserveAccess(gTestDrive);
+ test(r==KErrPermissionDenied);
+
+ //make sure nothing odd happens if we didnt already have access
+ r=TheFs.ReleaseReserveAccess(gTestDrive);
+ test(r==KErrNone);
+
+
+ GetFreeDiskSpace(free2);
+
+ r=TheFs.ReserveDriveSpace(gTestDrive,0x1000);
+ test(r==KErrNone);
+
+ GetFreeDiskSpace(free1);
+ diff = free2 - free1;
+ test(I64INT(diff) > 0xfe0 && I64INT(diff) < 0x1100);
+
+ r=TheFs.GetReserveAccess(gTestDrive);
+ test(r==KErrNone);
+
+ GetFreeDiskSpace(free1);
+ TInt64 temp = free2-free1;
+ test(I64INT(temp)>(-0x90) && I64INT(temp)<0x90);
+
+ r=TheFs.ReleaseReserveAccess(gTestDrive);
+ test(r==KErrNone);
+ GetFreeDiskSpace(free1);
+
+ diff = free2 - free1;
+ test(I64INT(diff) > 0xfe0 && I64INT(diff) < 0x1100);
+
+
+ //test reallocation of reserved space is possible
+ r=TheFs.ReserveDriveSpace(gTestDrive,0x2000);
+ test(r==KErrNone);
+
+ //test upper limit of reserved space
+ r=TheFs.ReserveDriveSpace(gTestDrive,0x2000000);
+ test(r==KErrArgument);
+
+ r=TheFs.ReserveDriveSpace(gTestDrive,0);
+ test(r==KErrNone);
+
+ r=TheFs.GetReserveAccess(gTestDrive);
+ test(r==KErrPermissionDenied);
+
+ //make sure nothing odd happens if we didnt already have access
+ r=TheFs.ReleaseReserveAccess(gTestDrive);
+ test(r==KErrNone);
+
+ r=TheFs.ReserveDriveSpace(gTestDrive,-45);
+ test(r==KErrArgument);
+ }
+
+
+static void Test2()
+//
+// Test multiple sessions, ensure the drive limit is not exceeded
+//
+ {
+
+ test.Next(_L("Test Session and total reserve limits"));
+
+ FormatDrive();
+
+ TInt i=0;
+ TInt r=0;
+ RFs sessions[17];
+ TVolumeInfo v;
+
+ //Connect Sessions
+ for(i=0; i<17; i++)
+ {
+ r = sessions[i].Connect();
+ test(r==KErrNone);
+ }
+
+ test.Next(_L("Test breaching sesson reserve limit"));
+ r=sessions[0].ReserveDriveSpace(gTestDrive,0x10001);
+ test(r==KErrArgument);
+
+ //Get Volume Free Space
+ r = sessions[0].Volume(v, gTestDrive);
+
+ if(v.iFree > 0x100000)
+ {
+ test.Next(_L("Test breaching drive reserve limit"));
+
+ for (i=0; i<16; i++)
+ {
+ r=sessions[i].ReserveDriveSpace(gTestDrive,0x10000);
+ test(r==KErrNone);
+ }
+
+ //The straw
+ r=sessions[16].ReserveDriveSpace(gTestDrive,0x10);
+ test(r==KErrTooBig);
+ }
+ else
+ {
+ test.Printf(_L("Drive too small: breaching drive reserve limit test skipped\n"));
+ test.Next(_L("Testing exhausting available drive free space instead"));
+
+ for(i=0; (v.iFree -= 0x10000) >= 0; i++)
+ {
+ r=sessions[i].ReserveDriveSpace(gTestDrive,0x10000);
+ test(r==KErrNone);
+ }
+
+ //The straw
+ r=sessions[i].ReserveDriveSpace(gTestDrive,0x10000);
+ test(r==KErrDiskFull);
+ }
+
+ //Close Sessions
+ for(i=0; i<17; i++)
+ {
+ SynchronousClose(sessions[i]);
+ }
+ }
+
+static void Test3()
+//
+// Test session cleanup
+//
+ {
+ test.Next(_L("Test session close and clean up of resrved space"));
+
+ FormatDrive();
+
+ RFs fs1;
+ RFs fs2;
+ TInt64 free2(0);
+ TInt64 free1(0);
+ TInt64 diff(0);
+
+ TInt r=0;
+ r = fs1.Connect();
+ test(r==KErrNone);
+ r = fs2.Connect();
+ test(r==KErrNone);
+
+ GetFreeDiskSpace(free1);
+
+ r=fs1.ReserveDriveSpace(gTestDrive,0x10000);
+ test(r==KErrNone);
+ r=fs2.ReserveDriveSpace(gTestDrive,0x10000);
+ test(r==KErrNone);
+
+ GetFreeDiskSpace(free2);
+ diff = free1 - free2;
+ test(I64INT(diff)>0x1FBD0 && I64INT(diff)<0x21000);
+
+ SynchronousClose(fs1);
+
+ GetFreeDiskSpace(free2);
+ diff = free1-free2;
+ test(I64INT(diff)>0xFA00 && I64INT(diff)<0x103C4);
+
+ r = fs1.Connect();
+ test(r==KErrNone);
+
+ GetFreeDiskSpace(free1);
+ diff= free1-free2;
+ test(I64INT(diff)== 0 || I64INT(diff)<0xFA0 );
+
+ r=fs1.ReserveDriveSpace(gTestDrive,0x10000);
+ test(r==KErrNone);
+
+ GetFreeDiskSpace(free2);
+ diff = free1 - free2;
+ test(I64INT(diff)>0xFA00 && I64INT(diff)<0x103C4);
+
+ // Make sure no reserve space is allocated
+ r=fs1.ReserveDriveSpace(gTestDrive,0);
+ test(r==KErrNone);
+ r=fs2.ReserveDriveSpace(gTestDrive,0);
+ test(r==KErrNone);
+
+ // Now fill up the disk
+ FillUpDisk();
+
+ // Should fail as there is no space
+ r=fs1.ReserveDriveSpace(gTestDrive,0x10000);
+ test(r==KErrDiskFull);
+
+ SynchronousClose(fs1);
+ SynchronousClose(fs2);
+ }
+
+
+static void Test4()
+//
+// Test real out of disk space conditions i.e. properly run out of disk space and try to
+// reserve an area etc
+//
+ {
+ test.Next(_L("Test Filling disk and using APIs"));
+
+ if(IsTestingLFFS())
+ {
+ //-- This test is not valid for LFFS, because free space on this FS can change itself because of some
+ //-- internal FS activities
+ test.Printf(_L("This test is inconsistent on LFFS\n"));
+ return;
+ }
+
+ FormatDrive();
+
+ RFs fs;
+ TInt r=fs.Connect();
+ test(r==KErrNone);
+ TInt64 freeA(0);
+ TInt64 freeB(0);
+ RFile file;
+
+ //start with known amount of space
+
+ //create a single file to use for futher tests
+ TBuf<20> buf;
+ buf=KTestFile;
+ buf[0]=(TUint16)gCh;
+
+ r=file.Replace(fs, buf, EFileWrite);
+ test(r==KErrNone);
+
+ r=file.Write(KTestData());
+ test(r==KErrNone);
+
+ file.Close();
+
+ r=fs.ReserveDriveSpace(gTestDrive,0x10000); //reserve some disk space
+ test(r==KErrNone);
+
+ FillUpDisk(); //fill up the disk
+
+ TVolumeInfo v; //get disk space
+ r=fs.Volume(v,gTestDrive);
+ test(r==KErrNone);
+ freeA=v.iFree;
+
+ r=fs.GetReserveAccess(gTestDrive); //get access to reserve space
+ test(r==KErrNone);
+
+ r=fs.Volume(v,gTestDrive); //get disk space
+ test(r==KErrNone);
+ freeB=v.iFree;
+
+ r=fs.ReleaseReserveAccess(gTestDrive); //release reserve space
+ test(r==KErrNone);
+
+ test(freeA == (freeB - 0x10000)); //test difference in space is equal to the amount reserved
+
+ r=fs.Volume(v,gTestDrive); //get disk space
+ test(r==KErrNone);
+ freeB=v.iFree;
+ test(freeA == freeB); //check reading is still correct
+
+ TBuf <20> dir = KDir();
+ dir[0]=(TUint16)gCh;
+ r=fs.MkDir(dir);
+ test(r==KErrDiskFull);
+
+ r=fs.MkDirAll(dir);
+ test(r==KErrDiskFull);
+
+ TFileName temp;
+ TBuf<5> drv = KDrv();
+ drv[0]=(TUint16)gCh;
+ r=file.Temp(fs, drv, temp, EFileWrite);
+ test(r==KErrDiskFull);
+
+ r=file.Replace(fs, buf, EFileWrite);
+ test(r==KErrDiskFull);
+
+ r=file.Create(fs, buf, EFileWrite);
+ test(r==KErrDiskFull);
+
+ r=file.Open(fs, buf, EFileWrite);
+ test(r==KErrNone);
+
+ r=file.Write(128, KTestData());
+
+ if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))
+ r = file.Flush();
+
+ test(r==KErrDiskFull);
+
+ r=file.SetSize(0x1000);
+ test(r==KErrDiskFull);
+
+ r=file.SetAtt(KEntryAttHidden,0);
+ test(r==KErrDiskFull);
+
+ TTime dtime;
+ r=file.SetModified(dtime);
+ test(r==KErrDiskFull);
+
+ r=file.Set(dtime,KEntryAttHidden,0);
+ test(r==KErrDiskFull);
+
+ r=file.Rename(buf);
+ test(r==KErrDiskFull);
+
+ file.Close();
+
+
+ // Test that we can create a temporary file & write to it after acquiring reserved access,
+ r=fs.GetReserveAccess(gTestDrive); //get access to reserve space
+ test(r==KErrNone);
+
+ r=fs.Volume(v,gTestDrive); //get disk space
+ test(r==KErrNone);
+ freeA = v.iFree;
+
+ r=file.Temp(fs, drv, temp, EFileWrite);
+ test(r==KErrNone);
+
+ r = file.Write(KTestData());
+ test (r == KErrNone);
+
+ // If write caching is enabled, call RFs::Entry() to flush the file "anonymously"
+ if ((gDriveCacheFlags & EFileCacheWriteOn) && (r == KErrNone))
+ {
+ r = file.Flush();
+ test (r == KErrNone);
+ }
+
+ r=fs.Volume(v,gTestDrive); //get disk space
+ test(r==KErrNone);
+ freeB = v.iFree;
+ test (freeB < freeA);
+
+ file.Close();
+
+ r=fs.ReleaseReserveAccess(gTestDrive); //release reserve space
+ test(r==KErrNone);
+
+
+ TBuf<20> newname =KNewName();
+ newname[0]=(TUint16)gCh;
+ r=fs.Rename(buf, newname);
+ test(r==KErrDiskFull);
+
+ r=fs.Replace(buf, newname);
+ test(r==KErrDiskFull);
+
+ r=fs.SetEntry(buf, dtime, KEntryAttHidden, 0);
+ test(r==KErrDiskFull);
+
+ r=fs.CreatePrivatePath(gTestDrive);
+ test(r==KErrDiskFull);
+
+ r=fs.SetVolumeLabel(_L("Moooo"), gTestDrive);
+ test(r==KErrDiskFull);
+
+ r=fs.SetModified(buf, dtime);
+ test(r==KErrDiskFull);
+
+ SynchronousClose(fs);
+ }
+
+
+
+static void Test5()
+//
+//
+//
+ {
+ test.Next(_L("Test Session limits"));
+
+ if(IsTestingLFFS())
+ {
+ //-- This test is not valid for LFFS, because free space on this FS can change itself because of some
+ //-- internal FS activities
+ test.Printf(_L("This test is inconsistent on LFFS\n"));
+ return;
+ }
+
+
+ RFs fs1;
+ RFs fs2;
+ TInt r=KErrNone;
+
+ r=fs1.Connect();
+ test(r==KErrNone);
+ r=fs2.Connect();
+ test(r==KErrNone);
+
+ FormatDrive();
+
+ r=fs1.ReserveDriveSpace(gTestDrive,0x10000);
+ test(r==KErrNone);
+
+ r=fs2.ReserveDriveSpace(gTestDrive,0x10000);
+ test(r==KErrNone);
+
+ FillUpDisk();
+
+ r=fs1.GetReserveAccess(gTestDrive);
+ test(r==KErrNone);
+
+ TBuf<20> dir = KDir();
+ dir[0]=(TUint16)gCh;
+
+
+ r=fs2.MkDir(dir);
+ test(r==KErrDiskFull);
+
+ r=fs1.ReserveDriveSpace(gTestDrive,0); //can not release reserve space while you have reserve access
+ test(r==KErrInUse);
+
+ r=fs1.ReleaseReserveAccess(gTestDrive);
+ test(r==KErrNone);
+
+ r=fs1.ReserveDriveSpace(gTestDrive,0);
+ test(r==KErrNone);
+
+ r=fs2.MkDir(dir);
+ test(r==KErrNone);
+
+ SynchronousClose(fs1);
+ SynchronousClose(fs2);
+ }
+
+static TInt RsrvSpaceThread(TAny* aArg)
+ {
+ TInt r=KErrNone;
+ TInt64 fr1;
+ TInt64 fr2;
+ TInt64 diff;
+
+ TVolumeInfo v;
+ r=((RFs*)aArg)->Volume(v,gTestDrive);
+ if(r!=KErrNone)
+ return(r);
+
+ fr1=v.iFree;
+
+ r=((RFs*)aArg)->ReserveDriveSpace(gTestDrive,0x10000);
+ if(r!=KErrNone)
+ return(r);
+
+ r=((RFs*)aArg)->Volume(v,gTestDrive);
+ if(r!=KErrNone)
+ return(r);
+ fr2=v.iFree;
+
+ diff=fr1-fr2;
+ if(!(I64INT(diff)> 0xef38 && I64INT(diff)<0xf100))
+ return(KErrGeneral);
+ return r;
+ }
+
+static TInt SessCloseThread(TAny* aArg)
+ {
+ TInt r=KErrNone;
+ TInt64 fr1;
+ TInt64 fr2;
+ TInt64 diff;
+
+ TVolumeInfo v;
+ r=((RFs*)aArg)->Volume(v,gTestDrive);
+ if(r!=KErrNone)
+ return(r);
+ fr1=v.iFree;
+
+ ((RFs*)aArg)->ReserveDriveSpace(gTestDrive,0x1000);
+
+ r=((RFs*)aArg)->Volume(v,gTestDrive);
+ if(r!=KErrNone)
+ return(r);
+ fr2=v.iFree;
+
+ diff=fr2-fr1;
+ if(!(I64INT(diff)> 0xef38 && I64INT(diff)<0xf100))
+ return(KErrGeneral);
+
+ SynchronousClose(*((RFs*)aArg));
+
+ return r;
+ }
+
+static void Test6()
+//
+// Test sharabale session
+//
+ {
+
+ test.Next(_L("Test sharable session"));
+
+ RFs fsess;
+ TInt r=KErrNone;
+ TInt64 free1(0);
+ TInt64 free2(0);
+ TInt64 diff(0);
+ RThread t[KNumberThreads];
+ TRequestStatus tStat[KNumberThreads];
+
+ r=fsess.Connect();
+ test(r==KErrNone);
+
+ FormatDrive();
+
+ r= fsess.ShareAuto();
+ test(r==KErrNone);
+
+ GetFreeDiskSpace(free1);
+
+ fsess.ReserveDriveSpace(gTestDrive,0x1000);
+
+ r = t[0].Create(_L("Sub_Thread1"),RsrvSpaceThread,KDefaultStackSize,KHeapSize,KHeapSize,&fsess);
+ test(r==KErrNone);
+
+ t[0].Rendezvous(tStat[0]);
+ t[0].Resume();
+
+ User::WaitForRequest(tStat[0]);
+
+ t[0].Close();
+ test(tStat[0]==KErrNone);
+
+ r = t[1].Create(_L("Sub_Thread2"),SessCloseThread,KDefaultStackSize,KHeapSize,KHeapSize,&fsess);
+ test(r==KErrNone);
+
+ t[1].Rendezvous(tStat[1]);
+ t[1].Resume();
+
+ User::WaitForRequest(tStat[1]);
+
+ t[1].Close();
+ test(tStat[1]==KErrNone);
+
+ GetFreeDiskSpace(free2);
+
+ diff = free1-free2;
+ test(I64INT(diff)== 0 || I64INT(diff)<0xFA0 );
+ }
+
+
+static void Test7()
+//
+// Tests notifier events for sessions with and without reserved access
+//
+ {
+ if(IsTestingLFFS())
+ {
+ // This test is not valid for LFFS...
+ test.Printf(_L("Test reserved access notification not run for LFFS\n"));
+ return;
+ }
+
+
+ test.Next(_L("Test reserved access notification"));
+
+ FormatDrive();
+
+ RFs theNrm;
+ RFs theRes;
+
+ TInt err = theNrm.Connect();
+ test(KErrNone == err);
+
+ err = theRes.Connect();
+ test(KErrNone == err);
+
+
+ TInt64 freeSpace(0);
+ GetFreeDiskSpace(freeSpace);
+
+ RFs theTestSession;
+ theTestSession.Connect();
+
+ _LIT(KFileFiller, "?:\\t_falseSpaceFiller");
+ TBuf<25> fileName;
+ fileName = KFileFiller;
+ fileName[0] = (TUint16)gCh;
+
+ err = theTestSession.Connect();
+ test(err == KErrNone);
+
+ // determine the cluster size
+ RFile theFile;
+ err=theFile.Replace(theTestSession, fileName, EFileShareAny | EFileWrite);
+ test(err==KErrNone);
+
+ // Neither notifier should be triggered here
+ err = theFile.SetSize(1);
+ test(KErrNone == err);
+ theFile.Close();
+
+ TInt64 newFreeSpace;
+ GetFreeDiskSpace(newFreeSpace);
+ TInt clusterSize = TInt(freeSpace - newFreeSpace);
+ theTestSession.Delete(fileName);
+ GetFreeDiskSpace(newFreeSpace);
+ test (newFreeSpace == freeSpace);
+
+ TInt resSpace = Max(0x1000, clusterSize);
+
+ TVolumeInfo volInfo;
+ theNrm.Volume(volInfo, gTestDrive);
+ test(volInfo.iFree == freeSpace);
+
+ err = theRes.ReserveDriveSpace(gTestDrive, resSpace);
+ test(KErrNone == err);
+ err = theRes.GetReserveAccess(gTestDrive);
+ test(KErrNone == err);
+
+ theRes.Volume(volInfo, gTestDrive);
+ test(volInfo.iFree == freeSpace);
+
+ theNrm.Volume(volInfo, gTestDrive);
+ test(volInfo.iFree == freeSpace - resSpace);
+
+
+ //
+ // Register the notifiers and verify that the only the "Normal"
+ // and not the "Reserved" session is triggered.
+ //
+ TRequestStatus statNrm;
+ TRequestStatus statRes;
+
+ TInt64 threshold(freeSpace - resSpace*2);
+ theNrm.NotifyDiskSpace(threshold, gTestDrive, statNrm);
+ theRes.NotifyDiskSpace(threshold, gTestDrive, statRes);
+ test((statNrm == KRequestPending) && (statRes == KRequestPending));
+
+
+ //
+ // Main part of the test starts here.
+ // First we create a new file, then we increase its size to cause the
+ // "Normal" notifier to trigger but not the "Reserved" notifier
+ //
+ err=theFile.Replace(theTestSession, fileName, EFileShareAny | EFileWrite);
+ test(err==KErrNone);
+ test((statNrm == KRequestPending) && (statRes == KRequestPending));
+
+ // Neither notifier should be triggered here
+ err = theFile.SetSize(resSpace);
+ test(KErrNone == err);
+ test((statNrm == KRequestPending) && (statRes == KRequestPending));
+
+ // This should trigger the "Normal" notifier, but not the "Reserved" one
+ err = theFile.SetSize(2*resSpace);
+ test(KErrNone == err);
+ test((statNrm == KErrNone) && (statRes == KRequestPending));
+
+
+ //
+ // Reset the "Normal" notifier then increase the amount of reserved space
+ // on the drive. This should re-trigger the "Normal" notifier but leave
+ // the "Reserved" notifier untouched.
+ //
+ theNrm.NotifyDiskSpace(threshold - resSpace, gTestDrive, statNrm);
+ test((statNrm == KRequestPending) && (statRes == KRequestPending));
+
+ err = theTestSession.ReserveDriveSpace(gTestDrive, resSpace * 3);
+ if (err != KErrArgument) // will have exceeded limit if resSpace = 32K
+ {
+ test(err == KErrNone);
+ test((statNrm == KErrNone) && (statRes == KRequestPending));
+ }
+
+ //
+ // All done - tidy up.
+ //
+ theFile.Close();
+ theTestSession.Delete(fileName);
+ theTestSession.Close();
+ theNrm.Close();
+ theRes.Close();
+ }
+
+LOCAL_C void TestForDEF142554()
+ {
+ test.Next(_L("Test for DEF142554: test RFile::Modified and RFile::Att when disk full"));
+
+ Format(gTestDrive);
+
+ TUint att;
+ TTime time;
+
+ RFs fs;
+ TInt err = fs.Connect();
+ test(err == KErrNone);
+
+ RFile file;
+ TBuf<20> fileName;
+ fileName = KTestFile;
+ fileName[0] = (TUint16)gCh;
+
+ err = fs.ReserveDriveSpace(gTestDrive,0x10000);
+ test(err == KErrNone);
+
+ err = file.Replace(fs, fileName, EFileWrite);
+ test(err == KErrNone);
+
+ err = file.Write(KTestData);
+ test(err == KErrNone);
+
+ err = file.Flush();
+ test(err == KErrNone);
+
+ file.Close();
+
+ err = file.Open(fs, fileName, EFileRead);
+ test(err == KErrNone);
+
+ err = file.Att(att);
+ test(err == KErrNone);
+
+ err = file.Modified(time);
+ test(err == KErrNone);
+
+ file.Close();
+
+ FillUpDisk();
+
+ err = file.Open(fs, fileName, EFileRead);
+ test(err == KErrNone);
+
+ TUint att1;
+ err = file.Att(att1);
+ test(err == KErrNone);
+ test(att1 == att);
+
+ TTime time1;
+ err = file.Modified(time1);
+ test(err == KErrNone);
+ test(time1 == time);
+
+ file.Close();
+ fs.Close();
+
+ }
+
+
+//-----------------------------------------------------------------------------
+
+/**
+ test creation of the the file that crosses 4G boundary on the FAT media
+
+*/
+static void TestFAT4G_Boundary()
+ {
+ const TInt64 K4Gig = 4*(TInt64)K1GigaByte;
+
+ test.Next(_L("Test files crossing 4G boundary on FAT"));
+
+ if(!Is_Fat32(TheFs, gTestDrive))
+ {
+ test.Printf(_L("This test requires FAT32. Skipping.\n"));
+ return;
+ }
+
+ TVolumeInfo volInfo;
+
+ TInt nRes = TheFs.Volume(volInfo,gTestDrive);
+ test(nRes == KErrNone);
+
+ if(volInfo.iSize < K4Gig+K1MegaByte)
+ {
+ test.Printf(_L("This test requires volume > 4G. Skipping.\n"));
+ return;
+ }
+
+ //-- 1. format the volume
+ FormatDrive();
+
+ //-- find out media position of the data region start
+ TFatBootSector bootSector;
+ nRes = ReadBootSector(TheFs, gTestDrive, 0, bootSector);
+ test(nRes == KErrNone);
+ test(bootSector.IsValid());
+
+ const TInt64 dataStartPos = bootSector.FirstDataSector() << KDefaultSectorLog2;
+ const TInt64 lowRegion = K4Gig - dataStartPos - K1MegaByte;
+
+
+ //-- 2. create several empty files that take a bit less that 4gig
+ //-- the drive is freshly formatted and the files will expand linearry
+ _LIT(KBaseFN, "\\LargeFile");
+
+ const TInt MaxDummyFiles = 5;
+ const TUint32 DummyFileLen = (TUint32)(lowRegion / MaxDummyFiles);
+ TInt i;
+ for(i=0; i<MaxDummyFiles; ++i)
+ {
+ nRes = CreateFileX(KBaseFN, i, DummyFileLen);
+ test(nRes == KErrNone);
+ }
+
+ //-- 3. create a real file that crosses 4G boundary
+ nRes = CreateCheckableStuffedFile(TheFs, KBaseFN, 5*K1MegaByte);
+ test(nRes == KErrNone);
+
+ test.Printf(_L("Verifying the file that crosses 4G boundary.\n"));
+
+ nRes = VerifyCheckableFile(TheFs, KBaseFN);
+ test(nRes == KErrNone);
+
+
+ nRes = TheFs.Delete(KBaseFN);
+ test(nRes == KErrNone);
+ for(i=0; i<MaxDummyFiles; ++i)
+ {
+ nRes = DeleteFileX(KBaseFN, i);
+ test(nRes == KErrNone);
+ }
+ }
+
+//-----------------------------------------------------------------------------
+
+GLDEF_C void CallTestsL()
+//
+// Do tests relative to session path
+//
+ {
+ //-- set up console output
+ Fat_Test_Utils::SetConsole(test.Console());
+
+
+ if (gSessionPath[0]=='C') //only test on non C drives
+ {
+ test.Printf(_L("TEST NOT RUN FOR THIS DRIVE"));
+ return;
+ }
+
+ if (UserSvr::DebugMask(2)&0x00000002) // TESTFAST mode set? (for automated test builds)
+ if(IsTestingLFFS())
+ {
+ // Don't run on LFFS (to increase speed of automated testing)
+ test.Printf(_L("TEST NOT RUN FOR THIS DRIVE"));
+ return;
+ }
+
+ //get the number of the drive we are currently testing
+ TInt r=0;
+ r=RFs::CharToDrive(gSessionPath[0],gTestDrive);
+ test(r==KErrNone);
+
+ r=RFs::DriveToChar(gTestDrive,gCh);
+ test(r==KErrNone);
+
+ //-- print drive information
+ PrintDrvInfo(TheFs, gTestDrive);
+
+ Test1(); //General test for new APIs
+ Test2(); //Test to ensure drive and session reserve limits are not exceeded
+ Test3();
+ Test4(); //test filling the drive and that each checked API fails
+ Test5();
+ Test6();
+ Test7();
+ TestForDEF142554();
+ Test2(); //run this test to check reserves are being cleared correctly
+
+ TestFAT4G_Boundary();
+
+ TurnAllocFailureOff();
+ }
+
+
+
+