diff -r 7d4490026038 -r 44f437012c90 persistentstorage/dbms/tdbms/t_dbood.cpp
--- a/persistentstorage/dbms/tdbms/t_dbood.cpp	Mon Sep 27 11:59:56 2010 +0100
+++ b/persistentstorage/dbms/tdbms/t_dbood.cpp	Tue Oct 19 16:26:13 2010 +0100
@@ -1,4 +1,4 @@
-// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
+// Copyright (c) 2004-2010 Nokia Corporation and/or its subsidiary(-ies).
 // All rights reserved.
 // This component and the accompanying materials are made available
 // under the terms of "Eclipse Public License v1.0"
@@ -88,6 +88,16 @@
 
 #endif
 
+//The drive that will be used in case if the original drive, where KTestDir is supposed to be created, is not present. 
+const TInt KTestDrive2 = EDriveC;
+_LIT(KTestDatabase2, "C:\\DBMS-TST\\T_DbmsOOD.DB");
+_LIT(KLargeFileName2, "C:\\DBMS-TST\\DeleteMe");
+
+TInt TheTestDrive = -1;
+TFileName TheTestDatabase;
+TFileName TheLargeFileName;
+
+	
 static void AssembleLargeFileName(const TDesC& aFileName, TInt aFileNumber, TDes& aResultPath)
 	{
 	_LIT(KFormatStr, "%S.%03d");
@@ -109,23 +119,23 @@
 		err = fsSession.Entry(aFullName, entry);
 		if(err == KErrNone)
 			{
-			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);
+			TheTest.Printf(_L("Deleting \"%S\" file.\n"), &aFullName);
 			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);
 			if(err != KErrNone)
 				{
-				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);
+				TheTest.Printf(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);
 				}
 			err = fsSession.Delete(aFullName);
 			if(err != KErrNone)
 				{
-				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);
+				TheTest.Printf(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);
 				}
 			}
 		fsSession.Close();
 		}
 	else
 		{
-		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);
+		TheTest.Printf(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);
 		}
 	return err;
 	}
@@ -136,7 +146,7 @@
 	for(TInt i=0;i<1000;++i)
 		{
 		TBuf<KMaxFileName> filePath;
-		AssembleLargeFileName(KLargeFileName, i, filePath);
+		AssembleLargeFileName(TheLargeFileName, i, filePath);
 		if(DeleteDataFile(filePath) != KErrNone)
 			{
 			break;
@@ -152,7 +162,7 @@
 		TheDb.Close();
 		}
 	TheDbSession.Close();
-	DeleteDataFile(KTestDatabase);
+	DeleteDataFile(TheTestDatabase);
 	DeleteLargeDataFiles();
 	}
 
