// Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <e32test.h>

#include <stdlib.h>

#include <bautils.h>

#include <hal.h>

#include <sqldb.h>

#include "sqlite3.h"

#include "SqliteSymbian.h"

#include "SqlResourceTester.h"

//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)

#ifdef _SQLPROFILER

TInt TheSqlSrvProfilerFileRead = 0;

TInt TheSqlSrvProfilerFileWrite = 0;

TInt TheSqlSrvProfilerFileSync = 0;

TInt TheSqlSrvProfilerFileSetSize = 0;

#endif

/////////////////////////////////////////////////////////////////////////////////////////////////

/// This test works only if the whole SQL component is built with SYSLIBS_TEST macro defined! ///

/////////////////////////////////////////////////////////////////////////////////////////////////

RTest TheTest(_L("t_sqldbconfigfile test"));

#ifdef SYSLIBS_TEST	

extern TBool IsStatementSupported(const TDesC& aStatementIn, const TDesC& aDbName, TDes& aStatementOut);

RFs TheFs;

RSqlDatabase TheDb;

sqlite3 *TheDbHandle = NULL;

_LIT(KCfgDb1, "c:[1111C1C1]a.db"); // shared, secure db

_LIT(KCfgDb2, "c:[1111C1C1]b.db"); // shared, secure db (no config file for it)

_LIT(KCfgDb3, "c:\\private\\1111C1C1\\c.db"); // private, secure db

_LIT(KCfgDb4, "c:\\test\\d.db"); // public db

_LIT(KCfgDb5, "c:[1111C1C1]e.db"); // shared, secure db (config file created before db is created)

_LIT(KCfgDb1ConfigFilePath, "c:\\private\\10281e17\\cfg[1111C1C1]a.db.0%d"); // config file version %d for a.db

_LIT(KCfgDb3ConfigFileV01Path, "c:\\private\\10281e17\\cfgc.db.01"); // config file v01 for c.db (unsupported)

_LIT(KCfgDb4ConfigFileV01Path, "c:\\private\\10281e17\\cfgd.db.01"); // config file v01 for d.db (unsupported)

_LIT(KCfgDb5ConfigFileV01Path, "c:\\private\\10281e17\\cfg[1111C1C1]e.db.01"); // config file v01 for e.db

_LIT(KCfgDb1CorruptConfigFilePath, "c:\\private\\10281e17\\cfg[1111C1C1]a.db.invalidextension"); // invalid config file name syntax

// config file valid contents (used for v02 and others)

_LIT8(KCfgConfigFileValidStmt, "CREATE INDEX newIdx ON table1(i3)  ;"); 

// config file v03 empty contents

_LIT8(KCfgDb1ConfigFileV03EmptyStmt, ""); 

// config file v04 unsupported contents

_LIT8(KCfgDb1ConfigFileV04UnsupportedStmt, "DELETE FROM table1"); 

// config file v05 only whitespace contents

_LIT8(KCfgDb1ConfigFileV05OnlyWhitespaceStmt, " \r\n   \r\n"); 

// config file v06 invalid schema contents

_LIT8(KCfgDb1ConfigFileV06InvalidSchemaStmt, "CREATE INDEX thisIdx ON table999(i3)"); 

// config file v07 unsupported comment style

_LIT8(KCfgDb1ConfigFileV07InvalidCommentedStmt, "CREATE INDEX ind1 ON table1(i2) // create an index"); 

// config file v08 sequence of different statements

_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);");

// config file v09 whitespace before and after statement

_LIT8(KCfgDb1ConfigFileV09WhitespacePreAndPostStmt, "  CREATE INDEX intIdx ON table1(i1)       "); 

// config file v10 valid contents

_LIT8(KCfgDb1ConfigFileV10ValidStmt, "CREATE INDEX i3Index ON table1(i3)\n"); 

// config file v11 valid contents (also tests that any amount spaces and tabs are allowed between 'CREATE' and 'INDEX')

_LIT8(KCfgDb1ConfigFileV11ValidStmt, "CREATE     INDEX i1Index ON table1(i1);\nCREATE	INDEX i2Index ON table1(i2)");

// config file v12 invalid stmt plus valid stmt

_LIT8(KCfgDb1ConfigFileV12InvalidPlusValidStmt, "CREATE UNIQUE INDEX uniqueIdx ON table1(i1);CREATE INDEX v12Idx ON table1(i2)");

// config file v13 supported SQL comment style

_LIT8(KCfgDb1ConfigFileV13SQLCommentStmt, "CREATE INDEX v13Idx ON table1(i1) -- this is an SQL comment");

// config file v14 supported 'C' comment style

_LIT8(KCfgDb1ConfigFileV14CCommentStmt, "CREATE INDEX v14Idx ON table1(i3) /* this is a C comment */;");

//KLongDbName1 is "long" enough to allow "-journal" to be added at the end.

//Also, on simulators/emulators the file names have a prefix with length of about 30 characters

//(something like \epoc\winscw\c\....)

_LIT(KLongDbName1,  "c:[1111C1C1]a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a.db");

_LIT(KLongCfgName1, "c:\\private\\10281e17\\cfg[1111C1C1]a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a123456789a.db.01");

_LIT(KSqlSrvPrivatePath, "\\private\\10281e17\\");

_LIT(KResetCollationDllSql, "UPDATE symbian_settings SET CollationDllName='hjagafsff'");

_LIT(KAttachDb1, "Db1");

_LIT(KAttachDb2, "Db2");

_LIT(KAttachDb5, "Db5");

///////////////////////////////////////////////////////////////////////////////////////

// Destroy functions

void KillSqlServer()

	{

	_LIT(KSqlSrvName, "sqlsrv.exe");

	TFullName name;

	//RDebug::Print(_L("Find and kill \"%S\" process.\n"), &aProcessName);

	TBuf<64> pattern(KSqlSrvName);

	TInt length = pattern.Length();

	pattern += _L("*");

	TFindProcess procFinder(pattern);

	while (procFinder.Next(name) == KErrNone)

		{

		if (name.Length() > length)

			{//If found name is a string containing aProcessName string.

			TChar c(name[length]);

			if (c.IsAlphaDigit() ||

				c == TChar('_') ||

				c == TChar('-'))

				{

				// If the found name is other valid application name

				// starting with aProcessName string.

				//RDebug::Print(_L(":: Process name: \"%S\".\n"), &name);

				continue;

				}

			}

		RProcess proc;

		if (proc.Open(name) == KErrNone)

			{

			proc.Kill(0);

			//RDebug::Print(_L("\"%S\" process killed.\n"), &name);

			}

		proc.Close();

		}

	}

void DeleteCfgFilesAndDbs()

	{

 	(void)RSqlDatabase::Delete(KLongDbName1);

 	(void)RSqlDatabase::Delete(KCfgDb1);

 	(void)RSqlDatabase::Delete(KCfgDb2);	

 	(void)RSqlDatabase::Delete(KCfgDb3);

 	(void)RSqlDatabase::Delete(KCfgDb4);

 	(void)RSqlDatabase::Delete(KCfgDb5);

 	(void)TheFs.Delete(KLongCfgName1);

 	(void)TheFs.Delete(KCfgDb3ConfigFileV01Path);

 	(void)TheFs.Delete(KCfgDb4ConfigFileV01Path);

 	(void)TheFs.Delete(KCfgDb5ConfigFileV01Path);

 	CFileMan* fileMan = 0;	

 	TRAPD(err, fileMan = CFileMan::NewL(TheFs));

 	if(KErrNone == err)

 		{

 		(void)fileMan->Delete(_L("c:\\private\\10281e17\\cfg[1111C1C1]a.db.*"));

		delete fileMan;			

 		}

  	}

void DestroyTestEnv()

	{

	if(TheDbHandle)

		{

		sqlite3_close(TheDbHandle);	

		TheDbHandle = NULL;

		}

	TheDb.Close();

	KillSqlServer();

	DeleteCfgFilesAndDbs();

	TheFs.Close();

	}

///////////////////////////////////////////////////////////////////////////////////////

// Test macros and functions

void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		DestroyTestEnv();

		TheTest(EFalse, aLine);

		}

	}

void Check(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		DestroyTestEnv();

		TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

		TheTest(EFalse, aLine);

		}

	}

#define TEST(arg) ::Check((arg), __LINE__)

#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

// OOM test functions

static TInt TheHandleCount1;

static TInt TheHandleCount2;

static TInt TheAllocatedCellsCount;

void MarkHandles()

	{

	RThread().HandleCount(TheHandleCount1, TheHandleCount2);

	}

void CheckHandles()

	{

	TInt endHandleCount1;

	TInt endHandleCount2;

	RThread().HandleCount(endHandleCount1, endHandleCount2);

	TEST2(TheHandleCount1, endHandleCount1);

	TEST2(TheHandleCount2, endHandleCount2);

	}

void MarkAllocatedCells()

	{

	TheAllocatedCellsCount = User::CountAllocCells();

	}

void CheckAllocatedCells()

	{

	TInt allocatedCellsCount = User::CountAllocCells();

	TEST2(allocatedCellsCount, TheAllocatedCellsCount);

	}

///////////////////////////////////////////////////////////////////////////////////////

// Set up functions

RSqlSecurityPolicy CreateSecurityPolicy()

	{

	const TSecurityPolicy KDefaultPolicy(TSecurityPolicy::EAlwaysPass);

	RSqlSecurityPolicy policy;

	TInt err = policy.Create(KDefaultPolicy);

	TEST2(err, KErrNone);

	err = policy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, KDefaultPolicy);

    TEST2(err, KErrNone);

    err = policy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, KDefaultPolicy);

    TEST2(err, KErrNone);

    err = policy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, KDefaultPolicy);

    TEST2(err, KErrNone);

    return policy;

	}

void DoCreateCfgFile(const TDesC& aFileName, const TDesC8& aData)

    {

    RFile file;

    TInt err = file.Create(TheFs, aFileName, EFileRead | EFileWrite);

    TEST2(err, KErrNone);

    err = file.Write(aData); 

    file.Close();   

    TEST2(err, KErrNone);

    }

// Create v01 of the test config files

void CreateCfgFiles()

	{

	TFileName fileName;

	TInt v1 = 1;

	fileName.Format(KCfgDb1ConfigFilePath, v1);

	// config file v01 contents for db1 (also tests that upper and lower case statements are both supported)

	_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)");

    DoCreateCfgFile(fileName, KCfgDb1ConfigFile01Stmts);

    // config file v01 contents for db3 (will not be processed as db3 is not a shared, secure db)

    _LIT8(KCfgDb3ConfigFile01Stmts, "CREATE INDEX idx ON table3(i1)");

    DoCreateCfgFile(KCfgDb3ConfigFileV01Path, KCfgDb3ConfigFile01Stmts);

    // config file v01 contents for db4 (will not be processed as db4 is not a shared, secure db)

    _LIT8(KCfgDb4ConfigFile01Stmts, "CREATE INDEX idx ON table4(i1)");

    DoCreateCfgFile(KCfgDb4ConfigFileV01Path, KCfgDb4ConfigFile01Stmts);

    // create the config file for Db5 before the database has been created

    // config file v01 contents for db5 (will eventually be processed after db5 itself is created)

    _LIT8(KCfgDb5ConfigFile01Stmts, "CREATE INDEX idx ON table5(i1);\r\n");

    DoCreateCfgFile(KCfgDb5ConfigFileV01Path, KCfgDb5ConfigFile01Stmts);

	}

void DoCreateCfgDb(const TDesC& aFileName, const TDesC& aCreateTblSql, const TDesC& aInsertSql, 

                   RSqlSecurityPolicy* aPolicy = NULL)

    {

    TInt err = aPolicy ? TheDb.Create(aFileName, *aPolicy) : TheDb.Create(aFileName);

    TEST2(err, KErrNone);

    err = TheDb.Exec(aCreateTblSql);

    TEST(err >= 0);

    err = TheDb.Exec(aInsertSql);

    TEST(err == 1);

    TheDb.Close();

    }

// Create the test databases

void CreateCfgDbs()

	{

    RSqlSecurityPolicy securityPolicy = CreateSecurityPolicy();

    DoCreateCfgDb(KCfgDb1, _L("CREATE TABLE table1(i1 INTEGER, i2 INTEGER, i3 INTEGER)"),

                           _L("INSERT INTO table1 (i1,i2,i3) values(1,2,3)"), &securityPolicy);

    DoCreateCfgDb(KCfgDb2, _L("CREATE TABLE table2(i1 INTEGER, i2 INTEGER, i3 INTEGER)"),

                           _L("INSERT INTO table2 (i1,i2,i3) values(4,5,6)"), &securityPolicy);

    securityPolicy.Close();

    DoCreateCfgDb(KCfgDb3, _L("CREATE TABLE table3(i1 INTEGER, i2 INTEGER)"),

                           _L("INSERT INTO table3 (i1,i2) values(7,8)"));

    DoCreateCfgDb(KCfgDb4, _L("CREATE TABLE table4(i1 INTEGER, i2 INTEGER, i3 INTEGER)"),

                           _L("INSERT INTO table4 (i1,i2,i3) values(9,10,11)"));

 	}

void CreateCfgFilesAndDbs()

	{

	CreateCfgFiles();

	CreateCfgDbs();

	// Must now kill the SQL Server so that the config files 

	// created above are found and processed when it restarts

	KillSqlServer();

 	}

// Create the Db5 test database (a config file for it already exists)

 void CreateDb5()

	{

 	RSqlSecurityPolicy securityPolicy = CreateSecurityPolicy();

    DoCreateCfgDb(KCfgDb5, _L("CREATE TABLE table5(i1 INTEGER, i2 INTEGER, i3 INTEGER)"),

                           _L("INSERT INTO table5 (i1,i2,i3) values(1,2,3)"), &securityPolicy);

 	securityPolicy.Close();

	}

void SetupTestEnv()

    {

	TInt err = TheFs.Connect();

	TEST2(err, KErrNone);

	_LIT(KTestDir, "c:\\test\\");

	err = TheFs.MkDir(KTestDir);

	TEST(err == KErrNone || err == KErrAlreadyExists);

	err = TheFs.CreatePrivatePath(EDriveC);

	TEST(err == KErrNone || err == KErrAlreadyExists);

	// Create the cfg dbs and config files

 	DeleteCfgFilesAndDbs(); // just incase any previous files are lingering

 	CreateCfgFilesAndDbs();

	}

///////////////////////////////////////////////////////////////////////////////////////

//

TInt CalcTimeMs(TUint32 aStartTicks, TUint32 aEndTicks)

	{

	static TInt freq = 0;

	if(freq == 0)

		{

		TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone);

		}

	TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;

	if(diffTicks < 0)

		{

		diffTicks = KMaxTUint32 + diffTicks + 1;

		}

	const TInt KMicroSecIn1Sec = 1000000;

	TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;

	return us / 1000;

	}

///////////////////////////////////////////////////////////////////////////////////////

// Config file replacement functions

void UpgradeDbConfigFile(TInt aCurrentVersion)

	{

    TInt newVersion = aCurrentVersion + 1;

    TEST(newVersion != 0 && newVersion != 1 && newVersion != 10 && newVersion != 11 && newVersion < 15);

    KillSqlServer();

	TFileName fname;

	fname.Format(KCfgDb1ConfigFilePath, aCurrentVersion);

	TInt err = TheFs.Delete(fname);

	TEST2(err, KErrNone);

	if(newVersion == 12)

	    {

        // also delete version 10 of file

	    fname.Format(KCfgDb1ConfigFilePath, 10);

        err = TheFs.Delete(fname);

        TEST2(err, KErrNone);   

	    }

	const TPtrC8 stmts[] = {KNullDesC8(), KNullDesC8(), 

	        KCfgConfigFileValidStmt(), 

	        KCfgDb1ConfigFileV03EmptyStmt(),

	        KCfgDb1ConfigFileV04UnsupportedStmt(),

	        KCfgDb1ConfigFileV05OnlyWhitespaceStmt(),

	        KCfgDb1ConfigFileV06InvalidSchemaStmt(),

	        KCfgDb1ConfigFileV07InvalidCommentedStmt(),

	        KCfgDb1ConfigFileV08SeqStmt(),

	        KCfgDb1ConfigFileV09WhitespacePreAndPostStmt(),

	        KNullDesC8(), KNullDesC8(),

	        KCfgDb1ConfigFileV12InvalidPlusValidStmt(),

	        KCfgDb1ConfigFileV13SQLCommentStmt(),

	        KCfgDb1ConfigFileV14CCommentStmt()};

    fname.Format(KCfgDb1ConfigFilePath, newVersion);

	DoCreateCfgFile(fname, stmts[newVersion]);

	}	

void DowngradeDbConfigFile(TInt aCurrentVersion)

	{

	TEST(aCurrentVersion > 1);

	KillSqlServer();

	TFileName fname;

	fname.Format(KCfgDb1ConfigFilePath, aCurrentVersion);

	TInt err = TheFs.Delete(fname);

	TEST2(err, KErrNone);

    fname.Format(KCfgDb1ConfigFilePath, aCurrentVersion - 1);

    DoCreateCfgFile(fname, KCfgConfigFileValidStmt);

	}

void CreateCorruptDbConfigFile(TInt aCurrentVersion)

	{

	KillSqlServer();

	TFileName fname;

	fname.Format(KCfgDb1ConfigFilePath, aCurrentVersion);

	TInt err = TheFs.Delete(fname);

	TEST2(err, KErrNone);

    DoCreateCfgFile(KCfgDb1CorruptConfigFilePath, KCfgConfigFileValidStmt);

	}	

void CreateTwoVersionsOfConfigFile()

	{

	KillSqlServer();

	TInt err = TheFs.Delete(KCfgDb1CorruptConfigFilePath);

	TEST2(err, KErrNone);

    TInt nextVersion = 10;

    TFileName fname;

    fname.Format(KCfgDb1ConfigFilePath, nextVersion);

    DoCreateCfgFile(fname, KCfgDb1ConfigFileV10ValidStmt);

	++nextVersion;

    fname.Format(KCfgDb1ConfigFilePath, nextVersion);

    DoCreateCfgFile(fname, KCfgDb1ConfigFileV11ValidStmt);

	}

///////////////////////////////////////////////////////////////////////////////////////

// DoDbCfgTests() functions

TInt GetDbCfgVersion(const TDesC& aDbName)

    {

    // Note: We have to use SQLite directly to access the settings

    // table as the SQL Server denies permission to access this table

    // as it is in a shared, secure database

    TParse parse;

    TInt err = parse.Set(aDbName, &KSqlSrvPrivatePath, 0);

    TEST2(err, KErrNone);

    TBuf8<KMaxFileName + 1> dbFileName;

    dbFileName.Copy(parse.FullName());

    sqlite3 *dbHandle = NULL;

    TInt rc = sqlite3_open((const char*)dbFileName.PtrZ(), &dbHandle);

    TEST2(rc, SQLITE_OK);

    _LIT(KGetDbCfgVersionSql, "SELECT Reserved AS DbCfgVersion FROM symbian_settings");

    TBuf<100> queryBuf;

    queryBuf.Copy(KGetDbCfgVersionSql);

    sqlite3_stmt* stmtHandle = NULL;

    const void* stmtTailZ = NULL;

    rc = sqlite3_prepare16_v2(dbHandle, queryBuf.PtrZ(), -1, &stmtHandle, &stmtTailZ);

    TEST2(rc, SQLITE_OK);

    rc = sqlite3_step(stmtHandle);

    TEST2(rc, SQLITE_ROW);

    TInt version = sqlite3_column_int(stmtHandle, 0);

    rc = sqlite3_step(stmtHandle);

    TEST2(rc, SQLITE_DONE);

    sqlite3_finalize(stmtHandle);

    sqlite3_close(dbHandle);

    return version;

    }

TBool GuessSystemSettingsTable(const TDesC& aDbName, TInt aVersion)

	{

	TInt dbCfgVersion = GetDbCfgVersion(aDbName);

	return dbCfgVersion == aVersion; 

	}

void CheckSystemSettingsTable(const TDesC& aDbName, TInt aVersion)

	{

    TInt dbCfgVersion = GetDbCfgVersion(aDbName);

    TEST2(dbCfgVersion, aVersion); 

	}

void CheckRecordCount(const TDesC& aTable)

	{

	// There should always be only 1 record in the table

	// in each database as INSERT and DELETE statements are

	// not supported in the config files

	TBuf<50> sql;

	sql.Format(_L("SELECT COUNT(*) FROM %S"), &aTable);

	TSqlScalarFullSelectQuery q(TheDb);

	TInt count = 0;

    TRAPD(err, count = q.SelectIntL(sql));

    TEST2(err, KErrNone);

    TEST2(count, 1);

	}

TInt ExpectedDb1IndexCount(TInt aExpectedStoredVersion)

	{

	TEST(aExpectedStoredVersion >= 0 && aExpectedStoredVersion < 15);

	const TInt KIdxCnt[] = {

	       -1, 

	        3,             // Only files 01 - 04, 09 and 11 will be successfully processed and so stored in the settings table

	        4,             // 1 more index should be added to db1 based on config file 02

	        4, 4, 4, 4, 4, // no more indices should be added to db1 based on config file 03 - 07 

	        6,             // 2 more indices should be added to db1 based on config file 08 

	        7,             // 1 more index should be added to db1 based on config file 09 

	        -1, 

	        9,             // 2 more indices should be added to db1 based on config file 11 

	        10,            // 1 more index should be added to db1 based on config file 12

	        11,            // 1 more index should be added to db1 based on config file 13

	        12};           // 1 more index should be added to db1 based on config file 14

	return KIdxCnt[aExpectedStoredVersion];

	}

void CheckIndexCount(TInt aExpectedIndexCount)

	{

	_LIT(KDbCheckNumIndices, "SELECT COUNT(*) FROM sqlite_master WHERE type = 'index'");

    TSqlScalarFullSelectQuery q(TheDb);

    TInt count = 0;

    TRAPD(err, count = q.SelectIntL(KDbCheckNumIndices));

    TEST2(err, KErrNone);

    TEST2(count, aExpectedIndexCount);

	}

void DoCfgOpenTest(TInt aExpectedStoredVersion, const TDesC& aDbFileName, const TDesC& aTblName, TInt aExpectedIndexCnt)

    {

    TInt err = TheDb.Open(aDbFileName);

    TEST2(err, KErrNone);

    CheckRecordCount(aTblName);

    CheckIndexCount(aExpectedIndexCnt);

    TheDb.Close();

    // Check that the ops in the specified config file have been applied.

    CheckSystemSettingsTable(aDbFileName, aExpectedStoredVersion);

    }

void DoCfgOpenTests(TInt aExpectedStoredVersion)

	{	

	// Open a shared, secure database - config ops should be applied on it.

    // There should still be only 1 record and 3 indices in the table.

	TheTest.Printf(_L("===CfgOpen: Open shared, secure database\r\n"));

	DoCfgOpenTest(aExpectedStoredVersion, KCfgDb1, _L("table1"), ExpectedDb1IndexCount(aExpectedStoredVersion));

	// Open again the same shared, secure database - no config should occur (it has already been done).

	TheTest.Printf(_L("===CfgOpen: Open shared, secure database again\r\n"));

    DoCfgOpenTest(aExpectedStoredVersion, KCfgDb1, _L("table1"), ExpectedDb1IndexCount(aExpectedStoredVersion));

	// Open a shared, secure database - no config should occur (there is no config file for this database)

	TheTest.Printf(_L("===CfgOpen: Open shared, secure database (that has no config file)\r\n"));

    DoCfgOpenTest(0, KCfgDb2, _L("table2"), 0);

	// Open a private, secure database - no config should occur

	TheTest.Printf(_L("===CfgOpen: Open private, secure database\r\n"));

    DoCfgOpenTest(0, KCfgDb3, _L("table3"), 0);

	// Open a public database - no config should occur

	TheTest.Printf(_L("===CfgOpen: Open public database\r\n"));

    DoCfgOpenTest(0, KCfgDb4, _L("table4"), 0);

	}

void DoUpgradedCfgOpenTest()

	{

	// Upgrade the config file for KCfgDb1, i.e. replace v1 file with v2 file

	UpgradeDbConfigFile(1);

	DoCfgOpenTests(2);	

	}

void DoBadCfgOpenTests()

	{

	// Test an empty config file

	UpgradeDbConfigFile(2); // the current file version is 02, replace it with 03

	DoCfgOpenTests(3); // version 03 will be successfully processed and stored in the settings table

	// Test a config file with unsupported operations (these will be ignored)

	UpgradeDbConfigFile(3); // the current file version is 03, replace it with 04

	DoCfgOpenTests(4); // version 04 will be successfully processed (the unsupported operations are ignored) and stored in the settings table

	// Test a config file with only whitespace in it

	UpgradeDbConfigFile(4); // the current file version is 04, replace it with 05

	DoCfgOpenTests(5); // version 05 will be successfully processed (the whitespace is ignored) and stored in the settings table

	// Test a config file with operations on an invalid table

	UpgradeDbConfigFile(5); // the current file version is 05, replace it with 06

	DoCfgOpenTests(6); // version 06 will be successfully processed (the failed-to-execute operation will be ignored) and stored in the settings table

	// Test a config file that contains an invalid comment style

	UpgradeDbConfigFile(6); // the current file version is 06, replace it with 07

	DoCfgOpenTests(7); // version 07 will be successfully processed (the line with invalid comment syntax will be ignored) and stored in the settings table

	// Test a config file that contains a sequence of statements as one statement (this is currently unsupported)

	UpgradeDbConfigFile(7); // the current file version is 07, replace it with 08

	DoCfgOpenTests(8); // version 08 will be successfully processed (the line with a sequence of statements is ignored) and stored in the settings table	

	// Test a config file that contains whitespace before and after the SQL statement

	UpgradeDbConfigFile(8); // the current file version is 08, replace it with 09

	DoCfgOpenTests(9); // version 09 will be successfully processed and stored in the settings table	

	// Test a config file that has a lower extension number

	DowngradeDbConfigFile(9); // the current file version is 09, replace it with 08

	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

	// Test a config file that has an invalid extension

	CreateCorruptDbConfigFile(8); // the current file version is 08, replace it with a file with an invalid extension

	DoCfgOpenTests(9); // the invalid file will NOT be processed, and 09 will remain stored in the settings table			

	// Test two versions of the config file (two versions should not be present at the same time)

	CreateTwoVersionsOfConfigFile(); // the current file has an invalid extension, delete it and create version 10 and version 11

	DoCfgOpenTests(11); // only version 11 will be processed (as it is the highest version), and 11 will be stored in the settings table

	// Test a config file that contains an invalid statement and a valid statement

	UpgradeDbConfigFile(11); // the current file versions are 10 and 11, replace them with 12

	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

	// Test a config file that contains a SQL style comment

	UpgradeDbConfigFile(12); // the current file version is 12, replace it with 13

	DoCfgOpenTests(13); // version 13 will be successfully processed (the SQL style comment will be ignored) and stored in the settings table

	// Test a config file that contains a 'C' style comment

	UpgradeDbConfigFile(13); // the current file version is 13, replace it with 14

	DoCfgOpenTests(14); // version 14 will be successfully processed (the 'C' style comment will be ignored) and stored in the settings table

	}

