// Copyright (c) 2008-2009 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"

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

/// 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(KTestDir, "c:\\test\\");

_LIT(KSqlSrvName, "sqlsrv.exe");

enum TConfigParamType {EPrmCacheSize, EPrmPageSize, EPrmDbEncoding};

TInt KillProcess(const TDesC& aProcessName);

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

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

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

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

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

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

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

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

_LIT(KGetSettingsSql, "SELECT * FROM symbian_settings WHERE Reserved==%d");

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

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

_LIT(KAttachDb1, "Db1");

_LIT(KAttachDb2, "Db2");

_LIT(KAttachDb5, "Db5");

_LIT(KDb1CheckNumRecords, "SELECT * FROM table1");

_LIT(KDb2CheckNumRecords, "SELECT * FROM table2");

_LIT(KDb3CheckNumRecords, "SELECT * FROM table3");

_LIT(KDb4CheckNumRecords, "SELECT * FROM table4");

_LIT(KDb5CheckNumRecords, "SELECT * FROM table5");

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

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

// Destroy functions

TInt KillProcess(const TDesC& aProcessName)

	{

	TFullName name;

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

	TBuf<64> pattern(aProcessName);

	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();

		}

	return KErrNone;

	}

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();

	(void)KillProcess(KSqlSrvName);

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

	TEST(TheHandleCount1 == endHandleCount1);

	TEST(TheHandleCount2 == endHandleCount2);

	}

void MarkAllocatedCells()

	{

	TheAllocatedCellsCount = User::CountAllocCells();

	}

void CheckAllocatedCells()

	{

	TInt allocatedCellsCount = User::CountAllocCells();

	TEST(allocatedCellsCount == TheAllocatedCellsCount);

	}

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

// Set up functions

TInt DoCreateSecurityPolicy(RSqlSecurityPolicy& securityPolicy)

	{

	const TSecurityPolicy KDefaultPolicy(TSecurityPolicy::EAlwaysPass);

	if((KErrNone != securityPolicy.Create(KDefaultPolicy))

	   ||

	   (KErrNone != securityPolicy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, KDefaultPolicy))

	   ||

	   (KErrNone != securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, KDefaultPolicy))

	   ||

	   (KErrNone != securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, KDefaultPolicy)))

		{

		return KErrGeneral;

		}

	return KErrNone;

	}

void CreateCfgFiles()

	{

 	// Create v01 of the test config files

 	RFile file;

	TFileName fileName;

	TInt v1 = 1;

	fileName.Format(KCfgDb1ConfigFilePath(), v1);

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

	TEST2(err, KErrNone);

	TPtrC8 pDb1((const TUint8*)KCfgDb1ConfigFile01Stmts().Ptr(), KCfgDb1ConfigFile01Stmts().Length());

	err = file.Write(pDb1);	

	file.Close();	

	TEST2(err, KErrNone);

	fileName.Copy(KCfgDb3ConfigFileV01Path);

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

	TEST2(err, KErrNone);

	TPtrC8 pDb3((const TUint8*)KCfgDb3ConfigFile01Stmts().Ptr(), KCfgDb3ConfigFile01Stmts().Length());

	err = file.Write(pDb3);	

	file.Close();	

	TEST2(err, KErrNone);	

	fileName.Copy(KCfgDb4ConfigFileV01Path);

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

	TEST2(err, KErrNone);

	TPtrC8 pDb4((const TUint8*)KCfgDb4ConfigFile01Stmts().Ptr(), KCfgDb4ConfigFile01Stmts().Length());

	err = file.Write(pDb4);	

	file.Close();	

	TEST2(err, KErrNone);

	fileName.Copy(KCfgDb5ConfigFileV01Path); // create the config file for Db5 before the database has been created

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

	TEST2(err, KErrNone);

	TPtrC8 pDb5((const TUint8*)KCfgDb5ConfigFile01Stmts().Ptr(), KCfgDb5ConfigFile01Stmts().Length());

	err = file.Write(pDb5);	

	file.Close();	

	TEST2(err, KErrNone);	

	}

void CreateCfgDbs()

	{

	// Create the test databases

 	TBuf<100> sql;

 	RSqlSecurityPolicy securityPolicy;

 	TInt err = DoCreateSecurityPolicy(securityPolicy);

 	TEST2(err, KErrNone);

 	err = TheDb.Create(KCfgDb1, securityPolicy);

 	TEST2(err, KErrNone);

 	sql.Copy(_L("CREATE TABLE table1(i1 INTEGER, i2 INTEGER, i3 INTEGER)"));

 	err = TheDb.Exec(sql);

 	TEST(err >= 0);

 	sql.Copy(_L("INSERT INTO table1 (i1,i2,i3) values(1,2,3)"));

 	err = TheDb.Exec(sql);

 	TEST(err == 1);

 	TheDb.Close();

 	err = TheDb.Create(KCfgDb2, securityPolicy);

 	TEST2(err, KErrNone);

 	sql.Copy(_L("CREATE TABLE table2(i1 INTEGER, i2 INTEGER, i3 INTEGER)"));

 	err = TheDb.Exec(sql);

 	TEST(err >= 0);

 	sql.Copy(_L("INSERT INTO table2 (i1,i2,i3) values(4,5,6)"));

 	err = TheDb.Exec(sql);

 	TEST(err == 1);

 	TheDb.Close();

 	securityPolicy.Close();

 	err = TheDb.Create(KCfgDb3);

 	TEST2(err, KErrNone);

 	sql.Copy(_L("CREATE TABLE table3(i1 INTEGER, i2 INTEGER)"));

 	err = TheDb.Exec(sql);

 	TEST(err >= 0);

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

 	err = TheDb.Exec(sql);

 	TEST(err == 1);

 	TheDb.Close();	

 	err = TheDb.Create(KCfgDb4);

 	TEST2(err, KErrNone);

 	sql.Copy(_L("CREATE TABLE table4(i1 INTEGER, i2 INTEGER, i3 INTEGER)"));

 	err = TheDb.Exec(sql);

 	TEST(err >= 0);

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

 	err = TheDb.Exec(sql);

 	TEST(err == 1);

 	TheDb.Close();

 	}