@@ -164,6 +174,7 @@
 	{
 	if(!aValue)
 		{
+		TheTest.Printf(_L("*** Expression evaluated to false\r\n"));
 		DeleteDataFiles();
 		TheTest(EFalse, aLine);
 		}
@@ -173,7 +184,7 @@
 	{
 	if(aValue != aExpected)
 		{
-		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
+		TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
 		DeleteDataFiles();
 		TheTest(EFalse, aLine);
 		}
@@ -190,10 +201,14 @@
 //TheFs.Connect() has to be called already.
 static void SetupTestDirectory()
     {
-	TInt err = TheFs.MkDir(KTestDatabase);
-	if(err != KErrNone)
+	TInt err = TheFs.MkDir(TheTestDatabase);
+	if(err != KErrNone && err != KErrAlreadyExists)
 	    {
-	    RDebug::Print(_L("*** SetupTestDirectory(), RFs::MkDir(), err=%d\r\n"), err);
+		TheTest.Printf(_L("*** SetupTestDirectory(), RFs::MkDir(), drive=%d, err=%d.\r\nNext attempt with drive %d.\r\n"), TheTestDrive, err, KTestDrive2);
+	    TheTestDrive = KTestDrive2;
+		TheTestDatabase.Copy(KTestDatabase2);
+		TheLargeFileName.Copy(KLargeFileName2);
+		err = TheFs.MkDir(TheTestDatabase);
 	    }
 	TEST(err == KErrNone || err == KErrAlreadyExists);
 	}
@@ -201,7 +216,7 @@
 //Leaves with info message printed out
 static void LeaveL(TInt aError, TInt aLine)
 	{
-	RDebug::Print(_L("*** Leave. Error: %d, Line: %d\r\n"), aError, aLine);
+	TheTest.Printf(_L("*** Leave. Error: %d, Line: %d\r\n"), aError, aLine);
 	User::Leave(aError);
 	}
 
@@ -240,7 +255,7 @@
 static TInt64 FreeDiskSpaceL()
 	{
 	TVolumeInfo volInfoBefore;
-	LEAVE_IF_ERROR(TheFs.Volume(volInfoBefore, KTestDrive));
+	LEAVE_IF_ERROR(TheFs.Volume(volInfoBefore, TheTestDrive));
 	return volInfoBefore.iFree;
 	}
 
@@ -262,13 +277,13 @@
 	TInt fileNo = 0;
 	const TInt KLargeFileSize = 1000000000;
 	TInt64 diskSpace = FreeDiskSpaceL();
-	RDebug::Print(_L("CreateLargeFileL: free space before = %ld\n"), diskSpace);
+	TheTest.Printf(_L("CreateLargeFileL: free space before = %ld\n"), diskSpace);
 	TBuf<KMaxFileName> filePath;
     const TInt64 KMinDiskSpace = 200;
 	//Reserve almost all disk space, except a small amount - 200 bytes.
 	while(diskSpace > KMinDiskSpace)
 		{
-		AssembleLargeFileName(KLargeFileName, fileNo++, filePath);
+		AssembleLargeFileName(TheLargeFileName, fileNo++, filePath);
 		TInt fileSize = KLargeFileSize;
         if(diskSpace < (TInt64)KLargeFileSize)
             {
@@ -277,17 +292,17 @@
             }
 		DoCreateLargeFileL(filePath, fileSize);
 		diskSpace = FreeDiskSpaceL();
-		RDebug::Print(_L("----CreateLargeFileL, step %d, free space = %ld\n"), fileNo, diskSpace);
+		TheTest.Printf(_L("----CreateLargeFileL, step %d, free space = %ld\n"), fileNo, diskSpace);
 		}
 	diskSpace = FreeDiskSpaceL();
-	RDebug::Print(_L("CreateLargeFileL: free space after = %ld\n"), diskSpace);
+	TheTest.Printf(_L("CreateLargeFileL: free space after = %ld\n"), diskSpace);
 	}
 
 //Reserves disk space for TheDbSession instance.
 //TheDbSession instance has to be connected already.
 static void ReserveDiskSpace()
 	{
-	TInt err = TheDbSession.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
+	TInt err = TheDbSession.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 	TEST2(err, KErrNone);
 	}
 
@@ -295,14 +310,14 @@
 //TheDbSession instance has to be connected already.
 static void FreeReservedSpace()
 	{
-	TheDbSession.FreeReservedSpace(KTestDrive);
+	TheDbSession.FreeReservedSpace(TheTestDrive);
 	}
 
 //Gets an access to the reserved disk space for TheDbSession instance.
 //TheDbSession instance has to be connected already.
 static void UnlockReservedSpace()
 	{
-	TInt err = TheDbSession.GetReserveAccess(KTestDrive);
+	TInt err = TheDbSession.GetReserveAccess(TheTestDrive);
 	TEST2(err, KErrNone);
 	}
 
@@ -310,7 +325,7 @@
 //TheDbSession instance has to be connected already.
 static void LockReservedSpace()
 	{
-	(void)TheDbSession.ReleaseReserveAccess(KTestDrive);
+	(void)TheDbSession.ReleaseReserveAccess(TheTestDrive);
 	}
 
 //Creates the test DBMS session
@@ -327,12 +342,12 @@
 static void CreateTestDatabase(RDbs& aDbs, RDbNamedDatabase& aDb)
 	{
 	//Create the test database.
-	TInt err = aDb.Replace(TheFs, KTestDatabase);
+	TInt err = aDb.Replace(TheFs, TheTestDatabase);
 	TEST2(err, KErrNone);
 	TheDb.Close();
 	//Open it now using DBMS session (so, on DBMS server side), because we want to test
 	//server side RFs sessions - handling "out of disk space" situations.
-	err = aDb.Open(aDbs, KTestDatabase);
+	err = aDb.Open(aDbs, TheTestDatabase);
 	TEST2(err, KErrNone);
 	}
 
@@ -412,37 +427,37 @@
 	LEAVE_IF_ERROR(dbs.Connect());
 
 	//Reserve disk space
-	TInt err = dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
+	TInt err = dbs.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 	TEST2(err, KErrNone);
 
 	//An attempt to re-reserve it
-   	err = dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
+   	err = dbs.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 	TEST2(err, KErrInUse);
 
 	//Get an access to the reserved disk space
-	err = dbs.GetReserveAccess(KTestDrive);
+	err = dbs.GetReserveAccess(TheTestDrive);
 	TEST2(err, KErrNone);
 
 	//An attempt to get an access to the reserved space twice.
-	err = dbs.GetReserveAccess(KTestDrive);
+	err = dbs.GetReserveAccess(TheTestDrive);
 	TEST2(err, KErrInUse);
 
 	//This call must fail, because it tries to get an access to the reserved space of
 	//not the same drive, for which ReserveDriveSpace() was called.
-	err = dbs.GetReserveAccess(KTestDrive + 1);
+	err = dbs.GetReserveAccess(TheTestDrive + 1);
 	TEST(err != KErrNone);
 
-	(void)dbs.ReleaseReserveAccess(KTestDrive);
+	(void)dbs.ReleaseReserveAccess(TheTestDrive);
 
 	//An attempt to release the reserved space twice. This call will panic in debug mode.
-	//(void)dbs.ReleaseReserveAccess(KTestDrive);
+	//(void)dbs.ReleaseReserveAccess(TheTestDrive);
 
 	//Cancel reserving an additional disk space
-	dbs.FreeReservedSpace(KTestDrive);
+	dbs.FreeReservedSpace(TheTestDrive);
 
 	//Cancel reserving an additional disk space twice
     //This call will panic in debug mode.
-	//dbs.FreeReservedSpace(KTestDrive);
+	//dbs.FreeReservedSpace(TheTestDrive);
 
 	CleanupStack::PopAndDestroy(&dbs);
 	}
@@ -460,9 +475,9 @@
 static void TransactionTestL()
 	{
     TVolumeIOParamInfo volIoPrm;
-    TInt err = TheFs.VolumeIOParam(KTestDrive, volIoPrm);
+    TInt err = TheFs.VolumeIOParam(TheTestDrive, volIoPrm);
     TEST2(err, KErrNone);
-    RDebug::Print(_L("--Drive %d. BlockSize=%d, ClusterSize=%d, RecReadBufSize=%d, RecWriteBufSize=%d\r\n"), KTestDrive, volIoPrm.iBlockSize, volIoPrm.iClusterSize, volIoPrm.iRecReadBufSize, volIoPrm.iRecWriteBufSize);
+    TheTest.Printf(_L("--Drive %d. BlockSize=%d, ClusterSize=%d, RecReadBufSize=%d, RecWriteBufSize=%d\r\n"), TheTestDrive, volIoPrm.iBlockSize, volIoPrm.iClusterSize, volIoPrm.iRecReadBufSize, volIoPrm.iRecWriteBufSize);
     /////////////////////////////////////////////////////////
 	CreateTestDbSession();
     //Rserve disk space
@@ -471,21 +486,21 @@
 	CreateTestDatabase(TheDbSession, TheDb);
 	CreateTestTableL(TheDb);
 	AddTestDataL(TheDb);
-    RDebug::Print(_L("--Simulate an \"out of disk space\" situation with creating a very large data file, which occupies almost the all the available disk space.\r\n"));
+	TheTest.Printf(_L("--Simulate an \"out of disk space\" situation with creating a very large data file, which occupies almost the all the available disk space.\r\n"));
 	CreateLargeFileL();
-    RDebug::Print(_L("--Attempt to delete test data records. The transaction must fail, because of \"out of disk space\".\r\n"));
+	TheTest.Printf(_L("--Attempt to delete test data records. The transaction must fail, because of \"out of disk space\".\r\n"));
     TInt64 diskSpace = FreeDiskSpaceL();
-	RDebug::Print(_L("--Attempt to delete test data records. Free disk space = %ld\n"), diskSpace);
+    TheTest.Printf(_L("--Attempt to delete test data records. Free disk space = %ld\n"), diskSpace);
 	TRAP(err, DeleteRecordsL());
-	RDebug::Print(_L("--DeleteRecordsL() returned %d error\r\n"), err);
+	TheTest.Printf(_L("--DeleteRecordsL() returned %d error\r\n"), err);
 	TEST(err != KErrNone);
-    RDebug::Print(_L("--The attempt failed with err=%d. Get an access to the reserved disk space.\r\n"), err);
+	TheTest.Printf(_L("--The attempt failed with err=%d. Get an access to the reserved disk space.\r\n"), err);
     UnlockReservedSpace();
-	RDebug::Print(_L("--Try again with getting an access to the reserved disk space.\n"));
+    TheTest.Printf(_L("--Try again with getting an access to the reserved disk space.\n"));
     diskSpace = FreeDiskSpaceL();
-    RDebug::Print(_L("After GetReserveAccess(), free disk space = %ld\r\n"), diskSpace);
+    TheTest.Printf(_L("After GetReserveAccess(), free disk space = %ld\r\n"), diskSpace);
 	DeleteRecordsL();
-	RDebug::Print(_L("--\"Delete\" transaction was completed successfully.\n"));
+	TheTest.Printf(_L("--\"Delete\" transaction was completed successfully.\n"));
     //Free the resources, used in the test
 	DeleteLargeDataFiles();
 	LockReservedSpace();
@@ -514,7 +529,7 @@
 
     RDbNamedDatabase db1;
     CleanupClosePushL(db1);
-	TInt err = db1.Open(dbSess1, KTestDatabase);
+	TInt err = db1.Open(dbSess1, TheTestDatabase);
 	TEST2(err, KErrNone);
 
 	RDbTable tbl1;
@@ -528,7 +543,7 @@
 
     RDbNamedDatabase db2;
     CleanupClosePushL(db2);
-	err = db2.Open(dbSess2, KTestDatabase);
+	err = db2.Open(dbSess2, TheTestDatabase);
 	TEST2(err, KErrNone);
 
 	RDbTable tbl2;
@@ -585,20 +600,20 @@
     LEAVE_IF_ERROR(dbSess2.Connect());
 
     //Play with "ReserveDriveSpace" on both sessions
-    TInt err = dbSess1.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
+    TInt err = dbSess1.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
     TEST2(err, KErrNone);
-    err = dbSess2.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
+    err = dbSess2.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
     TEST2(err, KErrNone);
-    dbSess2.FreeReservedSpace(KTestDrive);
-    err = dbSess2.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
+    dbSess2.FreeReservedSpace(TheTestDrive);
+    err = dbSess2.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
     TEST2(err, KErrNone);
 
     //Get an access to the reserved space through session 2
-	err = dbSess2.GetReserveAccess(KTestDrive);
+	err = dbSess2.GetReserveAccess(TheTestDrive);
     TEST2(err, KErrNone);
     //Free/re-reserve disk space for session 1.
-    dbSess1.FreeReservedSpace(KTestDrive);
-    err = dbSess1.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
+    dbSess1.FreeReservedSpace(TheTestDrive);
+    err = dbSess1.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
     TEST2(err, KErrNone);
 
     //Create session4
@@ -607,7 +622,7 @@
     LEAVE_IF_ERROR(dbSess4.Connect());
 
     //Try to reserve space for session 4.
-    err = dbSess4.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
+    err = dbSess4.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
     TEST2(err, KErrNone);
 
     //Create session3
@@ -615,41 +630,41 @@
     CleanupClosePushL(dbSess3);
     LEAVE_IF_ERROR(dbSess3.Connect());
     //Try to reserve space for session 3.
-    err = dbSess3.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
+    err = dbSess3.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
     TEST2(err, KErrNone);
 
     //Release and free session 2 access to the reserved space.
-    (void)dbSess2.ReleaseReserveAccess(KTestDrive);
-    dbSess2.FreeReservedSpace(KTestDrive);
+    (void)dbSess2.ReleaseReserveAccess(TheTestDrive);
+    dbSess2.FreeReservedSpace(TheTestDrive);
 
-    dbSess3.FreeReservedSpace(KTestDrive);
+    dbSess3.FreeReservedSpace(TheTestDrive);
     CleanupStack::PopAndDestroy(&dbSess3);
 
-    dbSess4.FreeReservedSpace(KTestDrive);
+    dbSess4.FreeReservedSpace(TheTestDrive);
     CleanupStack::PopAndDestroy(&dbSess4);
 
     //Get an access to the reserved space through session 2.
     //But it was freed, so the call will fail.
-	err = dbSess2.GetReserveAccess(KTestDrive);
+	err = dbSess2.GetReserveAccess(TheTestDrive);
     TEST(err != KErrNone);
 
     //Free/re-reserve disk space for session 1.
-    dbSess1.FreeReservedSpace(KTestDrive);
-    err = dbSess1.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
+    dbSess1.FreeReservedSpace(TheTestDrive);
+    err = dbSess1.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
     TEST2(err, KErrNone);
 
     //Grant/release the access to the reserved space for session 1.
-	err = dbSess1.GetReserveAccess(KTestDrive);
+	err = dbSess1.GetReserveAccess(TheTestDrive);
     TEST2(err, KErrNone);
-    (void)dbSess1.ReleaseReserveAccess(KTestDrive);
+    (void)dbSess1.ReleaseReserveAccess(TheTestDrive);
 
     //Grant an access to the reserved space for session 2.
     //The call will fail because there is no reserved disk space for session 2.
-	err = dbSess2.GetReserveAccess(KTestDrive);
+	err = dbSess2.GetReserveAccess(TheTestDrive);
     TEST(err != KErrNone);
 
     //Free the reserved space - session 1
-    dbSess1.FreeReservedSpace(KTestDrive);
+    dbSess1.FreeReservedSpace(TheTestDrive);
 
     CleanupStack::PopAndDestroy(&dbSess2);
     CleanupStack::PopAndDestroy(&dbSess1);
@@ -670,10 +685,10 @@
 	dbs.ResourceMark();
 	for(TInt count=1;;++count)
 		{
-        RDebug::Print(_L("OOMTest1. Count=%d\n"), count);
+		TheTest.Printf(_L("OOMTest1. Count=%d\n"), count);
 		dbs.SetHeapFailure(RHeap::EFailNext, count);
 
-		TInt ret = dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
+		TInt ret = dbs.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize);
 
 		if(ret == KErrNoMemory)
 			{
@@ -681,7 +696,7 @@
 			}
 		else if(ret == KErrNone)
 			{
-			dbs.FreeReservedSpace(KTestDrive);
+			dbs.FreeReservedSpace(TheTestDrive);
 			break;
 			}
 		else
@@ -706,14 +721,14 @@
     {
     RDbs dbs;
     TEST2(dbs.Connect(), KErrNone);
-	TEST2(dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize), KErrNone);
+	TEST2(dbs.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize), KErrNone);
 	dbs.ResourceMark();
 	for(TInt count=1;;++count)
 		{
-        RDebug::Print(_L("OOMTest2. Count=%d\n"), count);
+		TheTest.Printf(_L("OOMTest2. Count=%d\n"), count);
 		dbs.SetHeapFailure(RHeap::EFailNext, count);
 
-		TInt ret = dbs.GetReserveAccess(KTestDrive);
+		TInt ret = dbs.GetReserveAccess(TheTestDrive);
 
 		if(ret == KErrNoMemory)
 			{
@@ -721,7 +736,7 @@
 			}
 		else if(ret == KErrNone)
 			{
-			(void)dbs.ReleaseReserveAccess(KTestDrive);
+			(void)dbs.ReleaseReserveAccess(TheTestDrive);
 			break;
 			}
 		else
@@ -730,7 +745,7 @@
 			}
 		}
 
-	dbs.FreeReservedSpace(KTestDrive);
+	dbs.FreeReservedSpace(TheTestDrive);
     dbs.SetHeapFailure(RHeap::ENone, 0);
     dbs.Close();
     }
@@ -743,7 +758,7 @@
 	//Create DBMS session. Reserve drive space.
     RDbs dbs;
     TEST2(dbs.Connect(), KErrNone);
-	TEST2(dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize), KErrNone);
+	TEST2(dbs.ReserveDriveSpace(TheTestDrive, KReservedSpaceSize), KErrNone);
 	//Panic thread. See DBMS server behaviour - will it panic or not?
 	//If DBMS server panics in _DEBUG mode - DEF057265 is not properly fixed.
 	User::Panic(_L("Simulate DBMS client failuer"), 0);
@@ -813,6 +828,10 @@
 	CTrapCleanup* trapCleanup = CTrapCleanup::New();
 	TEST(trapCleanup != NULL);
 
+	TheTestDrive = KTestDrive;
+	TheTestDatabase.Copy(KTestDatabase);
+	TheLargeFileName.Copy(KLargeFileName);
+	
 	DeleteLargeDataFiles();
 
 	TInt err = TheFs.Connect();