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 <e32test.h>
sl@0: #include <bautils.h>
sl@0: #include <sqldb.h>
sl@0: #include <hal.h>
sl@0: #include "SqlUtil.h"
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: RTest TheTest(_L("t_sqlcompact1 test"));
sl@0: 
sl@0: RSqlDatabase TheDb;
sl@0: 
sl@0: const TInt KTextLen = 400;
sl@0: TBuf<KTextLen> TheText;
sl@0: TBuf<KTextLen + 100> TheSqlBuf;
sl@0: 
sl@0: _LIT(KTestDir, "c:\\test\\");
sl@0: _LIT(KDbName1, "c:\\test\\t_sqlcompact1_1.db");
sl@0: _LIT(KDbName2, "c:\\test\\t_sqlcompact1_2.db");
sl@0: _LIT(KDbName3, "c:\\test\\t_sqlcompact1_3.db");
sl@0: _LIT(KDbName4, "c:\\test\\t_sqlcompact1_4.db");
sl@0: 
sl@0: _LIT(KAttachName1, "UOOO");
sl@0: _LIT(KAttachName2, "FOOO");
sl@0: _LIT(KAttachName3, "AOOO");
sl@0: _LIT(KAttachName4, "EOOO");
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void DestroyTestEnv()
sl@0: 	{
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(KDbName4);
sl@0: 	(void)RSqlDatabase::Delete(KDbName3);
sl@0: 	(void)RSqlDatabase::Delete(KDbName2);
sl@0: 	(void)RSqlDatabase::Delete(KDbName1);
sl@0: 	}
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: 		DestroyTestEnv();
sl@0: 		RDebug::Print(_L("*** Test failure. Boolean expression evaluates to false.\r\n"));
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: void Check2(TInt aValue, TInt aExpected, TInt aLine)
sl@0: 	{
sl@0: 	if(aValue != aExpected)
sl@0: 		{
sl@0: 		DestroyTestEnv();
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) ::Check2(aValue, aExpected, __LINE__)
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //t_sqlcompact1 timeouts in WDP builds.
sl@0: //This function is used to check whether the time limit is reaqched or not.
sl@0: TBool IsTimeLimitReached()
sl@0: 	{
sl@0: 	struct TStartTime
sl@0: 		{
sl@0: 		TStartTime()
sl@0: 			{
sl@0: 			iTime.HomeTime();
sl@0: 			}
sl@0: 		TTime iTime;
sl@0: 		};
sl@0: 	
sl@0: 	static TStartTime startTime; 
sl@0: 	const TInt KTestTimeLimit = 100;//seconds
sl@0: 	
sl@0: 	TTime currTime;
sl@0: 	currTime.HomeTime();
sl@0: 	
sl@0: 	TTimeIntervalSeconds s;
sl@0: 	TInt err = currTime.SecondsFrom(startTime.iTime, s);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	return s.Int() > KTestTimeLimit;
sl@0: 	}
sl@0: 
sl@0: void GetHomeTimeAsString(TDes& aStr)
sl@0: 	{
sl@0: 	TTime time;
sl@0: 	time.HomeTime();
sl@0: 	TDateTime dt = time.DateTime();
sl@0: 	aStr.Format(_L("%02d:%02d:%02d.%06d"), dt.Hour(), dt.Minute(), dt.Second(), dt.MicroSecond());
sl@0: 	}
sl@0: 
sl@0: void CreateTestEnv()
sl@0:     {
sl@0:     RFs fs;
sl@0: 	TInt err = fs.Connect();
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	err = fs.MkDir(KTestDir);
sl@0: 	TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0: 
sl@0: 	fs.Close();
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void ReplaceDb(const TDesC& aDbName, TInt aPageSize)
sl@0: 	{
sl@0: 	(void)RSqlDatabase::Delete(aDbName);
sl@0: 	_LIT8(KConfigStr, "compaction=manual;page_size=");
sl@0: 	TBuf8<50> config;
sl@0: 	config.Copy(KConfigStr);
sl@0: 	config.AppendNum(aPageSize);
sl@0: 	TInt err = TheDb.Create(aDbName, &config);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	}
sl@0: 
sl@0: void CreateTable(const TDesC& aDbName)
sl@0: 	{
sl@0: 	TInt err = TheDb.Open(aDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("CREATE TABLE A(I INTEGER, T TEXT)"));
sl@0: 	TEST(err >= 0);
sl@0: 	TheDb.Close();
sl@0: 	}
sl@0: 
sl@0: void InsertRecords(const TDesC& aDbName)
sl@0: 	{
sl@0: 	TInt err = TheDb.Open(aDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("BEGIN TRANSACTION"));
sl@0: 	TEST(err >= 0);
sl@0: 	TheText.SetLength(TheText.MaxLength());
sl@0: 	TheText.Fill(TChar('A'));
sl@0: 	for(TInt i=0;i<100;++i)
sl@0: 		{
sl@0: 		TheSqlBuf.Format(_L("INSERT INTO A VALUES(%d, '%S')"), i + 1, &TheText);
sl@0: 		err = TheDb.Exec(TheSqlBuf);
sl@0: 		TEST2(err, 1);
sl@0: 		}
sl@0: 	err = TheDb.Exec(_L("COMMIT TRANSACTION"));
sl@0: 	TEST(err >= 0);
sl@0: 	TheDb.Close();
sl@0: 	}
sl@0: 
sl@0: TInt DeleteRecords(const TDesC& aDbName, TInt aPageCount, TInt aPageSize)
sl@0: 	{
sl@0: 	TInt freePageCount = -1;
sl@0: 	TInt err = TheDb.Open(aDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("BEGIN TRANSACTION"));
sl@0: 	TEST(err >= 0);
sl@0: 	for(TInt i=0;;++i)
sl@0: 		{
sl@0: 		TheSqlBuf.Format(_L("DELETE FROM A WHERE I=%d"), i + 1);
sl@0: 		err = TheDb.Exec(TheSqlBuf);
sl@0: 		TEST2(err, 1);
sl@0: 		RSqlDatabase::TSize s;
sl@0: 		err = TheDb.Size(s);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		freePageCount = s.iFree / aPageSize;
sl@0: 		if(freePageCount >= aPageCount)
sl@0: 			{
sl@0: 			break;	
sl@0: 			}
sl@0: 		}
sl@0: 	err = TheDb.Exec(_L("COMMIT TRANSACTION"));
sl@0: 	TEST(err >= 0);
sl@0: 	TheDb.Close();
sl@0: 	return freePageCount;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4072
sl@0: @SYMTestCaseDesc		Manual compaction on attached databases with different page size.
sl@0: 						The test creates couple of databases with manual compaction and 
sl@0: 						different page sizes, then inserts some records and deletes part of
sl@0: 						the just inserted records thus making some free pages.
sl@0: 						The test opens the first database and attaches all other databases the the first one.
sl@0: 						Then the test checks that RSqlDatabase::Size() returns correct information
sl@0: 						about the free database space. The test runs the manual compaction on the
sl@0: 						databases and checks again that the free database space is reported correctly.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Manual compaction on attached databases with different page size.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10405
sl@0:                         REQ10407
sl@0: */
sl@0: void CompactDbTest1()
sl@0: 	{
sl@0: 	const TPtrC KDbName[] = 	{KDbName1(), 	KDbName2(), 	KDbName3(), 	KDbName4()};
sl@0: 	const TPtrC KDbAttachName[]={KAttachName1(),KAttachName2(), KAttachName3(), KAttachName4()};
sl@0: 	const TInt KDbPageSize[] = 	{8192, 			1024, 			4096, 			2048};
sl@0: 	const TInt KFreePageCount[]={9, 			30, 			17, 			7};
sl@0: 		  TInt freePageCount[] ={0, 0, 0, 0};
sl@0: 	const TInt KSize = sizeof(KDbName) / sizeof(KDbName[0]);
sl@0: 	
sl@0: 	TInt i;
sl@0: 	
sl@0: 	TBuf<50> timeBuf;
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time1: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Create databases, tables, insert records, delete part of the just inserted records.
sl@0: 	for(i=0;i<KSize;++i)
sl@0: 		{
sl@0: 		ReplaceDb(KDbName[i], KDbPageSize[i]);
sl@0: 		CreateTable(KDbName[i]);
sl@0: 		InsertRecords(KDbName[i]);
sl@0: 		freePageCount[i] = DeleteRecords(KDbName[i], KFreePageCount[i], KDbPageSize[i]);
sl@0: 		}
sl@0: 
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time2: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Open the first database, attach all others.
sl@0: 	TInt err = TheDb.Open(KDbName1());
sl@0: 	TEST2(err, KErrNone);
sl@0: 	for(i=0;i<KSize;++i)
sl@0: 		{
sl@0: 		err = TheDb.Attach(KDbName[i], KDbAttachName[i]);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		}
sl@0: 
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time3: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Check the size of the main database.
sl@0: 	RSqlDatabase::TSize size;
sl@0: 	err = TheDb.Size(size);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST2((size.iFree / KDbPageSize[0]), freePageCount[0]);
sl@0: 		
sl@0: 	//For all attached database: check the size of the database, compact, check the size again.
sl@0: 	for(i=0;i<KSize;++i)
sl@0: 		{
sl@0: 		err = TheDb.Size(size, KDbAttachName[i]);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		TEST2((size.iFree / KDbPageSize[i]), freePageCount[i]);
sl@0: 		
sl@0: 		const TInt KCompactPageCount = 3;
sl@0: 		TInt rc = TheDb.Compact(KCompactPageCount * KDbPageSize[i], KDbAttachName[i]);
sl@0: 		TInt expected = KCompactPageCount * KDbPageSize[i];
sl@0: 		TEST2(rc, expected);
sl@0: 		err = TheDb.Size(size, KDbAttachName[i]);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		TInt count = size.iFree / KDbPageSize[i];
sl@0: 		expected = freePageCount[i] - KCompactPageCount;
sl@0: 		TEST2(count, expected);
sl@0: 		}
sl@0: 	
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time4: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Detach databases and close the main database.
sl@0: 	for(i=0;i<KSize;++i)
sl@0: 		{
sl@0: 		err = TheDb.Detach(KDbAttachName[i]);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		}
sl@0: 	TheDb.Close();
sl@0: 
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time5: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Cleanup.
sl@0: 	for(i=0;i<KSize;++i)
sl@0: 		{
sl@0: 		(void)RSqlDatabase::Delete(KDbName[i]);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //Creates a test database (with KDbName1 name). Inserts aRecordCount records.
sl@0: //The page size is specified in aPageSize parameter. But practically the page size is always 1024 bytes.
sl@0: //The record size is such that there is only one record per page.
sl@0: void PrepareDb(TInt aPageSize, TInt aRecordCount, TBool aManualCompaction = EFalse)
sl@0: 	{
sl@0: 	//Create the database
sl@0: 	(void)RSqlDatabase::Delete(KDbName1);
sl@0: 	_LIT8(KConfigStr, "page_size=");
sl@0: 	TBuf8<100> config;
sl@0: 	config.Copy(KConfigStr);
sl@0: 	config.AppendNum(aPageSize);
sl@0: 	if(aManualCompaction)
sl@0: 		{
sl@0: 		config.Append(_L(";compaction=manual;"));
sl@0: 		}
sl@0: 	TInt err = TheDb.Create(KDbName1, &config);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	
sl@0: 	err = TheDb.Exec(_L("BEGIN TRANSACTION"));
sl@0: 	TEST(err >= 0);
sl@0: 	err = TheDb.Exec(_L("CREATE TABLE A(I INTEGER, T TEXT)"));
sl@0: 	TEST(err >= 0);
sl@0: 	//Insert records
sl@0: 	TheText.SetLength(TheText.MaxLength());
sl@0: 	TheText.Fill(TChar('A'));
sl@0: 	for(TInt i=0;i<aRecordCount;++i)
sl@0: 		{
sl@0: 		TheSqlBuf.Format(_L("INSERT INTO A VALUES(%d, '%S')"), i + 1, &TheText);
sl@0: 		err = TheDb.Exec(TheSqlBuf);
sl@0: 		TEST2(err, 1);
sl@0: 		}
sl@0: 	err = TheDb.Exec(_L("COMMIT TRANSACTION"));
sl@0: 	TEST(err >= 0);
sl@0: 	//Delete all records making a lot of free pages. This operation should kick-off the background compaction
sl@0: 	err = TheDb.Exec(_L("DELETE FROM A WHERE 1"));
sl@0: 	TEST2(err, aRecordCount);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4073
sl@0: @SYMTestCaseDesc		Background compaction steps test.
sl@0: 						The test creates a database with background compaction mode, 
sl@0: 						then inserts records and deletes all of them. The count of records is such that when
sl@0: 						the records get deleted, the number of the free pages is very big and all free pages cannot
sl@0: 						be removed for just one compaction step.
sl@0: 						The test waits for ("compaction interval"/10 ms) time and checks that no compaction
sl@0: 						step has been run by the server during the pause and the free space size is the same as before the
sl@0: 						pause. Then the test waits for ("compaction interval" + "compaction step") time and checks that
sl@0: 						the background compaction step really happened and removed only part of the free pages.
sl@0: 						The same test is repeated again and the same check is performed again.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Background compaction steps test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10271
sl@0:                         REQ10272
sl@0: */
sl@0: void CompactDbTest2()
sl@0: 	{
sl@0: 	TBuf<50> timeBuf;
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time1: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	const TInt KPageSize = 1024;
sl@0: 	//Number of records to be added and removed from database. Need to be increased when testing on a faster 
sl@0: 	// hardware, otherwise at fastest case the background compaction could be finished in just 1 step.
sl@0: 	const TInt KRecordCount = 2000;	
sl@0: 	PrepareDb(KPageSize, KRecordCount);
sl@0: 
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time2: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Check the free space-1
sl@0: 	RSqlDatabase::TSize size1;
sl@0: 	TInt err = TheDb.Size(size1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("===Free space before compaction, pages=%d\r\n"), size1.iFree / KPageSize);
sl@0: 	TEST(size1.iSize >= (KRecordCount * KPageSize));
sl@0: 	
sl@0: 	//Wait KSqlCompactStepIntervalMs/10 ms. The background compaction should not be kicked-off.
sl@0: 	TTime time1;
sl@0: 	time1.HomeTime();
sl@0: 	User::After((KSqlCompactStepIntervalMs / 10) * 1000);
sl@0: 	TTime time2;
sl@0: 	time2.HomeTime();
sl@0: 	TTimeIntervalMicroSeconds intervalUs = time2.MicroSecondsFrom(time1);	
sl@0: 	//Check the free space-2
sl@0: 	RSqlDatabase::TSize size2;
sl@0: 	err = TheDb.Size(size2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("=== Wait time: %ld ms. Free space after compaction-1, pages=%d\r\n"), intervalUs.Int64() / 1000 ,size2.iFree / KPageSize);
sl@0: 	if(intervalUs > KSqlCompactStepIntervalMs * 1000)
sl@0: 		{
sl@0: 		TEST(size2.iFree <= size1.iFree);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		TEST(size2.iFree == size1.iFree);
sl@0: 		}
sl@0: 
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time3: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Wait (KSqlCompactStepIntervalMs + KSqlCompactStepLengthMs) ms. During the pause only part of the free pages
sl@0: 	//should be removed (whatever can be completed for KSqlCompactStepLengthMs ms).
sl@0: 	User::After((KSqlCompactStepIntervalMs + KSqlCompactStepLengthMs) * 1000);
sl@0: 	//Check the free space-3
sl@0: 	RSqlDatabase::TSize size3;
sl@0: 	err = TheDb.Size(size3);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("===Free space after compaction-2, pages=%d\r\n"), size3.iFree / KPageSize);
sl@0: 	if(size3.iFree == 0)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("WARNING: Background compaction finished in 1 step. Initial number of records need to be increased.\r\n"));
sl@0: 		}
sl@0: 	TEST(size3.iFree > 0 && size3.iFree < size2.iFree);
sl@0: 
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time4: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Wait another (KSqlCompactStepIntervalMs + KSqlCompactStepLengthMs) ms. During the pause only part of the free pages
sl@0: 	//should be removed (whatever can be completed for KSqlCompactStepLengthMs ms).
sl@0: 	User::After((KSqlCompactStepIntervalMs + KSqlCompactStepLengthMs) * 1000);
sl@0: 	//Check the free space-4
sl@0: 	RSqlDatabase::TSize size4;
sl@0: 	err = TheDb.Size(size4);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("===Free space after compaction-3, pages=%d\r\n"), size4.iFree / KPageSize);
sl@0: 	TEST((size4.iFree > 0 && size4.iFree < size3.iFree) || (size4.iFree == 0));
sl@0: 
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time5: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Cleanup
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(KDbName1);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4074
sl@0: @SYMTestCaseDesc		Background compaction timer test.
sl@0: 						The test creates a database with background compaction mode, 
sl@0: 						then inserts records and deletes all of them. The count of records is such that when
sl@0: 						the records get deleted, the number of the free pages is very big and all free pages cannot
sl@0: 						be removed for just one compaction step.
sl@0: 						Then the test executes a set of operations with the server. The amount of time needed for the
sl@0: 						operations to be executed is bigger than the ("compaction interval" + "compaction step") time.
sl@0: 						No compaction step should be executed during that time, because every operation resets the background 
sl@0: 						compaction timer.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Background compaction timer test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10271
sl@0:                         REQ10272
sl@0: */
sl@0: void CompactDbTest3()
sl@0: 	{
sl@0: 	TBuf<50> timeBuf;
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time1: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	const TInt KPageSize = 1024;
sl@0: 	const TInt KRecordCount = 1000;
sl@0: 	PrepareDb(KPageSize, KRecordCount);
sl@0: 
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time2: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Check the free space-1
sl@0: 	RSqlDatabase::TSize size1;
sl@0: 	TInt err = TheDb.Size(size1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("===Free space before operations, pages=%d. Db.Size=%d, Db.Free=%d\r\n"), size1.iFree / KPageSize, size1.iSize, size1.iFree);
sl@0: 	TEST(size1.iSize >= (KRecordCount * KPageSize));
sl@0: 
sl@0: 	//Execute a set of operations. The time needed for the operations to complete is bigger than
sl@0: 	//(KSqlCompactStepIntervalMs + KSqlCompactStepLengthMs) ms
sl@0: 	TInt freq = 0;
sl@0: 	TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone);
sl@0: 	TUint32 begin = User::FastCounter();
sl@0: 	TInt count = 0;
sl@0: 	TInt time = -1;
sl@0: 	for(;;++count)
sl@0: 		{
sl@0: 		err = TheDb.Exec(_L("SELECT COUNT(*) FROM A"));
sl@0: 		TEST(err >= 0);
sl@0: 		TUint32 current = User::FastCounter();
sl@0: 		TInt64 diffTicks = (TInt64)current - (TInt64)begin;
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: 		time = us / 1000;
sl@0: 		if(time > ((KSqlCompactStepIntervalMs + KSqlCompactStepLengthMs)))
sl@0: 			{
sl@0: 			break;	
sl@0: 			}
sl@0: 		}
sl@0: 	
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time3: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Check the free space-2
sl@0: 	RSqlDatabase::TSize size2;
sl@0: 	err = TheDb.Size(size2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("===%d operations completed for %d ms\r\n"), count, time);
sl@0: 	TheTest.Printf(_L("===Free space after operations, pages=%d\r\n"), size2.iFree / KPageSize);
sl@0: 	TEST(size1.iFree == size2.iFree);
sl@0: 	
sl@0: 	//Cleanup
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(KDbName1);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4103
sl@0: @SYMTestCaseDesc		Big manual compaction test.
sl@0: 						The test creates a database with 1000 free pages, then calls 
sl@0: 						RSqlDatabase::Compact(RSqlDatabase::EMaxCompaction).
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Big manual compaction test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10271
sl@0:                         REQ10272
sl@0: */
sl@0: void ManualCompactTest()
sl@0: 	{
sl@0: 	TBuf<50> timeBuf;
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time1: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Create a database with 1000 free pages
sl@0: 	const TInt KPageSize = 1024;
sl@0: 	const TInt KRecordCount = 1000;
sl@0: 	PrepareDb(KPageSize, KRecordCount, ETrue);//create the database with manual compaction mode
sl@0: 	
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time2: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Check the free space-1
sl@0: 	RSqlDatabase::TSize size1;
sl@0: 	TInt err = TheDb.Size(size1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	const TInt KFreePageCount = size1.iFree / KPageSize;
sl@0: 	TheTest.Printf(_L("===Free space before operations, pages=%d\r\n"), KFreePageCount);
sl@0: 	TEST(size1.iSize >= (KRecordCount * KPageSize));
sl@0: 	//Compact
sl@0: 	err = TheDb.Compact(RSqlDatabase::EMaxCompaction);
sl@0: 	TEST2(err, size1.iFree);
sl@0: 	
sl@0: 	GetHomeTimeAsString(timeBuf);
sl@0: 	TheTest.Printf(_L("===Time3: %S\r\n"), &timeBuf);
sl@0: 	
sl@0: 	//Cleanup
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(KDbName1);
sl@0: 	}
sl@0: 
sl@0: void DoTestsL()
sl@0: 	{
sl@0: 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4072 Manual Compact() - attached databases, different page sizes"));	
sl@0: 	CompactDbTest1();
sl@0: 
sl@0: 	if(IsTimeLimitReached())
sl@0: 		{
sl@0: 		TheTest.Printf(_L("===Test timeout!\r\n"));
sl@0: 		return;
sl@0: 		}
sl@0: 	
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4073 Background compaction steps test"));	
sl@0: 	CompactDbTest2();
sl@0: 
sl@0: 	if(IsTimeLimitReached())
sl@0: 		{
sl@0: 		TheTest.Printf(_L("===Test timeout!\r\n"));
sl@0: 		return;
sl@0: 		}
sl@0: 	
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4074 Background compaction timer test"));	
sl@0: 	CompactDbTest3();
sl@0: 
sl@0: 	if(IsTimeLimitReached())
sl@0: 		{
sl@0: 		TheTest.Printf(_L("===Test timeout!\r\n"));
sl@0: 		return;
sl@0: 		}
sl@0: 	
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:SYSLIB-SQL-UT-4103 Big manual compaction test"));	
sl@0: 	ManualCompactTest();
sl@0: 	}
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	TheTest.Title();
sl@0: 	
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 	TheTest(tc != NULL);
sl@0: 	
sl@0: 	__UHEAP_MARK;
sl@0: 	
sl@0: 	CreateTestEnv();
sl@0: 	TRAPD(err, DoTestsL());
sl@0: 	DestroyTestEnv();
sl@0: 	TEST2(err, KErrNone);
sl@0: 	
sl@0: 	__UHEAP_MARKEND;
sl@0: 	
sl@0: 	TheTest.End();
sl@0: 	TheTest.Close();
sl@0: 	
sl@0: 	delete tc;
sl@0: 	
sl@0: 	User::Heap().Check();
sl@0: 	return KErrNone;
sl@0: 	}