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 <stdlib.h>
sl@0: #include <bautils.h>
sl@0: #include <hal.h>
sl@0: #include <sqldb.h>
sl@0: #include "sqlite3.h"
sl@0: #include "SqliteSymbian.h"
sl@0: #include "SqlResourceTester.h"
sl@0: 
sl@0: //In order to be able to compile the test, the following variables are defined (used inside the OS porting layer, 
sl@0: //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: /// This test works only if the whole SQL component is built with SYSLIBS_TEST macro defined! ///
sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: RTest TheTest(_L("t_sqldbconfigfile test"));
sl@0: 
sl@0: #ifdef SYSLIBS_TEST	
sl@0: 
sl@0: extern TBool IsStatementSupported(const TDesC& aStatementIn, const TDesC& aDbName, TDes& aStatementOut);
sl@0: 
sl@0: RFs TheFs;
sl@0: RSqlDatabase TheDb;
sl@0: sqlite3 *TheDbHandle = NULL;
sl@0: 
sl@0: _LIT(KCfgDb1, "c:[1111C1C1]a.db"); // shared, secure db
sl@0: _LIT(KCfgDb2, "c:[1111C1C1]b.db"); // shared, secure db (no config file for it)
sl@0: _LIT(KCfgDb3, "c:\\private\\1111C1C1\\c.db"); // private, secure db
sl@0: _LIT(KCfgDb4, "c:\\test\\d.db"); // public db
sl@0: _LIT(KCfgDb5, "c:[1111C1C1]e.db"); // shared, secure db (config file created before db is created)
sl@0: 
sl@0: _LIT(KCfgDb1ConfigFilePath, "c:\\private\\10281e17\\cfg[1111C1C1]a.db.0%d"); // config file version %d for a.db
sl@0: _LIT(KCfgDb3ConfigFileV01Path, "c:\\private\\10281e17\\cfgc.db.01"); // config file v01 for c.db (unsupported)
sl@0: _LIT(KCfgDb4ConfigFileV01Path, "c:\\private\\10281e17\\cfgd.db.01"); // config file v01 for d.db (unsupported)
sl@0: _LIT(KCfgDb5ConfigFileV01Path, "c:\\private\\10281e17\\cfg[1111C1C1]e.db.01"); // config file v01 for e.db
sl@0: _LIT(KCfgDb1CorruptConfigFilePath, "c:\\private\\10281e17\\cfg[1111C1C1]a.db.invalidextension"); // invalid config file name syntax
sl@0: 
sl@0: // config file valid contents (used for v02 and others)
sl@0: _LIT8(KCfgConfigFileValidStmt, "CREATE INDEX newIdx ON table1(i3)  ;"); 
sl@0: // config file v03 empty contents
sl@0: _LIT8(KCfgDb1ConfigFileV03EmptyStmt, ""); 
sl@0: // config file v04 unsupported contents
sl@0: _LIT8(KCfgDb1ConfigFileV04UnsupportedStmt, "DELETE FROM table1"); 
sl@0: // config file v05 only whitespace contents
sl@0: _LIT8(KCfgDb1ConfigFileV05OnlyWhitespaceStmt, " \r\n   \r\n"); 
sl@0: // config file v06 invalid schema contents
sl@0: _LIT8(KCfgDb1ConfigFileV06InvalidSchemaStmt, "CREATE INDEX thisIdx ON table999(i3)"); 
sl@0: // config file v07 unsupported comment style
sl@0: _LIT8(KCfgDb1ConfigFileV07InvalidCommentedStmt, "CREATE INDEX ind1 ON table1(i2) // create an index"); 
sl@0: // config file v08 sequence of different statements
sl@0: _LIT8(KCfgDb1ConfigFileV08SeqStmt, ";  CREATE INDEX IdxFirst ON table1(i3)\r\n;  DELETE FROM table1;INSERT INTO table1 (i1,i2,i3) values(6,7,8);;CREATE INDEX IdxSecond ON table1(i1);");
sl@0: // config file v09 whitespace before and after statement
sl@0: _LIT8(KCfgDb1ConfigFileV09WhitespacePreAndPostStmt, "  CREATE INDEX intIdx ON table1(i1)       "); 
sl@0: // config file v10 valid contents
sl@0: _LIT8(KCfgDb1ConfigFileV10ValidStmt, "CREATE INDEX i3Index ON table1(i3)\n"); 
sl@0: // config file v11 valid contents (also tests that any amount spaces and tabs are allowed between 'CREATE' and 'INDEX')
sl@0: _LIT8(KCfgDb1ConfigFileV11ValidStmt, "CREATE     INDEX i1Index ON table1(i1);\nCREATE	INDEX i2Index ON table1(i2)");
sl@0: // config file v12 invalid stmt plus valid stmt
sl@0: _LIT8(KCfgDb1ConfigFileV12InvalidPlusValidStmt, "CREATE UNIQUE INDEX uniqueIdx ON table1(i1);CREATE INDEX v12Idx ON table1(i2)");
sl@0: // config file v13 supported SQL comment style
sl@0: _LIT8(KCfgDb1ConfigFileV13SQLCommentStmt, "CREATE INDEX v13Idx ON table1(i1) -- this is an SQL comment");
sl@0: // config file v14 supported 'C' comment style
sl@0: _LIT8(KCfgDb1ConfigFileV14CCommentStmt, "CREATE INDEX v14Idx ON table1(i3) /* this is a C comment */;");
sl@0: 
sl@0: //KLongDbName1 is "long" enough to allow "-journal" to be added at the end.
sl@0: //Also, on simulators/emulators the file names have a prefix with length of about 30 characters
sl@0: //(something like \epoc\winscw\c\....)
sl@0: _LIT(KLongDbName1,  "c:[1111C1C1]a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a.db");
sl@0: _LIT(KLongCfgName1, "c:\\private\\10281e17\\cfg[1111C1C1]a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a.db.01");
sl@0: 
sl@0: _LIT(KSqlSrvPrivatePath, "\\private\\10281e17\\");
sl@0: _LIT(KResetCollationDllSql, "UPDATE symbian_settings SET CollationDllName='hjagafsff'");
sl@0: 
sl@0: _LIT(KAttachDb1, "Db1");
sl@0: _LIT(KAttachDb2, "Db2");
sl@0: _LIT(KAttachDb5, "Db5");
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: // Destroy functions
sl@0: 
sl@0: void KillSqlServer()
sl@0: 	{
sl@0: 	_LIT(KSqlSrvName, "sqlsrv.exe");
sl@0: 	TFullName name;
sl@0: 	//RDebug::Print(_L("Find and kill \"%S\" process.\n"), &aProcessName);
sl@0: 	TBuf<64> pattern(KSqlSrvName);
sl@0: 	TInt length = pattern.Length();
sl@0: 	pattern += _L("*");
sl@0: 	TFindProcess procFinder(pattern);
sl@0: 
sl@0: 	while (procFinder.Next(name) == KErrNone)
sl@0: 		{
sl@0: 		if (name.Length() > length)
sl@0: 			{//If found name is a string containing aProcessName string.
sl@0: 			TChar c(name[length]);
sl@0: 			if (c.IsAlphaDigit() ||
sl@0: 				c == TChar('_') ||
sl@0: 				c == TChar('-'))
sl@0: 				{
sl@0: 				// If the found name is other valid application name
sl@0: 				// starting with aProcessName string.
sl@0: 				//RDebug::Print(_L(":: Process name: \"%S\".\n"), &name);
sl@0: 				continue;
sl@0: 				}
sl@0: 			}
sl@0: 		RProcess proc;
sl@0: 		if (proc.Open(name) == KErrNone)
sl@0: 			{
sl@0: 			proc.Kill(0);
sl@0: 			//RDebug::Print(_L("\"%S\" process killed.\n"), &name);
sl@0: 			}
sl@0: 		proc.Close();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void DeleteCfgFilesAndDbs()
sl@0: 	{
sl@0:  	(void)RSqlDatabase::Delete(KLongDbName1);
sl@0:  	(void)RSqlDatabase::Delete(KCfgDb1);
sl@0:  	(void)RSqlDatabase::Delete(KCfgDb2);	
sl@0:  	(void)RSqlDatabase::Delete(KCfgDb3);
sl@0:  	(void)RSqlDatabase::Delete(KCfgDb4);
sl@0:  	(void)RSqlDatabase::Delete(KCfgDb5);
sl@0:  	(void)TheFs.Delete(KLongCfgName1);
sl@0:  	(void)TheFs.Delete(KCfgDb3ConfigFileV01Path);
sl@0:  	(void)TheFs.Delete(KCfgDb4ConfigFileV01Path);
sl@0:  	(void)TheFs.Delete(KCfgDb5ConfigFileV01Path);
sl@0:  	CFileMan* fileMan = 0;	
sl@0:  	TRAPD(err, fileMan = CFileMan::NewL(TheFs));
sl@0:  	if(KErrNone == err)
sl@0:  		{
sl@0:  		(void)fileMan->Delete(_L("c:\\private\\10281e17\\cfg[1111C1C1]a.db.*"));
sl@0: 		delete fileMan;			
sl@0:  		}
sl@0:   	}
sl@0: 
sl@0: void DestroyTestEnv()
sl@0: 	{
sl@0: 	if(TheDbHandle)
sl@0: 		{
sl@0: 		sqlite3_close(TheDbHandle);	
sl@0: 		TheDbHandle = NULL;
sl@0: 		}
sl@0: 	TheDb.Close();
sl@0: 	KillSqlServer();
sl@0: 	DeleteCfgFilesAndDbs();
sl@0: 	TheFs.Close();
sl@0: 	}
sl@0: 	
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: // Test macros and functions
sl@0: 
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: 		TheTest.Printf(_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: // OOM test functions
sl@0: 
sl@0: static TInt TheHandleCount1;
sl@0: static TInt TheHandleCount2;
sl@0: static TInt TheAllocatedCellsCount;
sl@0: 
sl@0: void MarkHandles()
sl@0: 	{
sl@0: 	RThread().HandleCount(TheHandleCount1, TheHandleCount2);
sl@0: 	}
sl@0: 
sl@0: void CheckHandles()
sl@0: 	{
sl@0: 	TInt endHandleCount1;
sl@0: 	TInt endHandleCount2;
sl@0: 
sl@0: 	RThread().HandleCount(endHandleCount1, endHandleCount2);
sl@0: 
sl@0: 	TEST2(TheHandleCount1, endHandleCount1);
sl@0: 	TEST2(TheHandleCount2, endHandleCount2);
sl@0: 	}
sl@0: 
sl@0: void MarkAllocatedCells()
sl@0: 	{
sl@0: 	TheAllocatedCellsCount = User::CountAllocCells();
sl@0: 	}
sl@0: 
sl@0: void CheckAllocatedCells()
sl@0: 	{
sl@0: 	TInt allocatedCellsCount = User::CountAllocCells();
sl@0: 	TEST2(allocatedCellsCount, TheAllocatedCellsCount);
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: // Set up functions
sl@0: 
sl@0: RSqlSecurityPolicy CreateSecurityPolicy()
sl@0: 	{
sl@0: 	const TSecurityPolicy KDefaultPolicy(TSecurityPolicy::EAlwaysPass);
sl@0: 	RSqlSecurityPolicy policy;
sl@0: 	TInt err = policy.Create(KDefaultPolicy);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = policy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, KDefaultPolicy);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = policy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, KDefaultPolicy);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = policy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, KDefaultPolicy);
sl@0:     TEST2(err, KErrNone);
sl@0:     return policy;
sl@0: 	}
sl@0: 	
sl@0: void DoCreateCfgFile(const TDesC& aFileName, const TDesC8& aData)
sl@0:     {
sl@0:     RFile file;
sl@0:     TInt err = file.Create(TheFs, aFileName, EFileRead | EFileWrite);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = file.Write(aData); 
sl@0:     file.Close();   
sl@0:     TEST2(err, KErrNone);
sl@0:     }
sl@0: 
sl@0: // Create v01 of the test config files
sl@0: void CreateCfgFiles()
sl@0: 	{
sl@0: 	TFileName fileName;
sl@0: 	TInt v1 = 1;
sl@0: 	fileName.Format(KCfgDb1ConfigFilePath, v1);
sl@0: 
sl@0: 	// config file v01 contents for db1 (also tests that upper and lower case statements are both supported)
sl@0: 	_LIT8(KCfgDb1ConfigFile01Stmts, "CREATE INDEX idx ON table1(i1);CREATE INDEX idx2 ON table1(i2);INSERT INTO table1 (i1,i2,i3) values(5,8,9);DELETE FROM table1;create index multiidx ON TABLE1(i2,i3)");
sl@0:     DoCreateCfgFile(fileName, KCfgDb1ConfigFile01Stmts);
sl@0:     
sl@0:     // config file v01 contents for db3 (will not be processed as db3 is not a shared, secure db)
sl@0:     _LIT8(KCfgDb3ConfigFile01Stmts, "CREATE INDEX idx ON table3(i1)");
sl@0:     DoCreateCfgFile(KCfgDb3ConfigFileV01Path, KCfgDb3ConfigFile01Stmts);
sl@0:     
sl@0:     // config file v01 contents for db4 (will not be processed as db4 is not a shared, secure db)
sl@0:     _LIT8(KCfgDb4ConfigFile01Stmts, "CREATE INDEX idx ON table4(i1)");
sl@0:     DoCreateCfgFile(KCfgDb4ConfigFileV01Path, KCfgDb4ConfigFile01Stmts);
sl@0:     
sl@0:     // create the config file for Db5 before the database has been created
sl@0:     // config file v01 contents for db5 (will eventually be processed after db5 itself is created)
sl@0:     _LIT8(KCfgDb5ConfigFile01Stmts, "CREATE INDEX idx ON table5(i1);\r\n");
sl@0:     DoCreateCfgFile(KCfgDb5ConfigFileV01Path, KCfgDb5ConfigFile01Stmts);
sl@0: 	}
sl@0: 
sl@0: void DoCreateCfgDb(const TDesC& aFileName, const TDesC& aCreateTblSql, const TDesC& aInsertSql, 
sl@0:                    RSqlSecurityPolicy* aPolicy = NULL)
sl@0:     {
sl@0:     TInt err = aPolicy ? TheDb.Create(aFileName, *aPolicy) : TheDb.Create(aFileName);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = TheDb.Exec(aCreateTblSql);
sl@0:     TEST(err >= 0);
sl@0:     err = TheDb.Exec(aInsertSql);
sl@0:     TEST(err == 1);
sl@0:     TheDb.Close();
sl@0:     }
sl@0: 
sl@0: // Create the test databases
sl@0: void CreateCfgDbs()
sl@0: 	{
sl@0:     RSqlSecurityPolicy securityPolicy = CreateSecurityPolicy();
sl@0:     DoCreateCfgDb(KCfgDb1, _L("CREATE TABLE table1(i1 INTEGER, i2 INTEGER, i3 INTEGER)"),
sl@0:                            _L("INSERT INTO table1 (i1,i2,i3) values(1,2,3)"), &securityPolicy);
sl@0:     DoCreateCfgDb(KCfgDb2, _L("CREATE TABLE table2(i1 INTEGER, i2 INTEGER, i3 INTEGER)"),
sl@0:                            _L("INSERT INTO table2 (i1,i2,i3) values(4,5,6)"), &securityPolicy);
sl@0:     securityPolicy.Close();
sl@0:     DoCreateCfgDb(KCfgDb3, _L("CREATE TABLE table3(i1 INTEGER, i2 INTEGER)"),
sl@0:                            _L("INSERT INTO table3 (i1,i2) values(7,8)"));
sl@0:     DoCreateCfgDb(KCfgDb4, _L("CREATE TABLE table4(i1 INTEGER, i2 INTEGER, i3 INTEGER)"),
sl@0:                            _L("INSERT INTO table4 (i1,i2,i3) values(9,10,11)"));
sl@0:  	}
sl@0: 
sl@0: void CreateCfgFilesAndDbs()
sl@0: 	{
sl@0: 	CreateCfgFiles();
sl@0: 	CreateCfgDbs();
sl@0: 	
sl@0: 	// Must now kill the SQL Server so that the config files 
sl@0: 	// created above are found and processed when it restarts
sl@0: 	KillSqlServer();
sl@0:  	}
sl@0:  	
sl@0: // Create the Db5 test database (a config file for it already exists)
sl@0:  void CreateDb5()
sl@0: 	{
sl@0:  	RSqlSecurityPolicy securityPolicy = CreateSecurityPolicy();
sl@0:     DoCreateCfgDb(KCfgDb5, _L("CREATE TABLE table5(i1 INTEGER, i2 INTEGER, i3 INTEGER)"),
sl@0:                            _L("INSERT INTO table5 (i1,i2,i3) values(1,2,3)"), &securityPolicy);
sl@0:  	securityPolicy.Close();
sl@0: 	}
sl@0: 
sl@0: void SetupTestEnv()
sl@0:     {
sl@0: 	TInt err = TheFs.Connect();
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	_LIT(KTestDir, "c:\\test\\");
sl@0: 	err = TheFs.MkDir(KTestDir);
sl@0: 	TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0: 
sl@0: 	err = TheFs.CreatePrivatePath(EDriveC);
sl@0: 	TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0: 
sl@0: 	// Create the cfg dbs and config files
sl@0:  	DeleteCfgFilesAndDbs(); // just incase any previous files are lingering
sl@0:  	CreateCfgFilesAndDbs();
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: //
sl@0: TInt CalcTimeMs(TUint32 aStartTicks, TUint32 aEndTicks)
sl@0: 	{
sl@0: 	static TInt freq = 0;
sl@0: 	if(freq == 0)
sl@0: 		{
sl@0: 		TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone);
sl@0: 		}
sl@0: 	TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;
sl@0: 	if(diffTicks < 0)
sl@0: 		{
sl@0: 		diffTicks = KMaxTUint32 + diffTicks + 1;
sl@0: 		}
sl@0: 	const TInt KMicroSecIn1Sec = 1000000;
sl@0: 	TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;
sl@0: 	return us / 1000;
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: // Config file replacement functions
sl@0: 
sl@0: void UpgradeDbConfigFile(TInt aCurrentVersion)
sl@0: 	{
sl@0:     TInt newVersion = aCurrentVersion + 1;
sl@0:     TEST(newVersion != 0 && newVersion != 1 && newVersion != 10 && newVersion != 11 && newVersion < 15);
sl@0: 	
sl@0:     KillSqlServer();
sl@0: 		
sl@0: 	TFileName fname;
sl@0: 	fname.Format(KCfgDb1ConfigFilePath, aCurrentVersion);
sl@0: 	TInt err = TheFs.Delete(fname);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	
sl@0: 	if(newVersion == 12)
sl@0: 	    {
sl@0:         // also delete version 10 of file
sl@0: 	    fname.Format(KCfgDb1ConfigFilePath, 10);
sl@0:         err = TheFs.Delete(fname);
sl@0:         TEST2(err, KErrNone);   
sl@0: 	    }
sl@0: 
sl@0: 	const TPtrC8 stmts[] = {KNullDesC8(), KNullDesC8(), 
sl@0: 	        KCfgConfigFileValidStmt(), 
sl@0: 	        KCfgDb1ConfigFileV03EmptyStmt(),
sl@0: 	        KCfgDb1ConfigFileV04UnsupportedStmt(),
sl@0: 	        KCfgDb1ConfigFileV05OnlyWhitespaceStmt(),
sl@0: 	        KCfgDb1ConfigFileV06InvalidSchemaStmt(),
sl@0: 	        KCfgDb1ConfigFileV07InvalidCommentedStmt(),
sl@0: 	        KCfgDb1ConfigFileV08SeqStmt(),
sl@0: 	        KCfgDb1ConfigFileV09WhitespacePreAndPostStmt(),
sl@0: 	        KNullDesC8(), KNullDesC8(),
sl@0: 	        KCfgDb1ConfigFileV12InvalidPlusValidStmt(),
sl@0: 	        KCfgDb1ConfigFileV13SQLCommentStmt(),
sl@0: 	        KCfgDb1ConfigFileV14CCommentStmt()};
sl@0: 
sl@0:     fname.Format(KCfgDb1ConfigFilePath, newVersion);
sl@0: 	DoCreateCfgFile(fname, stmts[newVersion]);
sl@0: 	}	
sl@0: 	
sl@0: void DowngradeDbConfigFile(TInt aCurrentVersion)
sl@0: 	{
sl@0: 	TEST(aCurrentVersion > 1);
sl@0: 	
sl@0: 	KillSqlServer();
sl@0: 	
sl@0: 	TFileName fname;
sl@0: 	fname.Format(KCfgDb1ConfigFilePath, aCurrentVersion);
sl@0: 	TInt err = TheFs.Delete(fname);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	
sl@0:     fname.Format(KCfgDb1ConfigFilePath, aCurrentVersion - 1);
sl@0:     DoCreateCfgFile(fname, KCfgConfigFileValidStmt);
sl@0: 	}
sl@0: 	
sl@0: void CreateCorruptDbConfigFile(TInt aCurrentVersion)
sl@0: 	{
sl@0: 	KillSqlServer();
sl@0: 	
sl@0: 	TFileName fname;
sl@0: 	fname.Format(KCfgDb1ConfigFilePath, aCurrentVersion);
sl@0: 	TInt err = TheFs.Delete(fname);
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0:     DoCreateCfgFile(KCfgDb1CorruptConfigFilePath, KCfgConfigFileValidStmt);
sl@0: 	}	
sl@0: 	
sl@0: void CreateTwoVersionsOfConfigFile()
sl@0: 	{
sl@0: 	KillSqlServer();
sl@0: 	
sl@0: 	TInt err = TheFs.Delete(KCfgDb1CorruptConfigFilePath);
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0:     TInt nextVersion = 10;
sl@0:     TFileName fname;
sl@0:     fname.Format(KCfgDb1ConfigFilePath, nextVersion);
sl@0:     DoCreateCfgFile(fname, KCfgDb1ConfigFileV10ValidStmt);
sl@0: 	
sl@0: 	++nextVersion;
sl@0:     fname.Format(KCfgDb1ConfigFilePath, nextVersion);
sl@0:     DoCreateCfgFile(fname, KCfgDb1ConfigFileV11ValidStmt);
sl@0: 	}
sl@0:  
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: // DoDbCfgTests() functions
sl@0: 
sl@0: TInt GetDbCfgVersion(const TDesC& aDbName)
sl@0:     {
sl@0:     // Note: We have to use SQLite directly to access the settings
sl@0:     // table as the SQL Server denies permission to access this table
sl@0:     // as it is in a shared, secure database
sl@0:     
sl@0:     TParse parse;
sl@0:     TInt err = parse.Set(aDbName, &KSqlSrvPrivatePath, 0);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     TBuf8<KMaxFileName + 1> dbFileName;
sl@0:     dbFileName.Copy(parse.FullName());
sl@0:     
sl@0:     sqlite3 *dbHandle = NULL;
sl@0:     TInt rc = sqlite3_open((const char*)dbFileName.PtrZ(), &dbHandle);
sl@0:     TEST2(rc, SQLITE_OK);
sl@0:     
sl@0:     _LIT(KGetDbCfgVersionSql, "SELECT Reserved AS DbCfgVersion FROM symbian_settings");
sl@0:     TBuf<100> queryBuf;
sl@0:     queryBuf.Copy(KGetDbCfgVersionSql);
sl@0:     
sl@0:     sqlite3_stmt* stmtHandle = NULL;
sl@0:     const void* stmtTailZ = NULL;
sl@0:     rc = sqlite3_prepare16_v2(dbHandle, queryBuf.PtrZ(), -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:     
sl@0:     TInt version = sqlite3_column_int(stmtHandle, 0);
sl@0:     
sl@0:     rc = sqlite3_step(stmtHandle);
sl@0:     TEST2(rc, SQLITE_DONE);
sl@0:     
sl@0:     sqlite3_finalize(stmtHandle);
sl@0:     sqlite3_close(dbHandle);
sl@0:     
sl@0:     return version;
sl@0:     }
sl@0: 
sl@0: TBool GuessSystemSettingsTable(const TDesC& aDbName, TInt aVersion)
sl@0: 	{
sl@0: 	TInt dbCfgVersion = GetDbCfgVersion(aDbName);
sl@0: 	return dbCfgVersion == aVersion; 
sl@0: 	}
sl@0: 
sl@0: void CheckSystemSettingsTable(const TDesC& aDbName, TInt aVersion)
sl@0: 	{
sl@0:     TInt dbCfgVersion = GetDbCfgVersion(aDbName);
sl@0:     TEST2(dbCfgVersion, aVersion); 
sl@0: 	}
sl@0: 
sl@0: void CheckRecordCount(const TDesC& aTable)
sl@0: 	{
sl@0: 	// There should always be only 1 record in the table
sl@0: 	// in each database as INSERT and DELETE statements are
sl@0: 	// not supported in the config files
sl@0: 	TBuf<50> sql;
sl@0: 	sql.Format(_L("SELECT COUNT(*) FROM %S"), &aTable);
sl@0: 	TSqlScalarFullSelectQuery q(TheDb);
sl@0: 	TInt count = 0;
sl@0:     TRAPD(err, count = q.SelectIntL(sql));
sl@0:     TEST2(err, KErrNone);
sl@0:     TEST2(count, 1);
sl@0: 	}
sl@0: 	
sl@0: TInt ExpectedDb1IndexCount(TInt aExpectedStoredVersion)
sl@0: 	{
sl@0: 	TEST(aExpectedStoredVersion >= 0 && aExpectedStoredVersion < 15);
sl@0: 	const TInt KIdxCnt[] = {
sl@0: 	       -1, 
sl@0: 	        3,             // Only files 01 - 04, 09 and 11 will be successfully processed and so stored in the settings table
sl@0: 	        4,             // 1 more index should be added to db1 based on config file 02
sl@0: 	        4, 4, 4, 4, 4, // no more indices should be added to db1 based on config file 03 - 07 
sl@0: 	        6,             // 2 more indices should be added to db1 based on config file 08 
sl@0: 	        7,             // 1 more index should be added to db1 based on config file 09 
sl@0: 	        -1, 
sl@0: 	        9,             // 2 more indices should be added to db1 based on config file 11 
sl@0: 	        10,            // 1 more index should be added to db1 based on config file 12
sl@0: 	        11,            // 1 more index should be added to db1 based on config file 13
sl@0: 	        12};           // 1 more index should be added to db1 based on config file 14
sl@0: 	return KIdxCnt[aExpectedStoredVersion];
sl@0: 	}
sl@0: 
sl@0: void CheckIndexCount(TInt aExpectedIndexCount)
sl@0: 	{
sl@0: 	_LIT(KDbCheckNumIndices, "SELECT COUNT(*) FROM sqlite_master WHERE type = 'index'");
sl@0:     TSqlScalarFullSelectQuery q(TheDb);
sl@0:     TInt count = 0;
sl@0:     TRAPD(err, count = q.SelectIntL(KDbCheckNumIndices));
sl@0:     TEST2(err, KErrNone);
sl@0:     TEST2(count, aExpectedIndexCount);
sl@0: 	}
sl@0: 
sl@0: void DoCfgOpenTest(TInt aExpectedStoredVersion, const TDesC& aDbFileName, const TDesC& aTblName, TInt aExpectedIndexCnt)
sl@0:     {
sl@0:     TInt err = TheDb.Open(aDbFileName);
sl@0:     TEST2(err, KErrNone);
sl@0:     CheckRecordCount(aTblName);
sl@0:     CheckIndexCount(aExpectedIndexCnt);
sl@0:     TheDb.Close();
sl@0:     // Check that the ops in the specified config file have been applied.
sl@0:     CheckSystemSettingsTable(aDbFileName, aExpectedStoredVersion);
sl@0:     }
sl@0: 
sl@0: void DoCfgOpenTests(TInt aExpectedStoredVersion)
sl@0: 	{	
sl@0: 	// Open a shared, secure database - config ops should be applied on it.
sl@0:     // There should still be only 1 record and 3 indices in the table.
sl@0: 	TheTest.Printf(_L("===CfgOpen: Open shared, secure database\r\n"));
sl@0: 	DoCfgOpenTest(aExpectedStoredVersion, KCfgDb1, _L("table1"), ExpectedDb1IndexCount(aExpectedStoredVersion));
sl@0: 		
sl@0: 	// Open again the same shared, secure database - no config should occur (it has already been done).
sl@0: 	TheTest.Printf(_L("===CfgOpen: Open shared, secure database again\r\n"));
sl@0:     DoCfgOpenTest(aExpectedStoredVersion, KCfgDb1, _L("table1"), ExpectedDb1IndexCount(aExpectedStoredVersion));
sl@0: 	
sl@0: 	// Open a shared, secure database - no config should occur (there is no config file for this database)
sl@0: 	TheTest.Printf(_L("===CfgOpen: Open shared, secure database (that has no config file)\r\n"));
sl@0:     DoCfgOpenTest(0, KCfgDb2, _L("table2"), 0);
sl@0: 	
sl@0: 	// Open a private, secure database - no config should occur
sl@0: 	TheTest.Printf(_L("===CfgOpen: Open private, secure database\r\n"));
sl@0:     DoCfgOpenTest(0, KCfgDb3, _L("table3"), 0);
sl@0: 	
sl@0: 	// Open a public database - no config should occur
sl@0: 	TheTest.Printf(_L("===CfgOpen: Open public database\r\n"));
sl@0:     DoCfgOpenTest(0, KCfgDb4, _L("table4"), 0);
sl@0: 	}
sl@0: 	
sl@0: void DoUpgradedCfgOpenTest()
sl@0: 	{
sl@0: 	// Upgrade the config file for KCfgDb1, i.e. replace v1 file with v2 file
sl@0: 	UpgradeDbConfigFile(1);
sl@0: 	DoCfgOpenTests(2);	
sl@0: 	}
sl@0: 
sl@0: void DoBadCfgOpenTests()
sl@0: 	{
sl@0: 	// Test an empty config file
sl@0: 	UpgradeDbConfigFile(2); // the current file version is 02, replace it with 03
sl@0: 	DoCfgOpenTests(3); // version 03 will be successfully processed and stored in the settings table
sl@0: 	
sl@0: 	// Test a config file with unsupported operations (these will be ignored)
sl@0: 	UpgradeDbConfigFile(3); // the current file version is 03, replace it with 04
sl@0: 	DoCfgOpenTests(4); // version 04 will be successfully processed (the unsupported operations are ignored) and stored in the settings table
sl@0: 
sl@0: 	// Test a config file with only whitespace in it
sl@0: 	UpgradeDbConfigFile(4); // the current file version is 04, replace it with 05
sl@0: 	DoCfgOpenTests(5); // version 05 will be successfully processed (the whitespace is ignored) and stored in the settings table
sl@0: 
sl@0: 	// Test a config file with operations on an invalid table
sl@0: 	UpgradeDbConfigFile(5); // the current file version is 05, replace it with 06
sl@0: 	DoCfgOpenTests(6); // version 06 will be successfully processed (the failed-to-execute operation will be ignored) and stored in the settings table
sl@0: 
sl@0: 	// Test a config file that contains an invalid comment style
sl@0: 	UpgradeDbConfigFile(6); // the current file version is 06, replace it with 07
sl@0: 	DoCfgOpenTests(7); // version 07 will be successfully processed (the line with invalid comment syntax will be ignored) and stored in the settings table
sl@0: 
sl@0: 	// Test a config file that contains a sequence of statements as one statement (this is currently unsupported)
sl@0: 	UpgradeDbConfigFile(7); // the current file version is 07, replace it with 08
sl@0: 	DoCfgOpenTests(8); // version 08 will be successfully processed (the line with a sequence of statements is ignored) and stored in the settings table	
sl@0: 
sl@0: 	// Test a config file that contains whitespace before and after the SQL statement
sl@0: 	UpgradeDbConfigFile(8); // the current file version is 08, replace it with 09
sl@0: 	DoCfgOpenTests(9); // version 09 will be successfully processed and stored in the settings table	
sl@0: 
sl@0: 	// Test a config file that has a lower extension number
sl@0: 	DowngradeDbConfigFile(9); // the current file version is 09, replace it with 08
sl@0: 	DoCfgOpenTests(9); // version 08 will NOT be processed (as it is a lower version than that stored), and 09 will remain stored in the settings table
sl@0: 
sl@0: 	// Test a config file that has an invalid extension
sl@0: 	CreateCorruptDbConfigFile(8); // the current file version is 08, replace it with a file with an invalid extension
sl@0: 	DoCfgOpenTests(9); // the invalid file will NOT be processed, and 09 will remain stored in the settings table			
sl@0: 	
sl@0: 	// Test two versions of the config file (two versions should not be present at the same time)
sl@0: 	CreateTwoVersionsOfConfigFile(); // the current file has an invalid extension, delete it and create version 10 and version 11
sl@0: 	DoCfgOpenTests(11); // only version 11 will be processed (as it is the highest version), and 11 will be stored in the settings table
sl@0: 	
sl@0: 	// Test a config file that contains an invalid statement and a valid statement
sl@0: 	UpgradeDbConfigFile(11); // the current file versions are 10 and 11, replace them with 12
sl@0: 	DoCfgOpenTests(12); // version 12 will be successfully processed (the invalid statement will be ignored and the valid statement executed) and stored in the settings table
sl@0: 	
sl@0: 	// Test a config file that contains a SQL style comment
sl@0: 	UpgradeDbConfigFile(12); // the current file version is 12, replace it with 13
sl@0: 	DoCfgOpenTests(13); // version 13 will be successfully processed (the SQL style comment will be ignored) and stored in the settings table
sl@0: 	
sl@0: 	// Test a config file that contains a 'C' style comment
sl@0: 	UpgradeDbConfigFile(13); // the current file version is 13, replace it with 14
sl@0: 	DoCfgOpenTests(14); // version 14 will be successfully processed (the 'C' style comment will be ignored) and stored in the settings table
sl@0: 	}
sl@0: 		
sl@0: void DoNewDbCfgOpenTest()
sl@0: 	{
sl@0: 	// Create Db5 - a config file already exists for this database
sl@0: 	CreateDb5();
sl@0: 	
sl@0: 	// Open the shared, secure database Db5 - config ops should be applied on it.
sl@0: 	// There should now be 1 index in the table.
sl@0: 	TheTest.Printf(_L("===NewDbCfg: Open shared, secure database\r\n"));
sl@0:     DoCfgOpenTest(1, KCfgDb5, _L("table5"), 1);
sl@0: 		
sl@0: 	// Open again the same shared, secure database - no config should occur (it has already been done)
sl@0: 	TheTest.Printf(_L("===NewDbCfg: Open shared, secure database again\r\n"));
sl@0:     DoCfgOpenTest(1, KCfgDb5, _L("table5"), 1);
sl@0: 	}
sl@0: 	
sl@0: void DoCfgAttachTests(TInt aExpectedStoredVersion = 0)
sl@0: 	{			
sl@0: 	// Open a private, secure database - no config should occur
sl@0: 	TheTest.Printf(_L("===CfgAttach: Open private, secure database\r\n"));
sl@0: 	TInt err = TheDb.Open(KCfgDb3);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	// Attach a shared, secure database - the db1 config file should not be processed
sl@0: 	TheTest.Printf(_L("===CfgAttach: Attach shared, secure database\r\n"));
sl@0: 	err = TheDb.Attach(KCfgDb1, KAttachDb1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	CheckSystemSettingsTable(KCfgDb1, aExpectedStoredVersion); // check that the config file has not been processed for db1
sl@0: 	CheckSystemSettingsTable(KCfgDb3, 0);
sl@0: 	
sl@0: 	// Open a public database - no config should occur
sl@0: 	TheTest.Printf(_L("===CfgAttach: Open public database\r\n"));
sl@0:     err = TheDb.Open(KCfgDb4);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	// Attach a shared, secure database - no config should occur (there is no config file for this database)
sl@0: 	TheTest.Printf(_L("===CfgAttach: Attach shared, secure database (that has no config file)\r\n"));
sl@0: 	err = TheDb.Attach(KCfgDb2, KAttachDb2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	CheckSystemSettingsTable(KCfgDb2, 0);
sl@0: 	CheckSystemSettingsTable(KCfgDb4, 0);
sl@0: 	}
sl@0: 	
sl@0: void DoUpgradedCfgAttachTest()
sl@0: 	{
sl@0: 	// Upgrade the config file for KCfgDb1, i.e. replace v1 file with v2 file
sl@0: 	UpgradeDbConfigFile(1);	
sl@0: 	DoCfgAttachTests(2);
sl@0: 	}
sl@0: 	
sl@0: void DoBadCfgAttachTests()
sl@0: 	{
sl@0: 	// Test an empty config file
sl@0: 	UpgradeDbConfigFile(2); // the current file version is 02, replace it with 03
sl@0: 	DoCfgAttachTests(3); // version 03 will not be processed so no update to settings table
sl@0: 	
sl@0: 	// Test a config file with unsupported operations
sl@0: 	UpgradeDbConfigFile(3); // the current file version is 03, replace it with 04
sl@0: 	DoCfgAttachTests(4); // version 04 will not be processed so no update to settings table
sl@0: 	
sl@0: 	// Test a config file with only whitespace in it
sl@0: 	UpgradeDbConfigFile(4); // the current file version is 04, replace it with 05
sl@0: 	DoCfgAttachTests(5); // version 05 will not be processed so no update to settings table
sl@0: 	
sl@0: 	// Test a config file with operations on an invalid table
sl@0: 	UpgradeDbConfigFile(5); // the current file version is 05, replace it with 06
sl@0: 	DoCfgAttachTests(6); // version 06 will not be processed so no update to settings table
sl@0: 	
sl@0: 	// Test a config file that contains an invalid comment style
sl@0: 	UpgradeDbConfigFile(6); // the current file version is 06, replace it with 07
sl@0: 	DoCfgAttachTests(7); // version 07 will not be processed so no update to settings table
sl@0: 	
sl@0: 	// Test a config file that contains a sequence of statements as one statement (this is currently unsupported)
sl@0: 	UpgradeDbConfigFile(7); // the current file version is 07, replace it with 08
sl@0: 	DoCfgAttachTests(8); // version 08 will not be processed so no update to settings table
sl@0: 	
sl@0: 	// Test a config file that contains whitespace before and after the SQL statement
sl@0: 	UpgradeDbConfigFile(8); // the current file version is 08, replace it with 09
sl@0: 	DoCfgAttachTests(9); // version 09 will not be processed so no update to settings table
sl@0: 	
sl@0: 	// Test a config file that has a lower extension number
sl@0: 	DowngradeDbConfigFile(9); // the current file version is 09, replace it with 08
sl@0: 	DoCfgAttachTests(9); // version 08 will not be processed so no update to settings table
sl@0: 	
sl@0: 	// Test a config file that has an invalid extension
sl@0: 	CreateCorruptDbConfigFile(8); // the current file version is 08, replace it with a file with an invalid extension
sl@0: 	DoCfgAttachTests(9); // the invalid file will not be processed so no update to settings table
sl@0: 	
sl@0: 	// Test two versions of the config file (two versions should not be present at the same time)
sl@0: 	CreateTwoVersionsOfConfigFile(); // the current file has an invalid extension, delete it and create version 10 and version 11
sl@0: 	DoCfgAttachTests(11); // neither version 10 or 11 will be processed so no update to settings table
sl@0: 		
sl@0: 	// Test a config file that contains an invalid statement and a valid statement
sl@0: 	UpgradeDbConfigFile(11); // the current file versions are 10 and 11, replace them with 12
sl@0: 	DoCfgAttachTests(12); // version 12 will not be processed so no update to settings table
sl@0: 
sl@0: 	// Test a config file that contains a SQL style comment
sl@0: 	UpgradeDbConfigFile(12); // the current file version is 12, replace it with 13
sl@0: 	DoCfgAttachTests(13); // version 13 will not be processed so no update to settings table
sl@0: 	
sl@0: 	// Test a config file that contains a 'C' style comment
sl@0: 	UpgradeDbConfigFile(13); // the current file version is 13, replace it with 14
sl@0: 	DoCfgAttachTests(14); // version 14 will not be processed so no update to settings table
sl@0: 	}
sl@0: 	
sl@0: void DoNewDbCfgAttachTest()
sl@0: 	{
sl@0: 	// Create Db5 - a config file already exists for this
sl@0: 	CreateDb5();
sl@0: 	
sl@0: 	// Open a private, secure database - no config should occur
sl@0: 	TheTest.Printf(_L("===NewDbCfgAttach: Open private, secure database\r\n"));
sl@0: 	TInt err = TheDb.Open(KCfgDb3);
sl@0: 	TEST2(err, KErrNone);
sl@0:     CheckRecordCount(_L("table3"));
sl@0:     CheckIndexCount(0); 
sl@0: 	
sl@0: 	// Attach a shared, secure database - the db5 config file should not be processed
sl@0: 	TheTest.Printf(_L("===NewDbCfgAttach: Attach shared, secure database\r\n"));
sl@0: 	err = TheDb.Attach(KCfgDb5, KAttachDb5);
sl@0: 	TEST2(err, KErrNone);
sl@0:     CheckRecordCount(_L("table5"));
sl@0:     CheckIndexCount(0); // there should still be no indices in the table
sl@0: 	TheDb.Close();
sl@0: 	CheckSystemSettingsTable(KCfgDb5, 1); // check that the config file has been processed for db1
sl@0: 	CheckSystemSettingsTable(KCfgDb3, 0);
sl@0: 	}
sl@0: 	
sl@0: void ResetStoredCollationDll()
sl@0: 	{
sl@0: 	// Note: We have to use SQLite directly to access the settings
sl@0: 	// table as the SQL Server denies permission to access this table	
sl@0: 	// as it is in a shared, secure database
sl@0: 	
sl@0: 	TParse parse;
sl@0: 	parse.Set(KCfgDb1, &KSqlSrvPrivatePath, 0);
sl@0: 	
sl@0: 	TBuf8<KMaxFileName + 1> dbFileName;
sl@0: 	dbFileName.Copy(parse.FullName());
sl@0: 	
sl@0: 	sqlite3 *dbHandle = NULL;
sl@0: 	TInt rc = sqlite3_open((const char*)dbFileName.PtrZ(), &dbHandle);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	
sl@0: 	TBuf<100> queryBuf;
sl@0: 	queryBuf.Append(KResetCollationDllSql());	
sl@0: 	
sl@0: 	sqlite3_stmt* stmtHandle = NULL;
sl@0: 	const void* stmtTailZ = NULL;
sl@0: 	rc = sqlite3_prepare16_v2(dbHandle, queryBuf.PtrZ(), -1, &stmtHandle, &stmtTailZ);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	
sl@0: 	rc = sqlite3_step(stmtHandle);
sl@0: 	TEST2(rc, SQLITE_DONE);
sl@0: 	
sl@0: 	sqlite3_finalize(stmtHandle);
sl@0: 	sqlite3_close(dbHandle);
sl@0: 	}
sl@0: 	
sl@0: void CheckCollationDllUpdated()
sl@0: 	{
sl@0: 	// Note: We have to use SQLite directly to access the settings
sl@0: 	// table as the SQL Server denies permission to access this table
sl@0: 	// as it is in a shared, secure database
sl@0: 	
sl@0: 	TParse parse;
sl@0: 	parse.Set(KCfgDb1, &KSqlSrvPrivatePath, 0);
sl@0: 	
sl@0: 	TBuf8<KMaxFileName + 1> dbFileName;
sl@0: 	dbFileName.Copy(parse.FullName());
sl@0: 	
sl@0: 	sqlite3 *dbHandle = NULL;
sl@0: 	TInt rc = sqlite3_open((const char*)dbFileName.PtrZ(), &dbHandle);
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	
sl@0: 	_LIT(KGetCollationDllSql, "SELECT CollationDllName FROM symbian_settings");
sl@0:     TBuf<100> queryBuf;
sl@0: 	queryBuf.Append(KGetCollationDllSql());	
sl@0: 	
sl@0: 	sqlite3_stmt* stmtHandle = NULL;
sl@0: 	const void* stmtTailZ = NULL;
sl@0: 	rc = sqlite3_prepare16_v2(dbHandle, queryBuf.PtrZ(), -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: 	
sl@0: 	const TUint16* collationDllName = (const TUint16*)sqlite3_column_text16(stmtHandle, 0);
sl@0: 	TInt collationDllNameLen  = sqlite3_column_bytes(stmtHandle, 0) / sizeof(TUint16);
sl@0: 	TPtrC ptr(collationDllName, collationDllNameLen);
sl@0: 	
sl@0: 	rc = sqlite3_step(stmtHandle);
sl@0: 	TEST2(rc, SQLITE_DONE);
sl@0: 	
sl@0: 	sqlite3_finalize(stmtHandle);
sl@0: 	sqlite3_close(dbHandle);
sl@0: 	
sl@0: 	_LIT(KTestCollationDllName, "hjagafsff");//The same as the used in KResetCollationDllSql statement
sl@0: 	TEST(ptr != KTestCollationDllName);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4010
sl@0: @SYMTestCaseDesc		New database configuration files feature - unit test.
sl@0: 						The test opens several test databases, and the database configuration
sl@0: 						file for one of the shared, secure databases is processed. This is
sl@0: 						repeated for a variety of versions of the database configuration file, 
sl@0: 						both valid and invalid. The same tests are repeated for when attaching, 
sl@0: 						rather than opening, the test databases. The test also verifies that
sl@0: 						reindexing occurs if necessary when a database is opened or attached,
sl@0: 						regardless of whether or not database configuration is also required.
sl@0: 						Finally, the test also verifies that a config file that exists before
sl@0: 						the database itself is created will be processed when the database is
sl@0: 						opened for the first time.				
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			New database configuration files feature - unit test.
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMCR 					LMAN-79SJ7L
sl@0: */
sl@0: void DoDbCfgTests()
sl@0: 	{
sl@0: 	// Do 'open' tests for new db config file feature
sl@0: 	DoCfgOpenTests(1);         // open the test databases
sl@0:  	DoUpgradedCfgOpenTest();  // upgrade the config file for db1 and reopen the test databases
sl@0:  	DoBadCfgOpenTests();      // corrupt the config file for db1 (in a variety of ways) and reopen the test databases
sl@0:  	DoNewDbCfgOpenTest();		  // create a db for which a config file already exists and then open the db
sl@0:  
sl@0:  	// Recreate the original dbs and config files
sl@0:  	DeleteCfgFilesAndDbs();
sl@0:  	CreateCfgFilesAndDbs();
sl@0: 
sl@0:  	// Do 'attach' tests for new db config file feature
sl@0: 	DoCfgAttachTests(1);		// attach the test databases
sl@0:  	DoUpgradedCfgAttachTest(); // upgrade the config file for db1 and reattach the test databases
sl@0:  	DoBadCfgAttachTests();     // corrupt the config file for db1 (in a variety of ways) and reattach the test databases	
sl@0:     DoNewDbCfgAttachTest();	   // create a db for which a config file already exists and then attach the db
sl@0: 	
sl@0: 	// Recreate the original dbs and config files
sl@0:  	DeleteCfgFilesAndDbs();
sl@0:  	CreateCfgFilesAndDbs();
sl@0:  	
sl@0:  	// Do the test that causes both reindexing and db configuration to occur when db1 is opened
sl@0: 	ResetStoredCollationDll();
sl@0: 	DoCfgOpenTests(1);
sl@0: 	CheckCollationDllUpdated();
sl@0: 	
sl@0: 	// Recreate the original dbs and config files
sl@0:  	DeleteCfgFilesAndDbs();
sl@0:  	CreateCfgFilesAndDbs();
sl@0:  	
sl@0:  	// Do the test that causes reindexing to occur when db1 is attached (no db configuration occurs for attach)
sl@0: 	ResetStoredCollationDll();
sl@0: 	DoCfgAttachTests(1);
sl@0: 	CheckCollationDllUpdated(); // db1's stored collation dll name should now match db3's (to which Db1 is attached) stored collation name
sl@0: 	}	
sl@0: 		
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4013
sl@0: @SYMTestCaseDesc		New database configuration files feature - OOM test.
sl@0: 						The test opens a shared secure database for which there
sl@0: 						exists a database configuration file that is to be processed.
sl@0: 						The open call is executed within an OOM loop, which causes
sl@0: 						an OOM error to occur at different stages of the open call. 
sl@0: 						The test verifies that OOM errors are handled correctly and 
sl@0: 						that on the final loop - when no OOM errors occur - the database is 
sl@0: 						successfully opened and the database configuration file is processed.	
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			New database configuration files feature - OOM test.
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMCR 					LMAN-79SJ7L
sl@0: */
sl@0: void DoDbCfgOOMTests()
sl@0: 	{
sl@0: 	// Recreate the original dbs and config files
sl@0: 	DeleteCfgFilesAndDbs();
sl@0: 	CreateCfgFilesAndDbs();
sl@0: 	
sl@0: 	// The server is stopped at the end of CreateCfgFilesAndDbs().
sl@0: 	// Before the test loop below begins we attach Db1 so that the 
sl@0: 	// server starts up again and stores Db1's security policy in
sl@0: 	// CSqlServer::iSecurityMap. Otherwise there will be unmatching 
sl@0: 	// allocated cells in the test below. Do not call Detach() before 
sl@0: 	// Close(). We 'attach' Db1 here rather than 'open' it because 
sl@0: 	// open is the API that we want to test in the while loop
sl@0: 	TInt err = TheDb.Open(KCfgDb3);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Attach(KCfgDb1, KAttachDb1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	
sl@0: 	err = KErrNoMemory;
sl@0: 	TInt failingAllocationNo = 0;
sl@0: 	while(err == KErrNoMemory)
sl@0: 		{		
sl@0: 		MarkHandles();
sl@0: 		MarkAllocatedCells();
sl@0: 		
sl@0: 		__UHEAP_MARK;
sl@0: 
sl@0: 		TheTest.Printf(_L("%d\r"), failingAllocationNo + 1);
sl@0: 
sl@0: 		// Set failure rate
sl@0: 		TSqlResourceTester::SetDbHeapFailure(RHeap::EDeterministic, ++failingAllocationNo);
sl@0: 		err = TheDb.Open(KCfgDb1);
sl@0: 		if(err != KErrNoMemory)
sl@0: 			{
sl@0: 			TEST2(err, KErrNone);
sl@0: 			TheDb.Close();
sl@0: 			if(GuessSystemSettingsTable(KCfgDb1, 0))
sl@0: 				{
sl@0: 				err = KErrNoMemory;
sl@0: 				}
sl@0: 			}
sl@0: 		
sl@0: 		// Reset failure rate
sl@0: 		TSqlResourceTester::SetDbHeapFailure(RHeap::ENone, 0);
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: 	TheTest.Printf(_L("\r\n"));
sl@0: 	CheckSystemSettingsTable(KCfgDb1, 1); // check that the settings table has been updated with v01 of the config file
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4014
sl@0: @SYMTestCaseDesc		New database configuration files feature - File I/O failures test.
sl@0: 						The test opens a shared secure database for which there
sl@0: 						exists a database configuration file that is to be processed.
sl@0: 						The open call is executed within a file I/O failure loop, which
sl@0: 						causes a selection of file I/O errors to occur at different stages 
sl@0: 						of the open call. 
sl@0: 						The test verifies that file I/O errors are handled correctly and 
sl@0: 						that on the final loop - when no file I/O errors occur - the database 
sl@0: 						is successfully opened and the database configuration file is processed.
sl@0: 						NOTE: This test also acts as the test case for defect DEF116688.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			New database configuration files feature - File I/O failures test.
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMCR					LMAN-79SJ7L
sl@0: */
sl@0: void DoDbCfgFileIOFailuresTests()
sl@0: 	{
sl@0: 	// Recreate the original dbs and config files
sl@0: 	DeleteCfgFilesAndDbs();
sl@0: 	CreateCfgFilesAndDbs();
sl@0: 	
sl@0: 	// The server is stopped at the end of CreateCfgFilesAndDbs().
sl@0: 	// Before the test loop below begins we start the server again
sl@0: 	// by opening Db3) so that any server start up file i/o ops will 
sl@0: 	// succeed. We don't open Db1 here because opening Db1 is what 
sl@0: 	// we want to test in the while loop
sl@0: 	TInt err = TheDb.Open(KCfgDb3);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 
sl@0: 	TBool isFinished = EFalse;
sl@0: 	err = KErrNotFound;
sl@0: 	TInt iter = 0;
sl@0: 	TheTest.Printf(_L("Iteration\r\n"));
sl@0: 	for(TInt cnt = 0; !isFinished; ++cnt)
sl@0: 		{	
sl@0: 		for(TInt fsError = KErrNotFound; fsError >= KErrUnderflow; --fsError) // errors -1 to -10 will be generated
sl@0: 			{
sl@0: 			TheTest.Printf(_L("%d/%d   \r"), ++iter, fsError);
sl@0: 			(void)TheFs.SetErrorCondition(fsError, cnt); // set error code and how soon it is to occur
sl@0: 			err = TheDb.Open(KCfgDb1);
sl@0: 			(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 			TheDb.Close();
sl@0: 			if(err != KErrNone)
sl@0: 				{
sl@0: 				// An error has occured. We know that this means that the database 
sl@0: 				// configuration part of the open call wasn't reached (because the
sl@0: 				// database configuration part returns KErrNone even if it fails).
sl@0: 				// But check anyway that the database content is still the same as
sl@0: 				// before, i.e. the settings table has not been updated
sl@0: 				CheckSystemSettingsTable(KCfgDb1, 0);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				// Either the database configuration file for Db1 has been successfully
sl@0: 				// processed or it failed part-way through being processed (KErrNone is 
sl@0: 				// returned in this case too).
sl@0: 				// If it was the former then the the settings table will have 
sl@0: 				// been updated to store v01 of the config file
sl@0: 				if(GuessSystemSettingsTable(KCfgDb1, 1))
sl@0: 					{
sl@0: 					isFinished = ETrue;	
sl@0: 					break;
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	TheTest.Printf(_L("\r\n"));
sl@0: 	TEST2(err, KErrNone);		
sl@0: 	// Check that the database configuration was allowed to be successfully applied in one of the loops
sl@0: 	CheckSystemSettingsTable(KCfgDb1, 1); // check that the settings table has been updated with v01 of the config file		
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4015
sl@0: @SYMTestCaseDesc		New database configuration files feature - Performance test.
sl@0: 						The test measures:
sl@0: 						- the startup time of the SQL Server when 0 and 4 database 
sl@0: 						configuration files exist
sl@0: 						- the time taken to open a shared, secure database when a 
sl@0: 						database configuration file does and does not exist for it
sl@0: 						- the time taken to open a shared, secure database when a 
sl@0: 						database configuration file exists for it but it has already
sl@0: 						been processed
sl@0: 						- the time taken to attach a shared, secure database when a 
sl@0: 						database configuration file does and does not exist for it
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			New database configuration files feature - Performance test.
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMCR 					LMAN-79SJ7L
sl@0: */
sl@0: void DoDbCfgPerfTests()
sl@0: 	{
sl@0: 	// Recreate the original dbs
sl@0: 	DeleteCfgFilesAndDbs();
sl@0: 	CreateCfgDbs(); 
sl@0: 	KillSqlServer();
sl@0: 
sl@0: 	// Measure the start up time of the server when
sl@0: 	// there are no database configuration files to be cached.
sl@0: 	// Open Db4 (public db):
sl@0: 	// No reindexing required
sl@0: 	// Database configuration is not considered
sl@0: 	TUint32 start = User::FastCounter();
sl@0: 	TInt err = TheDb.Open(KCfgDb4);
sl@0: 	TUint32 end = User::FastCounter();
sl@0: 	TEST2(err, KErrNone);
sl@0:     CheckRecordCount(_L("table4"));
sl@0:     CheckIndexCount(0);
sl@0: 	TheDb.Close();
sl@0: 	CheckSystemSettingsTable(KCfgDb4, 0);
sl@0: 	TInt ms = CalcTimeMs(start, end);
sl@0: 	TheTest.Printf(_L("Execution time: Server startup (via Open call) - no database config files to cache: %d ms\r\n"), ms);
sl@0: 	
sl@0: 	// Measure the time to open Db1 when no database
sl@0: 	// configuration file exists for it.
sl@0: 	// Open Db1 (shared, secure db):
sl@0: 	// No reindexing required
sl@0: 	// Database configuration is considered but no config file is found
sl@0: 	start = User::FastCounter();
sl@0: 	err = TheDb.Open(KCfgDb1);
sl@0: 	end = User::FastCounter();
sl@0: 	TEST2(err, KErrNone);
sl@0:     CheckRecordCount(_L("table1"));
sl@0:     CheckIndexCount(0);
sl@0: 	TheDb.Close();
sl@0: 	CheckSystemSettingsTable(KCfgDb1, 0);
sl@0: 	ms = CalcTimeMs(start, end);
sl@0: 	TheTest.Printf(_L("Execution time: Open shared, secure Db1 - no config file is found: %d ms\r\n"), ms);
sl@0: 	
sl@0: 	// Measure the time to attach Db1 (database configuration will not be considered).
sl@0: 	// Attach Db1 (shared, secure db):
sl@0: 	// No reindexing required
sl@0: 	// Database configuration is not considered
sl@0: 	TheDb.Open(KCfgDb3);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	start = User::FastCounter();	
sl@0: 	err = TheDb.Attach(KCfgDb1, KAttachDb1);
sl@0: 	end = User::FastCounter();
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	CheckSystemSettingsTable(KCfgDb3, 0);
sl@0: 	CheckSystemSettingsTable(KCfgDb1, 0);
sl@0: 	ms = CalcTimeMs(start, end);
sl@0: 	TheTest.Printf(_L("Execution time: Attach shared, secure Db1 - database config is not considered: %d ms\r\n"), ms);
sl@0: 	
sl@0: 	// Create the 4 version 01 config files now
sl@0: 	CreateCfgFiles(); 
sl@0: 	KillSqlServer(); // stop the server so that the files are found when it is restarted
sl@0: 	
sl@0: 	// Measure the start up time of the server when
sl@0: 	// there are 4 database configuration files to be cached.
sl@0: 	// Open Db4 (public db):
sl@0: 	// No reindexing required
sl@0: 	// Database configuration is not considered
sl@0: 	start = User::FastCounter();
sl@0: 	err = TheDb.Open(KCfgDb4);
sl@0: 	end = User::FastCounter();
sl@0: 	TEST2(err, KErrNone);
sl@0:     CheckRecordCount(_L("table4"));
sl@0:     CheckIndexCount(0);
sl@0: 	TheDb.Close();
sl@0: 	CheckSystemSettingsTable(KCfgDb4, 0);
sl@0: 	ms = CalcTimeMs(start, end);
sl@0: 	TheTest.Printf(_L("Execution time: Server startup (via Open call) - 4 database config files to cache: %d ms\r\n"), ms);
sl@0: 	
sl@0: 	// Measure the time to open Db1 when a database
sl@0: 	// configuration file exists for it.
sl@0: 	// Open Db1 (shared, secure db):
sl@0: 	// No reindexing required
sl@0: 	// Database configuration is considered, a file is found and config is applied (3 indices are created)
sl@0: 	start = User::FastCounter();
sl@0: 	err = TheDb.Open(KCfgDb1);
sl@0: 	end = User::FastCounter();
sl@0: 	TEST2(err, KErrNone);
sl@0:     CheckRecordCount(_L("table1"));
sl@0:     CheckIndexCount(3);
sl@0: 	TheDb.Close();
sl@0: 	CheckSystemSettingsTable(KCfgDb1, 1);
sl@0: 	ms = CalcTimeMs(start, end);
sl@0: 	TheTest.Printf(_L("Execution time: Open shared, secure Db1 - config file is found and applied: %d ms\r\n"), ms);
sl@0: 	
sl@0: 	// Measure the time to open Db1 when a database
sl@0: 	// configuration file exists for it but is has already been processed.
sl@0: 	// Open Db1 (shared, secure db):
sl@0: 	// No reindexing required
sl@0: 	// Database configuration is considered, a file is found but it has already been processed
sl@0: 	start = User::FastCounter();
sl@0: 	err = TheDb.Open(KCfgDb1);
sl@0: 	end = User::FastCounter();
sl@0: 	TEST2(err, KErrNone);
sl@0:     CheckRecordCount(_L("table1"));
sl@0:     CheckIndexCount(3);
sl@0: 	TheDb.Close();
sl@0: 	CheckSystemSettingsTable(KCfgDb1, 1);
sl@0: 	ms = CalcTimeMs(start, end);
sl@0: 	TheTest.Printf(_L("Execution time: Open shared, secure Db1 - config file is found but already processed: %d ms\r\n"), ms);	
sl@0: 	
sl@0: 	// Measure the time to attach Db1 (database configuration will not be considered).
sl@0: 	// Attach Db1 (shared, secure db):
sl@0: 	// No reindexing required
sl@0: 	// Database configuration is not considered
sl@0: 	TheDb.Open(KCfgDb3);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	start = User::FastCounter();	
sl@0: 	err = TheDb.Attach(KCfgDb1, KAttachDb1);
sl@0: 	end = User::FastCounter();
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	CheckSystemSettingsTable(KCfgDb3, 0);
sl@0: 	CheckSystemSettingsTable(KCfgDb1, 1);
sl@0: 	ms = CalcTimeMs(start, end);
sl@0: 	TheTest.Printf(_L("Execution time: Attach shared, secure Db1 - database config is not considered: %d ms\r\n"), ms);
sl@0: 	}
sl@0: 
sl@0: void TestStatements()
sl@0: 	{
sl@0: 	_LIT(KDbName, "attachDb");
sl@0: 	TBuf<200> buf;
sl@0: 
sl@0: 	// supported statements
sl@0: 	TBool rc = IsStatementSupported(_L("CREATE INDEX idx ON tbl(ColA)"), KDbName, buf); 
sl@0: 	TEST(rc);
sl@0: 	rc = IsStatementSupported(_L("CREATE INDEX IF NOT EXISTS idx ON tbl(ColA)"), KDbName, buf); 
sl@0: 	TEST(rc);
sl@0: 
sl@0: 	// unsupported statements
sl@0: 	rc = IsStatementSupported(_L("CREATE UNIQUE INDEX idx ON tbl(ColA)"), KDbName, buf); 
sl@0: 	TEST(!rc);
sl@0: 	rc = IsStatementSupported(_L("CREATE idx ON tbl(ColA)"), KDbName, buf); 
sl@0: 	TEST(!rc);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4030
sl@0: @SYMTestCaseDesc		Test IsStatementSupportedLC function.
sl@0: 						This function checks either SQL statement from DB configuration file is supported or not.
sl@0: 						In the case of supported statement, function allocates buffer and copies statement into that buffer.
sl@0: 						Call IsStatementSupportedLC on several supported and unsupported SQL statements.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			Test IsStatementSupportedLC function.
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMDEF					DEF118058
sl@0: */
sl@0: void DoIsStatementSupportedTests()
sl@0: 	{
sl@0: 	TestStatements();
sl@0: 	}
sl@0: 
sl@0: void DoLongDbNameTest()
sl@0: 	{
sl@0: 	//Create the database	
sl@0:  	RSqlSecurityPolicy securityPolicy = CreateSecurityPolicy();
sl@0:  	
sl@0:  	TInt err = TheDb.Create(KLongDbName1, securityPolicy);
sl@0:  	TEST2(err, KErrNone);
sl@0:  	err = TheDb.Exec(_L("CREATE TABLE table1(i1 INTEGER, i2 INTEGER, i3 INTEGER)"));
sl@0:  	TEST(err >= 0);
sl@0:  	err = TheDb.Exec(_L("INSERT INTO table1 (i1,i2,i3) values(1,2,3)"));
sl@0:  	TEST(err == 1);
sl@0:  	TheDb.Close();
sl@0:  	//Kill the server (to reload config file names at the server startup)
sl@0:  	KillSqlServer();
sl@0: 	///////////////////////////////////////////////////////////////////////
sl@0: 	TheTest.Printf(_L("Open a database with a long name\r\n"));
sl@0: 	//Create cfg file
sl@0:  	RFile file;
sl@0: 	TFileName fileName;
sl@0: 	err = file.Create(TheFs, KLongCfgName1, EFileRead | EFileWrite);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TPtrC8 pDb1((const TUint8*)KCfgConfigFileValidStmt().Ptr(), KCfgConfigFileValidStmt().Length());
sl@0: 	err = file.Write(pDb1);	
sl@0: 	file.Close();	
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Open the database
sl@0: 	err = TheDb.Open(KLongDbName1);
sl@0: 	TEST2(err, KErrNone);
sl@0:     CheckRecordCount(_L("table1"));
sl@0:     CheckIndexCount(1); // there should now be 1 index in the table
sl@0: 	TheDb.Close();
sl@0: 	const TInt KVersion = 1;
sl@0: 	CheckSystemSettingsTable(KLongDbName1, KVersion); // check that the ops in the specified config file have been applied
sl@0: 	///////////////////////////////////////////////////////////////////////
sl@0: 	TheTest.Printf(_L("Attach a database with a long logical name\r\n"));
sl@0: 	//Attached database test
sl@0: 	//Recreate the database
sl@0:  	(void)RSqlDatabase::Delete(KLongDbName1);
sl@0:  	err = TheDb.Create(KLongDbName1, securityPolicy);
sl@0:  	TEST2(err, KErrNone);
sl@0:  	err = TheDb.Exec(_L("CREATE TABLE table1(i1 INTEGER, i2 INTEGER, i3 INTEGER)"));
sl@0:  	TEST(err >= 0);
sl@0:  	err = TheDb.Exec(_L("INSERT INTO table1 (i1,i2,i3) values(1,2,3)"));
sl@0:  	TEST(err == 1);
sl@0:  	TheDb.Close();
sl@0:  	//Kill the server (to reload config file names at the server startup)
sl@0:  	KillSqlServer();
sl@0: 	//Open the main database
sl@0:  	err = TheDb.Open(KCfgDb1);
sl@0:  	securityPolicy.Close();
sl@0: 	TEST2(err, KErrNone);
sl@0: 	//Attach a database with a very long logical name
sl@0: 	TFileName attachDbName;
sl@0: 	attachDbName.SetLength(KMaxFileName);
sl@0: 	attachDbName.Fill(TChar('A'));
sl@0:  	err = TheDb.Attach(KLongDbName1, attachDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0:  	err = TheDb.Detach(attachDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0:  	TheDb.Close();
sl@0: 	CheckSystemSettingsTable(KLongDbName1, KVersion); // check that the ops in the specified config file have been applied
sl@0: 	//Cleanup
sl@0:  	(void)RSqlDatabase::Delete(KLongDbName1);
sl@0: 	}
sl@0: 
sl@0: void DoTests()
sl@0:     {
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4010 Database config files test"));
sl@0:     DoDbCfgTests();
sl@0:     
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4013 Database config files OOM test"));
sl@0:     DoDbCfgOOMTests();
sl@0:     
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4014 Database config files file I/O error simulation test"));
sl@0:     DoDbCfgFileIOFailuresTests();
sl@0:     
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4015 Database config files performance test"));
sl@0:     DoDbCfgPerfTests();
sl@0: 
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4030 Database config files - supported SQl statements test"));
sl@0:     DoIsStatementSupportedTests();
sl@0: 
sl@0:     TheTest.Next(_L("'Long database name' tests"));
sl@0:     DoLongDbNameTest();
sl@0:     }
sl@0: 
sl@0: #endif	//SYSLIBS_TEST
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: #ifdef SYSLIBS_TEST	
sl@0: 	TheTest.Start(_L("Setting up the test environment"));
sl@0: 	SetupTestEnv();
sl@0: 	sqlite3SymbianLibInit();
sl@0: 	DoTests();
sl@0:  	DestroyTestEnv();
sl@0: 	sqlite3SymbianLibFinalize();
sl@0: 	CloseSTDLIB();
sl@0: 	TheTest.End();
sl@0: #else
sl@0:  	TheTest.Start(_L("This test works only if the whole SQL component is built with SYSLIBS_TEST macro defined!"));
sl@0: 	TheTest.End();
sl@0: #endif	
sl@0: 	
sl@0: 	__UHEAP_MARKEND;
sl@0: 	
sl@0: 	TheTest.Close();
sl@0: 	
sl@0: 	delete tc;
sl@0: 	
sl@0: 	User::Heap().Check();
sl@0: 	return KErrNone;
sl@0: 	}