void CreateCfgFilesAndDbs()

	{

	CreateCfgFiles();

	CreateCfgDbs();

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

	// created above are found and processed when it restarts

	(void)KillProcess(KSqlSrvName);

 	}

 void CreateDb5()

	{

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

 	TBuf<100> sql;

 	RSqlSecurityPolicy securityPolicy;

 	TInt err = DoCreateSecurityPolicy(securityPolicy);

 	TEST2(err, KErrNone);

 	err = TheDb.Create(KCfgDb5, securityPolicy);

 	TEST2(err, KErrNone);

 	sql.Copy(_L("CREATE TABLE table5(i1 INTEGER, i2 INTEGER, i3 INTEGER)"));

 	err = TheDb.Exec(sql);

 	TEST(err >= 0);

 	sql.Copy(_L("INSERT INTO table5 (i1,i2,i3) values(1,2,3)"));

 	err = TheDb.Exec(sql);

 	TEST(err == 1);

 	TheDb.Close();

 	securityPolicy.Close();

	}

void SetupTestEnv()

    {

	TInt err = TheFs.Connect();

	TEST2(err, KErrNone);

	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(const TInt aCurrentVersion)

	{

	(void)KillProcess(KSqlSrvName);

	TFileName oldFile;

	oldFile.Format(KCfgDb1ConfigFilePath(), aCurrentVersion);

	TInt err = TheFs.Delete(oldFile);

	TEST2(err, KErrNone);

	RFile file;

	TFileName newFile;

	TInt newVersion = aCurrentVersion+1;

	newFile.Format(KCfgDb1ConfigFilePath(), newVersion);

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

	TEST2(err, KErrNone);

	switch(newVersion)

		{

			case 2:

				{

				TPtrC8 p((const TUint8*)KCfgConfigFileValidStmt().Ptr(), KCfgConfigFileValidStmt().Length());

				err = file.Write(p);

				break;

				}

			case 3:

				{

				TPtrC8 p((const TUint8*)KCfgDb1ConfigFileV03EmptyStmt().Ptr(), KCfgDb1ConfigFileV03EmptyStmt().Length());

				err = file.Write(p);

				break;

				}

			case 4:

				{

				TPtrC8 p((const TUint8*)KCfgDb1ConfigFileV04UnsupportedStmt().Ptr(), KCfgDb1ConfigFileV04UnsupportedStmt().Length());

				err = file.Write(p);

				break;	

				}

			case 5:

				{

				TPtrC8 p((const TUint8*)KCfgDb1ConfigFileV05OnlyWhitespaceStmt().Ptr(), KCfgDb1ConfigFileV05OnlyWhitespaceStmt().Length());

				err = file.Write(p);

				break;

				}	

			case 6:

				{

				TPtrC8 p((const TUint8*)KCfgDb1ConfigFileV06InvalidSchemaStmt().Ptr(), KCfgDb1ConfigFileV06InvalidSchemaStmt().Length());

				err = file.Write(p);

				break;

				}

			case 7:

				{

				TPtrC8 p((const TUint8*)KCfgDb1ConfigFileV07InvalidCommentedStmt().Ptr(), KCfgDb1ConfigFileV07InvalidCommentedStmt().Length());

				err = file.Write(p);	

				break;

				}

			case 8:

				{

				TPtrC8 p((const TUint8*)KCfgDb1ConfigFileV08SeqStmt().Ptr(), KCfgDb1ConfigFileV08SeqStmt().Length());

				err = file.Write(p);	

				break;

				}

			case 9:

				{

				TPtrC8 p((const TUint8*)KCfgDb1ConfigFileV09WhitespacePreAndPostStmt().Ptr(), KCfgDb1ConfigFileV09WhitespacePreAndPostStmt().Length());

				err = file.Write(p);	

				break;

				}

			case 12:

				{

				// also delete version 10 of file

				oldFile.Format(KCfgDb1ConfigFilePath(), 10);

				err = TheFs.Delete(oldFile);

				TEST2(err, KErrNone);	

				TPtrC8 p((const TUint8*)KCfgDb1ConfigFileV12InvalidPlusValidStmt().Ptr(), KCfgDb1ConfigFileV12InvalidPlusValidStmt().Length());

				err = file.Write(p);

				break;

				}

			case 13:

				{

				TPtrC8 p((const TUint8*)KCfgDb1ConfigFileV13SQLCommentStmt().Ptr(), KCfgDb1ConfigFileV13SQLCommentStmt().Length());

				err = file.Write(p);	

				break;

				}

			case 14:

				{

				TPtrC8 p((const TUint8*)KCfgDb1ConfigFileV14CCommentStmt().Ptr(), KCfgDb1ConfigFileV14CCommentStmt().Length());

				err = file.Write(p);	

				break;

				}

			default:

				{

				err = KErrArgument;

				break;

				}		

		}

	file.Close();

	TEST2(err, KErrNone);

	}	

void DowngradeDbConfigFile(const TInt aCurrentVersion)

	{

	(void)KillProcess(KSqlSrvName);

	TFileName oldFile;

	oldFile.Format(KCfgDb1ConfigFilePath(), aCurrentVersion);

	TInt err = TheFs.Delete(oldFile);

	TEST2(err, KErrNone);