void DoNewDbCfgOpenTest()

	{

	// Create Db5 - a config file already exists for this database

	CreateDb5();

	// Open the shared, secure database Db5 - config ops should be applied on it.

	// There should now be 1 index in the table.

	TheTest.Printf(_L("===NewDbCfg: Open shared, secure database\r\n"));

    DoCfgOpenTest(1, KCfgDb5, _L("table5"), 1);

	// Open again the same shared, secure database - no config should occur (it has already been done)

	TheTest.Printf(_L("===NewDbCfg: Open shared, secure database again\r\n"));

    DoCfgOpenTest(1, KCfgDb5, _L("table5"), 1);

	}

void DoCfgAttachTests(TInt aExpectedStoredVersion = 0)

	{			

	// Open a private, secure database - no config should occur

	TheTest.Printf(_L("===CfgAttach: Open private, secure database\r\n"));

	TInt err = TheDb.Open(KCfgDb3);

	TEST2(err, KErrNone);

	// Attach a shared, secure database - the db1 config file should not be processed

	TheTest.Printf(_L("===CfgAttach: Attach shared, secure database\r\n"));

	err = TheDb.Attach(KCfgDb1, KAttachDb1);

	TEST2(err, KErrNone);

	TheDb.Close();

	CheckSystemSettingsTable(KCfgDb1, aExpectedStoredVersion); // check that the config file has not been processed for db1

	CheckSystemSettingsTable(KCfgDb3, 0);

	// Open a public database - no config should occur

	TheTest.Printf(_L("===CfgAttach: Open public database\r\n"));

    err = TheDb.Open(KCfgDb4);

	TEST2(err, KErrNone);

	// Attach a shared, secure database - no config should occur (there is no config file for this database)

	TheTest.Printf(_L("===CfgAttach: Attach shared, secure database (that has no config file)\r\n"));

	err = TheDb.Attach(KCfgDb2, KAttachDb2);

	TEST2(err, KErrNone);

	TheDb.Close();

	CheckSystemSettingsTable(KCfgDb2, 0);

	CheckSystemSettingsTable(KCfgDb4, 0);

	}

void DoUpgradedCfgAttachTest()

	{

	// Upgrade the config file for KCfgDb1, i.e. replace v1 file with v2 file

	UpgradeDbConfigFile(1);	

	DoCfgAttachTests(2);

	}

void DoBadCfgAttachTests()

	{

	// Test an empty config file

	UpgradeDbConfigFile(2); // the current file version is 02, replace it with 03

	DoCfgAttachTests(3); // version 03 will not be processed so no update to settings table

	// Test a config file with unsupported operations

	UpgradeDbConfigFile(3); // the current file version is 03, replace it with 04

	DoCfgAttachTests(4); // version 04 will not be processed so no update to settings table

	// Test a config file with only whitespace in it

	UpgradeDbConfigFile(4); // the current file version is 04, replace it with 05

	DoCfgAttachTests(5); // version 05 will not be processed so no update to settings table

	// Test a config file with operations on an invalid table

	UpgradeDbConfigFile(5); // the current file version is 05, replace it with 06

	DoCfgAttachTests(6); // version 06 will not be processed so no update to settings table

	// Test a config file that contains an invalid comment style

	UpgradeDbConfigFile(6); // the current file version is 06, replace it with 07

	DoCfgAttachTests(7); // version 07 will not be processed so no update to settings table

	// Test a config file that contains a sequence of statements as one statement (this is currently unsupported)

	UpgradeDbConfigFile(7); // the current file version is 07, replace it with 08

	DoCfgAttachTests(8); // version 08 will not be processed so no update to settings table

	// Test a config file that contains whitespace before and after the SQL statement

	UpgradeDbConfigFile(8); // the current file version is 08, replace it with 09

	DoCfgAttachTests(9); // version 09 will not be processed so no update to settings table

	// Test a config file that has a lower extension number

	DowngradeDbConfigFile(9); // the current file version is 09, replace it with 08

	DoCfgAttachTests(9); // version 08 will not be processed so no update to settings table

	// Test a config file that has an invalid extension

	CreateCorruptDbConfigFile(8); // the current file version is 08, replace it with a file with an invalid extension

	DoCfgAttachTests(9); // the invalid file will not be processed so no update to settings table

	// Test two versions of the config file (two versions should not be present at the same time)

	CreateTwoVersionsOfConfigFile(); // the current file has an invalid extension, delete it and create version 10 and version 11

	DoCfgAttachTests(11); // neither version 10 or 11 will be processed so no update to settings table

	// Test a config file that contains an invalid statement and a valid statement

	UpgradeDbConfigFile(11); // the current file versions are 10 and 11, replace them with 12

	DoCfgAttachTests(12); // version 12 will not be processed so no update to settings table

	// Test a config file that contains a SQL style comment

	UpgradeDbConfigFile(12); // the current file version is 12, replace it with 13

	DoCfgAttachTests(13); // version 13 will not be processed so no update to settings table

	// Test a config file that contains a 'C' style comment

	UpgradeDbConfigFile(13); // the current file version is 13, replace it with 14

	DoCfgAttachTests(14); // version 14 will not be processed so no update to settings table

	}

