sl@0: // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // Testing new RDbs methods, which handle "Out of disk space" situations.
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include <e32test.h>
sl@0: #include <f32file.h>
sl@0: #include <d32dbms.h>
sl@0: 
sl@0: /////////////////////////////////////////////////////////////////
sl@0: //Globals
sl@0: 
sl@0: //If you change KTestDrive, don't forget to change KTestDatabase too!!!
sl@0: 
sl@0: #if  defined __WINSCW__ || defined __WINS__
sl@0: 
sl@0: 	//The C: drive may be too big and may be used concurently by other applications. 
sl@0: 	//The T: drive is more suitable for the test if running on the emulator
sl@0: 	const TInt				KTestDrive = EDriveT;
sl@0: 	_LIT(					KTestDatabase, "T:\\DBMS-TST\\T_DbmsOOD.DB");
sl@0: 	
sl@0: #elif defined __X86GCC__
sl@0: 
sl@0: 	const TInt				KTestDrive = EDriveG;
sl@0: 	_LIT(					KTestDatabase, "G:\\DBMS-TST\\T_DbmsOOD.DB");
sl@0: 	
sl@0: #else
sl@0: 
sl@0: 	const TInt				KTestDrive = EDriveE;
sl@0: 	_LIT(					KTestDatabase, "E:\\DBMS-TST\\T_DbmsOOD.DB");
sl@0: 	
sl@0: #endif
sl@0: 
sl@0: const TInt				KReservedSpaceSize = 0; //The aSpace parameter of RDbs::ReserveDriveSpace()
sl@0:                                                 //is not used at the moment and shall be set to 0.
sl@0: 
sl@0: static RTest			TheTest(_L("t_dbood - \"Out of Disk space\" test"));
sl@0: static RFs				TheFs;
sl@0: static RDbNamedDatabase TheDb;
sl@0: static RDbs				TheDbSession;
sl@0: 
sl@0: //Test table defs
sl@0: _LIT(KTestTableName, "TABLE1");
sl@0: 
sl@0: const TInt KTestRecordsCount = 350;
sl@0: 
sl@0: struct TColDef
sl@0: 	{
sl@0: 	const TText*	iName;
sl@0: 	TDbColType		iType;
sl@0: 	TInt			iAttributes;
sl@0: 	};
sl@0: static TColDef const KColDefs[]=
sl@0: 	{
sl@0: 		{_S("ID"), EDbColUint32, TDbCol::EAutoIncrement},
sl@0: 		{_S("DATA"), EDbColBinary, TDbCol::ENotNull},
sl@0: 		{0}
sl@0: 	};
sl@0: 
sl@0: //One or more files with KLargeFileName name and ".<n>" extension, where n is
sl@0: //000, 001, 002, 003...
sl@0: //will be created and they will occupy almost all available disk space.
sl@0: //The idea is to perform after that "delete"
sl@0: //transaction, which has to fail, because of "out of disk space" condition.
sl@0: #if  defined __WINSCW__ || defined __WINS__
sl@0: 
sl@0: 	_LIT(KLargeFileName, "T:\\DBMS-TST\\DeleteMe");
sl@0: 
sl@0: #elif defined  __X86GCC__
sl@0: 
sl@0: 	_LIT(KLargeFileName, "G:\\DBMS-TST\\DeleteMe");
sl@0: 
sl@0: #else
sl@0: 
sl@0: 	_LIT(KLargeFileName, "E:\\DBMS-TST\\DeleteMe");
sl@0: 
sl@0: #endif
sl@0: 
sl@0: static void AssembleLargeFileName(const TDesC& aFileName, TInt aFileNumber, TDes& aResultPath)
sl@0: 	{
sl@0: 	_LIT(KFormatStr, "%S.%03d");
sl@0: 	aResultPath.Format(KFormatStr, &aFileName, aFileNumber);
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: //Create/Destroy test environment - global functions
sl@0: 
sl@0: //Deletes "aFullName" file.
sl@0: static TInt DeleteDataFile(const TDesC& aFullName)
sl@0: 	{
sl@0: 	RFs fsSession;
sl@0: 	TInt err = fsSession.Connect();
sl@0: 	if(err == KErrNone)
sl@0: 		{
sl@0: 		TEntry entry;
sl@0: 		err = fsSession.Entry(aFullName, entry);
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);
sl@0: 			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);
sl@0: 			if(err != KErrNone)
sl@0: 				{
sl@0: 				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);
sl@0: 				}
sl@0: 			err = fsSession.Delete(aFullName);
sl@0: 			if(err != KErrNone)
sl@0: 				{
sl@0: 				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);
sl@0: 				}
sl@0: 			}
sl@0: 		fsSession.Close();
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);
sl@0: 		}
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: //Deletes large data files only
sl@0: static void DeleteLargeDataFiles()
sl@0: 	{
sl@0: 	for(TInt i=0;i<1000;++i)
sl@0: 		{
sl@0: 		TBuf<KMaxFileName> filePath;
sl@0: 		AssembleLargeFileName(KLargeFileName, i, filePath);
sl@0: 		if(DeleteDataFile(filePath) != KErrNone)
sl@0: 			{
sl@0: 			break;
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //Deletes data files used by the test
sl@0: static void DeleteDataFiles()
sl@0: 	{
sl@0: 	if(TheDbSession.Handle())
sl@0: 		{
sl@0: 		TheDb.Close();
sl@0: 		}
sl@0: 	TheDbSession.Close();
sl@0: 	DeleteDataFile(KTestDatabase);
sl@0: 	DeleteLargeDataFiles();
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: //Tests macros and functions.
sl@0: //If (!aValue) then the test will be panicked, the test data files will be deleted.
sl@0: static void Check(TInt aValue, TInt aLine)
sl@0: 	{
sl@0: 	if(!aValue)
sl@0: 		{
sl@0: 		DeleteDataFiles();
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: //If (aValue != aExpected) then the test will be panicked, the test data files will be deleted.
sl@0: static void Check(TInt aValue, TInt aExpected, TInt aLine)
sl@0: 	{
sl@0: 	if(aValue != aExpected)
sl@0: 		{
sl@0: 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
sl@0: 		DeleteDataFiles();
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: //Use these to test conditions.
sl@0: #define TEST(arg) Check((arg), __LINE__)
sl@0: #define TEST2(aValue, aExpected) Check(aValue, aExpected, __LINE__)
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: //Global functions
sl@0: 
sl@0: //Prepares the test directory.
sl@0: //TheFs.Connect() has to be called already.
sl@0: static void SetupTestDirectory()
sl@0:     {
sl@0: 	TInt err = TheFs.MkDir(KTestDatabase);
sl@0: 	if(err != KErrNone)
sl@0: 	    {
sl@0: 	    RDebug::Print(_L("*** SetupTestDirectory(), RFs::MkDir(), err=%d\r\n"), err);
sl@0: 	    }
sl@0: 	TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0: 	}
sl@0: 
sl@0: //Leaves with info message printed out
sl@0: static void LeaveL(TInt aError, TInt aLine)
sl@0: 	{
sl@0: 	RDebug::Print(_L("*** Leave. Error: %d, Line: %d\r\n"), aError, aLine);
sl@0: 	User::Leave(aError);
sl@0: 	}
sl@0: 
sl@0: //Leaves if aError < 0 with info message printed out
sl@0: static void LeaveIfErrorL(TInt aError, TInt aLine)
sl@0: 	{
sl@0: 	if(aError < KErrNone)
sl@0: 		{
sl@0: 		LeaveL(aError, aLine);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //Use LEAVE() macro instead of User::Leave() and LEAVE_IF_ERROR() macro instead of
sl@0: //User::LeaveIfError(). They will print the line number, where the "leave" was called.
sl@0: #define LEAVE(aError) LeaveL(aError, __LINE__)
sl@0: #define LEAVE_IF_ERROR(aError) LeaveIfErrorL(aError, __LINE__)
sl@0: 
sl@0: //Creates one or more large files with the total size near to the size of the available disk space.
sl@0: //The idea is to cause  an "out of disk space" condition.
sl@0: static void FillLargeDataFileL(RFile& aFile, TInt aSize)
sl@0: 	{
sl@0:     TInt err = KErrDiskFull;
sl@0:     while(err == KErrDiskFull)
sl@0:         {
sl@0:         err = aFile.SetSize(aSize);
sl@0:         aSize -= 100;
sl@0:         if(aSize <= 0)
sl@0:             {
sl@0:             break;
sl@0:             }
sl@0:         }
sl@0:     TEST(err == KErrNone || err == KErrDiskFull);
sl@0: 	}
sl@0: 
sl@0: //Gets the available space of the tested drive.
sl@0: static TInt64 FreeDiskSpaceL()
sl@0: 	{
sl@0: 	TVolumeInfo volInfoBefore;
sl@0: 	LEAVE_IF_ERROR(TheFs.Volume(volInfoBefore, KTestDrive));
sl@0: 	return volInfoBefore.iFree;
sl@0: 	}
sl@0: 
sl@0: //Creates large data file with aSize size (in bytes).
sl@0: static void DoCreateLargeFileL(const TDesC& aPath, TInt aSize)
sl@0: 	{
sl@0: 	RFile file;
sl@0: 	CleanupClosePushL(file);
sl@0: 	LEAVE_IF_ERROR(file.Replace(TheFs, aPath, EFileRead | EFileWrite));
sl@0: 	FillLargeDataFileL(file, aSize);
sl@0: 	LEAVE_IF_ERROR(file.Flush());
sl@0: 	CleanupStack::PopAndDestroy(&file);
sl@0: 	}
sl@0: 
sl@0: //Creates enough number of large data files to fill the available disk space.
sl@0: //It will change FilesCount global variable's value.
sl@0: static void CreateLargeFileL()
sl@0: 	{
sl@0: 	TInt fileNo = 0;
sl@0: 	const TInt KLargeFileSize = 1000000000;
sl@0: 	TInt64 diskSpace = FreeDiskSpaceL();
sl@0: 	RDebug::Print(_L("CreateLargeFileL: free space before = %ld\n"), diskSpace);
sl@0: 	TBuf<KMaxFileName> filePath;
sl@0:     const TInt64 KMinDiskSpace = 200;
sl@0: 	//Reserve almost all disk space, except a small amount - 200 bytes.
sl@0: 	while(diskSpace > KMinDiskSpace)
sl@0: 		{
sl@0: 		AssembleLargeFileName(KLargeFileName, fileNo++, filePath);
sl@0: 		TInt fileSize = KLargeFileSize;
sl@0:         if(diskSpace < (TInt64)KLargeFileSize)
sl@0:             {
sl@0: 		    TInt64 lastFileSize = diskSpace - KMinDiskSpace;
sl@0:             fileSize = I64LOW(lastFileSize);
sl@0:             }
sl@0: 		DoCreateLargeFileL(filePath, fileSize);
sl@0: 		diskSpace = FreeDiskSpaceL();
sl@0: 		RDebug::Print(_L("----CreateLargeFileL, step %d, free space = %ld\n"), fileNo, diskSpace);
sl@0: 		}
sl@0: 	diskSpace = FreeDiskSpaceL();
sl@0: 	RDebug::Print(_L("CreateLargeFileL: free space after = %ld\n"), diskSpace);
sl@0: 	}
sl@0: 
sl@0: //Reserves disk space for TheDbSession instance.
sl@0: //TheDbSession instance has to be connected already.
sl@0: static void ReserveDiskSpace()
sl@0: 	{
sl@0: 	TInt err = TheDbSession.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: //Frees already reserved disk space for TheDbSession instance.
sl@0: //TheDbSession instance has to be connected already.
sl@0: static void FreeReservedSpace()
sl@0: 	{
sl@0: 	TheDbSession.FreeReservedSpace(KTestDrive);
sl@0: 	}
sl@0: 
sl@0: //Gets an access to the reserved disk space for TheDbSession instance.
sl@0: //TheDbSession instance has to be connected already.
sl@0: static void UnlockReservedSpace()
sl@0: 	{
sl@0: 	TInt err = TheDbSession.GetReserveAccess(KTestDrive);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: //Releases the access to the reserved disk space.
sl@0: //TheDbSession instance has to be connected already.
sl@0: static void LockReservedSpace()
sl@0: 	{
sl@0: 	(void)TheDbSession.ReleaseReserveAccess(KTestDrive);
sl@0: 	}
sl@0: 
sl@0: //Creates the test DBMS session
sl@0: static void CreateTestDbSession()
sl@0: 	{
sl@0: 	TInt err = TheDbSession.Connect();
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: //Creates the test database
sl@0: //TheDbSession instance has to be connected already.
sl@0: //TheFs.Connect() has to be called already.
sl@0: static void CreateTestDatabase(RDbs& aDbs, RDbNamedDatabase& aDb)
sl@0: 	{
sl@0: 	//Create the test database.
sl@0: 	TInt err = aDb.Replace(TheFs, KTestDatabase);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	//Open it now using DBMS session (so, on DBMS server side), because we want to test
sl@0: 	//server side RFs sessions - handling "out of disk space" situations.
sl@0: 	err = aDb.Open(aDbs, KTestDatabase);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: //Creates a test table
sl@0: static void CreateTestTableL(RDbNamedDatabase& aDb)
sl@0: 	{
sl@0: 	CDbColSet* colSet = CDbColSet::NewLC();
sl@0: 	for(const TColDef* colDef=KColDefs;colDef->iName;++colDef)
sl@0: 		{
sl@0: 		TDbCol col(TPtrC(colDef->iName), colDef->iType);
sl@0: 		col.iAttributes = colDef->iAttributes;
sl@0: 		colSet->AddL(col);
sl@0: 		}
sl@0: 	TEST2(aDb.CreateTable(KTestTableName, *colSet), KErrNone);
sl@0: 	CleanupStack::PopAndDestroy(colSet);
sl@0: 	}
sl@0: 
sl@0: //Adds some data to the test table
sl@0: static void AddTestDataL(RDbNamedDatabase& aDb)
sl@0: 	{
sl@0: 	RDbTable tbl;
sl@0: 	CleanupClosePushL(tbl);
sl@0: 	TEST2(tbl.Open(aDb, KTestTableName, RDbRowSet::EUpdatable), KErrNone);
sl@0: 	for(TInt i=0;i<KTestRecordsCount;++i)
sl@0: 		{
sl@0: 		tbl.InsertL();
sl@0: 		tbl.SetColL(2, _L8("1ABCDEFGHI2ABCDEFGHI3ABCDEFGHI4ABCDEFGHI5ABCDEFGHI6ABCDEFGHI7ABCDEFGHI8ABCDEFGHI9ABCDEFGHI0ABCDEFGHI"));
sl@0: 		tbl.PutL();
sl@0: 		}
sl@0: 	TEST(tbl.CountL() == KTestRecordsCount);
sl@0: 	CleanupStack::PopAndDestroy(&tbl);
sl@0: 	}
sl@0: 
sl@0: //Deletes some records from the test table using "delete" transaction.
sl@0: //Do not put TEST or TEST2 macro calls here (except for record count checks)!
sl@0: //The method must leave if some of the calls inside fail.
sl@0: static void DeleteRecordsL()
sl@0: 	{
sl@0: 	RDbTable tbl;
sl@0: 	CleanupClosePushL(tbl);
sl@0: 	LEAVE_IF_ERROR(tbl.Open(TheDb, KTestTableName, RDbRowSet::EUpdatable));
sl@0: 	TEST(tbl.CountL() == KTestRecordsCount);
sl@0: 	TheDb.Begin();
sl@0: 	tbl.FirstL();
sl@0: 	for(TInt i=0;i<(KTestRecordsCount/2);++i)
sl@0: 		{
sl@0: 		tbl.DeleteL();
sl@0: 		tbl.NextL();
sl@0: 		}
sl@0: 	TInt err = TheDb.Commit();
sl@0: 	if(err != KErrNone)
sl@0: 		{
sl@0: 		TheDb.Rollback();
sl@0: 		LEAVE(err);
sl@0: 		}
sl@0: 	TEST(tbl.CountL() == (KTestRecordsCount / 2));
sl@0: 	CleanupStack::PopAndDestroy(&tbl);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: The function simply calls RDbs::ReserveDriveSpace(), RDbs::GetReserveAccess(),
sl@0: RDbs::ReleaseReserveAccess() methods and checks the return values.
sl@0: It might be usefull for debugging in case if something gets wrong.
sl@0: 
sl@0: @SYMTestCaseID          SYSLIB-DBMS-CT-0647
sl@0: @SYMTestCaseDesc        Tests for attempting to reserve disk space
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         Calls up RDbs::ReserveDriveSpace(), RDbs::GetReserveAccess(),
sl@0:                         RDbs::ReleaseReserveAccess() methods and checks the return values.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: static void SimpleCallsL()
sl@0: 	{
sl@0: 	RDbs dbs;
sl@0: 	CleanupClosePushL(dbs);
sl@0: 	LEAVE_IF_ERROR(dbs.Connect());
sl@0: 
sl@0: 	//Reserve disk space
sl@0: 	TInt err = dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	//An attempt to re-reserve it
sl@0:    	err = dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
sl@0: 	TEST2(err, KErrInUse);
sl@0: 
sl@0: 	//Get an access to the reserved disk space
sl@0: 	err = dbs.GetReserveAccess(KTestDrive);
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	//An attempt to get an access to the reserved space twice.
sl@0: 	err = dbs.GetReserveAccess(KTestDrive);
sl@0: 	TEST2(err, KErrInUse);
sl@0: 
sl@0: 	//This call must fail, because it tries to get an access to the reserved space of
sl@0: 	//not the same drive, for which ReserveDriveSpace() was called.
sl@0: 	err = dbs.GetReserveAccess(KTestDrive + 1);
sl@0: 	TEST(err != KErrNone);
sl@0: 
sl@0: 	(void)dbs.ReleaseReserveAccess(KTestDrive);
sl@0: 
sl@0: 	//An attempt to release the reserved space twice. This call will panic in debug mode.
sl@0: 	//(void)dbs.ReleaseReserveAccess(KTestDrive);
sl@0: 
sl@0: 	//Cancel reserving an additional disk space
sl@0: 	dbs.FreeReservedSpace(KTestDrive);
sl@0: 
sl@0: 	//Cancel reserving an additional disk space twice
sl@0:     //This call will panic in debug mode.
sl@0: 	//dbs.FreeReservedSpace(KTestDrive);
sl@0: 
sl@0: 	CleanupStack::PopAndDestroy(&dbs);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-DBMS-CT-0648
sl@0: @SYMTestCaseDesc        Transactions test
sl@0: 						Simulating  an "out of disk space" situation
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         Transaction test under "out of disk space" circumstances
sl@0: 						while reserving disk space.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: static void TransactionTestL()
sl@0: 	{
sl@0:     TVolumeIOParamInfo volIoPrm;
sl@0:     TInt err = TheFs.VolumeIOParam(KTestDrive, volIoPrm);
sl@0:     TEST2(err, KErrNone);
sl@0:     RDebug::Print(_L("--Drive %d. BlockSize=%d, ClusterSize=%d, RecReadBufSize=%d, RecWriteBufSize=%d\r\n"), KTestDrive, volIoPrm.iBlockSize, volIoPrm.iClusterSize, volIoPrm.iRecReadBufSize, volIoPrm.iRecWriteBufSize);
sl@0:     /////////////////////////////////////////////////////////
sl@0: 	CreateTestDbSession();
sl@0:     //Rserve disk space
sl@0: 	ReserveDiskSpace();
sl@0:     //Create test database and table. Add some test data to them.
sl@0: 	CreateTestDatabase(TheDbSession, TheDb);
sl@0: 	CreateTestTableL(TheDb);
sl@0: 	AddTestDataL(TheDb);
sl@0:     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"));
sl@0: 	CreateLargeFileL();
sl@0:     RDebug::Print(_L("--Attempt to delete test data records. The transaction must fail, because of \"out of disk space\".\r\n"));
sl@0:     TInt64 diskSpace = FreeDiskSpaceL();
sl@0: 	RDebug::Print(_L("--Attempt to delete test data records. Free disk space = %ld\n"), diskSpace);
sl@0: 	TRAP(err, DeleteRecordsL());
sl@0: 	RDebug::Print(_L("--DeleteRecordsL() returned %d error\r\n"), err);
sl@0: 	TEST(err != KErrNone);
sl@0:     RDebug::Print(_L("--The attempt failed with err=%d. Get an access to the reserved disk space.\r\n"), err);
sl@0:     UnlockReservedSpace();
sl@0: 	RDebug::Print(_L("--Try again with getting an access to the reserved disk space.\n"));
sl@0:     diskSpace = FreeDiskSpaceL();
sl@0:     RDebug::Print(_L("After GetReserveAccess(), free disk space = %ld\r\n"), diskSpace);
sl@0: 	DeleteRecordsL();
sl@0: 	RDebug::Print(_L("--\"Delete\" transaction was completed successfully.\n"));
sl@0:     //Free the resources, used in the test
sl@0: 	DeleteLargeDataFiles();
sl@0: 	LockReservedSpace();
sl@0:     FreeReservedSpace();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-DBMS-CT-0649
sl@0: @SYMTestCaseDesc        OOD tests with two DBMS sessions.
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         The test actually checks that the DBMS server is in a stable state, when there is more
sl@0: 						than one RDbs session and a shared database is accessed.
sl@0: 						The first check is that the shared database can be accessed without any problem through
sl@0: 						any of the sessions: first or second.
sl@0: 						Then the second session is closed and the shared database is accessed
sl@0: 						through the first DBMS session - the operations should not fail.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: static void TwoSessTestL()
sl@0:     {
sl@0:     //Create session1, open a shared database, open a shared table through session 1
sl@0:     RDbs dbSess1;
sl@0:     CleanupClosePushL(dbSess1);
sl@0:     LEAVE_IF_ERROR(dbSess1.Connect());
sl@0: 
sl@0:     RDbNamedDatabase db1;
sl@0:     CleanupClosePushL(db1);
sl@0: 	TInt err = db1.Open(dbSess1, KTestDatabase);
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	RDbTable tbl1;
sl@0: 	CleanupClosePushL(tbl1);
sl@0: 	TEST2(tbl1.Open(db1, KTestTableName, RDbRowSet::EUpdatable), KErrNone);
sl@0: 
sl@0:     //Create session2, open shared database, open shared table through session 2
sl@0:     RDbs dbSess2;
sl@0:     CleanupClosePushL(dbSess2);
sl@0:     LEAVE_IF_ERROR(dbSess2.Connect());
sl@0: 
sl@0:     RDbNamedDatabase db2;
sl@0:     CleanupClosePushL(db2);
sl@0: 	err = db2.Open(dbSess2, KTestDatabase);
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	RDbTable tbl2;
sl@0: 	CleanupClosePushL(tbl2);
sl@0: 	TEST2(tbl2.Open(db2, KTestTableName, RDbRowSet::EUpdatable), KErrNone);
sl@0: 
sl@0:     //Here we have two sessions and two instances of RDbNamedDatabase type, which
sl@0:     //operate on a shared database. Insert a record through the sessions.
sl@0: 
sl@0: 	tbl1.InsertL();
sl@0: 	tbl1.SetColL(2, _L8("--------------------------1----------------------------------------"));
sl@0: 	tbl1.PutL();
sl@0: 
sl@0: 	tbl2.InsertL();
sl@0: 	tbl2.SetColL(2, _L8("========================2======================================"));
sl@0: 	tbl2.PutL();
sl@0: 
sl@0:     //Close the second session. It should be able to access the shared database via the
sl@0:     //first session.
sl@0: 
sl@0: 	CleanupStack::PopAndDestroy(&tbl2);
sl@0:     CleanupStack::PopAndDestroy(&db2);
sl@0:     CleanupStack::PopAndDestroy(&dbSess2);
sl@0: 
sl@0:     //Try to access again the shared database.
sl@0: 	tbl1.InsertL();
sl@0: 	tbl1.SetColL(2, _L8("+++++++++++++++++++++++++++++++++++3++++++++++++++++++++++++++++++++++++++++++"));
sl@0: 	tbl1.PutL();
sl@0: 
sl@0: 	CleanupStack::PopAndDestroy(&tbl1);
sl@0:     CleanupStack::PopAndDestroy(&db1);
sl@0:     CleanupStack::PopAndDestroy(&dbSess1);
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-DBMS-CT-0650
sl@0: @SYMTestCaseDesc        OOD tests with more than one DBMS session.
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         The test calls ReserveDriveSpace/GetReserveAccess/ReleaseReserveAccess in a different
sl@0: 						combinations on four DBMS sessions. The test should not fail or panic.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: static void TwoSessTest2L()
sl@0:     {
sl@0:     //Create session1
sl@0:     RDbs dbSess1;
sl@0:     CleanupClosePushL(dbSess1);
sl@0:     LEAVE_IF_ERROR(dbSess1.Connect());
sl@0: 
sl@0:     //Create session2
sl@0:     RDbs dbSess2;
sl@0:     CleanupClosePushL(dbSess2);
sl@0:     LEAVE_IF_ERROR(dbSess2.Connect());
sl@0: 
sl@0:     //Play with "ReserveDriveSpace" on both sessions
sl@0:     TInt err = dbSess1.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = dbSess2.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
sl@0:     TEST2(err, KErrNone);
sl@0:     dbSess2.FreeReservedSpace(KTestDrive);
sl@0:     err = dbSess2.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
sl@0:     TEST2(err, KErrNone);
sl@0: 
sl@0:     //Get an access to the reserved space through session 2
sl@0: 	err = dbSess2.GetReserveAccess(KTestDrive);
sl@0:     TEST2(err, KErrNone);
sl@0:     //Free/re-reserve disk space for session 1.
sl@0:     dbSess1.FreeReservedSpace(KTestDrive);
sl@0:     err = dbSess1.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
sl@0:     TEST2(err, KErrNone);
sl@0: 
sl@0:     //Create session4
sl@0:     RDbs dbSess4;
sl@0:     CleanupClosePushL(dbSess4);
sl@0:     LEAVE_IF_ERROR(dbSess4.Connect());
sl@0: 
sl@0:     //Try to reserve space for session 4.
sl@0:     err = dbSess4.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
sl@0:     TEST2(err, KErrNone);
sl@0: 
sl@0:     //Create session3
sl@0:     RDbs dbSess3;
sl@0:     CleanupClosePushL(dbSess3);
sl@0:     LEAVE_IF_ERROR(dbSess3.Connect());
sl@0:     //Try to reserve space for session 3.
sl@0:     err = dbSess3.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
sl@0:     TEST2(err, KErrNone);
sl@0: 
sl@0:     //Release and free session 2 access to the reserved space.
sl@0:     (void)dbSess2.ReleaseReserveAccess(KTestDrive);
sl@0:     dbSess2.FreeReservedSpace(KTestDrive);
sl@0: 
sl@0:     dbSess3.FreeReservedSpace(KTestDrive);
sl@0:     CleanupStack::PopAndDestroy(&dbSess3);
sl@0: 
sl@0:     dbSess4.FreeReservedSpace(KTestDrive);
sl@0:     CleanupStack::PopAndDestroy(&dbSess4);
sl@0: 
sl@0:     //Get an access to the reserved space through session 2.
sl@0:     //But it was freed, so the call will fail.
sl@0: 	err = dbSess2.GetReserveAccess(KTestDrive);
sl@0:     TEST(err != KErrNone);
sl@0: 
sl@0:     //Free/re-reserve disk space for session 1.
sl@0:     dbSess1.FreeReservedSpace(KTestDrive);
sl@0:     err = dbSess1.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
sl@0:     TEST2(err, KErrNone);
sl@0: 
sl@0:     //Grant/release the access to the reserved space for session 1.
sl@0: 	err = dbSess1.GetReserveAccess(KTestDrive);
sl@0:     TEST2(err, KErrNone);
sl@0:     (void)dbSess1.ReleaseReserveAccess(KTestDrive);
sl@0: 
sl@0:     //Grant an access to the reserved space for session 2.
sl@0:     //The call will fail because there is no reserved disk space for session 2.
sl@0: 	err = dbSess2.GetReserveAccess(KTestDrive);
sl@0:     TEST(err != KErrNone);
sl@0: 
sl@0:     //Free the reserved space - session 1
sl@0:     dbSess1.FreeReservedSpace(KTestDrive);
sl@0: 
sl@0:     CleanupStack::PopAndDestroy(&dbSess2);
sl@0:     CleanupStack::PopAndDestroy(&dbSess1);
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-DBMS-CT-0651
sl@0: @SYMTestCaseDesc        Out of memory tests
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         Checks RDbs::ReserveDriveSpace() behaviour under OOM circumstances
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: static void OOMTest1()
sl@0:     {
sl@0:     RDbs dbs;
sl@0:     TEST2(dbs.Connect(), KErrNone);
sl@0: 	dbs.ResourceMark();
sl@0: 	for(TInt count=1;;++count)
sl@0: 		{
sl@0:         RDebug::Print(_L("OOMTest1. Count=%d\n"), count);
sl@0: 		dbs.SetHeapFailure(RHeap::EFailNext, count);
sl@0: 
sl@0: 		TInt ret = dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize);
sl@0: 
sl@0: 		if(ret == KErrNoMemory)
sl@0: 			{
sl@0: 	        dbs.ResourceCheck();
sl@0: 			}
sl@0: 		else if(ret == KErrNone)
sl@0: 			{
sl@0: 			dbs.FreeReservedSpace(KTestDrive);
sl@0: 			break;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			TEST2(ret, KErrNone);
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0:     dbs.SetHeapFailure(RHeap::ENone, 0);
sl@0:     dbs.Close();
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-DBMS-CT-0652
sl@0: @SYMTestCaseDesc        Out of memory tests
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         Checks RDbs::GetReserveAccess() behaviour under OOM circumstances
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: static void OOMTest2()
sl@0:     {
sl@0:     RDbs dbs;
sl@0:     TEST2(dbs.Connect(), KErrNone);
sl@0: 	TEST2(dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize), KErrNone);
sl@0: 	dbs.ResourceMark();
sl@0: 	for(TInt count=1;;++count)
sl@0: 		{
sl@0:         RDebug::Print(_L("OOMTest2. Count=%d\n"), count);
sl@0: 		dbs.SetHeapFailure(RHeap::EFailNext, count);
sl@0: 
sl@0: 		TInt ret = dbs.GetReserveAccess(KTestDrive);
sl@0: 
sl@0: 		if(ret == KErrNoMemory)
sl@0: 			{
sl@0: 	        dbs.ResourceCheck();
sl@0: 			}
sl@0: 		else if(ret == KErrNone)
sl@0: 			{
sl@0: 			(void)dbs.ReleaseReserveAccess(KTestDrive);
sl@0: 			break;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			TEST2(ret, KErrNone);
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	dbs.FreeReservedSpace(KTestDrive);
sl@0:     dbs.SetHeapFailure(RHeap::ENone, 0);
sl@0:     dbs.Close();
sl@0:     }
sl@0: 
sl@0: 
sl@0: //Used in DEF057265().
sl@0: static TInt ThreadFunc(void*)
sl@0: 	{
sl@0: 	User::SetJustInTime(EFalse);	// disable debugger panic handling
sl@0: 	//Create DBMS session. Reserve drive space.
sl@0:     RDbs dbs;
sl@0:     TEST2(dbs.Connect(), KErrNone);
sl@0: 	TEST2(dbs.ReserveDriveSpace(KTestDrive, KReservedSpaceSize), KErrNone);
sl@0: 	//Panic thread. See DBMS server behaviour - will it panic or not?
sl@0: 	//If DBMS server panics in _DEBUG mode - DEF057265 is not properly fixed.
sl@0: 	User::Panic(_L("Simulate DBMS client failuer"), 0);
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: //DEF057265 - Panics when uninstalling a java midlet while it is running.
sl@0: //The test will run one thread. Inside the thread's function the test will create
sl@0: //DBMS session and reserve some disk space. Then the test will panic the thread
sl@0: //(without freeing the reserved disk space).
sl@0: //If DBMS server panics in _DEBUG mode - the defect is not fixed.
sl@0: void DEF057265()
sl@0: 	{
sl@0: 	_LIT(KSessThreadName,"SessThrd");
sl@0: 	RThread sessThread;
sl@0: 	TEST2(sessThread.Create(KSessThreadName, &ThreadFunc, 0x2000, 0, 0), KErrNone);
sl@0: 
sl@0: 	TRequestStatus sessThreadStatus;
sl@0: 	sessThread.Logon(sessThreadStatus);
sl@0: 	TEST2(sessThreadStatus.Int(), KRequestPending);
sl@0: 
sl@0: 	sessThread.Resume();
sl@0: 	User::WaitForRequest(sessThreadStatus);
sl@0: 	TEST2(sessThread.ExitType(), EExitPanic);
sl@0: 
sl@0: 	User::SetJustInTime(EFalse);	// disable debugger panic handling
sl@0: 	sessThread.Close();//This Close() operation will force DBMS server to close
sl@0: 					   //created in ThreadFunc() DBMS session.
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: //The main test function.
sl@0: //Call your new test functions from here
sl@0: static void RunTestsL()
sl@0: 	{
sl@0: 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0647 RDbs OOD methods calls "));
sl@0: 	SimpleCallsL();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0648 Transaction test with reserving disk space "));
sl@0: 	TransactionTestL();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0649 Two DBMS sessions test "));
sl@0:     TwoSessTestL();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0650 Two DBMS sessions test-2 "));
sl@0:     TwoSessTest2L();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0651 DBMS OOD - OOM test 1 "));
sl@0:     OOMTest1();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0652 DBMS OOD - OOM test 2 "));
sl@0:     OOMTest2();
sl@0: 
sl@0: 	TheTest.Next(_L("DEF057265  Panics when uninstalling a java midlet while it is running"));
sl@0: 	DEF057265();
sl@0: 
sl@0: 	//Add tests here!
sl@0: 	}
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	TheTest.Title();
sl@0: 
sl@0: 	__UHEAP_MARK;
sl@0: 
sl@0: 	CTrapCleanup* trapCleanup = CTrapCleanup::New();
sl@0: 	TEST(trapCleanup != NULL);
sl@0: 
sl@0: 	DeleteLargeDataFiles();
sl@0: 
sl@0: 	TInt err = TheFs.Connect();
sl@0: 	TEST2(err, KErrNone);
sl@0: 	SetupTestDirectory();
sl@0: 
sl@0: 	TRAP(err, RunTestsL());
sl@0: 	TheDb.Close();
sl@0: 	TheDbSession.Close();
sl@0: 	TheFs.Close();
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	DeleteDataFiles();//delete the data files used by this test
sl@0: 
sl@0: 	TheTest.End();
sl@0: 	TheTest.Close();
sl@0: 
sl@0: 	delete trapCleanup;
sl@0: 
sl@0: 	__UHEAP_MARKEND;
sl@0: 
sl@0: 	return 0;
sl@0: 	}
sl@0: 
sl@0: