sl@0: // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
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: 
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: RTest TheTest(_L("t_sqlcompact3 test"));
sl@0: RSqlDatabase TheDb;
sl@0: RSqlStatement TheStmt;
sl@0: 
sl@0: _LIT(KTestDir, "c:\\test\\");
sl@0: _LIT(KTestDbName1, "c:\\test\\t_sqlcompact3_1.db");
sl@0: _LIT(KTestPrivDbName, "c:\\private\\21212124\\t_sqlcompact3_2.db");
sl@0: _LIT(KTestPrivDbNameZ,"z:\\private\\21212124\\t_sqldb1.db");//Created outside the test app
sl@0: _LIT(KTestPrivDbNameC,"c:\\private\\21212124\\t_sqldb1.db");
sl@0: _LIT(KTestSecureDbName, "c:[21212124]t_sqlcompact3_3.db");
sl@0: _LIT8(KTestFullSecureDbNameZ, "c:\\private\\10281e17\\[21212124]t_sqlcompact3_3.db\x0");
sl@0: 
sl@0: const TInt KAutoVacuum = 1;
sl@0: const TInt KIncrementalVacuum = 2;
sl@0: const TInt KSqlDefaultVacuum = KIncrementalVacuum;
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: 	TheStmt.Close();
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(KTestPrivDbNameC);
sl@0: 	(void)RSqlDatabase::Delete(KTestSecureDbName);
sl@0: 	(void)RSqlDatabase::Delete(KTestPrivDbName);
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName1);
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: 		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: 	err = fs.CreatePrivatePath(EDriveC);
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: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4056
sl@0: @SYMTestCaseDesc		Manual compaction - configuration test.
sl@0: 						The test creates a database with a manual compaction mode.
sl@0: 						The test reopens the database and verifies that the compaction mode is persistent and is still manual.
sl@0: 						Then the test reopens the database using different compaction mode in the configuration string and 
sl@0: 						verifies that the original (manual) compaction mode cannot be changed when the database is opened.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Manual compaction - configuration test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10274
sl@0:                         REQ10402
sl@0: */
sl@0: void CompactConfigTest1L()
sl@0: 	{
sl@0: 	//Create a test database with "manual" compaction mode
sl@0: 	_LIT8(KConfigStr1, "encoding=utf-8;compaction=manual");
sl@0: 	TInt err = TheDb.Create(KTestDbName1, &KConfigStr1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be "incremental"
sl@0: 	TSqlScalarFullSelectQuery scalarQuery(TheDb);
sl@0: 	TInt compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KIncrementalVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Close and open the database again. The SQLite vacuum mode should be "incremental".
sl@0: 	err = TheDb.Open(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KIncrementalVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Close and open the database again with a config string with "auto" compaction mode. 
sl@0: 	//The SQLite vacuum mode should stay unchanged.
sl@0: 	_LIT8(KConfigStr2, "compaction=auto");
sl@0: 	err = TheDb.Open(KTestDbName1, &KConfigStr2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KIncrementalVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Delete database
sl@0: 	err = RSqlDatabase::Delete(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4057
sl@0: @SYMTestCaseDesc		Auto compaction - configuration test.
sl@0: 						The test creates a database with an auto compaction mode.
sl@0: 						The test reopens the database and verifies that the compaction mode is persistent and is still auto.
sl@0: 						Then the test reopens the database using different compaction mode in the configuration string and 
sl@0: 						verifies that the original (auto) compaction mode cannot be changed when the database is opened.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Auto compaction - configuration test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10274
sl@0:                         REQ10400
sl@0: */
sl@0: void CompactConfigTest2L()
sl@0: 	{
sl@0: 	//Create a test database with "auto" compaction mode
sl@0: 	_LIT8(KConfigStr1, "encoding=utf-8;compaction=auto");
sl@0: 	TInt err = TheDb.Create(KTestDbName1, &KConfigStr1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be "auto"
sl@0: 	TSqlScalarFullSelectQuery scalarQuery(TheDb);
sl@0: 	TInt compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Create a test database with "synchronous" compaction mode
sl@0: 	err = RSqlDatabase::Delete(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	_LIT8(KConfigStr3, "encoding=utf-8;compaction=synchronous");
sl@0: 	err = TheDb.Create(KTestDbName1, &KConfigStr3);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be "auto"
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Close and open the database again. The SQLite vacuum mode should be "auto".
sl@0: 	err = TheDb.Open(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Close and open the database again with a config string with "background" compaction mode. 
sl@0: 	//The SQLite vacuum mode should stay unchanged.
sl@0: 	_LIT8(KConfigStr2, "compaction=background");
sl@0: 	err = TheDb.Open(KTestDbName1, &KConfigStr2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Delete database
sl@0: 	err = RSqlDatabase::Delete(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4058
sl@0: @SYMTestCaseDesc		Background compaction - configuration test.
sl@0: 						The test creates a database with a background compaction mode.
sl@0: 						The test reopens the database and verifies that the compaction mode is persistent and is still background.
sl@0: 						Then the test reopens the database using different compaction mode in the configuration string and 
sl@0: 						verifies that the original (background) compaction mode cannot be changed when the database is opened.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Background compaction - configuration test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10274
sl@0: */
sl@0: void CompactConfigTest3L()
sl@0: 	{
sl@0: 	//Create a test database with "background" compaction mode
sl@0: 	_LIT8(KConfigStr1, "encoding=utf-8;compaction=background");
sl@0: 	TInt err = TheDb.Create(KTestDbName1, &KConfigStr1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be "incremental"
sl@0: 	TSqlScalarFullSelectQuery scalarQuery(TheDb);
sl@0: 	TInt compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KIncrementalVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Close and open the database again. The SQLite vacuum mode should be "incremental".
sl@0: 	err = TheDb.Open(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KIncrementalVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Close and open the database again with a config string with "manual" compaction mode. 
sl@0: 	//The SQLite vacuum mode should stay unchanged.
sl@0: 	_LIT8(KConfigStr2, "compaction=manual");
sl@0: 	err = TheDb.Open(KTestDbName1, &KConfigStr2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KIncrementalVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Delete database
sl@0: 	err = RSqlDatabase::Delete(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4059
sl@0: @SYMTestCaseDesc		Background compaction - no configuration string test.
sl@0: 						The test creates a database without using a configuration string.
sl@0: 						The database should be created with default compaction mode - background.
sl@0: 						The test reopens the database and verifies that the compaction mode is persistent and is still background.
sl@0: 						Then the test reopens the database using different compaction mode in the configuration string and 
sl@0: 						verifies that the original (background) compaction mode cannot be changed when the database is opened.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Background compaction - no configuration string test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10273
sl@0:                         REQ10274
sl@0: */
sl@0: void CompactConfigTest4L()
sl@0: 	{
sl@0: 	//Create a test database without configuration string
sl@0: 	TInt err = TheDb.Create(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be KSqlDefaultVacuum
sl@0: 	TSqlScalarFullSelectQuery scalarQuery(TheDb);
sl@0: 	TInt compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KSqlDefaultVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Delete database
sl@0: 	err = RSqlDatabase::Delete(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Create a test database with invalid configuration string
sl@0: 	_LIT8(KConfigStr1, "encoding=utf-8;compaction=backgrund");
sl@0: 	err = TheDb.Create(KTestDbName1, &KConfigStr1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be KSqlDefaultVacuum
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KSqlDefaultVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Delete database
sl@0: 	err = RSqlDatabase::Delete(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Create a test database with invalid configuration string
sl@0: 	_LIT8(KConfigStr2, "compactin=background");
sl@0: 	err = TheDb.Create(KTestDbName1, &KConfigStr2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be KSqlDefaultVacuum
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KSqlDefaultVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Delete database
sl@0: 	err = RSqlDatabase::Delete(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4060
sl@0: @SYMTestCaseDesc		Private database and compaction configuration test.
sl@0: 						The test verifies that a private database can be created using auto, background or 
sl@0: 						manual compaction mode and that the compaction mode does not chage after reopening 
sl@0: 						the database.
sl@0: 						The test also verifies that if the database is legacy, read-only, then the compaction
sl@0: 						mode is auto.
sl@0: 						The test also verifies that if the database is legacy, r/w, then the compaction
sl@0: 						mode will be changed from auto to background.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Private database and compaction configuration test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10273
sl@0:                         REQ10274
sl@0:                         REQ10400
sl@0:                         REQ10402
sl@0: */
sl@0: void CompactConfigTest5L()
sl@0: 	{
sl@0: 	//Create a private test database with "auto" compaction mode
sl@0: 	_LIT8(KConfigStr1, "encoding=utf-8;compaction=auto");
sl@0: 	TInt err = TheDb.Create(KTestPrivDbName, &KConfigStr1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be "auto"
sl@0: 	TSqlScalarFullSelectQuery scalarQuery(TheDb);
sl@0: 	TInt compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Close and open the database again. The SQLite vacuum mode should be "auto".
sl@0: 	err = TheDb.Open(KTestPrivDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Close and open the database again with a config string with "background" compaction mode. 
sl@0: 	//The SQLite vacuum mode should stay unchanged.
sl@0: 	_LIT8(KConfigStr2, "compaction=background");
sl@0: 	err = TheDb.Open(KTestPrivDbName, &KConfigStr2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Delete database
sl@0: 	err = RSqlDatabase::Delete(KTestPrivDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Create a private test database - no config string
sl@0: 	err = TheDb.Create(KTestPrivDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be KSqlDefaultVacuum
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KSqlDefaultVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Close and open the database again. The SQLite vacuum mode should be KSqlDefaultVacuum.
sl@0: 	err = TheDb.Open(KTestPrivDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KSqlDefaultVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Close and open the database again with a config string with "auto" compaction mode. 
sl@0: 	//The SQLite vacuum mode should stay unchanged.
sl@0: 	err = TheDb.Open(KTestPrivDbName, &KConfigStr1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KSqlDefaultVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Delete database
sl@0: 	err = RSqlDatabase::Delete(KTestPrivDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Open an existing private database that is read-only (on drive Z:)
sl@0: 	err = TheDb.Open(KTestPrivDbNameZ, &KConfigStr1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite compact mode should be "auto" (this is an old database (pre-"background compact" era))
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	TheDb.Close();
sl@0: 	//Open the same database after copying it to drive C: (r/w private database). The compaction mode should change from auto to background.
sl@0: 	RFs fs;
sl@0: 	err = fs.Connect();
sl@0: 	TEST2(err, KErrNone);
sl@0: 	CFileMan* fm = CFileMan::NewL(fs);
sl@0: 	TEST(fm != NULL);
sl@0: 	err = fm->Copy(KTestPrivDbNameZ, KTestPrivDbNameC);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//"Copy" operation executed without errors. Now it is a time to turn off the read-only
sl@0: 	//flag of the target file (which may be on if the source file is on a read-only drive)
sl@0: 	err = fs.SetAtt(KTestPrivDbNameC, 0, KEntryAttReadOnly);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	delete fm;
sl@0: 	fs.Close();
sl@0: 	err = TheDb.Open(KTestPrivDbNameC);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KSqlDefaultVacuum);
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(KTestPrivDbNameC);
sl@0: 	}
sl@0: 
sl@0: RSqlSecurityPolicy CreateTestSecurityPolicy()
sl@0: 	{
sl@0: 	const TSecurityPolicy KDefaultPolicy(TSecurityPolicy::EAlwaysPass);
sl@0: 	RSqlSecurityPolicy securityPolicy;
sl@0: 	TInt err = securityPolicy.Create(KDefaultPolicy);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	return securityPolicy;
sl@0: 	}
sl@0: 
sl@0: void TestCompactMode(TInt aExpectedCompactMode)
sl@0: 	{
sl@0: 	sqlite3 *dbHandle = NULL;
sl@0: 	TInt rc = sqlite3_open((const char*)KTestFullSecureDbNameZ().Ptr(), &dbHandle);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 
sl@0: 	sqlite3_stmt* stmtHandle = NULL;
sl@0: 	const char* stmtTailZ = NULL;
sl@0: 	rc = sqlite3_prepare_v2(dbHandle, "PRAGMA auto_vacuum", -1, &stmtHandle, &stmtTailZ);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 
sl@0: 	rc = sqlite3_step(stmtHandle);
sl@0: 	TEST2(rc, SQLITE_ROW);
sl@0: 	TInt compact = sqlite3_column_int(stmtHandle, 0); 
sl@0: 	
sl@0: 	sqlite3_finalize(stmtHandle);
sl@0: 	sqlite3_close(dbHandle);
sl@0: 	
sl@0: 	TEST2(compact, aExpectedCompactMode);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4061
sl@0: @SYMTestCaseDesc		Secure shared database and compaction configuration test.
sl@0: 						The test verifies that a secure shared database can be created using auto, background or 
sl@0: 						manual compaction mode and that the compaction mode does not chage after reopening 
sl@0: 						the database.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Secure shared database and compaction configuration test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10273
sl@0:                         REQ10274
sl@0:                         REQ10400
sl@0:                         REQ10402
sl@0: */
sl@0: void CompactConfigTest6L()
sl@0: 	{
sl@0: 	//Create a secure test database with "auto" compaction mode.
sl@0: 	RSqlSecurityPolicy securityPolicy = CreateTestSecurityPolicy();
sl@0: 	_LIT8(KConfigStr1, "encoding=utf-8;compaction=auto");
sl@0: 	TInt err = TheDb.Create(KTestSecureDbName, securityPolicy, &KConfigStr1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	securityPolicy.Close();
sl@0: 	TheDb.Close();
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be "auto"
sl@0: 	TestCompactMode(KAutoVacuum);
sl@0: 	//Close and open the database again. The SQLite vacuum mode should be "auto".
sl@0: 	err = TheDb.Open(KTestSecureDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	TestCompactMode(KAutoVacuum);
sl@0: 	//Close and open the database again with a config string with "background" compaction mode. 
sl@0: 	//The SQLite vacuum mode should stay unchanged.
sl@0: 	_LIT8(KConfigStr2, "compaction=background");
sl@0: 	err = TheDb.Open(KTestSecureDbName, &KConfigStr2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	TestCompactMode(KAutoVacuum);
sl@0: 	//Delete database
sl@0: 	err = RSqlDatabase::Delete(KTestSecureDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Create a private test database - no config string
sl@0: 	securityPolicy = CreateTestSecurityPolicy();
sl@0: 	err = TheDb.Create(KTestSecureDbName, securityPolicy);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	securityPolicy.Close();
sl@0: 	TheDb.Close();
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be KSqlDefaultVacuum.
sl@0: 	TestCompactMode(KSqlDefaultVacuum);
sl@0: 	//Close and open the database again. The SQLite vacuum mode should be KSqlDefaultVacuum.
sl@0: 	err = TheDb.Open(KTestSecureDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	TestCompactMode(KSqlDefaultVacuum);
sl@0: 	//Close and open the database again with a config string with "auto" compaction mode. 
sl@0: 	//The SQLite vacuum mode should stay unchanged.
sl@0: 	err = TheDb.Open(KTestSecureDbName, &KConfigStr1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	TestCompactMode(KSqlDefaultVacuum);
sl@0: 	//Delete database
sl@0: 	err = RSqlDatabase::Delete(KTestSecureDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4062
sl@0: @SYMTestCaseDesc		Compaction configuration test - multiple connections.
sl@0: 						The test creates a database with auto or background compaction mode.
sl@0: 						Then the test opens more connections to the same database.
sl@0: 						The test verifies that the compaction mode of the connections opened later is
sl@0: 						the same as the compaction mode of the database that was openen first.
sl@0: 						The test also verifies that the compactino mode cannot be changed even if the second
sl@0: 						connection is opened with a configuration string with a specified different compaction mode.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Compaction configuration test - multiple connections.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10273
sl@0:                         REQ10274
sl@0:                         REQ10400
sl@0: */
sl@0: void CompactConfigTest7L()
sl@0: 	{
sl@0: 	//Create a test database with "auto" compaction mode.
sl@0: 	_LIT8(KConfigStr1, "encoding=utf-8;compaction  =   auto");
sl@0: 	TInt err = TheDb.Create(KTestDbName1, &KConfigStr1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be "auto"
sl@0: 	TSqlScalarFullSelectQuery scalarQuery(TheDb);
sl@0: 	TInt compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	//Open a second connection to the same database - no config string
sl@0: 	RSqlDatabase db2;
sl@0: 	err = db2.Open(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be "auto"
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	TSqlScalarFullSelectQuery scalarQuery2(db2);
sl@0: 	compact = scalarQuery2.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	//Open a third connection to the same database - "background" compaction mode config string
sl@0: 	_LIT8(KConfigStr2, "  encoding =    utf-8 ; ; ; compaction  =   background   ");
sl@0: 	RSqlDatabase db3;
sl@0: 	err = db3.Open(KTestDbName1, &KConfigStr2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be "auto"
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	compact = scalarQuery2.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	TSqlScalarFullSelectQuery scalarQuery3(db3);
sl@0: 	compact = scalarQuery3.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	//Close & Delete database
sl@0: 	db3.Close();
sl@0: 	db2.Close();
sl@0: 	TheDb.Close();
sl@0: 	err = RSqlDatabase::Delete(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//
sl@0: 	//
sl@0: 	//Create a test database with "background" compaction mode
sl@0: 	_LIT8(KConfigStr3, "compaction  =   background   ;;;;");
sl@0: 	err = TheDb.Create(KTestDbName1, &KConfigStr3);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be "incremental"
sl@0: 	scalarQuery.SetDatabase(TheDb);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KIncrementalVacuum);
sl@0: 	//Open a second connection to the same database - no config string
sl@0: 	err = db2.Open(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be "incremental"
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KIncrementalVacuum);
sl@0: 	scalarQuery2.SetDatabase(db2);
sl@0: 	compact = scalarQuery2.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KIncrementalVacuum);
sl@0: 	//Open a third connection to the same database - "auto" compaction mode config string
sl@0: 	_LIT8(KConfigStr4, "  encoding =    utf-16 ; compaction  =   auto   ; ; ; ");
sl@0: 	err = db3.Open(KTestDbName1, &KConfigStr4);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check the vacuum mode. The SQLite vacuum mode should be "incremental"
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KIncrementalVacuum);
sl@0: 	compact = scalarQuery2.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KIncrementalVacuum);
sl@0: 	scalarQuery3.SetDatabase(db3);
sl@0: 	compact = scalarQuery3.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KIncrementalVacuum);
sl@0: 	//Close & Delete database
sl@0: 	db3.Close();
sl@0: 	db2.Close();
sl@0: 	TheDb.Close();
sl@0: 	err = RSqlDatabase::Delete(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4063
sl@0: @SYMTestCaseDesc		Compaction configuration test - attached database.
sl@0: 						The test creates a database with an auto compaction mode.
sl@0: 						Then the test attaches the same database.
sl@0: 						The test verifies that the compaction mode of the main and the attached database is the same - auto.
sl@0: @SYMTestPriority		Medium
sl@0: @SYMTestActions			Compaction configuration test - attached database.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10273
sl@0:                         REQ10274
sl@0:                         REQ10400
sl@0: */
sl@0: void CompactConfigTest8L()
sl@0: 	{
sl@0: 	//Create a test database with "auto" compaction mode
sl@0: 	_LIT8(KConfigStr1, "; ;; ; compaction  =   auto; ");
sl@0: 	TInt err = TheDb.Create(KTestDbName1, &KConfigStr1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Attach a database
sl@0: 	err = TheDb.Attach(KTestDbName1, _L("db2"));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check compact for both main and attached database
sl@0: 	TSqlScalarFullSelectQuery scalarQuery(TheDb);
sl@0: 	TInt compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA db2.auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	//Detach
sl@0: 	err = TheDb.Detach(_L("db2"));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Check compact again
sl@0: 	compact = scalarQuery.SelectIntL(_L("PRAGMA auto_vacuum"));
sl@0: 	TEST2(compact, KAutoVacuum);
sl@0: 	//
sl@0: 	TheDb.Close();
sl@0: 	err = RSqlDatabase::Delete(KTestDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: void DoTestsL()
sl@0: 	{
sl@0: 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4056 Compaction configuration tests 1 - manual compact"));	
sl@0: 	CompactConfigTest1L();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4057 Compaction configuration tests 2 - auto compact"));	
sl@0: 	CompactConfigTest2L();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4058 Compaction configuration tests 3 - background compact"));	
sl@0: 	CompactConfigTest3L();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4059 Compaction configuration tests 4 - invalid compact"));	
sl@0: 	CompactConfigTest4L();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4060 Compaction configuration tests 5 - private databases"));	
sl@0: 	CompactConfigTest5L();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4061 Compaction configuration tests 6 - secure databases"));	
sl@0: 	CompactConfigTest6L();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4062 Compaction configuration tests 7 - multiple connections"));	
sl@0: 	CompactConfigTest7L();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4063 Compaction configuration tests 8 - attached databases"));	
sl@0: 	CompactConfigTest8L();
sl@0: 	}
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	TheTest.Title();
sl@0: 	
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 	
sl@0: 	__UHEAP_MARK;
sl@0: 	
sl@0: 	DestroyTestEnv();
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: 	}