void DoNewDbCfgAttachTest()

	{

	// Create Db5 - a config file already exists for this

	CreateDb5();

	// Open a private, secure database - no config should occur

	TheTest.Printf(_L("===NewDbCfgAttach: Open private, secure database\r\n"));

	TInt err = TheDb.Open(KCfgDb3);

	TEST2(err, KErrNone);

    CheckRecordCount(_L("table3"));

    CheckIndexCount(0); 

	// Attach a shared, secure database - the db5 config file should not be processed

	TheTest.Printf(_L("===NewDbCfgAttach: Attach shared, secure database\r\n"));

	err = TheDb.Attach(KCfgDb5, KAttachDb5);

	TEST2(err, KErrNone);

    CheckRecordCount(_L("table5"));

    CheckIndexCount(0); // there should still be no indices in the table

	TheDb.Close();

	CheckSystemSettingsTable(KCfgDb5, 1); // check that the config file has been processed for db1

	CheckSystemSettingsTable(KCfgDb3, 0);

	}

void ResetStoredCollationDll()

	{

	// Note: We have to use SQLite directly to access the settings

	// table as the SQL Server denies permission to access this table	

	// as it is in a shared, secure database

	TParse parse;

	parse.Set(KCfgDb1, &KSqlSrvPrivatePath, 0);

	TBuf8<KMaxFileName + 1> dbFileName;

	dbFileName.Copy(parse.FullName());

	sqlite3 *dbHandle = NULL;

	TInt rc = sqlite3_open((const char*)dbFileName.PtrZ(), &dbHandle);

	TEST2(rc, SQLITE_OK);

	TBuf<100> queryBuf;

	queryBuf.Append(KResetCollationDllSql());	

	sqlite3_stmt* stmtHandle = NULL;

	const void* stmtTailZ = NULL;

	rc = sqlite3_prepare16_v2(dbHandle, queryBuf.PtrZ(), -1, &stmtHandle, &stmtTailZ);

	TEST2(rc, SQLITE_OK);

	rc = sqlite3_step(stmtHandle);

	TEST2(rc, SQLITE_DONE);

	sqlite3_finalize(stmtHandle);

	sqlite3_close(dbHandle);

	}

void CheckCollationDllUpdated()

	{

	// Note: We have to use SQLite directly to access the settings

	// table as the SQL Server denies permission to access this table

	// as it is in a shared, secure database

	TParse parse;

	parse.Set(KCfgDb1, &KSqlSrvPrivatePath, 0);

	TBuf8<KMaxFileName + 1> dbFileName;

	dbFileName.Copy(parse.FullName());

	sqlite3 *dbHandle = NULL;

	TInt rc = sqlite3_open((const char*)dbFileName.PtrZ(), &dbHandle);

	TEST2(rc, SQLITE_OK);

	_LIT(KGetCollationDllSql, "SELECT CollationDllName FROM symbian_settings");

    TBuf<100> queryBuf;

	queryBuf.Append(KGetCollationDllSql());	

	sqlite3_stmt* stmtHandle = NULL;

	const void* stmtTailZ = NULL;

	rc = sqlite3_prepare16_v2(dbHandle, queryBuf.PtrZ(), -1, &stmtHandle, &stmtTailZ);

	TEST2(rc, SQLITE_OK);

	rc = sqlite3_step(stmtHandle);

	TEST2(rc, SQLITE_ROW);

	const TUint16* collationDllName = (const TUint16*)sqlite3_column_text16(stmtHandle, 0);

	TInt collationDllNameLen  = sqlite3_column_bytes(stmtHandle, 0) / sizeof(TUint16);

	TPtrC ptr(collationDllName, collationDllNameLen);

	rc = sqlite3_step(stmtHandle);

	TEST2(rc, SQLITE_DONE);

	sqlite3_finalize(stmtHandle);

	sqlite3_close(dbHandle);

	_LIT(KTestCollationDllName, "hjagafsff");//The same as the used in KResetCollationDllSql statement

	TEST(ptr != KTestCollationDllName);

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4010

@SYMTestCaseDesc		New database configuration files feature - unit test.

						The test opens several test databases, and the database configuration

						file for one of the shared, secure databases is processed. This is

						repeated for a variety of versions of the database configuration file, 

						both valid and invalid. The same tests are repeated for when attaching, 

						rather than opening, the test databases. The test also verifies that

						reindexing occurs if necessary when a database is opened or attached,

						regardless of whether or not database configuration is also required.

						Finally, the test also verifies that a config file that exists before

						the database itself is created will be processed when the database is

						opened for the first time.				

@SYMTestPriority		High

@SYMTestActions			New database configuration files feature - unit test.

@SYMTestExpectedResults The test must not fail

@SYMCR 					LMAN-79SJ7L

*/

void DoDbCfgTests()

	{

	// Do 'open' tests for new db config file feature

	DoCfgOpenTests(1);         // open the test databases

 	DoUpgradedCfgOpenTest();  // upgrade the config file for db1 and reopen the test databases

 	DoBadCfgOpenTests();      // corrupt the config file for db1 (in a variety of ways) and reopen the test databases

 	DoNewDbCfgOpenTest();		  // create a db for which a config file already exists and then open the db

 	// Recreate the original dbs and config files

 	DeleteCfgFilesAndDbs();

 	CreateCfgFilesAndDbs();

 	// Do 'attach' tests for new db config file feature

	DoCfgAttachTests(1);		// attach the test databases

 	DoUpgradedCfgAttachTest(); // upgrade the config file for db1 and reattach the test databases

 	DoBadCfgAttachTests();     // corrupt the config file for db1 (in a variety of ways) and reattach the test databases	

    DoNewDbCfgAttachTest();	   // create a db for which a config file already exists and then attach the db

	// Recreate the original dbs and config files

 	DeleteCfgFilesAndDbs();

 	CreateCfgFilesAndDbs();

 	// Do the test that causes both reindexing and db configuration to occur when db1 is opened

	ResetStoredCollationDll();

	DoCfgOpenTests(1);

	CheckCollationDllUpdated();

	// Recreate the original dbs and config files

 	DeleteCfgFilesAndDbs();

 	CreateCfgFilesAndDbs();

 	// Do the test that causes reindexing to occur when db1 is attached (no db configuration occurs for attach)

	ResetStoredCollationDll();

	DoCfgAttachTests(1);

	CheckCollationDllUpdated(); // db1's stored collation dll name should now match db3's (to which Db1 is attached) stored collation name

	}	

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4013

@SYMTestCaseDesc		New database configuration files feature - OOM test.

						The test opens a shared secure database for which there

						exists a database configuration file that is to be processed.

						The open call is executed within an OOM loop, which causes

						an OOM error to occur at different stages of the open call. 

						The test verifies that OOM errors are handled correctly and 

						that on the final loop - when no OOM errors occur - the database is 

						successfully opened and the database configuration file is processed.	

@SYMTestPriority		High

@SYMTestActions			New database configuration files feature - OOM test.

@SYMTestExpectedResults The test must not fail

@SYMCR 					LMAN-79SJ7L

*/

void DoDbCfgOOMTests()

	{

	// Recreate the original dbs and config files

	DeleteCfgFilesAndDbs();

	CreateCfgFilesAndDbs();

	// The server is stopped at the end of CreateCfgFilesAndDbs().

	// Before the test loop below begins we attach Db1 so that the 

	// server starts up again and stores Db1's security policy in

	// CSqlServer::iSecurityMap. Otherwise there will be unmatching 

	// allocated cells in the test below. Do not call Detach() before 

	// Close(). We 'attach' Db1 here rather than 'open' it because 

	// open is the API that we want to test in the while loop

	TInt err = TheDb.Open(KCfgDb3);

	TEST2(err, KErrNone);

	err = TheDb.Attach(KCfgDb1, KAttachDb1);

	TEST2(err, KErrNone);

	TheDb.Close();

	err = KErrNoMemory;

	TInt failingAllocationNo = 0;

	while(err == KErrNoMemory)

		{		

		MarkHandles();

		MarkAllocatedCells();

		__UHEAP_MARK;

		TheTest.Printf(_L("%d\r"), failingAllocationNo + 1);

		// Set failure rate

		TSqlResourceTester::SetDbHeapFailure(RHeap::EDeterministic, ++failingAllocationNo);

		err = TheDb.Open(KCfgDb1);

		if(err != KErrNoMemory)

			{

			TEST2(err, KErrNone);

			TheDb.Close();

			if(GuessSystemSettingsTable(KCfgDb1, 0))

				{

				err = KErrNoMemory;

				}

			}

		// Reset failure rate

		TSqlResourceTester::SetDbHeapFailure(RHeap::ENone, 0);

		TheDb.Close();

		__UHEAP_MARKEND;

		CheckAllocatedCells();	    	

		CheckHandles();	    	

		}

	TEST2(err, KErrNone);

	TheTest.Printf(_L("\r\n"));

	CheckSystemSettingsTable(KCfgDb1, 1); // check that the settings table has been updated with v01 of the config file

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4014

@SYMTestCaseDesc		New database configuration files feature - File I/O failures test.

						The test opens a shared secure database for which there

						exists a database configuration file that is to be processed.

						The open call is executed within a file I/O failure loop, which

						causes a selection of file I/O errors to occur at different stages 

						of the open call. 

						The test verifies that file I/O errors are handled correctly and 

						that on the final loop - when no file I/O errors occur - the database 

						is successfully opened and the database configuration file is processed.

						NOTE: This test also acts as the test case for defect DEF116688.

@SYMTestPriority		High

@SYMTestActions			New database configuration files feature - File I/O failures test.

@SYMTestExpectedResults The test must not fail

@SYMCR					LMAN-79SJ7L

*/

void DoDbCfgFileIOFailuresTests()

	{

	// Recreate the original dbs and config files

	DeleteCfgFilesAndDbs();

	CreateCfgFilesAndDbs();

	// The server is stopped at the end of CreateCfgFilesAndDbs().

	// Before the test loop below begins we start the server again