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 <stdlib.h>
sl@0: #include "sqlite3.h"
sl@0: #include "SqliteSymbian.h"
sl@0: #include "SqlResourceTester.h"
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: RTest TheTest(_L("t_sqlcompact4 test"));
sl@0: TParse TheParse;
sl@0: TDriveName TheDrive;
sl@0: 
sl@0: RSqlDatabase TheDb;
sl@0: sqlite3* TheSqliteDb = NULL;
sl@0: TBuf<256> TheCmd;
sl@0: 
sl@0: const TInt KTextLen = 1000;
sl@0: const TInt KRecLen = 2000;
sl@0: 
sl@0: TBuf<KTextLen> TheText;
sl@0: TBuf8<KRecLen> TheSqlQuery;
sl@0: TBuf8<KRecLen> TheSqlFmt;
sl@0: TBuf<KTextLen + 50> TheSqlTexLen;
sl@0: 
sl@0: _LIT(KDefaultDriveName, "c:");
sl@0: _LIT(KTestDir, "c:\\test\\");
sl@0: _LIT(KTestDbTemplate8, "c:\\test\\t_sqlcompact4_tmpl8.dat");
sl@0: _LIT(KTestDbTemplate16, "c:\\test\\t_sqlcompact4_tmpl16.dat");
sl@0: _LIT(KDbName, "c:\\test\\t_sqlcompact4_1.db");
sl@0: _LIT(KDbName2, "c:\\test\\t_sqlcompact4_2.db");
sl@0: _LIT(KRoDbName, "z:\\test\\testdb1.db");//Created outside the test app
sl@0: TFileName TheTestDbName;
sl@0: 
sl@0: const TInt KMaxThreadCount = 100;
sl@0: TInt32 TheTestThreadCount = 8;
sl@0: 
sl@0: const TInt KTestDbPageSize = 1024;
sl@0: 
sl@0: TInt TheOriginalDbSize8 = -1;
sl@0: TInt TheCompactedDbSize8 = -1;
sl@0: 
sl@0: TInt TheOriginalDbSize16 = -1;
sl@0: TInt TheCompactedDbSize16 = -1;
sl@0: 
sl@0: //In order to be able to compile the test, the following variables are defined (used inside the OS porting layer, when _SQLPROFILER macro is defined)
sl@0: #ifdef _SQLPROFILER
sl@0: TInt TheSqlSrvProfilerFileRead = 0;
sl@0: TInt TheSqlSrvProfilerFileWrite = 0;
sl@0: TInt TheSqlSrvProfilerFileSync = 0;
sl@0: TInt TheSqlSrvProfilerFileSetSize = 0;
sl@0: #endif
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void DestroyTestEnv()
sl@0: 	{
sl@0: 	if(TheSqliteDb)
sl@0: 		{
sl@0: 		sqlite3_close(TheSqliteDb);
sl@0: 		TheSqliteDb = NULL;
sl@0: 		}
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(KDbName2);
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	(void)RSqlDatabase::Delete(KTestDbTemplate16);
sl@0: 	(void)RSqlDatabase::Delete(KTestDbTemplate8);
sl@0: 	sqlite3SymbianLibFinalize();
sl@0: 	CloseSTDLIB();
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 Check(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) ::Check(aValue, aExpected, __LINE__)
sl@0: 
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: 	TheParse.Set(TheDrive, &KTestDir, 0);
sl@0: 
sl@0: 	err = fs.MkDir(TheParse.DriveAndPath());
sl@0: 	TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0: 
sl@0: 	fs.Close();
sl@0: 
sl@0: 	sqlite3SymbianLibInit();
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void CreateTestDatabase8()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("Create UTF8 test database: %S\r\n"), &KTestDbTemplate8);
sl@0: 	(void)RSqlDatabase::Delete(KTestDbTemplate8);
sl@0: 	TBuf8<KMaxFileName> fname;
sl@0: 	fname.Copy(KTestDbTemplate8);
sl@0: 	TheSqliteDb = NULL;
sl@0: 	TInt rc = sqlite3_open((const char*)fname.PtrZ(), &TheSqliteDb);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	TBuf8<100> sql;
sl@0: 	_LIT8(KSql, "PRAGMA page_size=%d\x0");
sl@0: 	sql.Format(KSql, KTestDbPageSize);
sl@0: 	rc = sqlite3_exec(TheSqliteDb, (const char*)sql.Ptr(), 0, 0, 0);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	rc = sqlite3_exec(TheSqliteDb, "CREATE TABLE A(Id INTEGER,Data BLOB)", 0, 0, 0);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	//Insert records
sl@0: 	rc = sqlite3_exec(TheSqliteDb, "BEGIN", 0, 0, 0);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	TheSqlQuery.Copy(_L8("INSERT INTO A VALUES(%d,x'"));
sl@0: 	for(TInt j=0;j<(KRecLen-50);++j)
sl@0: 		{
sl@0: 		TheSqlQuery.Append(_L8("A"));
sl@0: 		}
sl@0: 	TheSqlQuery.Append(_L8("')"));
sl@0: 	const TInt KRecCount = 100;	
sl@0: 	for(TInt i=0;i<KRecCount;++i)
sl@0: 		{
sl@0: 		TheSqlFmt.Format(TheSqlQuery, i + 1);
sl@0: 		rc = sqlite3_exec(TheSqliteDb, (const char*)TheSqlFmt.PtrZ(), 0, 0, 0);
sl@0: 		TEST2(rc, SQLITE_OK);
sl@0: 		}
sl@0: 	rc = sqlite3_exec(TheSqliteDb, "COMMIT", 0, 0, 0);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	//Free some space
sl@0: 	rc = sqlite3_exec(TheSqliteDb, "DELETE FROM A WHERE Id > 10", 0, 0, 0);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	sqlite3_close(TheSqliteDb);
sl@0: 	TheSqliteDb = NULL;
sl@0: 	}
sl@0: 
sl@0: void CreateTestDatabase16()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("Create UTF16 test database: %S\r\n"), &KTestDbTemplate16);
sl@0: 	(void)RSqlDatabase::Delete(KTestDbTemplate16);
sl@0: 	TBuf<KMaxFileName> fname;
sl@0: 	fname.Copy(KTestDbTemplate16);
sl@0: 	TheSqliteDb = NULL;
sl@0: 	TInt rc = sqlite3_open16(fname.PtrZ(), &TheSqliteDb);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	TBuf8<100> sql;
sl@0: 	_LIT8(KSql, "PRAGMA page_size=%d\x0");
sl@0: 	sql.Format(KSql, KTestDbPageSize);
sl@0: 	rc = sqlite3_exec(TheSqliteDb, (const char*)sql.Ptr(), 0, 0, 0);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	rc = sqlite3_exec(TheSqliteDb, "CREATE TABLE A(Id INTEGER,Data BLOB)", 0, 0, 0);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	//Insert records
sl@0: 	rc = sqlite3_exec(TheSqliteDb, "BEGIN", 0, 0, 0);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	TheSqlQuery.Copy(_L8("INSERT INTO A VALUES(%d,x'"));
sl@0: 	for(TInt j=0;j<(KRecLen-50);++j)
sl@0: 		{
sl@0: 		TheSqlQuery.Append(_L8("A"));
sl@0: 		}
sl@0: 	TheSqlQuery.Append(_L8("')"));
sl@0: 	const TInt KRecCount = 100;	
sl@0: 	for(TInt i=0;i<KRecCount;++i)
sl@0: 		{
sl@0: 		TheSqlFmt.Format(TheSqlQuery, i + 1);
sl@0: 		rc = sqlite3_exec(TheSqliteDb, (const char*)TheSqlFmt.PtrZ(), 0, 0, 0);
sl@0: 		TEST2(rc, SQLITE_OK);
sl@0: 		}
sl@0: 	rc = sqlite3_exec(TheSqliteDb, "COMMIT", 0, 0, 0);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	//Free some space
sl@0: 	rc = sqlite3_exec(TheSqliteDb, "DELETE FROM A WHERE Id > 10", 0, 0, 0);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	sqlite3_close(TheSqliteDb);
sl@0: 	TheSqliteDb = NULL;
sl@0: 	}
sl@0: 	
sl@0: void CreateDatabase8(const TDesC& aTargetDbName)
sl@0: 	{
sl@0: 	RFs fs;
sl@0: 	TInt err = fs.Connect();
sl@0: 	TEST2(err, KErrNone);		
sl@0: 	CFileMan* fm = NULL;
sl@0: 	TRAP(err, fm = CFileMan::NewL(fs));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = fm->Copy(KTestDbTemplate8, aTargetDbName);
sl@0: 	delete fm;
sl@0: 	fs.Close();
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: void CreateDatabase16(const TDesC& aTargetDbName)
sl@0: 	{
sl@0: 	RFs fs;
sl@0: 	TInt err = fs.Connect();
sl@0: 	TEST2(err, KErrNone);		
sl@0: 	CFileMan* fm = NULL;
sl@0: 	TRAP(err, fm = CFileMan::NewL(fs));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = fm->Copy(KTestDbTemplate16, aTargetDbName);
sl@0: 	delete fm;
sl@0: 	fs.Close();
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: void CalculateMaxCompaction8()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("UTF8 test database - calculate max compaction\r\n"));
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	CreateDatabase8(TheTestDbName);
sl@0: 	TInt err = TheDb.Open(TheTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	RSqlDatabase::TSize size1;
sl@0: 	err = TheDb.Size(size1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("UTF8.Database before compaction: size %ld, free space %ld\r\n"), size1.iSize, size1.iFree);
sl@0: 	err = TheDb.Compact(RSqlDatabase::EMaxCompaction);
sl@0: 	TEST2(err, size1.iFree);
sl@0: 	RSqlDatabase::TSize size2;
sl@0: 	err = TheDb.Size(size2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("UTF8.Database after compaction: size %ld, free space %ld\r\n"), size2.iSize, size2.iFree);
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	TheOriginalDbSize8 = size1.iSize;
sl@0: 	TheCompactedDbSize8 = size2.iSize;
sl@0: 	TEST(TheOriginalDbSize8 > 0);
sl@0: 	TEST(TheCompactedDbSize8 > 0 && TheCompactedDbSize8 < TheOriginalDbSize8);
sl@0: 	}
sl@0: 
sl@0: void CalculateMaxCompaction16()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("UTF16 test database - calculate max compaction\r\n"));
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	CreateDatabase16(TheTestDbName);
sl@0: 	TInt err = TheDb.Open(TheTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	RSqlDatabase::TSize size1;
sl@0: 	err = TheDb.Size(size1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("UTF16.Database before compaction: size %ld, free space %ld\r\n"), size1.iSize, size1.iFree);
sl@0: 	err = TheDb.Compact(RSqlDatabase::EMaxCompaction);
sl@0: 	TEST2(err, size1.iFree);
sl@0: 	RSqlDatabase::TSize size2;
sl@0: 	err = TheDb.Size(size2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("UTF16.Database after compaction: size %ld, free space %ld\r\n"), size2.iSize, size2.iFree);
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	TheOriginalDbSize16 = size1.iSize;
sl@0: 	TheCompactedDbSize16 = size2.iSize;
sl@0: 	TEST(TheOriginalDbSize16 > 0);
sl@0: 	TEST(TheCompactedDbSize16 > 0 && TheCompactedDbSize16 < TheOriginalDbSize16);
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: 
sl@0: enum TCompactionType {ESyncCompaction, EAsyncCompaction, EMaxCompactionType};
sl@0: 
sl@0: TInt DoCompact(TCompactionType aType, TInt aSize, const TDesC& aAttachDbName = KNullDesC)
sl@0: 	{
sl@0: 	TInt err = KErrGeneral;
sl@0: 	switch(aType)
sl@0: 		{
sl@0: 		case ESyncCompaction:
sl@0: 			err = TheDb.Compact(aSize, aAttachDbName);
sl@0: 			break;
sl@0: 		case EAsyncCompaction:
sl@0: 			{
sl@0: 			TRequestStatus stat;				
sl@0: 			TheDb.Compact(aSize, stat, aAttachDbName);
sl@0: 			User::WaitForRequest(stat);
sl@0: 			TEST(stat != KRequestPending);
sl@0: 			err = stat.Int();
sl@0: 			break;
sl@0: 			}
sl@0: 		default:
sl@0: 			TEST(0);
sl@0: 			break;	
sl@0: 		}
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: TInt DoManualCompaction(TCompactionType aType, const TDesC& aMainDb, TInt aSize, TBool aRoFlag = EFalse)
sl@0: 	{
sl@0: 	if(!aRoFlag)
sl@0: 		{
sl@0: 		(void)RSqlDatabase::Delete(aMainDb);
sl@0: 		CreateDatabase8(aMainDb);
sl@0: 		}
sl@0: 
sl@0: 	TInt err = TheDb.Open(aMainDb);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	
sl@0: 	err = DoCompact(aType, aSize);
sl@0: 		
sl@0: 	TheDb.Close();
sl@0: 	if(!aRoFlag)
sl@0: 		{
sl@0: 		(void)RSqlDatabase::Delete(aMainDb);
sl@0: 		}
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: TInt DoManualCompaction(TCompactionType aType, TInt aSize, const TDesC& aAttachDbName)
sl@0: 	{
sl@0: 	return DoCompact(aType, aSize, aAttachDbName);
sl@0: 	}
sl@0: 
sl@0: void DoManualCompaction(TCompactionType aType, TInt aSize, TInt aCompactedSize)
sl@0: 	{
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	CreateDatabase8(TheTestDbName);
sl@0: 
sl@0: 	TInt err = TheDb.Open(TheTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	
sl@0: 	err = DoCompact(aType, aSize);
sl@0: 	TEST(err >= 0);
sl@0: 	
sl@0: 	RSqlDatabase::TSize size;
sl@0: 	err = TheDb.Size(size);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST2(size.iSize, aCompactedSize);
sl@0: 		
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	}
sl@0: 
sl@0: void DoManualCompaction(TCompactionType aType, TInt aSize, TInt aCompactedSize, const TDesC& aAttachDbName)
sl@0: 	{
sl@0: 	TInt err = DoCompact(aType, aSize, aAttachDbName);
sl@0: 	TEST(err >= 0);
sl@0: 	
sl@0: 	RSqlDatabase::TSize size;
sl@0: 	err = TheDb.Size(size, aAttachDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST2(size.iSize, aCompactedSize);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4064
sl@0: @SYMTestCaseDesc		Manual compaction - negative tests.
sl@0: 						The test creates a database with a manual compaction mode.
sl@0: 						Then the test executes the following negative tests using both synchronous and
sl@0: 						asynchronous Compact() methods:
sl@0: 							- RSqlDatabase::Compact() called with aSize parameter value = KMinTInt;
sl@0: 							- RSqlDatabase::Compact() called with negative aSize parameter value;
sl@0: 							- RSqlDatabase::Compact() called on a read-only database;
sl@0: 							- RSqlDatabase::Compact() called on an attached read-only database;
sl@0: 							- RSqlDatabase::Compact() called on a nonexisting attached database with very long name;
sl@0: 							- RSqlDatabase::Compact() called with aSize = 0;
sl@0: 							- RSqlDatabase::Compact() called on a read-only database where the version number of symbian_settings table is 3;
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Manual compaction - negative tests.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10273
sl@0:                         REQ10274
sl@0:                         REQ10402
sl@0: */
sl@0: void ManualCompactionNegativeTest()
sl@0: 	{
sl@0: 	for(TInt i=0;i<EMaxCompactionType;++i)
sl@0: 		{
sl@0: 		//Specifying KMaxTInt as aSize argument value.
sl@0: 		TInt err = DoManualCompaction((TCompactionType)i, TheTestDbName, KMaxTInt);
sl@0: 		TEST(err > 0);
sl@0: 		//Specifying KMinTInt as aSize argument value.
sl@0: 		err = DoManualCompaction((TCompactionType)i, TheTestDbName, KMinTInt);
sl@0: 		TEST2(err, KErrArgument);
sl@0: 		//Specifying another negative value as aSize argument value.
sl@0: 		err = DoManualCompaction((TCompactionType)i, TheTestDbName, -357);
sl@0: 		TEST2(err, KErrArgument);
sl@0: 		//Specifying zero as aSize argument value.
sl@0: 		err = DoManualCompaction((TCompactionType)i, TheTestDbName, 0);
sl@0: 		TEST2(err, 0);
sl@0: 		//Read-only database - old format (version 3 of symbian_settings table)
sl@0: 		err = DoManualCompaction((TCompactionType)i, KRoDbName, RSqlDatabase::EMaxCompaction, ETrue);
sl@0: 		TEST2(err, KSqlErrReadOnly);
sl@0: 		//
sl@0: 		(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 		CreateDatabase16(TheTestDbName);
sl@0: 		err = TheDb.Open(TheTestDbName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		_LIT(KAttachDbName, "Db");
sl@0: 		//Attached read-only database
sl@0: 		err = TheDb.Attach(KRoDbName, KAttachDbName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		err = DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, KAttachDbName);
sl@0: 		TEST2(err, KSqlErrReadOnly);
sl@0: 		err = TheDb.Detach(KAttachDbName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		//Nonexisting attached database 
sl@0: 		err = DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, _L("aaa"));
sl@0: 		TEST2(err, KSqlErrGeneral);
sl@0:         //Very long name of a  nonexisting attached database 
sl@0:         TBuf<KMaxFileName + 10> fname;
sl@0:         fname.SetLength(fname.MaxLength());
sl@0:         fname.Fill(0xDD);
sl@0:         err = DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, fname);
sl@0:         TEST2(err, KErrBadName);
sl@0:         //Invalid attached database name 
sl@0:         fname.Copy(_L("c:\\|aaa|.db"));
sl@0:         err = DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, fname);
sl@0:         TEST2(err, KSqlErrGeneral);
sl@0:         //
sl@0: 		TheDb.Close();
sl@0: 		(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4065
sl@0: @SYMTestCaseDesc		Manual compaction - functional tests.
sl@0: 						The test creates a database with a manual compaction mode.
sl@0: 						Then the test executes the following functional tests using both synchronous and
sl@0: 						asynchronous Compact() methods:
sl@0: 							- RSqlDatabase::Compact() called with aSize parameter value = RSqlDatabase::EMaxCompaction;
sl@0: 							- RSqlDatabase::Compact() called with aSize parameter value = 0. No pages should be removed;
sl@0: 							- RSqlDatabase::Compact() called with aSize parameter value = 1. 1 page should be removed;
sl@0: 							- RSqlDatabase::Compact() called with aSize parameter value = "db page size - 1". 1 page should be removed;
sl@0: 							- RSqlDatabase::Compact() called with aSize parameter value = "db page size * <cnt>". <cnt> pages should be removed;
sl@0: 							- RSqlDatabase::Compact() called with aSize parameter value > the free db space. All free pages should be removed;
sl@0: 						The same functional tests are repeated with an attached database.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Manual compaction - functional tests.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10273
sl@0:                         REQ10274
sl@0:                         REQ10402
sl@0: */
sl@0: void ManualCompactionTest()
sl@0: 	{
sl@0: 	for(TInt i=0;i<EMaxCompactionType;++i)
sl@0: 		{
sl@0: 		//Calling Compact() with aSize = RSqlDatabase::EMaxCompaction
sl@0: 		DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, TheCompactedDbSize8);
sl@0: 		//Calling Compact() with aSize = 0. 0 pages expected to be removed
sl@0: 		DoManualCompaction((TCompactionType)i, 0, TheOriginalDbSize8);
sl@0: 		//Calling Compact() with aSize = 1. 1 page expected to be removed
sl@0: 		DoManualCompaction((TCompactionType)i, 1, TheOriginalDbSize8 - KTestDbPageSize);
sl@0: 		//Calling Compact() with aSize = KTestDbPageSize - 1. 1 page expected to be removed
sl@0: 		DoManualCompaction((TCompactionType)i, KTestDbPageSize - 1, TheOriginalDbSize8 - KTestDbPageSize);
sl@0: 		//Calling Compact() with aSize = KTestDbPageSize. 1 page expected to be removed
sl@0: 		DoManualCompaction((TCompactionType)i, KTestDbPageSize, TheOriginalDbSize8 - KTestDbPageSize);
sl@0: 		const TInt KPagesCnt1 = 17;
sl@0: 		//Calling Compact() with aSize = KTestDbPageSize * KPagesCnt1. KPagesCnt1 pages expected to be removed
sl@0: 		DoManualCompaction((TCompactionType)i, KTestDbPageSize * KPagesCnt1, TheOriginalDbSize8 - KTestDbPageSize * KPagesCnt1);
sl@0: 		//Calling Compact() with aSize > TheOriginalDbSize8. All free pages expected to be removed
sl@0: 		DoManualCompaction((TCompactionType)i, TheOriginalDbSize8 + 2000, TheCompactedDbSize8);
sl@0: 		//Attached database
sl@0: 		(void)RSqlDatabase::Delete(KDbName2);
sl@0: 		TInt err = TheDb.Create(KDbName2);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 		CreateDatabase16(TheTestDbName);
sl@0: 		_LIT(KAttachDbName, "Db");
sl@0: 		err = TheDb.Attach(TheTestDbName, KAttachDbName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		TInt newDatabaseSize = TheOriginalDbSize16;
sl@0: 		//Calling Compact() with aSize = 0. 0 pages expected to be removed
sl@0: 		DoManualCompaction((TCompactionType)i, 0, newDatabaseSize, KAttachDbName);
sl@0: 		//Calling Compact() with aSize = 1. 1 page expected to be removed
sl@0: 		DoManualCompaction((TCompactionType)i, 1, TheOriginalDbSize16 - KTestDbPageSize, KAttachDbName);
sl@0: 		newDatabaseSize -= KTestDbPageSize;
sl@0: 		//Calling Compact() with aSize = KTestDbPageSize - 1. 1 page expected to be removed
sl@0: 		DoManualCompaction((TCompactionType)i, KTestDbPageSize - 1, newDatabaseSize - KTestDbPageSize, KAttachDbName);
sl@0: 		newDatabaseSize -= KTestDbPageSize;
sl@0: 		//Calling Compact() with aSize = KTestDbPageSize. 1 page expected to be removed
sl@0: 		DoManualCompaction((TCompactionType)i, KTestDbPageSize, newDatabaseSize - KTestDbPageSize, KAttachDbName);
sl@0: 		newDatabaseSize -= KTestDbPageSize;
sl@0: 		//Calling Compact() with aSize = KTestDbPageSize * KPagesCnt1. KPagesCnt1 pages expected to be removed
sl@0: 		DoManualCompaction((TCompactionType)i, KTestDbPageSize * KPagesCnt1, newDatabaseSize - KTestDbPageSize * KPagesCnt1, KAttachDbName);
sl@0: 		newDatabaseSize -= KTestDbPageSize * KPagesCnt1;
sl@0: 		//Calling Compact() with aSize > newDatabaseSize. All free pages expected to be removed
sl@0: 		DoManualCompaction((TCompactionType)i, newDatabaseSize + 2000, TheCompactedDbSize16, KAttachDbName);
sl@0: 		//
sl@0: 		err = TheDb.Detach(KAttachDbName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		TheDb.Close();
sl@0: 		(void)RSqlDatabase::Delete(KDbName2);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: enum TSizeTestType {EManualSizeTest, EAutoSizeTest};
sl@0: 
sl@0: void DoCompactionDbSizeTest(TSizeTestType aType)
sl@0: 	{
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	_LIT8(KConfig1, "compaction=manual");
sl@0: 	_LIT8(KConfig2, "compaction=auto");
sl@0: 	TInt err = TheDb.Create(TheTestDbName, aType == EManualSizeTest ? &KConfig1 : &KConfig2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("CREATE TABLE A(T TEXT)"));
sl@0: 	TEST2(err, 1);
sl@0: 	//
sl@0: 	RSqlDatabase::TSize size;
sl@0: 	err = TheDb.Size(size);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST2(size.iFree, 0);
sl@0: 	//
sl@0: 	const TInt KRecCnt = 50;
sl@0: 	for(TInt i=0;i<KRecCnt;++i)
sl@0: 		{
sl@0: 		err = TheDb.Exec(_L("INSERT INTO A VALUES('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaaa')"));
sl@0: 		TEST2(err, 1);
sl@0: 		}
sl@0: 	//
sl@0: 	err = TheDb.Size(size);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST2(size.iFree, 0);
sl@0: 	//
sl@0: 	err = TheDb.Exec(_L("DELETE FROM A WHERE 1"));
sl@0: 	TEST2(err, KRecCnt);
sl@0: 	//
sl@0: 	err = TheDb.Size(size);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	if(aType == EManualSizeTest)
sl@0: 		{
sl@0: 		TEST(size.iFree > 0);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		TEST2(size.iFree, 0);
sl@0: 		}
sl@0: 	//
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4066
sl@0: @SYMTestCaseDesc		RSqlDatabase::Size(TSize&) called on a database with manual compaction mode.
sl@0: 						The test creates a database with a manual compaction mode.
sl@0: 						Then the test inserts some records and deletes the records making some free database pages.
sl@0: 						The test calls RSqlDatabase::Size(TSize&) before and after the delete operation and verifies
sl@0: 						that the database file size stays unchanged.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			RSqlDatabase::Size(TSize&) called on a database with manual compaction mode.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10407
sl@0: */
sl@0: void ManualCompactionSizeTest()
sl@0: 	{
sl@0: 	DoCompactionDbSizeTest(EManualSizeTest);
sl@0: 	}
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //////////////////////////////////         OOM testing        ////////////////////////////////////////////////////////////
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void PrintEndOfOomTest(TInt aFailingAllocationNo)
sl@0: 	{
sl@0: 	TheTest.Printf(_L("=== OOM Test succeeded at heap failure rate of %d ===\r\n"), aFailingAllocationNo);
sl@0: 	}
sl@0: 
sl@0: void SetDbHeapFailure(TInt aFailingAllocationNo)
sl@0: 	{
sl@0: 	const TInt KDelayedDbHeapFailureMask = 0x1000;
sl@0: 	TSqlResourceTester::SetDbHeapFailure(RHeap::EDeterministic | KDelayedDbHeapFailureMask, aFailingAllocationNo);
sl@0: 	}
sl@0: 	
sl@0: void ResetDbHeapFailure()
sl@0: 	{
sl@0: 	TSqlResourceTester::SetDbHeapFailure(RHeap::ENone, 0);
sl@0: 	}
sl@0: 
sl@0: static TInt TheHandleCount1B;
sl@0: static TInt TheHandleCount2B;
sl@0: static TInt TheAllocatedCellsCountB;
sl@0: 
sl@0: void MarkHandles()
sl@0: 	{
sl@0: 	RThread().HandleCount(TheHandleCount1B, TheHandleCount2B);
sl@0: 	}
sl@0: 
sl@0: void CheckHandles()
sl@0: 	{
sl@0: 	TInt endHandleCount1E;
sl@0: 	TInt endHandleCount2E;
sl@0: 
sl@0: 	RThread().HandleCount(endHandleCount1E, endHandleCount2E);
sl@0: 
sl@0: 	TEST(TheHandleCount1B == endHandleCount1E);
sl@0: 	TEST(TheHandleCount2B == endHandleCount2E);
sl@0: 	}
sl@0: 
sl@0: void MarkAllocatedCells()
sl@0: 	{
sl@0: 	TheAllocatedCellsCountB = User::CountAllocCells();
sl@0: 	}
sl@0: 
sl@0: void CheckAllocatedCells()
sl@0: 	{
sl@0: 	TInt allocatedCellsCountE = User::CountAllocCells();
sl@0: 	TEST(allocatedCellsCountE == TheAllocatedCellsCountB);
sl@0: 	}
sl@0: 
sl@0: typedef void (*TDbFuncPtrL)(const TDesC& aDbName);
sl@0: 
sl@0: void DoManualCompactionOomTest(TDbFuncPtrL aTestFunctionPtrL, const TDesC& aDbFileName, const TDesC& aAttachDbFileName, const TDesC& aDbName)
sl@0: 	{
sl@0: 	const TInt KDoDbOomTestAllocLimitServer = 1000;
sl@0: 	TInt failingAllocation = 0;
sl@0: 	TInt allocation = 0;
sl@0: 	TInt err = KErrNoMemory;
sl@0: 	while(allocation < KDoDbOomTestAllocLimitServer)
sl@0: 		{
sl@0: 		MarkHandles();
sl@0: 		MarkAllocatedCells();
sl@0: 		
sl@0: 		__UHEAP_MARK;
sl@0: 
sl@0: 		SetDbHeapFailure(++allocation);
sl@0: 
sl@0: 		err = TheDb.Open(aDbFileName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		if(aAttachDbFileName != KNullDesC)
sl@0: 			{
sl@0: 			TEST(aDbName != KNullDesC);
sl@0: 			err = TheDb.Attach(aAttachDbFileName, aDbName);
sl@0: 			TEST(err == KErrNone || err == KErrNoMemory);
sl@0: 			}
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			TRAP(err, (*aTestFunctionPtrL)(aDbName));
sl@0: 			if(err != KErrNoMemory)
sl@0: 				{			
sl@0: 				TEST2(err, KErrNone);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				failingAllocation = allocation;	
sl@0: 				}
sl@0: 			}
sl@0: 			
sl@0: 		ResetDbHeapFailure();
sl@0: 
sl@0: 		if(aAttachDbFileName != KNullDesC)
sl@0: 			{
sl@0: 			(void)TheDb.Detach(aDbName);
sl@0: 			}
sl@0: 		TheDb.Close();
sl@0: 
sl@0: 		__UHEAP_MARKEND;
sl@0: 
sl@0: 		CheckAllocatedCells();	    	
sl@0: 		CheckHandles();	
sl@0: 		}
sl@0: 	TEST2(err, KErrNone);
sl@0: 	PrintEndOfOomTest(failingAllocation + 1);
sl@0: 	}
sl@0: 
sl@0: void OomTest1L(const TDesC&)
sl@0: 	{
sl@0: 	User::LeaveIfError(TheDb.Compact(RSqlDatabase::EMaxCompaction));
sl@0: 	}
sl@0: 
sl@0: void OomTest2L(const TDesC& aDbName)
sl@0: 	{
sl@0: 	TEST(aDbName != KNullDesC);
sl@0: 	User::LeaveIfError(TheDb.Compact(RSqlDatabase::EMaxCompaction, aDbName));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4068
sl@0: @SYMTestCaseDesc		RSqlDatabase::Compact() - OOM test.
sl@0: 						The test creates a database with a manual compaction mode.
sl@0: 						Then the test calls Compact() in an OOM loop.
sl@0: 						The same OOM test is repeated for Compact() called an attached database.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			RSqlDatabase::Compact() - OOM test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10405
sl@0: */
sl@0: void ManualCompactionOomTest()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("Main database - manual compaction - OOM test\r\n"));
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	CreateDatabase8(TheTestDbName);
sl@0: 	DoManualCompactionOomTest(&OomTest1L, TheTestDbName, KNullDesC, KNullDesC);
sl@0: 	TInt err = TheDb.Open(TheTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	RSqlDatabase::TSize size;
sl@0: 	err = TheDb.Size(size);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST2(size.iSize, TheCompactedDbSize8);
sl@0: 	TheDb.Close();
sl@0: 
sl@0: 	TheTest.Printf(_L("Attached database - manual compaction - OOM test\r\n"));
sl@0: 	(void)RSqlDatabase::Delete(KDbName2);
sl@0: 	err = TheDb.Create(KDbName2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	CreateDatabase16(TheTestDbName);
sl@0: 	DoManualCompactionOomTest(&OomTest2L, KDbName2, TheTestDbName, _L("Db"));
sl@0: 	err = TheDb.Open(TheTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Size(size);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST2(size.iSize, TheCompactedDbSize16);
sl@0: 	TheDb.Close();
sl@0: 
sl@0: 	(void)RSqlDatabase::Delete(KDbName2);
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	}
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4067
sl@0: @SYMTestCaseDesc		RSqlDatabase::Size(TSize&) called on a database with auto compaction mode.
sl@0: 						The test creates a database with an auto compaction mode.
sl@0: 						Then the test inserts some records and deletes the records.
sl@0: 						The test calls RSqlDatabase::Size(TSize&) after the delete operation and verifies
sl@0: 						that the database file does not contain any free pages.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			RSqlDatabase::Size(TSize&) called on a database with auto compaction mode.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10407
sl@0:                         REQ10400
sl@0: */
sl@0: void AutoCompactionSizeTest()
sl@0: 	{
sl@0: 	DoCompactionDbSizeTest(EAutoSizeTest);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4069
sl@0: @SYMTestCaseDesc		Background compaction functional test.
sl@0: 						The test executes a 10 iterations loop with a "sleep" time 1000000 us at the beginning.
sl@0: 						The "sleep" time is divided by 2 on each iteration.
sl@0: 						In each iteration the test creates a database with free pages count big enough to kick-off the
sl@0: 						background compaction. Then the test executes enough Exec()s in order to kick-off the background compaction.
sl@0: 						Then the test "sleeps" the calculated "sleep" time and checks after that the database size and free pages
sl@0: 						count and prints them out. After the last iteration the same test is repeated with no "sleep" time.
sl@0: 						The test verifies how the client connection activity affects the possibility of the server to run the
sl@0: 						background compaction. 
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Background compaction functional test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10271
sl@0:                         REQ10407
sl@0: */
sl@0: void BackgroundCompactionTest()
sl@0: 	{
sl@0: 	TInt interval = 1000000;//us
sl@0: 	const TInt KIterationCnt = 10;
sl@0: 	TheTest.Printf(_L("===Sleep after Exec()\r\n"));
sl@0: 	for(TInt i=0;i<KIterationCnt;++i)
sl@0: 		{
sl@0: 		(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 		CreateDatabase8(TheTestDbName);
sl@0: 		TInt err = TheDb.Open(TheTestDbName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		RSqlDatabase::TSize size1;
sl@0: 		err = TheDb.Size(size1);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		TheTest.Printf(_L("---------------------------------\r\n"));
sl@0: 		TheTest.Printf(_L("===Sleep time %d ms. Database before background compaction: size %ld, free space %ld\r\n"), interval / 1000, size1.iSize, size1.iFree);
sl@0: 		//Simulate Exec() activities
sl@0: 		for(TInt j=0;j<100;++j)
sl@0: 			{
sl@0: 			err = TheDb.Exec(_L8("SELECT Id FROM A LIMIT 1"));
sl@0: 			TEST(err >= 0);
sl@0: 			}
sl@0: 		User::After(interval);
sl@0: 		RSqlDatabase::TSize size2;
sl@0: 		err = TheDb.Size(size2);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		TheTest.Printf(_L("===Database after background compaction: size %ld, free space %ld\r\n"), size2.iSize, size2.iFree);
sl@0: 		TEST(size2.iSize <= size1.iSize);
sl@0: 		TEST(size2.iFree <= size1.iFree);
sl@0: 		interval /= 2;
sl@0: 		TheDb.Close();
sl@0: 		}
sl@0: 	TheTest.Printf(_L("===No sleep\r\n"));
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	CreateDatabase8(TheTestDbName);
sl@0: 	TInt err = TheDb.Open(TheTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	RSqlDatabase::TSize size1;
sl@0: 	err = TheDb.Size(size1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("===Database before background compaction: size %ld, free space %ld\r\n"), size1.iSize, size1.iFree);
sl@0: 	//Simulate Exec() activities
sl@0: 	for(TInt j=0;j<100;++j)
sl@0: 		{
sl@0: 		err = TheDb.Exec(_L8("SELECT Id FROM A LIMIT 1"));
sl@0: 		TEST(err >= 0);
sl@0: 		}
sl@0: 	RSqlDatabase::TSize size2;
sl@0: 	err = TheDb.Size(size2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("===Database after background compaction: size %ld, free space %ld\r\n"), size2.iSize, size2.iFree);
sl@0: 	TEST(size2.iSize <= size1.iSize);
sl@0: 	TEST(size2.iFree <= size1.iFree);
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(TheTestDbName);
sl@0: 	}
sl@0: 
sl@0: struct TThreadData
sl@0: 	{
sl@0: 	TThreadData(const TDesC& aFileName, TInt aSleepInterval) :
sl@0: 		iDbName(aFileName),
sl@0: 		iSleepInterval(aSleepInterval)
sl@0: 		{
sl@0: 		TInt err = iCritSection.CreateLocal();
sl@0: 		TEST2(err, KErrNone);
sl@0: 		iCritSection.Wait();
sl@0: 		Mem::FillZ(&iSize1, sizeof(iSize1));
sl@0: 		Mem::FillZ(&iSize2, sizeof(iSize2));
sl@0: 		}
sl@0: 	TFileName iDbName;	
sl@0: 	RCriticalSection iCritSection;
sl@0: 	RSqlDatabase::TSize iSize1;
sl@0: 	RSqlDatabase::TSize iSize2;
sl@0: 	TInt	iSleepInterval;
sl@0: 	};
sl@0: 
sl@0: TInt ThreadFunc(void* aPrm)
sl@0: 	{
sl@0: 	TEST(aPrm != NULL);
sl@0: 
sl@0: 	__UHEAP_MARK;
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 	TheTest(tc != NULL);
sl@0: 
sl@0: 	//Wait for a signal from the main thread
sl@0: 	TThreadData* thrdat = (TThreadData*)aPrm;
sl@0: 	thrdat->iCritSection.Wait();
sl@0: 
sl@0: 	RSqlDatabase db;
sl@0: 	TInt err = db.Open(thrdat->iDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = db.Size(thrdat->iSize1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Simulate Exec() activities
sl@0: 	for(TInt j=0;j<100;++j)
sl@0: 		{
sl@0: 		err = db.Exec(_L8("SELECT Id FROM A LIMIT 1"));
sl@0: 		TEST(err >= 0);
sl@0: 		if((j % 10) == 0 && thrdat->iSleepInterval > 0)
sl@0: 			{
sl@0: 			User::After(thrdat->iSleepInterval);
sl@0: 			}
sl@0: 		}
sl@0: 	err = db.Size(thrdat->iSize2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	db.Close();
sl@0: 
sl@0: 	delete tc;	
sl@0: 	__UHEAP_MARKEND;
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4070
sl@0: @SYMTestCaseDesc		Background compaction load test.
sl@0: 						The test runs 8 threads. Each thread connects to a different database.
sl@0: 						Each database has space in the free pages above the "free pages" threshold - 
sl@0: 						the background compaction will be scheduled at the moment when the database is opened.
sl@0: 						Every thread executes some operations on the opened database - that will delay the background compaction.
sl@0: 						After every 10 operations the thread sleeps for a specified interval of a time.
sl@0: 						After all threads complete, the test checks the database size and free pages count and
sl@0: 						prints them out.
sl@0: 						The test verifies the ability of the SQL server to run the background compaction under a load.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Background compaction load test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10271
sl@0:                         REQ10407
sl@0: */
sl@0: void BackgroundCompactionLoadTest()
sl@0: 	{
sl@0: 	RThread threads[KMaxThreadCount];
sl@0: 	TThreadData* thrdata[KMaxThreadCount] = {NULL};
sl@0: 	TRequestStatus thrstat[KMaxThreadCount];
sl@0: 	
sl@0: 	const TInt KSleepInterval[] = {0, 50000, 100000, 300000, 500000, 800000};//us
sl@0: 	const TInt KTestCnt = sizeof(KSleepInterval) / sizeof(KSleepInterval[0]);
sl@0: 	
sl@0: 	for(TInt k=0;k<KTestCnt;++k)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("=================================================\r\n"));
sl@0: 		TheTest.Printf(_L("===Sleep interval %d ms\r\n"), KSleepInterval[k] / 1000);
sl@0: 		TheTest.Printf(_L("=================================================\r\n"));
sl@0: 		//Create test databases and threads
sl@0: 		for(TInt i=0;i<TheTestThreadCount;++i)
sl@0: 			{
sl@0: 			//Database
sl@0: 			TBuf<16> fname;
sl@0: 			fname.Copy(_L("\\test\\a"));
sl@0: 			fname.AppendNum(i + 1);
sl@0: 			fname.Append(_L(".db"));
sl@0: 			TheParse.Set(TheDrive, &fname, 0);
sl@0: 			(void)RSqlDatabase::Delete(TheParse.FullName());
sl@0: 			CreateDatabase8(TheParse.FullName());
sl@0: 			//Thread data
sl@0: 			thrdata[i] = new TThreadData(TheParse.FullName(), KSleepInterval[k]);
sl@0: 			TEST(thrdata[i] != NULL);
sl@0: 			//Thread
sl@0: 			TBuf<16> thrname;
sl@0: 			thrname.Copy(_L("Thread"));
sl@0: 			thrname.AppendNum(i + 1);
sl@0: 			TInt err = threads[i].Create(thrname, &ThreadFunc, 0x2000, 0x1000, 0x10000, thrdata[i], EOwnerProcess);
sl@0: 			TEST2(err, KErrNone);
sl@0: 			threads[i].Logon(thrstat[i]);
sl@0: 			TEST2(thrstat[i].Int(), KRequestPending);
sl@0: 			threads[i].Resume();
sl@0: 			}
sl@0: 		//Enable the threads
sl@0: 		for(TInt i=0;i<TheTestThreadCount;++i)
sl@0: 			{
sl@0: 			thrdata[i]->iCritSection.Signal();	
sl@0: 			}
sl@0: 		//Wait for cmpletion
sl@0: 		for(TInt i=0;i<TheTestThreadCount;++i)
sl@0: 			{
sl@0: 			User::WaitForRequest(thrstat[i]);
sl@0: 			}
sl@0: 		//Report
sl@0: 		for(TInt i=0;i<TheTestThreadCount;++i)
sl@0: 			{
sl@0: 			TheTest.Printf(_L("===Thread %d, database %S\r\n"), i + 1, &(thrdata[i]->iDbName));
sl@0: 			TheTest.Printf(_L("===Before background compaction: size %6ld, free space %6ld\r\n"), thrdata[i]->iSize1.iSize, thrdata[i]->iSize1.iFree);
sl@0: 			TheTest.Printf(_L("===After background compaction:  size %6ld, free space %6ld\r\n"), thrdata[i]->iSize2.iSize, thrdata[i]->iSize2.iFree);
sl@0: 			TEST(thrdata[i]->iSize2.iSize <= thrdata[i]->iSize1.iSize);
sl@0: 			TEST(thrdata[i]->iSize2.iFree <= thrdata[i]->iSize1.iFree);
sl@0: 			}
sl@0: 		//Destroy
sl@0: 		for(TInt i=0;i<TheTestThreadCount;++i)
sl@0: 			{
sl@0: 			(void)RSqlDatabase::Delete(thrdata[i]->iDbName);
sl@0: 			thrdata[i]->iCritSection.Close();
sl@0: 			delete thrdata[i];
sl@0: 			thrdata[i] = NULL;
sl@0: 			CLOSE_AND_WAIT(threads[i]);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4071
sl@0: @SYMTestCaseDesc		Background compaction in a DDL transaction test.
sl@0: 						The test creates a database, begins a transaction that modifies the database structure  
sl@0: 						and executes enough operations in order free enough space to kick-off the background compaction. 
sl@0: 						The test should not report any failures caused by the fact that the main database connection is
sl@0: 						in a DML transaction and at the same time the background connection may try to execute
sl@0: 						a "PRAGMA freelist_count" statement.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Background compaction in a DDL transaction test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10271
sl@0: */
sl@0: void BackgroundCompactionInDDLTransactionTest()
sl@0: 	{
sl@0: 	const TInt KOperationCount = 100;
sl@0: 	(void)RSqlDatabase::Delete(KDbName);
sl@0: 	TInt err = TheDb.Create(KDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("BEGIN"));
sl@0: 	TEST(err >= 0);
sl@0: 	err = TheDb.Exec(_L("CREATE TABLE A(I INTEGER, T TEXT)"));
sl@0: 	TEST2(err, 1);
sl@0: 	TheText.SetLength(KTextLen);
sl@0: 	TheText.Fill(TChar('A'));
sl@0: 	for(TInt i=0;i<=KOperationCount;++i)	
sl@0: 		{
sl@0: 		TheSqlTexLen.Format(_L("INSERT INTO A VALUES(%d, '%S')"), i + 1, &TheText);
sl@0: 		err = TheDb.Exec(TheSqlTexLen);
sl@0: 		TEST2(err, 1);
sl@0: 		}
sl@0: 	err = TheDb.Exec(_L("COMMIT"));
sl@0: 	TEST(err >= 0);
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(KDbName);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-CT-4209
sl@0: @SYMTestCaseDesc		Corrupted database background compaction test.
sl@0: 						The test creates a database, inserts records, then deletes part of the records.
sl@0: 						The free pages count should be big enough to kick off the background compaction.
sl@0: 						But the database is closed immediatelly and then the db file is corrupted in a such
sl@0: 						way that during the "database open" operation the corruption is not detected.
sl@0: 						But the corruption is detected during the background compaction. The SQL server
sl@0: 						should detect during the compaction that the databas eis corrupted and should
sl@0: 						stop compacting the database (and draining the battery). Unfortunatelly, this 
sl@0: 						cannot be tested automatically, so a breakpoint should be set at the User::After()
sl@0: 						call, and then the SQL server side should be debugged in order to berify that the
sl@0: 						background compaction is really stopped for that database.  
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			Corrupted database background compaction test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF					ou1cimx1#406830
sl@0: */
sl@0: void CorruptedDbBckgCompactionTest()
sl@0: 	{
sl@0: 	//Step 1: Create a database with some records
sl@0: 	const TInt KOperationCount = 100;
sl@0: 	(void)RSqlDatabase::Delete(KDbName);
sl@0: 	TInt err = TheDb.Create(KDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("BEGIN"));
sl@0: 	TEST(err >= 0);
sl@0: 	err = TheDb.Exec(_L("CREATE TABLE A(I INTEGER, T TEXT)"));
sl@0: 	TEST2(err, 1);
sl@0: 	TheText.SetLength(KTextLen);
sl@0: 	TheText.Fill(TChar('A'));
sl@0: 	for(TInt i=0;i<=KOperationCount;++i)	
sl@0: 		{
sl@0: 		TheSqlTexLen.Format(_L("INSERT INTO A VALUES(%d, '%S')"), i + 1, &TheText);
sl@0: 		err = TheDb.Exec(TheSqlTexLen);
sl@0: 		TEST2(err, 1);
sl@0: 		}
sl@0: 	err = TheDb.Exec(_L("COMMIT"));
sl@0: 	TEST(err >= 0);
sl@0: 	//Step 2: Delete some records to free some space
sl@0: 	err = TheDb.Exec(_L("DELETE FROM A WHERE (I % 2) = 0"));
sl@0: 	TEST(err > 0);
sl@0: 	//Step 3: Close the database
sl@0: 	TheDb.Close();
sl@0: 	//Step 4: Corrupt the database
sl@0:     RFs fs;
sl@0: 	err = fs.Connect();
sl@0: 	TEST2(err, KErrNone);
sl@0: 	RFile file;
sl@0: 	err = file.Open(fs, KDbName, EFileRead | EFileWrite); 
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TInt pos = 5000;
sl@0: 	err = file.Seek(ESeekStart, pos);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheSqlQuery.SetLength(1000);
sl@0: 	for(TInt i=0;i<30;++i)
sl@0: 		{
sl@0: 		err = file.Write(TheSqlQuery);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		}
sl@0: 	file.Close();
sl@0: 	//Step 5: Check the background compaction. Wait 10 seconds allowing the SQL server to try to compact the
sl@0: 	//        database. The SQL server should detect that the SQL database is corrupted and should stop trying to
sl@0: 	//        compact the database.
sl@0: 	err = TheDb.Open(KDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	User::After(10000000);
sl@0: 	//
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(KDbName);
sl@0: 	}
sl@0: 
sl@0: void DoTestsL()
sl@0: 	{
sl@0: 	CreateTestDatabase8();
sl@0: 	CalculateMaxCompaction8();
sl@0: 	CreateTestDatabase16();
sl@0: 	CalculateMaxCompaction16();
sl@0: 
sl@0: 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4064 Manual Compact() - negative tests"));	
sl@0: 	ManualCompactionNegativeTest();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4065 Manual Compact() tests"));	
sl@0: 	ManualCompactionTest();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4066 Manual compaction db size test"));	
sl@0: 	ManualCompactionSizeTest();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4068 Manual compaction - OOM test"));	
sl@0: 	ManualCompactionOomTest();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4067 Auto compaction db size test"));	
sl@0: 	AutoCompactionSizeTest();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4069 Background compaction test"));	
sl@0: 	BackgroundCompactionTest();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4070 Background compaction - load test"));	
sl@0: 	BackgroundCompactionLoadTest();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4071 Background compaction activated inside a DDL transaction - test"));	
sl@0: 	BackgroundCompactionInDDLTransactionTest();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4209 Corrupted database background compaction test"));	
sl@0: 	CorruptedDbBckgCompactionTest();
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: 	TheTest.Printf(_L("Usage:\r\n  t_sqlcompact4 [[drive:] [test thread count]]\r\n"));
sl@0: 	TheDrive.Copy(KDefaultDriveName);
sl@0: 	User::CommandLine(TheCmd);
sl@0: 	TheCmd.TrimAll();
sl@0: 	if(TheCmd.Length() > 0)
sl@0: 		{
sl@0: 		TInt pos = TheCmd.Locate(TChar(' '));
sl@0: 		TheTest(pos > 0);
sl@0: 		TPtrC prm1(TheCmd.Left(pos));
sl@0: 		TPtrC prm2(TheCmd.Mid(pos + 1));
sl@0: 		
sl@0: 		TheDrive.Copy(prm1);
sl@0: 		
sl@0: 		TLex lex(prm2);
sl@0: 		lex.Val(TheTestThreadCount);
sl@0: 		}
sl@0: 	TheParse.Set(TheDrive, &KDbName, 0);
sl@0: 	TheTestDbName.Copy(TheParse.FullName());
sl@0: 	TheTest.Printf(_L("Test database: %S\r\n"), &TheTestDbName);
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: 	}