sl@0: // Copyright (c) 2008-2010 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: //
sl@0: 
sl@0: #include <f32file.h>
sl@0: #include <e32test.h>
sl@0: #include <hal.h>
sl@0: #include <stdlib.h>
sl@0: #include <sqldb.h>
sl@0: #include "sqlite3.h"
sl@0: #include "SqliteSymbian.h"
sl@0: #include "SqlSrvStatementUtil.h"
sl@0: #include "SqlPanic.h"
sl@0: #include "SqlCompact.h"
sl@0: #include "SqlCompactConn.h"
sl@0: #include "SqlCompactEntry.h"
sl@0: #include "SqlUtil.h"
sl@0: 
sl@0: const TInt KOperationCount = 20;
sl@0: const TInt KFreePageThresholdKb = 5;
sl@0: const TInt KFreePageThreshold = 5;
sl@0: 
sl@0: const TInt KCompactStepInterval = 5;//ms
sl@0: 
sl@0: TSqlCompactSettings TheCompactionSettings;
sl@0: 
sl@0: static RTest 			TheTest(_L ("t_sqlcompact2.exe"));
sl@0: static CTrapCleanup*	TheTrapCleanup = NULL;
sl@0: static RFs 				TheFs;
sl@0: static TBuf<KMaxFileName + 1> TheFileNameZ;
sl@0: static TBuf8<KMaxFileName + 1> TheFileNameZ8;
sl@0: 
sl@0: const TInt KBlobMaxSize = 1024 * 32;
sl@0: static TBuf8<KBlobMaxSize> TheBlob;
sl@0: 
sl@0: static sqlite3* 		TheDbHandle = NULL;
sl@0: 
sl@0: _LIT8(KFreePageCountPragma, "PRAGMA freelist_count\x0");
sl@0: 
sl@0: TBuf<256>  TheCmd;
sl@0: TDriveName TheDriveName;
sl@0: TParse     TheParse;
sl@0: TFileName  TheDbName;
sl@0: 
sl@0: class CSqlCompactTestActive;
sl@0: CSqlCompactTestActive* TheTestActive = NULL;
sl@0: 
sl@0: const TTimeIntervalMicroSeconds32 KInterval(200000);
sl@0: 
sl@0: static TInt TheProcessHandleCount = 0;
sl@0: static TInt TheThreadHandleCount = 0;
sl@0: static TInt TheAllocatedCellsCount = 0;
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: const TInt KBurstRate = 100;
sl@0: #endif
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void DeleteTestFiles()
sl@0: 	{
sl@0: 	::CloseDbHandle(TheDbHandle);
sl@0: 	(void)TheFs.Delete(TheDbName);
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: //Test macros and functions
sl@0: void Check(TInt aValue, TInt aLine)
sl@0: 	{
sl@0: 	if(!aValue)
sl@0: 		{
sl@0: 		DeleteTestFiles();
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: void Check(TInt aValue, TInt aExpected, TInt aLine)
sl@0: 	{
sl@0: 	if(aValue != aExpected)
sl@0: 		{
sl@0: 		DeleteTestFiles();
sl@0: 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
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: void TestEnvCreate()
sl@0: 	{	
sl@0: 	TInt err = sqlite3SymbianLibInit();
sl@0: 	__ASSERT_ALWAYS(err == KErrNone, User::Invariant());
sl@0: 	TheFs = sqlite3SymbianFs();
sl@0: 	for(TInt i=0;i<('Z'-'A');++i)
sl@0: 		{
sl@0: 		TheFs.CreatePrivatePath(i);
sl@0: 		}
sl@0: 	err = TheFs.MkDir(TheDbName);
sl@0: 	TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0: 	DeleteTestFiles();
sl@0: 	}
sl@0: 
sl@0: void TestEnvDestroy()
sl@0: 	{
sl@0: 	DeleteTestFiles();
sl@0: 	sqlite3SymbianLibFinalize();
sl@0: 	CloseSTDLIB();
sl@0: 	}
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void MarkHandles()
sl@0: 	{
sl@0: 	RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);
sl@0: 	}
sl@0: 	
sl@0: void MarkAllocatedCells()
sl@0: 	{
sl@0: 	TheAllocatedCellsCount = User::CountAllocCells();
sl@0: 	}
sl@0: 
sl@0: void CheckHandles()
sl@0: 	{
sl@0: 	TInt processHandleCount = 0;
sl@0: 	TInt threadHandleCount = 0;
sl@0: 
sl@0: 	RThread().HandleCount(processHandleCount, threadHandleCount);
sl@0: 
sl@0: 	TEST(processHandleCount == TheProcessHandleCount);
sl@0: 	TEST(threadHandleCount == TheThreadHandleCount);
sl@0: 	}
sl@0: 	
sl@0: void CheckAllocatedCells()
sl@0: 	{
sl@0: 	TInt allocatedCellsCount = User::CountAllocCells();
sl@0: 	TEST(allocatedCellsCount == TheAllocatedCellsCount);
sl@0: 	}
sl@0: 		
sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: const TDesC& FileNameZ(const TDesC& aFileName)
sl@0: 	{
sl@0: 	TheFileNameZ.Copy(aFileName);
sl@0: 	TheFileNameZ.ZeroTerminate();
sl@0: 	return TheFileNameZ;
sl@0: 	}
sl@0: 
sl@0: const TDesC8& FileNameZ8(const TDesC& aFileName)
sl@0: 	{
sl@0: 	TheFileNameZ8.Copy(aFileName);
sl@0: 	TheFileNameZ8.ZeroTerminate();
sl@0: 	return TheFileNameZ8;
sl@0: 	}
sl@0: 
sl@0: TInt FreePageCount()
sl@0: 	{
sl@0: 	sqlite3_stmt* stmtHandle = NULL;
sl@0: 	TInt err = ::StmtPrepare8(TheDbHandle, KFreePageCountPragma, stmtHandle);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST(stmtHandle != NULL);
sl@0: 	err = ::StmtNext(stmtHandle);
sl@0: 	TEST2(err, KSqlAtRow);
sl@0: 	TInt pageCount = sqlite3_column_int(stmtHandle, 0);
sl@0: 	TEST(pageCount >= 0);
sl@0: 	::FinalizeStmtHandle(stmtHandle);
sl@0: 	return pageCount;
sl@0: 	}
sl@0: 
sl@0: void PrintInfo(TInt aProcessedPages, const TDesC& aMediaTypeName, TUint32 aStartTicks, TUint32 aEndTicks)
sl@0: 	{
sl@0: 	static TInt freq = 0;
sl@0: 	if(freq == 0)
sl@0: 		{
sl@0: 		TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone);
sl@0: 		}
sl@0: 	TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;
sl@0: 	if(diffTicks < 0)
sl@0: 		{
sl@0: 		diffTicks = KMaxTUint32 + diffTicks + 1;
sl@0: 		}
sl@0: 	const TInt KMicroSecIn1Sec = 1000000;
sl@0: 	TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;
sl@0: 	TheTest.Printf(_L("####Media type: %S. Processed pages: %d. Ticks: %ld. Execution time: %d ms\r\n"), 
sl@0: 							&aMediaTypeName, aProcessedPages, diffTicks, us / 1000);
sl@0: 	}
sl@0: 
sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //////////////////////////////        CSqlCompactTestActive declaration              /////////////////////////////////////////////
sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: class CSqlCompactTestActive : public CActive
sl@0: 	{
sl@0: private:
sl@0: 	enum TCommand
sl@0: 		{
sl@0: 		ECmdInvalidTest,	
sl@0: 		ECmdBeginTest1,
sl@0: 		ECmdEndTest1,
sl@0: 		ECmdBeginTest2,
sl@0: 		ECmdEndTest2,
sl@0: 		ECmdBeginTest3,
sl@0: 		ECmdEndTest3,
sl@0: 		ECmdStopTests	
sl@0: 		};
sl@0: 	
sl@0: public:
sl@0: 	static void New();
sl@0: 	virtual ~CSqlCompactTestActive();
sl@0: 	void OomTest();
sl@0: 	void FileIoErrTest();
sl@0: 	void PerformanceTest();
sl@0: 	void FreePageUpdateTest();
sl@0: 	
sl@0: protected:		
sl@0: 	virtual void DoCancel();
sl@0: 	virtual void RunL();
sl@0: 	virtual TInt RunError(TInt aError);
sl@0: 	
sl@0: private:
sl@0: 	CSqlCompactTestActive();
sl@0: 	void Complete(TCommand aNextCommand);
sl@0: 	void Schedule(TCommand aNextCommand, TTimeIntervalMicroSeconds32 aInterval);
sl@0: 
sl@0: 	void CreateTestDatabase();
sl@0: 	void CreateTestDatabase2();
sl@0: 	void PrepareDb(TBool aNewDb);
sl@0: 	void InsertTestRecords(TInt aOpCount = KOperationCount);
sl@0: 	void UpdateTestRecords(TInt aOpCount = KOperationCount);
sl@0: 	void DeleteTestRecords(TInt aOpCount = KOperationCount);
sl@0: 	void DeleteTestRecords2();
sl@0: 	void TestEnd();
sl@0: 	
sl@0: 	void UpdateTestBegin();
sl@0: 	void UpdateTestEnd();
sl@0: 	void DeleteTestBegin();
sl@0: 	void DeleteTestEnd();
sl@0: 	void SingleOpCompactTestBegin();
sl@0: 	void SingleOpCompactTestEnd();
sl@0: 	void DoOomTest1();
sl@0: 	void DoOomTest2();
sl@0: 	void DoOomTest3();
sl@0: 	void DoOomTest4();
sl@0: 	void DoOomTest5();
sl@0: 
sl@0: private:
sl@0: 	TInt			iCommand;
sl@0: 	CSqlCompactor*	iCompactor;
sl@0: 	RTimer			iTimer;
sl@0: 
sl@0: 	};
sl@0: 
sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //////////////////////////////        CSqlCompactTestActive implementation             ///////////////////////////////////////////
sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void CSqlCompactTestActive::New()
sl@0: 	{
sl@0: 	TheTestActive = new CSqlCompactTestActive;
sl@0: 	TEST(TheTestActive != NULL);
sl@0: 	}
sl@0: 
sl@0: CSqlCompactTestActive::~CSqlCompactTestActive()
sl@0: 	{
sl@0: 	Cancel();
sl@0: 	iTimer.Close();
sl@0: 	delete iCompactor;
sl@0: 	}
sl@0: 	
sl@0: void CSqlCompactTestActive::DoCancel()
sl@0: 	{
sl@0: 	iTimer.Cancel();
sl@0: 	TRequestStatus* stat = &iStatus;
sl@0: 	User::RequestComplete(stat, KErrNone);
sl@0: 	}
sl@0: 	
sl@0: void CSqlCompactTestActive::RunL()
sl@0: 	{
sl@0: 	switch(iCommand)
sl@0: 		{
sl@0: 		case CSqlCompactTestActive::ECmdBeginTest1:
sl@0: 			TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4053 Update test"));
sl@0: 			UpdateTestBegin();
sl@0: 			Schedule(CSqlCompactTestActive::ECmdEndTest1, KInterval);
sl@0: 			break;
sl@0: 		case CSqlCompactTestActive::ECmdEndTest1:
sl@0: 			UpdateTestEnd();
sl@0: 			Complete(CSqlCompactTestActive::ECmdBeginTest2);
sl@0: 			break;
sl@0: 		case CSqlCompactTestActive::ECmdBeginTest2:
sl@0: 			TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4054 Delete test"));
sl@0: 			DeleteTestBegin();
sl@0: 			Schedule(CSqlCompactTestActive::ECmdEndTest2, KInterval);
sl@0: 			break;
sl@0: 		case CSqlCompactTestActive::ECmdEndTest2:
sl@0: 			DeleteTestEnd();
sl@0: 			Complete(CSqlCompactTestActive::ECmdBeginTest3);
sl@0: 			break;
sl@0: 		case CSqlCompactTestActive::ECmdBeginTest3:
sl@0: 			TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4055 Single operation - compaction test"));
sl@0: 			SingleOpCompactTestBegin();
sl@0: 			Schedule(CSqlCompactTestActive::ECmdEndTest3, KInterval);
sl@0: 			break;
sl@0: 		case CSqlCompactTestActive::ECmdEndTest3:
sl@0: 			SingleOpCompactTestEnd();
sl@0: 			Complete(CSqlCompactTestActive::ECmdStopTests);
sl@0: 			break;
sl@0: 		case CSqlCompactTestActive::ECmdStopTests:
sl@0: 			CActiveScheduler::Stop();
sl@0: 			break;
sl@0: 		case CSqlCompactTestActive::ECmdInvalidTest:
sl@0: 		default:
sl@0: 			TEST(0);
sl@0: 			break;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: TInt CSqlCompactTestActive::RunError(TInt aError)
sl@0: 	{
sl@0: 	TEST2(aError, KErrNone);
sl@0: 	return aError;
sl@0: 	}
sl@0: 
sl@0: CSqlCompactTestActive::CSqlCompactTestActive() :
sl@0: 	CActive(CActive::EPriorityStandard),
sl@0: 	iCommand(CSqlCompactTestActive::ECmdInvalidTest),
sl@0: 	iCompactor(NULL)
sl@0: 	{
sl@0: 	TInt err = sqlite3_enable_shared_cache(1);
sl@0: 	TEST2(err, SQLITE_OK);
sl@0: 	TRAP(err, iCompactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = iTimer.CreateLocal();
sl@0: 	TEST2(err, KErrNone);
sl@0: 	CActiveScheduler::Add(this);
sl@0: 	Complete(CSqlCompactTestActive::ECmdBeginTest1);
sl@0: 	}
sl@0: 
sl@0: void CSqlCompactTestActive::Complete(CSqlCompactTestActive::TCommand aNextCommand)
sl@0: 	{
sl@0: 	TEST(!IsActive());
sl@0: 	iCommand = aNextCommand;
sl@0: 	TRequestStatus* stat = &iStatus;
sl@0: 	User::RequestComplete(stat, KErrNone);
sl@0: 	SetActive();	
sl@0: 	}
sl@0: 
sl@0: void CSqlCompactTestActive::Schedule(TCommand aNextCommand, TTimeIntervalMicroSeconds32 aInterval)
sl@0: 	{
sl@0: 	TEST(!IsActive());
sl@0: 	iCommand = aNextCommand;
sl@0: 	iTimer.After(iStatus, aInterval);
sl@0: 	TEST2(iStatus.Int(), KRequestPending);
sl@0: 	SetActive();
sl@0: 	}
sl@0: 
sl@0: void CSqlCompactTestActive::CreateTestDatabase()
sl@0: 	{
sl@0: 	TInt err = ::CreateDbHandle8(::FileNameZ8(TheDbName), TheDbHandle);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	_LIT8(KCreateTableSql, "CREATE TABLE A(I INTEGRER, B BLOB)\x0");
sl@0: 	err = ::DbExecStmt8(TheDbHandle, KCreateTableSql);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: void CSqlCompactTestActive::InsertTestRecords(TInt aOpCount)
sl@0: 	{
sl@0: 	TheBlob.SetLength(SQLITE_DEFAULT_PAGE_SIZE);
sl@0: 	for(TInt i=0;i<aOpCount;++i)
sl@0: 		{
sl@0: 		_LIT8(KInsertSql, "INSERT INTO A VALUES(%d, :Prm)\x0");
sl@0: 		TBuf8<sizeof(KInsertSql) + 10> sqlBuf1;
sl@0: 		sqlBuf1.Format(KInsertSql, i + 1);
sl@0: 		sqlite3_stmt* stmtHandle = NULL;
sl@0: 		TInt err = ::StmtPrepare8(TheDbHandle, sqlBuf1, stmtHandle);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		TEST(stmtHandle != NULL);
sl@0: 		err = sqlite3_bind_blob(stmtHandle, 1, TheBlob.Ptr(), SQLITE_DEFAULT_PAGE_SIZE, SQLITE_STATIC);
sl@0: 		TEST2(err, SQLITE_OK);
sl@0: 		err = ::StmtExec(stmtHandle);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		::FinalizeStmtHandle(stmtHandle);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //Creates a test database (with KDbName name). 
sl@0: void CSqlCompactTestActive::CreateTestDatabase2()
sl@0:     {
sl@0:     //Create the database
sl@0:     const TInt KPageSize = 1024;
sl@0:     _LIT8(KConfigStr, "page_size=");
sl@0:     TBuf8<100> config;
sl@0:     config.Copy(KConfigStr);
sl@0:     config.AppendNum(KPageSize);
sl@0:     TInt err = KErrNone;
sl@0:     err = ::CreateDbHandle8(::FileNameZ8(TheDbName), TheDbHandle);
sl@0:     TEST2(err, KErrNone);  
sl@0:     _LIT8(KCreateTableSql, "CREATE TABLE A(I INTEGER, T TEXT)\x0");
sl@0:     err = ::DbExecStmt8(TheDbHandle, KCreateTableSql);
sl@0:     TEST2(err, KErrNone);
sl@0:     }
sl@0: 
sl@0: //Insert 1000 records. The record size is such that there is only two records per page.
sl@0: void CSqlCompactTestActive::PrepareDb(TBool aDeleteRecords)
sl@0:     {
sl@0:     //Insert records
sl@0:     const TInt KRecordCount = 1000;
sl@0:     const TInt KTextLen = 400;
sl@0:     TBuf<KTextLen> TheText;
sl@0:     TBuf<KTextLen + 100> TheSqlBuf;
sl@0:     TheText.SetLength(TheText.MaxLength());
sl@0:     TheText.Fill(TChar('A'));
sl@0:     for(TInt i=0;i<KRecordCount;++i)
sl@0:         {
sl@0:         TheSqlBuf.Format(_L("INSERT INTO A VALUES(%d, '%S')"), i + 1, &TheText);
sl@0:         _LIT(KZero, "\x0");
sl@0:         TheSqlBuf.Append(KZero);
sl@0:         TInt err = ::DbExecStmt16(TheDbHandle, TheSqlBuf);
sl@0:         TEST2(err, KErrNone);
sl@0:         }
sl@0:     if(aDeleteRecords)
sl@0:         {   
sl@0:         //Delete all records to make a lot of free pages. 
sl@0:         _LIT(KDeleteAll, "DELETE FROM A WHERE 1\x0");
sl@0:         TheSqlBuf = KDeleteAll;
sl@0:         TInt err = ::DbExecStmt16(TheDbHandle, TheSqlBuf);
sl@0:         TEST2(err, KErrNone);
sl@0:         }
sl@0:     }
sl@0: 
sl@0: void CSqlCompactTestActive::UpdateTestRecords(TInt aOpCount)
sl@0: 	{
sl@0: 	for(TInt i=0;i<aOpCount;++i)
sl@0: 		{
sl@0: 		_LIT8(KUpdateSql, "UPDATE A SET B=x'1122' WHERE I=%d\x0");
sl@0: 		TBuf8<sizeof(KUpdateSql) + 10> sqlBuf2;
sl@0: 		sqlBuf2.Format(KUpdateSql, i + 1);
sl@0: 		TInt err = ::DbExecStmt8(TheDbHandle, sqlBuf2);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CSqlCompactTestActive::DeleteTestRecords(TInt aOpCount)
sl@0: 	{
sl@0: 	for(TInt i=0;i<aOpCount;++i)
sl@0: 		{
sl@0: 		_LIT8(KDeleteSql, "DELETE FROM A WHERE I=%d\x0");
sl@0: 		TBuf8<sizeof(KDeleteSql) + 10> sqlBuf2;
sl@0: 		sqlBuf2.Format(KDeleteSql, i + 1);
sl@0: 		TInt err = ::DbExecStmt8(TheDbHandle, sqlBuf2);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CSqlCompactTestActive::DeleteTestRecords2()
sl@0: 	{
sl@0: 	_LIT8(KDeleteSql, "DELETE FROM A\x0");
sl@0: 	TInt err = ::DbExecStmt8(TheDbHandle, KDeleteSql);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: void CSqlCompactTestActive::TestEnd()
sl@0: 	{
sl@0: 	TInt freePageCount = ::FreePageCount();
sl@0: 	TEST2(freePageCount, 0);
sl@0: 	iCompactor->ReleaseEntry(TheDbName);
sl@0: 	::CloseDbHandle(TheDbHandle);
sl@0: 	TheDbHandle = NULL;
sl@0: 	(void)TheFs.Delete(TheDbName);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4053
sl@0: @SYMTestCaseDesc		Background compaction scheduled by a set of UPDATE operations.
sl@0: 						The test uses the server background compaction classes directly.
sl@0: 						The test creates a database, inserts records and updates the records.
sl@0: 						The update operations free enough disk space to kick-off the background compaction.
sl@0: 						The test active object, that simulates the SQL server, is activated and the
sl@0: 						background compaction - executed.
sl@0: 						The test checks at the end that the background compaction really happened - in
sl@0: 						CSqlCompactTestActive::UpdateTestEnd().
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Background compaction scheduled by a set of UPDATE operations.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10271
sl@0:                         REQ10272
sl@0: */
sl@0: void CSqlCompactTestActive::UpdateTestBegin()
sl@0: 	{
sl@0: 	CreateTestDatabase();
sl@0: 	TRAPD(err, iCompactor->AddEntryL(TheDbName, TheCompactionSettings));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	InsertTestRecords();
sl@0: 	UpdateTestRecords();
sl@0: 	TInt freePageCount = ::FreePageCount();
sl@0: 	TEST(freePageCount > KFreePageThreshold);
sl@0: 	}
sl@0: 
sl@0: void CSqlCompactTestActive::UpdateTestEnd()
sl@0: 	{
sl@0: 	TestEnd();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4054
sl@0: @SYMTestCaseDesc		Background compaction scheduled by a set of DELETE operations.
sl@0: 						The test uses the server background compaction classes directly.
sl@0: 						The test creates a database, inserts records and deletes the records.
sl@0: 						The delete operations free enough disk space to kick-off the background compaction.
sl@0: 						The test active object, that simulates the SQL server, is activated and the
sl@0: 						background compaction - executed.
sl@0: 						The test checks at the end that the background compaction really happened - in
sl@0: 						CSqlCompactTestActive::DeleteTestEnd().
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Background compaction scheduled by a set of DELETE operations.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10271
sl@0:                         REQ10272
sl@0: */
sl@0: void CSqlCompactTestActive::DeleteTestBegin()
sl@0: 	{
sl@0: 	CreateTestDatabase();
sl@0: 	TRAPD(err, iCompactor->AddEntryL(TheDbName, TheCompactionSettings));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	InsertTestRecords();
sl@0: 	DeleteTestRecords();
sl@0: 	TInt freePageCount = ::FreePageCount();
sl@0: 	TEST(freePageCount >= KFreePageThreshold);
sl@0: 	}
sl@0: 	
sl@0: void CSqlCompactTestActive::DeleteTestEnd()
sl@0: 	{
sl@0: 	TestEnd();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4055
sl@0: @SYMTestCaseDesc		Background compaction, initiated by a single operation.
sl@0: 						The test uses the server background compaction classes directly.
sl@0: 						The test creates a database, inserts records and deletes the records using just
sl@0: 						a single DELETE SQL statement.
sl@0: 						The test active object, that simulates the SQL server, schedules 
sl@0: 						CSqlCompactTestActive::SingleOpCompactTestEnd() for execution. The code in
sl@0: 						SingleOpCompactTestEnd() checks that the background compaction has been activated and closes the
sl@0: 						database connection. The "database close" operation should start the compaction
sl@0: 						because the total size of free pages is above the "free pages" threshold (in Kb).
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Background compaction, initiated by a single operation.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10271
sl@0:                         REQ10272
sl@0: */
sl@0: void CSqlCompactTestActive::SingleOpCompactTestBegin()
sl@0: 	{
sl@0: 	CreateTestDatabase();
sl@0: 	TRAPD(err, iCompactor->AddEntryL(TheDbName, TheCompactionSettings));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	InsertTestRecords();
sl@0: 	DeleteTestRecords2();
sl@0: 	TInt freePageCount = ::FreePageCount();
sl@0: 	TEST(freePageCount >= KFreePageThreshold);
sl@0: 	}
sl@0: 
sl@0: void CSqlCompactTestActive::SingleOpCompactTestEnd()
sl@0: 	{
sl@0: 	TestEnd();
sl@0: 	}
sl@0: 
sl@0: //Background compaction - OOM test.
sl@0: //CSqlCompactor::NewL() is the function tested in an OOM simulation loop.
sl@0: //The expectation is that if the iteration fails with KErrNoMemory, no memory leak will occur and the compactor object won't be created.
sl@0: void CSqlCompactTestActive::DoOomTest1()
sl@0: 	{
sl@0: 	TInt err = KErrNoMemory;
sl@0: 	TInt failingAllocationNo = 0;
sl@0: 	while(err == KErrNoMemory)
sl@0: 		{
sl@0: 		MarkHandles();
sl@0: 		MarkAllocatedCells();
sl@0: 				
sl@0: 		__UHEAP_MARK;
sl@0: 		
sl@0: 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++failingAllocationNo, KBurstRate);
sl@0: 		
sl@0: 		CSqlCompactor* compactor = NULL;
sl@0: 		TRAP(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));
sl@0: 		
sl@0: 		__UHEAP_RESET;
sl@0: 
sl@0: 		if(err == KErrNone)	
sl@0: 			{
sl@0: 			TEST(compactor != NULL);
sl@0: 			delete compactor;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			TEST(!compactor);
sl@0: 			TEST2(err, KErrNoMemory);	
sl@0: 			}
sl@0: 							
sl@0: 		__UHEAP_MARKEND;
sl@0: 
sl@0: 		CheckAllocatedCells();	    	
sl@0: 		CheckHandles();	    	
sl@0: 		}
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("=== CSqlCompactor::NewL() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0: 	}
sl@0: 
sl@0: //Background compaction - OOM test.
sl@0: //CSqlCompactor::AddEntryL() is the function tested in an OOM simulation loop.
sl@0: //The expectation is that no memory leak will occur if OOM iteration fails with KErrNoMemory.
sl@0: //The expectation also is that if the iteration fails with KErrNoMemory, no entry will be added to the compactor.
sl@0: void CSqlCompactTestActive::DoOomTest2()
sl@0: 	{
sl@0: 	CSqlCompactor* compactor = NULL;
sl@0: 	TRAPD(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST(compactor != NULL);
sl@0: 	
sl@0: 	err = KErrNoMemory;
sl@0: 	TInt failingAllocationNo = 0;
sl@0: 	while(err == KErrNoMemory)
sl@0: 		{
sl@0: 		MarkHandles();
sl@0: 		MarkAllocatedCells();
sl@0: 				
sl@0: 		__UHEAP_MARK;
sl@0: 		
sl@0: 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++failingAllocationNo, KBurstRate);
sl@0: 		
sl@0: 		TRAP(err, compactor->AddEntryL(TheDbName, TheCompactionSettings));
sl@0: 		
sl@0: 		__UHEAP_RESET;
sl@0: 
sl@0: 		if(err == KErrNone)	
sl@0: 			{
sl@0: 			TEST2(compactor->iEntries.Count(), 1);
sl@0: 			compactor->ReleaseEntry(TheDbName);
sl@0: 			compactor->iEntries.Compress();
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			TEST2(compactor->iEntries.Count(), 0);
sl@0: 			TEST2(err, KErrNoMemory);	
sl@0: 			}
sl@0: 							
sl@0: 		__UHEAP_MARKEND;
sl@0: 
sl@0: 		CheckAllocatedCells();	    	
sl@0: 		CheckHandles();	    	
sl@0: 		}
sl@0: 	delete compactor;
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("=== CSqlCompactor::AddEntryL() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0: 	}
sl@0: 
sl@0: //Background compaction - OOM test.
sl@0: //CSqlCompactor::NewL() and CSqlCompactor::AddEntryL() are the functions tested in an OOM simulation loop.
sl@0: //At the end of the iteration CSqlCompactor::ReleaseEntry() is not called. 
sl@0: //The CSqlCompactor's destructor should properly release the entry if the compactor and the entry have been created successfully.
sl@0: //The expectation is that no memory leak will occur if OOM iteration fails with KErrNoMemory.
sl@0: void CSqlCompactTestActive::DoOomTest3()
sl@0: 	{
sl@0: 	TInt err = KErrNoMemory;
sl@0: 	TInt failingAllocationNo = 0;
sl@0: 	while(err == KErrNoMemory)
sl@0: 		{
sl@0: 		MarkHandles();
sl@0: 		MarkAllocatedCells();
sl@0: 				
sl@0: 		__UHEAP_MARK;
sl@0: 		
sl@0: 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++failingAllocationNo, KBurstRate);
sl@0: 		
sl@0: 		CSqlCompactor* compactor = NULL;
sl@0: 		TRAP(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			TRAP(err, (void)compactor->AddEntryL(TheDbName, TheCompactionSettings));
sl@0: 			}
sl@0: 		
sl@0: 		__UHEAP_RESET;
sl@0: 
sl@0: 		if(err == KErrNone)	
sl@0: 			{
sl@0: 			TEST(compactor != NULL);
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			TEST2(err, KErrNoMemory);	
sl@0: 			}
sl@0: 		delete compactor;
sl@0: 							
sl@0: 		__UHEAP_MARKEND;
sl@0: 
sl@0: 		CheckAllocatedCells();	    	
sl@0: 		CheckHandles();	    	
sl@0: 		}
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("=== CSqlCompactor::NewL()+CSqlCompactor::AddEntryL() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0: 	}
sl@0: 
sl@0: //Background compaction - OOM test.
sl@0: //The test database is created inside the OOM loop, at the beginning of each OOM iteration. The database has enough free space.
sl@0: //Then the Compact() method is called. The expectation is that if the iteration fails with KErrNoMemory error, no memory leak will occur.
sl@0: void CSqlCompactTestActive::DoOomTest4()
sl@0: 	{
sl@0: 	TInt err = KErrNoMemory;
sl@0: 	TInt failingAllocationNo = 0;
sl@0: 	while(err == KErrNoMemory)
sl@0: 		{
sl@0: 		MarkHandles();
sl@0: 		MarkAllocatedCells();
sl@0: 						
sl@0: 		__UHEAP_MARK;
sl@0: 		
sl@0: 		(void)TheFs.Delete(TheDbName);
sl@0: 		CreateTestDatabase();
sl@0: 		CSqlCompactor* compactor = NULL;
sl@0: 		TRAP(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));
sl@0: 		TEST2(err, KErrNone);
sl@0: 		TRAP(err, compactor->AddEntryL(TheDbName, TheCompactionSettings));
sl@0: 		TEST2(err, KErrNone);
sl@0: 		InsertTestRecords();
sl@0: 		DeleteTestRecords();
sl@0: 		TInt freePageCount = ::FreePageCount();
sl@0: 		TEST(freePageCount >= KFreePageThreshold);
sl@0: 		
sl@0: 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++failingAllocationNo, KBurstRate);
sl@0: 
sl@0: 		CSqlCompactEntry* impl = compactor->iEntries[0];
sl@0: 		err = impl->Compact();
sl@0: 		
sl@0: 		__UHEAP_RESET;
sl@0: 
sl@0: 		if(err != KErrNone)	
sl@0: 			{
sl@0: 			TEST2(err, KErrNoMemory);	
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			TInt freePageCount2 = ::FreePageCount();
sl@0: 			TEST(freePageCount2 < freePageCount);
sl@0: 			}
sl@0: 		delete compactor;
sl@0: 		::CloseDbHandle(TheDbHandle);
sl@0: 		TheDbHandle = NULL;
sl@0: 							
sl@0: 		__UHEAP_MARKEND;
sl@0: 
sl@0: 		CheckAllocatedCells();	    	
sl@0: 		CheckHandles();	    	
sl@0: 		}
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("=== CSqlCompactEntry::Compact() OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0: 	(void)TheFs.Delete(TheDbName);
sl@0: 	}
sl@0: 
sl@0: //Background compaction - OOM test.
sl@0: //The test database is created outside the OOM loop. The database has enough free space.
sl@0: //Then the Compact() method is called under OOM simulation. 
sl@0: //The expectation is that if the iteration fails with KErrNoMemory error, no memory leak will occur and the number of 
sl@0: //the free pages is the same as it was at the beginning of the OOM iteration.
sl@0: void CSqlCompactTestActive::DoOomTest5()
sl@0: 	{
sl@0: 	__UHEAP_MARK;
sl@0: 	
sl@0: 	CreateTestDatabase();
sl@0: 	CSqlCompactor* compactor = NULL;
sl@0: 	TRAPD(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TRAP(err, compactor->AddEntryL(TheDbName, TheCompactionSettings));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	InsertTestRecords();
sl@0: 	DeleteTestRecords();
sl@0: 	TInt freePageCount = ::FreePageCount();
sl@0: 	TEST(freePageCount >= KFreePageThreshold);
sl@0: 	err = KErrNoMemory;
sl@0: 	TInt failingAllocationNo = 0;
sl@0: 	while(err == KErrNoMemory)
sl@0: 		{
sl@0: 		TInt freePageCount2 = ::FreePageCount();
sl@0: 		
sl@0: 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, ++failingAllocationNo, KBurstRate);
sl@0: 
sl@0: 		CSqlCompactEntry* impl = compactor->iEntries[0];
sl@0: 		impl->iPageCount = freePageCount2;
sl@0: 		err = impl->Compact();
sl@0: 		
sl@0: 		__UHEAP_RESET;
sl@0: 
sl@0: 		if(err != KErrNone)	
sl@0: 			{
sl@0: 			TEST2(err, KErrNoMemory);	
sl@0: 			TInt freePageCount3 = ::FreePageCount();
sl@0: 			TEST2(freePageCount2, freePageCount3);
sl@0: 			}
sl@0: 	}
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TInt freePageCount4 = ::FreePageCount();
sl@0: 	TEST(freePageCount4 < freePageCount);
sl@0: 
sl@0: 	compactor->ReleaseEntry(TheDbName);
sl@0: 	delete compactor;
sl@0: 	::CloseDbHandle(TheDbHandle);
sl@0: 	TheDbHandle = NULL;
sl@0: 	
sl@0: 	__UHEAP_MARKEND;
sl@0: 	
sl@0: 	TheTest.Printf(_L("=== CSqlCompactEntry::Compact()-2 OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0: 	(void)TheFs.Delete(TheDbName);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4050
sl@0: @SYMTestCaseDesc		Background compaction - OOM tests.
sl@0: 						The test uses directly the SQL server background compaction classes and does OOM tests for:
sl@0: 						creating the database compaction object (CSqlCompactor), adding a new background database connection, 
sl@0: 						calling directly the background compaction method.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Background compaction - OOM tests.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10271
sl@0: */
sl@0: void CSqlCompactTestActive::OomTest()
sl@0: 	{
sl@0: 	CreateTestDatabase();
sl@0: 	::CloseDbHandle(TheDbHandle);
sl@0: 	TheDbHandle = NULL;
sl@0: 	
sl@0: 	DoOomTest1();
sl@0: 	DoOomTest2();
sl@0: 	DoOomTest3();
sl@0: 
sl@0: 	(void)TheFs.Delete(TheDbName);
sl@0: 	
sl@0: 	DoOomTest4();
sl@0: 	DoOomTest5();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4051
sl@0: @SYMTestCaseDesc		Background compaction - file I/O error simulation test.
sl@0: 						The test calls the background compaction method, CSqlCompactEntry::Compact(),
sl@0: 						in a file I/O error simulation loop.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Background compaction - file I/O error simulation test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10271
sl@0: */
sl@0: void CSqlCompactTestActive::FileIoErrTest()
sl@0: 	{
sl@0: 	CreateTestDatabase();
sl@0: 	CSqlCompactor* compactor = NULL;
sl@0: 	TRAPD(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TRAP(err, compactor->AddEntryL(TheDbName, TheCompactionSettings));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	InsertTestRecords();
sl@0: 	DeleteTestRecords();
sl@0: 	TInt freePageCount = ::FreePageCount();
sl@0: 	TEST(freePageCount >= KFreePageThreshold);
sl@0: 	err = KErrGeneral;
sl@0: 	TInt ioCounter = 0;
sl@0: 	while(err != KErrNone)
sl@0: 		{
sl@0: 		TInt freePageCount2 = ::FreePageCount();
sl@0: 		if(freePageCount2 == 0)
sl@0: 			{
sl@0: 			err = KErrNone;
sl@0: 			break;	
sl@0: 			}
sl@0: 		
sl@0: 		(void)TheFs.SetErrorCondition(err, ioCounter++);
sl@0: 
sl@0: 		CSqlCompactEntry* impl = compactor->iEntries[0];
sl@0: 		impl->iPageCount = freePageCount2;
sl@0: 		err = impl->Compact();
sl@0: 		
sl@0: 		(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 
sl@0: 		//check the database free pages count - all bets are off in a case of an I/O error. 
sl@0: 		//The free page count may actually have been reduced.
sl@0: 		TInt freePageCount3 = ::FreePageCount();
sl@0: 		TEST(freePageCount3  <= freePageCount2);
sl@0: 		}
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TInt freePageCount4 = ::FreePageCount();
sl@0: 
sl@0: 	compactor->ReleaseEntry(TheDbName);
sl@0: 	delete compactor;
sl@0: 	::CloseDbHandle(TheDbHandle);
sl@0: 	TheDbHandle = NULL;
sl@0: 	
sl@0: 	TheTest.Printf(_L("=== CSqlCompactEntry::Compact() \"file I/O\" error simulation test succeeded at iteration %d, free pages %d ===\r\n"), ioCounter, freePageCount4);
sl@0: 	(void)TheFs.Delete(TheDbName);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4052
sl@0: @SYMTestCaseDesc		Compaction - performance test.
sl@0: 						The test creates a test database (the default drive is C:, but different drive 
sl@0: 						can be specified as a test argument) and runs a compaction performance test. 
sl@0: 						The performance result is printed out.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Compaction - performance test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10271
sl@0:                         REQ10272
sl@0: */
sl@0: void CSqlCompactTestActive::PerformanceTest()
sl@0: 	{
sl@0: 	TInt err = TheParse.Set(TheDbName, NULL, NULL);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TPtrC driveName = TheParse.Drive();
sl@0: 	TEST(driveName.Length() > 0);
sl@0: 	TInt driveNumber = -1;
sl@0: 	err = RFs::CharToDrive(driveName[0], driveNumber);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TDriveNumber driveNo = static_cast <TDriveNumber> (driveNumber);
sl@0: 	TDriveInfo driveInfo;
sl@0: 	err = TheFs.Drive(driveInfo, driveNo);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	
sl@0: 	_LIT(KType1, "Not present");
sl@0: 	_LIT(KType2, "Unknown");
sl@0: 	_LIT(KType3, "Floppy");
sl@0: 	_LIT(KType4, "Hard disk");
sl@0: 	_LIT(KType5, "CD ROM");
sl@0: 	_LIT(KType6, "RAM disk");
sl@0: 	_LIT(KType7, "Flash");
sl@0: 	_LIT(KType8, "ROM drive");
sl@0: 	_LIT(KType9, "Remote drive");
sl@0: 	_LIT(KType10,"NAND flash");
sl@0: 	_LIT(KType11,"Rotating media");
sl@0: 	TPtrC KMediaTypeNames[] = {KType1(), KType2(), KType3(), KType4(), KType5(), KType6(), KType7(), KType8(), KType9(), KType10(), KType11()};
sl@0: 	TheTest.Printf(_L("Drive: %C: %S. File: \"%S\"\r\n"), 'A' + driveNo, &KMediaTypeNames[driveInfo.iType], &TheDbName);
sl@0: 
sl@0: 	(void)TheFs.Delete(TheDbName);
sl@0: 	CreateTestDatabase();
sl@0: 	const TInt KRecCount = 90;
sl@0: 	InsertTestRecords(KRecCount);
sl@0: 	DeleteTestRecords2();
sl@0: 	TInt freePageCount = ::FreePageCount();
sl@0: 	TInt processedPages = 0;
sl@0: 	TheTest.Printf(_L("   Free pages count = %d\r\n"), freePageCount);
sl@0: 	TUint32 start = User::FastCounter();
sl@0: 	err = ::DbCompact(TheDbHandle, KNullDesC, freePageCount, processedPages);
sl@0: 	TUint32 end = User::FastCounter();
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST2(processedPages, freePageCount);
sl@0: 	::CloseDbHandle(TheDbHandle);
sl@0: 	TheDbHandle = NULL;
sl@0: 	(void)TheFs.Delete(TheDbName);
sl@0: 	PrintInfo(processedPages, KMediaTypeNames[driveInfo.iType], start, end);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4239
sl@0: @SYMTestCaseDesc        Free page update test.
sl@0:                         The test creates a database with some records and deletes them all. The records are inserted such that when
sl@0:                         they get deleted, it leaves a great deal of free pages.
sl@0:                         Then the test refill the pages which ware empty. After that, the test call ::DbCompact(...) with the number of free
sl@0:                         pages previously. The free page count should be updated with "0" since all free pages have been refilled since. 
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: */
sl@0: void CSqlCompactTestActive::FreePageUpdateTest()
sl@0:     {
sl@0:      (void)TheFs.Delete(TheDbName);
sl@0:     
sl@0:     //Create the database with 1000 records and then delete all of them
sl@0:     CreateTestDatabase2();
sl@0:     
sl@0:     CSqlCompactor* compactor = NULL;
sl@0:     TRAPD(err, compactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));
sl@0:     TEST2(err, KErrNone);
sl@0:     TRAP(err, compactor->AddEntryL(TheDbName, TheCompactionSettings));
sl@0:     TEST2(err, KErrNone);
sl@0: 
sl@0:     PrepareDb(ETrue);
sl@0:     TInt freePageCount = ::FreePageCount();
sl@0:     TEST(freePageCount > KSqlCompactFreePageThresholdKb);
sl@0:     TheTest.Printf(_L("   Free pages count = %d\r\n"), freePageCount);
sl@0:   
sl@0:     //Refill the database
sl@0:     PrepareDb(EFalse);
sl@0:    
sl@0:     CSqlCompactEntry* impl = compactor->iEntries[0];
sl@0:     impl->iPageCount = freePageCount;
sl@0:     err = impl->Compact();
sl@0:     TEST2(err, KErrNone);
sl@0:     TEST2(impl->iPageCount, 0);
sl@0: 
sl@0:     compactor->ReleaseEntry(TheDbName);
sl@0:     delete compactor;
sl@0:     ::CloseDbHandle(TheDbHandle);
sl@0:     TheDbHandle = NULL;
sl@0:     (void)TheFs.Delete(TheDbName);
sl@0:     }
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void DoTests()
sl@0: 	{
sl@0: 	CActiveScheduler* scheduler = new CActiveScheduler;
sl@0: 	TEST(scheduler != NULL);
sl@0: 	CActiveScheduler::Install(scheduler);
sl@0: 	
sl@0: 	CSqlCompactTestActive::New();
sl@0: 	
sl@0: 	TheCompactionSettings.iFreePageThresholdKb = KFreePageThresholdKb;
sl@0: 
sl@0: 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4050 \"Out of memory\" test"));
sl@0: 	TheTestActive->OomTest();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4051 \"File I/O\" error simulation test"));
sl@0: 	TheTestActive->FileIoErrTest();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4052 Compaction - performance test"));
sl@0: 	TheTestActive->PerformanceTest();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4239 Free page update test"));
sl@0: 	TheTestActive->FreePageUpdateTest();
sl@0: 
sl@0: 	CActiveScheduler::Start();
sl@0: 	
sl@0: 	delete TheTestActive;
sl@0: 	TheTestActive = NULL;
sl@0: 	delete scheduler;
sl@0: 	}
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //Usage: "t_sqlcompact2 [<drive letter>:]"
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	TheTest.Title();
sl@0: 	
sl@0: 	TheTrapCleanup = CTrapCleanup::New ();
sl@0: 	__ASSERT_ALWAYS(TheTrapCleanup != NULL, User::Invariant());
sl@0: 
sl@0: 	__UHEAP_MARK;
sl@0: 
sl@0: 	User::CommandLine(TheCmd);
sl@0: 	TheCmd.TrimAll();
sl@0: 	if(TheCmd.Length() > 0)
sl@0: 		{
sl@0: 		TheDriveName.Copy(TheCmd);
sl@0: 		}
sl@0: 
sl@0: 	_LIT(KDbName, "c:\\test\\t_sqlcompact2_1.db");
sl@0: 	TheParse.Set(TheDriveName, &KDbName, 0);
sl@0: 	const TDesC& dbFilePath = TheParse.FullName();
sl@0: 	TheDbName.Copy(dbFilePath);
sl@0: 	
sl@0: 	TestEnvCreate();
sl@0: 	
sl@0: 	DoTests();
sl@0: 
sl@0: 	TestEnvDestroy();
sl@0: 	
sl@0: 	__UHEAP_MARKEND;
sl@0: 
sl@0: 	TheTest.End();
sl@0: 	TheTest.Close();
sl@0: 
sl@0: 	delete TheTrapCleanup;
sl@0: 
sl@0: 	return KErrNone;
sl@0: 	}