FCL/sf/os/kernelhwsrv: comparison kerneltest/f32test/server/t

equal deleted inserted replaced

-:55a0a1279a7e
+:206a6eaaeb71
 RTest test(_L("t_falsespace"));
 const TInt KNumberThreads=2;
 const TInt KHeapSize=0x2000;
+//-- this is taken from the file server. Hardcoded constant that specifies session limits on reserving the drive space
+const TInt KMaxSessionDriveReserved	=0x10000;
 static TInt RsrvSpaceThread(TAny* aArg);
 static TInt SessCloseThread(TAny* aArg);
 static void GetFreeDiskSpace(TInt64 &aFree);
 	test(s.Int()==KRequestPending);
 	aSession.Close();
 	User::WaitForRequest(s);
 	}
+//-----------------------------------------------------------------------------
+/**
+Get a cluster size for the currently mounted FS (if it supports clusters).
+@return 0 if there was an error (e.g. cluster size query is not supported), otherwise a cluster size
+*/
+static TUint32 FsClusterSize()
+{
+TVolumeIOParamInfo volIop;
+TInt nRes = TheFs.VolumeIOParam(gTestDrive, volIop);
+if(nRes != KErrNone || volIop.iClusterSize < 512 || !IsPowerOf2(volIop.iClusterSize))
+{
+test.Printf(_L("FsClusterSize() The FS hasn't reported a cluster size\n"));
+return 0;
+}
+return volIop.iClusterSize;
+}
 static TInt CreateFileX(const TDesC& aBaseName,TInt aX, TInt aFileSize)
 //
 // Create a large file. Return KErrEof or KErrNone
 //
 static void FillUpDisk()
 //
 // Test that a full disk is ok
 //
 	{
+	test.Next(_L("Fill disk to capacity\n"));
-	test.Start(_L("Fill disk to capacity"));
 	TInt r=TheFs.MkDirAll(KBasePath);
 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 	gCount=0;
 	TFileName sessionPath;
 	r=TheFs.SessionPath(sessionPath);
 			I64HIGH(freespaceAfterScanDrive), I64LOW(freespaceAfterScanDrive));
 		}
 		while (freespaceBeforeScanDrive != freespaceAfterScanDrive );
 	gCount--;
-	test.End();
 	}
 static void GetFreeDiskSpace(TInt64 &aFree)
 //
 //	Get free disk space
 static void Test1()
 //
 //	Test the API fundamentaly works for one session
 //
 	{
-	test.Next(_L("Test Disk Space reserve APIs"));
+	test.Next(_L("Test Disk Space reserve APIs\n"));
 	TInt r=0;
 FormatDrive();
 	TInt64 free2;
 //
 //	Test multiple sessions, ensure the drive limit is not exceeded
 //
 	{
-	test.Next(_L("Test Session and total reserve limits"));
+	test.Next(_L("Test Session and total reserve limits\n"));
 FormatDrive();
 	TInt i=0;
 	TInt r=0;
 		{
 		r = sessions[i].Connect();
 		test_KErrNone(r);
 		}
-	test.Next(_L("Test breaching sesson reserve limit"));
+	test.Next(_L("Test breaching sesson reserve limit\n"));
 	r=sessions[0].ReserveDriveSpace(gTestDrive,0x10001);
 	test_Value(r, r == KErrArgument);
 	//Get Volume Free Space
 	r = sessions[0].Volume(v, gTestDrive);
 	if(v.iFree > 0x100000)
 		{
-		test.Next(_L("Test breaching drive reserve limit"));
+		test.Next(_L("Test breaching drive reserve limit\n"));
 		for (i=0; i<16; i++)
 			{
 			r=sessions[i].ReserveDriveSpace(gTestDrive,0x10000);
 			test_KErrNone(r);
 		test_Value(r, 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"));
+		test.Next(_L("Testing exhausting available drive free space instead\n"));
 		for(i=0; (v.iFree -= 0x10000) >= 0; i++)
 			{
 			r=sessions[i].ReserveDriveSpace(gTestDrive,0x10000);
 			test_KErrNone(r);
 static void Test3()
 //
 //	Test session cleanup
 //
 	{
-	test.Next(_L("Test session close and clean up of resrved space"));
+	test.Next(_L("Test session close and clean up of resrved space\n"));
 	FormatDrive();
 	RFs fs1;
 	RFs fs2;
 //
 //	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"));
+	test.Next(_L("Test Filling disk and using APIs\n"));
 	if(IsTestingLFFS())
 		{
-		//-- This test is not valid for LFFS, because free space on this FS can change itself because of some
+		//-- This test is not valid for LFFS, because free space on this FS can change itself because of some internal FS activities
-//-- internal FS activities
 		test.Printf(_L("This test is inconsistent on LFFS\n"));
+		return;
+		}
+const TInt KThreshold = 0x10000;
+//-- check that the cluster size doesn't exceed the max. limit
+const TInt KClusterSz = FsClusterSize();
+if(KClusterSz > KThreshold)
+{
+test.Printf(_L("The cluster size(%d) is bigger than threshold to test (%d)! Skipping the test!\n"), KClusterSz, KThreshold);
 		return;
 		}
 FormatDrive();
 	r=file.Write(KTestData());
 	test_KErrNone(r);
 	file.Close();
-	r=fs.ReserveDriveSpace(gTestDrive,0x10000);		//reserve some disk space
+	r=fs.ReserveDriveSpace(gTestDrive,KThreshold);		//reserve some disk space
 	test_KErrNone(r);
 	FillUpDisk();									//fill up the disk
 	TVolumeInfo v;									//get disk space
 	freeB=v.iFree;
 	r=fs.ReleaseReserveAccess(gTestDrive);			//release reserve space
 	test_KErrNone(r);
-	test(freeA == (freeB - 0x10000));				//test difference in space is equal to the amount reserved
+	test(freeA == (freeB - KThreshold));				//test difference in space is equal to the amount reserved
 	r=fs.Volume(v,gTestDrive);						//get disk space
 	test_KErrNone(r);
 	freeB=v.iFree;
 	test(freeA == freeB);							//check reading is still correct
 static void Test5()
 //
 //
 //
 	{
-	test.Next(_L("Test Session limits"));
+	test.Next(_L("Test Session limits\n"));
 	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 sharabale session
 //
 	{
-	test.Next(_L("Test sharable session"));
+	test.Next(_L("Test sharable session\n"));
 	RFs fsess;
 	TInt r=KErrNone;
 	TInt64 free1(0);
 	TInt64 free2(0);
 static void Test7()
 //
 // Tests notifier events for sessions with and without reserved access
 //
 	{
+	test.Next(_L("Test reserved access notification\n"));
 	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();
+//-- find out the cluster size
+const TInt KClusterSz = FsClusterSize();
+if(!IsPowerOf2(KClusterSz))
+{
+test.Printf(_L("The FS hasn't reported a cluster size. The test is inconsistent, skipping\n"));
+return;
+}
+//-- check that the cluster size doesn't exceed the max. limit
+if(KClusterSz > KMaxSessionDriveReserved)
+{
+test.Printf(_L("The cluster size(%d) is bigger than reserve limit (%d)! Skipping the test!\n"), KClusterSz, KMaxSessionDriveReserved);
+return;
+}
+const TInt resSpace = Max(0x1000, KClusterSz);
 	RFs theNrm;
 	RFs theRes;
 	TInt err = theNrm.Connect();
 	fileName[0] = (TUint16)gCh;
 	err = theTestSession.Connect();
 	test_KErrNone(err);
-	// determine the cluster size
-	RFile theFile;
-	err=theFile.Replace(theTestSession, fileName, EFileShareAny | EFileWrite);
-	test_KErrNone(err);
-	// 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(volInfo.iFree == freeSpace);
 	theNrm.Volume(volInfo, gTestDrive);
 	test(volInfo.iFree == freeSpace - resSpace);
+RFile theFile;
 	//
 	// Register the notifiers and verify that the only the "Normal"
 	// and not the "Reserved" session is triggered.
 	//
 	theRes.Close();
 	}
 LOCAL_C void TestForDEF142554()
 {
-test.Next(_L("Test for DEF142554: test RFile::Modified and RFile::Att when disk full"));
+test.Next(_L("Test for DEF142554: test RFile::Modified and RFile::Att when disk full\n"));
 Format(gTestDrive);
 TUint att;
 TTime time;
 */
 static void TestFAT4G_Boundary()
 	{
 const TInt64 K4Gig = 4*(TInt64)K1GigaByte;
-	test.Next(_L("Test files crossing 4G boundary on FAT"));
+	test.Next(_L("Test files crossing 4G boundary on FAT\n"));
 if(!Is_Fat32(TheFs, gTestDrive))
 		{
 		test.Printf(_L("This test requires FAT32. Skipping.\n"));
 		return;
 		}
 	}
 void TestRAMDriveNotification()
 	{
-	test.Next(_L("Verifying RFs::ReserveDriveSpace() triggers RFs::NotifyDiskSpace() events"));
+	test.Next(_L("Verifying RFs::ReserveDriveSpace() triggers RFs::NotifyDiskSpace() events\n"));
 	TInt64 freeSpace;
 	GetFreeDiskSpace(freeSpace);
 	test.Printf(_L("free space: 0x%Lx bytes\n"), freeSpace);
 	// set a notification on half the amount we plan to reserve
 	TInt reserve = 4096;
 	TInt64 trigger = freeSpace - 2048;
-	test.Printf(_L("setting notification for space to fall below: 0x%Lx bytes ... "), trigger);
+	test.Printf(_L("setting notification for space to fall below: 0x%Lx bytes ... \n"), trigger);
 	TRequestStatus stat;
 	TheFs.NotifyDiskSpace(trigger, gTestDrive, stat);
 	test_Value(stat.Int(), stat == KRequestPending);
 	test.Printf(_L("ok\n"));
 	// reserve the space and validate that this triggers the notification
-	test.Printf(_L("reserving 0x%x bytes ..."), reserve);
+	test.Printf(_L("reserving 0x%x bytes ...\n"), reserve);
 	TInt r = TheFs.ReserveDriveSpace(gTestDrive, reserve);
 	test_KErrNone(r);
 	test.Printf(_L("ok\n"));
-	test.Printf(_L("validating that the disk space notification triggered ... "));
+	test.Printf(_L("validating that the disk space notification triggered ...\n"));
 	User::After(2000000);	// 2 seconds should be enough to cause the trigger
 	test_Value(stat.Int(), stat == KErrNone);
 	test.Printf(_L("ok\n"));
 	}
 /**
 Test that the reserving some drive space does not takes more space than required.
 */
 void Test0()
 {
-test.Next(_L("test ReserveDriveSpace threshold"));
+test.Next(_L("test ReserveDriveSpace threshold\n"));
 TInt nRes;
-TVolumeIOParamInfo volIop;
 TInt64 freespace=0;
 //-- 1. format the volume
 FormatDrive();
 GetFreeDiskSpace(freespace);
 const TInt64 freeSpace1 = freespace; //-- initial amount of free space on the volume
-nRes = TheFs.VolumeIOParam(gTestDrive, volIop);
+const TInt KClusterSz = FsClusterSize();
-test_KErrNone(nRes);
-const TInt KClusterSz = volIop.iClusterSize;
 if(!IsPowerOf2(KClusterSz))
 {
-test.Next(_L("The FS hasn't reported a cluster size. The test is inconsistent, skipping"));
+test.Printf(_L("The FS hasn't reported a cluster size. The test is inconsistent, skipping\n"));
 return;
 }
+//-- check that the cluster size doesn't exceed the max. limit
+if(KClusterSz > KMaxSessionDriveReserved)
+{
+test.Printf(_L("The cluster size(%d) is bigger than reserve limit (%d)! Skipping the test!\n"), KClusterSz, KMaxSessionDriveReserved);
+return;
+}
 //-- reserve exactly 1 cluster worth drive space.
 nRes = TheFs.ReserveDriveSpace(gTestDrive, KClusterSz);
 test_KErrNone(nRes);
 	Fat_Test_Utils::SetConsole(test.Console());
 	// If TESTFAST mode (for automated test builds) is set, don't run LFFS tests.
 	if ((UserSvr::DebugMask(2) & 0x00000002) && IsTestingLFFS())
 		{
-		test.Printf(_L("TEST NOT RUN FOR LFFS DRIVE"));
+		test.Printf(_L("TEST NOT RUN FOR LFFS DRIVE\n"));
 		return;
 		}
 	//get the number of the drive we are currently testing
 	TInt r=0;

changeset 291	206a6eaaeb71
parent 175	5af6c74cd793