// Copyright (c) 2007-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 <sqldb.h>

//#include "SqlUtil.h"

#include "SqlSrvConfig.h"

#include "SqlResourceTester.h"

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

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

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

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

#ifdef SYSLIBS_TEST	

RFs TheFs;

RSqlDatabase TheDb;

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

_LIT(KTestDbName, "c:\\test\\t_sqlconfigfile.db");

_LIT(KSqlSrvConfigFile, "c:\\test\\t_sqlserver.cfg");

_LIT(KSqlSrvName, "sqlsrv.exe");

enum TConfigParamType {EPrmCacheSize, EPrmPageSize, EPrmDbEncoding};

//Default configuration parameter values, defined in ../test/sqlserver.cfg file

//(the same as the build-time configuration parameter values)

const TInt KDefaultPageSize = 1024;

const TInt KDefaultCacheSize = (TSqlSrvConfigParams::KDefaultSoftHeapLimitKb * 1024) / KDefaultPageSize;

const TSqlSrvConfigParams::TDbEncoding KDefaultEncoding = TSqlSrvConfigParams::EEncUtf16;

TInt KillProcess(const TDesC& aProcessName);

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

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

	{

	TheDb.Close();

	(void)KillProcess(KSqlSrvName);

	(void)TheFs.Delete(KTestDbName);

	(void)TheFs.Delete(KSqlSrvConfigFile);

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

		RDebug::Print(_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 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);

	(void)TheFs.Delete(KTestDbName);

	(void)TheFs.Delete(KSqlSrvConfigFile);

	}

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

// Parameter check functions

TInt DoGetConfigParamValueL(RSqlDatabase& aDb, TConfigParamType aPrmType)

	{

	TSqlScalarFullSelectQuery q(aDb);

	TInt res = 0;

	switch(aPrmType)

		{

		case EPrmCacheSize:

			res = q.SelectIntL(_L8("PRAGMA cache_size"));

			break;

		case EPrmPageSize:

			res = q.SelectIntL(_L8("PRAGMA page_size"));

			break;

		case EPrmDbEncoding:

			{

			TBuf<20> dbEncodingText;

			res = q.SelectTextL(_L8("PRAGMA encoding"), dbEncodingText);

			TEST2(res, KErrNone);

			if(dbEncodingText.FindF(_L("UTF-16")) >= 0)

				{

				res = TSqlSrvConfigParams::EEncUtf16;	

				}

			else if(dbEncodingText.FindF(_L("UTF-8")) >= 0)

				{

				res = TSqlSrvConfigParams::EEncUtf8;	

				}

			else

				{

				TEST2(0, 1);

				}

			}

			break;

		default:

			TEST2(0, 1);

			break;

		}

	return res;

	}

TInt GetConfigParamValue(RSqlDatabase& aDb, TConfigParamType aPrmType)

	{

	TInt res = 0;

	TRAPD(err, res = DoGetConfigParamValueL(aDb, aPrmType));

	TEST2(err, KErrNone);

	return res;

	}

void AssertConfigPrmValues(RSqlDatabase& aDb, TInt aExpectedCacheSize, TInt aExpectedPageSize, TInt aExpectedDbEncoding)

	{

	TInt cacheSize = GetConfigParamValue(aDb, EPrmCacheSize);

	TInt pageSize = GetConfigParamValue(aDb, EPrmPageSize);

	TInt dbEncoding = GetConfigParamValue(aDb, EPrmDbEncoding);

	TEST2(cacheSize, aExpectedCacheSize);

	TEST2(pageSize, aExpectedPageSize);

	TEST2(dbEncoding, aExpectedDbEncoding);

	}

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

// Config file replacement functions

// File config strings are 16-bit.

void ReplaceConfigFile(const TDesC16& aConfig)

	{

	(void)KillProcess(KSqlSrvName);

	(void)TheFs.Delete(KSqlSrvConfigFile);

	RFile file;

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

	TEST2(err, KErrNone);

	TPtrC8 p((const TUint8*)aConfig.Ptr(), aConfig.Length() * sizeof(TUint16));

	err = file.Write(p);

	file.Close();

	TEST2(err, KErrNone);

	}

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

//

/**

@SYMTestCaseID			SYSLIB-SQL-UT-3603

@SYMTestCaseDesc		Bad config file test

						The test creates bad config files like:

							- empty config file;

							- "\n" config file;

							- "\r\n" config file;

							- config file with comment lines only;

						Then the test restarts the SQL server and checks that the bad config file is detected and 

						appropriate error code - returned to the caller (during "database create" operation).

@SYMTestPriority		High

@SYMTestActions			Bad config file test

@SYMTestExpectedResults The test must not fail

@SYMREQ					REQ8162

*/

void BadCfgFileTest()

	{

	//Empty config file	

	ReplaceConfigFile(_L(""));

	TInt err = TheDb.Create(KTestDbName);

	TEST2(err, KErrEof);//BC kept - an empty config file is treated as invalid

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"\n" config file	

	ReplaceConfigFile(_L("\n"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrEof);//BC compatible

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"\r\n" config file	

	ReplaceConfigFile(_L("\r\n"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrEof);//BC compatible

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"        \r\n" config file	

	ReplaceConfigFile(_L("        \r\n"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrEof);//BC compatible

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"  # \r\n" config file

	ReplaceConfigFile(_L("  # \r\n"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrEof);//BC compatible

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"  # \r\na=b\r\n" config file

	ReplaceConfigFile(_L("  # \r\na=b\r\n"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrNone);

	AssertConfigPrmValues(TheDb, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"  # \r\n   a=b   \r\n" config file

	ReplaceConfigFile(_L("  # \r\n   a=b   \r\n"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrNone);

	AssertConfigPrmValues(TheDb, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"  # \r\n   a=b  " config file

	ReplaceConfigFile(_L("  # \r\n   a=b  "));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrNone);

	AssertConfigPrmValues(TheDb, KDefaultCacheSize, KDefaultPageSize, KDefaultEncoding);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	(void)TheFs.Delete(KSqlSrvConfigFile);

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-3604

@SYMTestCaseDesc		Config file with bad parameters test

						The test creates config files with bad parameters like:

							- negative cache size;

							- non-numeric cache size value;

							- empty cache size value;

							- negative page size;

							- non-numeric page size value;

							- empty page size value;

							- negative soft heap limit size;

							- non-numeric soft heap limit value;

							- empty soft heap limit value;

							- too small soft heap limit value;

							- too big soft heap limit value;

							- negative free page threshold value;

							- empty free page threshold value;

							- non-numeric free page threshold value;

						Then the test restarts the SQL server and checks that the bad config file is detected and 

						appropriate error code - returned to the caller (during "database create" operation).

@SYMTestPriority		High

@SYMTestActions			Config file with bad parameters test

@SYMTestExpectedResults The test must not fail

@SYMREQ					REQ8162

                        REQ10271

*/

void BadCfgFileParametersTest()

	{

	/////////////// cache_size  ////////////////

	//"cache_size=-20;" config file

	ReplaceConfigFile(_L("cache_size=-20;"));

	TInt err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"cache_size=456.90" config file

	ReplaceConfigFile(_L("cache_size=456.90"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrNone);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"cache_size='dfjkhdfjk';" config file

	ReplaceConfigFile(_L("cache_size='dfjkhdfjk';"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"cache_size=;" config file

	ReplaceConfigFile(_L("cache_size=;"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	/////////////// page_size  ////////////////

	//"page_size=-55" config file

	ReplaceConfigFile(_L("page_size=-55"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"page_size=25.89" config file

	ReplaceConfigFile(_L("page_size=25.89"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrNone);//BC compatible

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"page_size=gffgrtj" config file

	ReplaceConfigFile(_L("page_size=gffgrtj"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"page_size=" config file

	ReplaceConfigFile(_L("page_size="));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	////////   soft_heap_limit_kb    ///////////

	//"soft_heap_limit_kb=-10" config file

	ReplaceConfigFile(_L("soft_heap_limit_kb=-10"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"soft_heap_limit_kb=5" config file (bellow min limit - 8Kb when SYSLIBS_TEST macro is defined)

	ReplaceConfigFile(_L("soft_heap_limit_kb=5"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"soft_heap_limit_kb=8" config file (the min limit - 8Kb when SYSLIBS_TEST macro is defined)

	ReplaceConfigFile(_L("soft_heap_limit_kb=8"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrNone);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"soft_heap_limit_kb=2000000000" config file (above max limit)

	ReplaceConfigFile(_L("soft_heap_limit_kb=2000000000"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"soft_heap_limit_kb=KMaxTInt/1024" config file (the max limit)

	TBuf<32> configBuf;

	configBuf.Copy(_L("soft_heap_limit_kb="));

	TInt maxSoftHeapLimit = KMaxTInt / 1024;

	configBuf.AppendNum(maxSoftHeapLimit);

	ReplaceConfigFile(configBuf);

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrNone);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"soft_heap_limit_kb=sdfcvyua" config file

	ReplaceConfigFile(_L("soft_heap_limit_kb=sdfcvyua"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"soft_heap_limit_kb=" config file

	ReplaceConfigFile(_L("soft_heap_limit_kb="));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"soft_heap_limit_kb=1023.456" config file

	ReplaceConfigFile(_L("soft_heap_limit_kb=1023.456"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrNone);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	////////   free_space_threshold_kb    ///////////

	//"free_space_threshold_kb=-10" config file

	ReplaceConfigFile(_L("free_space_threshold_kb=-10"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"free_space_threshold_kb=0" config file

	ReplaceConfigFile(_L("free_space_threshold_kb=0"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrNone);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"free_space_threshold_kb=" config file

	ReplaceConfigFile(_L("free_space_threshold_kb="));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"free_space_threshold_kb=34.56" config file

	ReplaceConfigFile(_L("free_space_threshold_kb=34.56"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrNone);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

	//"free_space_threshold_kb=gfghfg" config file

	ReplaceConfigFile(_L("free_space_threshold_kb=gfghfg"));

	err = TheDb.Create(KTestDbName);

	TEST2(err, KErrArgument);

	TheDb.Close();

	(void)RSqlDatabase::Delete(KTestDbName);

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

	(void)TheFs.Delete(KSqlSrvConfigFile);

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-3605

@SYMTestCaseDesc		Config parameters conflict test.

						1) The test creates a database with cache size parameter value specified in both the config file and the

							config string. The expectation is that the config string parameter will be used.

						2) The test creates a database with page size parameter value specified in both the config file and the

							config string. The expectation is that the config string parameter will be used.

						3) The test creates a database with encoding parameter value specified in both the config file and the

							config string. The expectation is that the config string parameter will be used.

						4) The test creates a database with soft heap limit value specified in both the config file and the

							config string. The expectation is that the database creation will fail (the soft heap limit

							cannot be configured using a config string).

						5) The test creates a database with free page threshold value specified in both the config file and the

							config string. The expectation is that the database creation will succeeds. The free page threshold

							value from the config file will be used.

@SYMTestPriority		High

@SYMTestActions			Config parameters conflict test

@SYMTestExpectedResults The test must not fail

@SYMREQ					REQ8162

                        REQ10271

*/

void CfgFileConflictTest()

	{

	//"cache_size=200" config file

	//"cache_size=100" client config string

	ReplaceConfigFile(_L("cache_size=200"));

	_LIT8(KConfigStr1, "cache_size=100");