// Copyright (c) 2004-2009 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"

 // 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:

 // Testing new RDbs methods, which handle "Out of disk space" situations.

 // 

 //

 #include <e32test.h>

 #include <f32file.h>

 #include <d32dbms.h>

 /////////////////////////////////////////////////////////////////

 //Globals

 //If you change KTestDrive, don't forget to change KTestDatabase too!!!

 #if  defined __WINSCW__ || defined __WINS__

 	//The C: drive may be too big and may be used concurently by other applications. 

 	//The T: drive is more suitable for the test if running on the emulator

 	const TInt				KTestDrive = EDriveT;

 	_LIT(					KTestDatabase, "T:\\DBMS-TST\\T_DbmsOOD.DB");

 #elif defined __X86GCC__

 	const TInt				KTestDrive = EDriveG;

 	_LIT(					KTestDatabase, "G:\\DBMS-TST\\T_DbmsOOD.DB");

 #else

 	const TInt				KTestDrive = EDriveE;

 	_LIT(					KTestDatabase, "E:\\DBMS-TST\\T_DbmsOOD.DB");

 #endif

 const TInt				KReservedSpaceSize = 0; //The aSpace parameter of RDbs::ReserveDriveSpace()

                                                 //is not used at the moment and shall be set to 0.

 static RTest			TheTest(_L("t_dbood - \"Out of Disk space\" test"));

 static RFs				TheFs;

 static RDbNamedDatabase TheDb;

 static RDbs				TheDbSession;

 //Test table defs

 _LIT(KTestTableName, "TABLE1");

 const TInt KTestRecordsCount = 350;

 struct TColDef

 	{

 	const TText*	iName;

 	TDbColType		iType;

 	TInt			iAttributes;

 	};

 static TColDef const KColDefs[]=

 	{

 		{_S("ID"), EDbColUint32, TDbCol::EAutoIncrement},

 		{_S("DATA"), EDbColBinary, TDbCol::ENotNull},

 		{0}

 	};

 //One or more files with KLargeFileName name and ".<n>" extension, where n is

 //000, 001, 002, 003...

 //will be created and they will occupy almost all available disk space.

 //The idea is to perform after that "delete"

 //transaction, which has to fail, because of "out of disk space" condition.

 #if  defined __WINSCW__ || defined __WINS__

 	_LIT(KLargeFileName, "T:\\DBMS-TST\\DeleteMe");

 #elif defined  __X86GCC__

 	_LIT(KLargeFileName, "G:\\DBMS-TST\\DeleteMe");

 #else

 	_LIT(KLargeFileName, "E:\\DBMS-TST\\DeleteMe");

 #endif

 static void AssembleLargeFileName(const TDesC& aFileName, TInt aFileNumber, TDes& aResultPath)

 	{

 	_LIT(KFormatStr, "%S.%03d");

 	aResultPath.Format(KFormatStr, &aFileName, aFileNumber);

 	}

 ///////////////////////////////////////////////////////////////////////////////////////

 ///////////////////////////////////////////////////////////////////////////////////////

 //Create/Destroy test environment - global functions

 //Deletes "aFullName" file.

 static TInt DeleteDataFile(const TDesC& aFullName)

 	{

 	RFs fsSession;

 	TInt err = fsSession.Connect();

 	if(err == KErrNone)

 		{

 		TEntry entry;

 		err = fsSession.Entry(aFullName, entry);

 		if(err == KErrNone)

 			{

 			RDebug::Print(_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);

 				}

 			err = fsSession.Delete(aFullName);

 			if(err != KErrNone)

 				{

 				RDebug::Print(_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);

 		}

 	return err;

 	}

 //Deletes large data files only

 static void DeleteLargeDataFiles()

 	{

 	for(TInt i=0;i<1000;++i)

 		{

 		TBuf<KMaxFileName> filePath;

 		AssembleLargeFileName(KLargeFileName, i, filePath);

 		if(DeleteDataFile(filePath) != KErrNone)

 			{

 			break;

 			}

 		}

 	}

 //Deletes data files used by the test

 static void DeleteDataFiles()

 	{

 	if(TheDbSession.Handle())

 		{

 		TheDb.Close();

 		}

 	TheDbSession.Close();

 	DeleteDataFile(KTestDatabase);

 	DeleteLargeDataFiles();

 	}

 ///////////////////////////////////////////////////////////////////////////////////////

 ///////////////////////////////////////////////////////////////////////////////////////

 //Tests macros and functions.

 //If (!aValue) then the test will be panicked, the test data files will be deleted.

 static void Check(TInt aValue, TInt aLine)

 	{

 	if(!aValue)

 		{

 		DeleteDataFiles();

 		TheTest(EFalse, aLine);

 		}

 	}

 //If (aValue != aExpected) then the test will be panicked, the test data files will be deleted.

 static void Check(TInt aValue, TInt aExpected, TInt aLine)

 	{

 	if(aValue != aExpected)

 		{

 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

 		DeleteDataFiles();

 		TheTest(EFalse, aLine);

 		}

 	}

 //Use these to test conditions.

 #define TEST(arg) Check((arg), __LINE__)

 #define TEST2(aValue, aExpected) Check(aValue, aExpected, __LINE__)

 ///////////////////////////////////////////////////////////////////////////////////////

 ///////////////////////////////////////////////////////////////////////////////////////

 //Global functions

 //Prepares the test directory.

 //TheFs.Connect() has to be called already.

 static void SetupTestDirectory()

     {

 	TInt err = TheFs.MkDir(KTestDatabase);

 	if(err != KErrNone)

 	    {

 	    RDebug::Print(_L("*** SetupTestDirectory(), RFs::MkDir(), err=%d\r\n"), err);

 	    }

 	TEST(err == KErrNone || err == KErrAlreadyExists);

 	}

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

 	User::Leave(aError);

 	}

 //Leaves if aError < 0 with info message printed out

 static void LeaveIfErrorL(TInt aError, TInt aLine)

 	{

 	if(aError < KErrNone)

 		{

 		LeaveL(aError, aLine);

 		}

 	}

 //Use LEAVE() macro instead of User::Leave() and LEAVE_IF_ERROR() macro instead of

 //User::LeaveIfError(). They will print the line number, where the "leave" was called.

 #define LEAVE(aError) LeaveL(aError, __LINE__)

 #define LEAVE_IF_ERROR(aError) LeaveIfErrorL(aError, __LINE__)

 //Creates one or more large files with the total size near to the size of the available disk space.

 //The idea is to cause  an "out of disk space" condition.

 static void FillLargeDataFileL(RFile& aFile, TInt aSize)

 	{

     TInt err = KErrDiskFull;

     while(err == KErrDiskFull)

         {

         err = aFile.SetSize(aSize);

         aSize -= 100;

         if(aSize <= 0)

             {

             break;

             }

         }

     TEST(err == KErrNone || err == KErrDiskFull);

 	}

 //Gets the available space of the tested drive.

 static TInt64 FreeDiskSpaceL()

 	{

 	TVolumeInfo volInfoBefore;

 	LEAVE_IF_ERROR(TheFs.Volume(volInfoBefore, KTestDrive));

 	return volInfoBefore.iFree;

 	}

 //Creates large data file with aSize size (in bytes).

 static void DoCreateLargeFileL(const TDesC& aPath, TInt aSize)

 	{

 	RFile file;

 	CleanupClosePushL(file);

 	LEAVE_IF_ERROR(file.Replace(TheFs, aPath, EFileRead | EFileWrite));

 	FillLargeDataFileL(file, aSize);

 	LEAVE_IF_ERROR(file.Flush());

 	CleanupStack::PopAndDestroy(&file);

 	}

 //Creates enough number of large data files to fill the available disk space.

 //It will change FilesCount global variable's value.

 static void CreateLargeFileL()

 	{

 	TInt fileNo = 0;

 	const TInt KLargeFileSize = 1000000000;

 	TInt64 diskSpace = FreeDiskSpaceL();

 	RDebug::Print(_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);

 		TInt fileSize = KLargeFileSize;

         if(diskSpace < (TInt64)KLargeFileSize)

             {

 		    TInt64 lastFileSize = diskSpace - KMinDiskSpace;

             fileSize = I64LOW(lastFileSize);

             }

 		DoCreateLargeFileL(filePath, fileSize);

 		diskSpace = FreeDiskSpaceL();

 		RDebug::Print(_L("----CreateLargeFileL, step %d, free space = %ld\n"), fileNo, diskSpace);

 		}

 	diskSpace = FreeDiskSpaceL();

 	RDebug::Print(_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);

 	TEST2(err, KErrNone);

 	}

 //Frees already reserved disk space for TheDbSession instance.

 //TheDbSession instance has to be connected already.

 static void FreeReservedSpace()

 	{

 	TheDbSession.FreeReservedSpace(KTestDrive);

 	}

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

 	TEST2(err, KErrNone);

 	}

 //Releases the access to the reserved disk space.

 //TheDbSession instance has to be connected already.

 static void LockReservedSpace()

 	{

 	(void)TheDbSession.ReleaseReserveAccess(KTestDrive);

 	}

 //Creates the test DBMS session

 static void CreateTestDbSession()

 	{

 	TInt err = TheDbSession.Connect();

 	TEST2(err, KErrNone);

 	}

 //Creates the test database

 //TheDbSession instance has to be connected already.

 //TheFs.Connect() has to be called already.

 static void CreateTestDatabase(RDbs& aDbs, RDbNamedDatabase& aDb)

 	{

 	//Create the test database.

 	TInt err = aDb.Replace(TheFs, KTestDatabase);

 	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);

 	TEST2(err, KErrNone);

 	}

 //Creates a test table

 static void CreateTestTableL(RDbNamedDatabase& aDb)

 	{

 	CDbColSet* colSet = CDbColSet::NewLC();

 	for(const TColDef* colDef=KColDefs;colDef->iName;++colDef)

 		{

 		TDbCol col(TPtrC(colDef->iName), colDef->iType);

 		col.iAttributes = colDef->iAttributes;

 		colSet->AddL(col);

 		}

 	TEST2(aDb.CreateTable(KTestTableName, *colSet), KErrNone);

 	CleanupStack::PopAndDestroy(colSet);

 	}

 //Adds some data to the test table

 static void AddTestDataL(RDbNamedDatabase& aDb)

 	{

 	RDbTable tbl;

 	CleanupClosePushL(tbl);

 	TEST2(tbl.Open(aDb, KTestTableName, RDbRowSet::EUpdatable), KErrNone);

 	for(TInt i=0;i<KTestRecordsCount;++i)

 		{

 		tbl.InsertL();

 		tbl.SetColL(2, _L8("1ABCDEFGHI2ABCDEFGHI3ABCDEFGHI4ABCDEFGHI5ABCDEFGHI6ABCDEFGHI7ABCDEFGHI8ABCDEFGHI9ABCDEFGHI0ABCDEFGHI"));

 		tbl.PutL();

 		}

 	TEST(tbl.CountL() == KTestRecordsCount);

 	CleanupStack::PopAndDestroy(&tbl);

 	}

 //Deletes some records from the test table using "delete" transaction.

 //Do not put TEST or TEST2 macro calls here (except for record count checks)!

 //The method must leave if some of the calls inside fail.

 static void DeleteRecordsL()

 	{

 	RDbTable tbl;

 	CleanupClosePushL(tbl);

 	LEAVE_IF_ERROR(tbl.Open(TheDb, KTestTableName, RDbRowSet::EUpdatable));

 	TEST(tbl.CountL() == KTestRecordsCount);

 	TheDb.Begin();

 	tbl.FirstL();

 	for(TInt i=0;i<(KTestRecordsCount/2);++i)

 		{

 		tbl.DeleteL();

 		tbl.NextL();

 		}

 	TInt err = TheDb.Commit();

 	if(err != KErrNone)

 		{

 		TheDb.Rollback();

 		LEAVE(err);

 		}

 	TEST(tbl.CountL() == (KTestRecordsCount / 2));

 	CleanupStack::PopAndDestroy(&tbl);

 	}

 /**

 The function simply calls RDbs::ReserveDriveSpace(), RDbs::GetReserveAccess(),

 RDbs::ReleaseReserveAccess() methods and checks the return values.

 It might be usefull for debugging in case if something gets wrong.

 @SYMTestCaseID          SYSLIB-DBMS-CT-0647

 @SYMTestCaseDesc        Tests for attempting to reserve disk space

 @SYMTestPriority        Medium

 @SYMTestActions         Calls up RDbs::ReserveDriveSpace(), RDbs::GetReserveAccess(),

                         RDbs::ReleaseReserveAccess() methods and checks the return values.

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 static void SimpleCallsL()

 	{

 	RDbs dbs;

 	CleanupClosePushL(dbs);

 	LEAVE_IF_ERROR(dbs.Connect());

 	//Reserve disk space

 	TInt err = dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);

 	TEST2(err, KErrNone);

 	//An attempt to re-reserve it

    	err = dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);

 	TEST2(err, KErrInUse);

 	//Get an access to the reserved disk space

 	err = dbs.GetReserveAccess(KTestDrive);

 	TEST2(err, KErrNone);

 	//An attempt to get an access to the reserved space twice.

 	err = dbs.GetReserveAccess(KTestDrive);

 	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);

 	TEST(err != KErrNone);

 	(void)dbs.ReleaseReserveAccess(KTestDrive);

 	//An attempt to release the reserved space twice. This call will panic in debug mode.

 	//(void)dbs.ReleaseReserveAccess(KTestDrive);

 	//Cancel reserving an additional disk space

 	dbs.FreeReservedSpace(KTestDrive);

 	//Cancel reserving an additional disk space twice

     //This call will panic in debug mode.

 	//dbs.FreeReservedSpace(KTestDrive);

 	CleanupStack::PopAndDestroy(&dbs);

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0648

 @SYMTestCaseDesc        Transactions test

 						Simulating  an "out of disk space" situation

 @SYMTestPriority        Medium

 @SYMTestActions         Transaction test under "out of disk space" circumstances

 						while reserving disk space.

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 static void TransactionTestL()

 	{

     TVolumeIOParamInfo volIoPrm;

     TInt err = TheFs.VolumeIOParam(KTestDrive, 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);

     /////////////////////////////////////////////////////////

 	CreateTestDbSession();

     //Rserve disk space

 	ReserveDiskSpace();

     //Create test database and table. Add some test data to them.

 	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"));

 	CreateLargeFileL();

     RDebug::Print(_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);

 	TRAP(err, DeleteRecordsL());

 	RDebug::Print(_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);

     UnlockReservedSpace();

 	RDebug::Print(_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);

 	DeleteRecordsL();

 	RDebug::Print(_L("--\"Delete\" transaction was completed successfully.\n"));

     //Free the resources, used in the test

 	DeleteLargeDataFiles();

 	LockReservedSpace();

     FreeReservedSpace();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0649

 @SYMTestCaseDesc        OOD tests with two DBMS sessions.

 @SYMTestPriority        Medium

 @SYMTestActions         The test actually checks that the DBMS server is in a stable state, when there is more

 						than one RDbs session and a shared database is accessed.

 						The first check is that the shared database can be accessed without any problem through

 						any of the sessions: first or second.

 						Then the second session is closed and the shared database is accessed

 						through the first DBMS session - the operations should not fail.

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 static void TwoSessTestL()

     {

     //Create session1, open a shared database, open a shared table through session 1

     RDbs dbSess1;

     CleanupClosePushL(dbSess1);

     LEAVE_IF_ERROR(dbSess1.Connect());

     RDbNamedDatabase db1;

     CleanupClosePushL(db1);

 	TInt err = db1.Open(dbSess1, KTestDatabase);

 	TEST2(err, KErrNone);

 	RDbTable tbl1;

 	CleanupClosePushL(tbl1);

 	TEST2(tbl1.Open(db1, KTestTableName, RDbRowSet::EUpdatable), KErrNone);

     //Create session2, open shared database, open shared table through session 2

     RDbs dbSess2;

     CleanupClosePushL(dbSess2);

     LEAVE_IF_ERROR(dbSess2.Connect());

     RDbNamedDatabase db2;

     CleanupClosePushL(db2);

 	err = db2.Open(dbSess2, KTestDatabase);

 	TEST2(err, KErrNone);

 	RDbTable tbl2;

 	CleanupClosePushL(tbl2);

 	TEST2(tbl2.Open(db2, KTestTableName, RDbRowSet::EUpdatable), KErrNone);

     //Here we have two sessions and two instances of RDbNamedDatabase type, which

     //operate on a shared database. Insert a record through the sessions.

 	tbl1.InsertL();

 	tbl1.SetColL(2, _L8("--------------------------1----------------------------------------"));

 	tbl1.PutL();

 	tbl2.InsertL();

 	tbl2.SetColL(2, _L8("========================2======================================"));

 	tbl2.PutL();

     //Close the second session. It should be able to access the shared database via the

     //first session.

 	CleanupStack::PopAndDestroy(&tbl2);

     CleanupStack::PopAndDestroy(&db2);

     CleanupStack::PopAndDestroy(&dbSess2);

     //Try to access again the shared database.

 	tbl1.InsertL();

 	tbl1.SetColL(2, _L8("+++++++++++++++++++++++++++++++++++3++++++++++++++++++++++++++++++++++++++++++"));

 	tbl1.PutL();

 	CleanupStack::PopAndDestroy(&tbl1);

     CleanupStack::PopAndDestroy(&db1);

     CleanupStack::PopAndDestroy(&dbSess1);

     }

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0650

 @SYMTestCaseDesc        OOD tests with more than one DBMS session.

 @SYMTestPriority        Medium

 @SYMTestActions         The test calls ReserveDriveSpace/GetReserveAccess/ReleaseReserveAccess in a different

 						combinations on four DBMS sessions. The test should not fail or panic.

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 static void TwoSessTest2L()

     {

     //Create session1

     RDbs dbSess1;

     CleanupClosePushL(dbSess1);

     LEAVE_IF_ERROR(dbSess1.Connect());

     //Create session2

     RDbs dbSess2;

     CleanupClosePushL(dbSess2);

     LEAVE_IF_ERROR(dbSess2.Connect());

     //Play with "ReserveDriveSpace" on both sessions

     TInt err = dbSess1.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);

     TEST2(err, KErrNone);

     err = dbSess2.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);

     TEST2(err, KErrNone);

     dbSess2.FreeReservedSpace(KTestDrive);

     err = dbSess2.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);

     TEST2(err, KErrNone);

     //Get an access to the reserved space through session 2

 	err = dbSess2.GetReserveAccess(KTestDrive);

     TEST2(err, KErrNone);

     //Free/re-reserve disk space for session 1.

     dbSess1.FreeReservedSpace(KTestDrive);

     err = dbSess1.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);

     TEST2(err, KErrNone);

     //Create session4

     RDbs dbSess4;

     CleanupClosePushL(dbSess4);

     LEAVE_IF_ERROR(dbSess4.Connect());

     //Try to reserve space for session 4.

     err = dbSess4.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);

     TEST2(err, KErrNone);

     //Create session3

     RDbs dbSess3;

     CleanupClosePushL(dbSess3);

     LEAVE_IF_ERROR(dbSess3.Connect());

     //Try to reserve space for session 3.

     err = dbSess3.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);

     TEST2(err, KErrNone);

     //Release and free session 2 access to the reserved space.

     (void)dbSess2.ReleaseReserveAccess(KTestDrive);

     dbSess2.FreeReservedSpace(KTestDrive);

     dbSess3.FreeReservedSpace(KTestDrive);

     CleanupStack::PopAndDestroy(&dbSess3);

     dbSess4.FreeReservedSpace(KTestDrive);

     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);

     TEST(err != KErrNone);

     //Free/re-reserve disk space for session 1.

     dbSess1.FreeReservedSpace(KTestDrive);

     err = dbSess1.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);

     TEST2(err, KErrNone);

     //Grant/release the access to the reserved space for session 1.

 	err = dbSess1.GetReserveAccess(KTestDrive);

     TEST2(err, KErrNone);

     (void)dbSess1.ReleaseReserveAccess(KTestDrive);

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

     TEST(err != KErrNone);

     //Free the reserved space - session 1

     dbSess1.FreeReservedSpace(KTestDrive);

     CleanupStack::PopAndDestroy(&dbSess2);

     CleanupStack::PopAndDestroy(&dbSess1);

     }

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0651

 @SYMTestCaseDesc        Out of memory tests

 @SYMTestPriority        Medium

 @SYMTestActions         Checks RDbs::ReserveDriveSpace() behaviour under OOM circumstances

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 static void OOMTest1()

     {

     RDbs dbs;

     TEST2(dbs.Connect(), KErrNone);

 	dbs.ResourceMark();

 	for(TInt count=1;;++count)

 		{

         RDebug::Print(_L("OOMTest1. Count=%d\n"), count);

 		dbs.SetHeapFailure(RHeap::EFailNext, count);

 		TInt ret = dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);

 		if(ret == KErrNoMemory)

 			{

 	        dbs.ResourceCheck();

 			}

 		else if(ret == KErrNone)

 			{

 			dbs.FreeReservedSpace(KTestDrive);

 			break;

 			}

 		else

 			{

 			TEST2(ret, KErrNone);

 			}

 		}

     dbs.SetHeapFailure(RHeap::ENone, 0);

     dbs.Close();

     }

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0652

 @SYMTestCaseDesc        Out of memory tests

 @SYMTestPriority        Medium

 @SYMTestActions         Checks RDbs::GetReserveAccess() behaviour under OOM circumstances

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 static void OOMTest2()

     {

     RDbs dbs;

     TEST2(dbs.Connect(), KErrNone);

 	TEST2(dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize), KErrNone);

 	dbs.ResourceMark();

 	for(TInt count=1;;++count)

 		{

         RDebug::Print(_L("OOMTest2. Count=%d\n"), count);

 		dbs.SetHeapFailure(RHeap::EFailNext, count);

 		TInt ret = dbs.GetReserveAccess(KTestDrive);

 		if(ret == KErrNoMemory)

 			{

 	        dbs.ResourceCheck();

 			}

 		else if(ret == KErrNone)

 			{

 			(void)dbs.ReleaseReserveAccess(KTestDrive);

 			break;

 			}

 		else

 			{

 			TEST2(ret, KErrNone);

 			}

 		}

 	dbs.FreeReservedSpace(KTestDrive);

     dbs.SetHeapFailure(RHeap::ENone, 0);

     dbs.Close();

     }

 //Used in DEF057265().

 static TInt ThreadFunc(void*)

 	{

 	User::SetJustInTime(EFalse);	// disable debugger panic handling

 	//Create DBMS session. Reserve drive space.

     RDbs dbs;

     TEST2(dbs.Connect(), KErrNone);

 	TEST2(dbs.ReserveDriveSpace(KTestDrive, 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);

 	return KErrNone;

 	}

 //DEF057265 - Panics when uninstalling a java midlet while it is running.

 //The test will run one thread. Inside the thread's function the test will create

 //DBMS session and reserve some disk space. Then the test will panic the thread

 //(without freeing the reserved disk space).

 //If DBMS server panics in _DEBUG mode - the defect is not fixed.

 void DEF057265()

 	{

 	_LIT(KSessThreadName,"SessThrd");

 	RThread sessThread;

 	TEST2(sessThread.Create(KSessThreadName, &ThreadFunc, 0x2000, 0, 0), KErrNone);

 	TRequestStatus sessThreadStatus;

 	sessThread.Logon(sessThreadStatus);

 	TEST2(sessThreadStatus.Int(), KRequestPending);

 	sessThread.Resume();

 	User::WaitForRequest(sessThreadStatus);

 	TEST2(sessThread.ExitType(), EExitPanic);

 	User::SetJustInTime(EFalse);	// disable debugger panic handling

 	sessThread.Close();//This Close() operation will force DBMS server to close

 					   //created in ThreadFunc() DBMS session.

 	}

 ///////////////////////////////////////////////////////////////////////////////////////

 ///////////////////////////////////////////////////////////////////////////////////////

 //The main test function.

 //Call your new test functions from here

 static void RunTestsL()

 	{

 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0647 RDbs OOD methods calls "));

 	SimpleCallsL();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0648 Transaction test with reserving disk space "));

 	TransactionTestL();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0649 Two DBMS sessions test "));

     TwoSessTestL();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0650 Two DBMS sessions test-2 "));

     TwoSessTest2L();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0651 DBMS OOD - OOM test 1 "));

     OOMTest1();

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0652 DBMS OOD - OOM test 2 "));

     OOMTest2();

 	TheTest.Next(_L("DEF057265  Panics when uninstalling a java midlet while it is running"));

 	DEF057265();

 	//Add tests here!

 	}

 TInt E32Main()

 	{

 	TheTest.Title();

 	__UHEAP_MARK;

 	CTrapCleanup* trapCleanup = CTrapCleanup::New();

 	TEST(trapCleanup != NULL);

 	DeleteLargeDataFiles();

 	TInt err = TheFs.Connect();

 	TEST2(err, KErrNone);

 	SetupTestDirectory();

 	TRAP(err, RunTestsL());

 	TheDb.Close();

 	TheDbSession.Close();

 	TheFs.Close();

 	TEST2(err, KErrNone);

 	DeleteDataFiles();//delete the data files used by this test

 	TheTest.End();

 	TheTest.Close();

 	delete trapCleanup;

 	__UHEAP_MARKEND;

 	return 0;

 	}