// Copyright (c) 2006-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 <bautils.h>
#include <sqldb.h>

#define __SQLSRV_STRINGS__
#include "SqlSrvStrings.h"

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

RFs TheFs;
RSqlDatabase TheDb;
TParse TheFileNameParse;
RTest TheTest(_L("t_sqlauthorizer test"));

const TSecurityPolicy KPolicy1(ECapabilityReadUserData, ECapabilityNetworkControl,  ECapabilityWriteUserData);
const TSecurityPolicy KPolicy2(ECapabilityReadUserData);

_LIT8(KPragma , 		"PRAGMA %S.%S\x0");
_LIT8(KPragmaWithParam, "PRAGMA %S.%S%S\x0");

_LIT(KPublicDir,  "C:\\test\\");
_LIT(KPrivateDir, "C:\\private\\21212129\\");

_LIT(KPublicDbName,	 "C:\\test\\t_sqlauthorizer.db");
_LIT(KSecureDbName,  "C:[21212129]t_sqlauthorizer.db");
_LIT(KPrivateDbName, "C:\\private\\21212129\\t_sqlauthorizer.db");
_LIT(KAttachDb, "AttachedDB");

_LIT(KCreateTable1, "CREATE TABLE A(Id INTEGER,Name TEXT)");
_LIT(KCreateTable2, "CREATE TABLE B(Id INTEGER,Address TEXT, Num INTEGER, FOREIGN KEY (Address) REFERENCES A(id))");
_LIT(KCreateIndex, 	"CREATE INDEX Index1 ON B (Num)");
_LIT(KInsertTable, 	"INSERT INTO A VALUES(1, 'AAA')");

TBuf8<KMaxFileName + 64> TheSql;
const TInt KNumPragma = 34;

//////////////////////////////////////////// Input List  ///////////////////////////////////////////////
struct TInputList
	{
	const TPtrC8 iPragmaName;
	const TPtrC8 iReadParam;
	const TPtrC8 iWriteParam;
	};

const TInputList KInputList [KNumPragma] = 
	{
	////////////////////////////////////////////////////////////////////////////////////////////////
	//	Pragma Name	  	  		 |Read Parameter   |Write Parameter			|Pragma Command    
	////////////////////////////////////////////////////////////////////////////////////////////////
		{KAutoVacuum(), 		  KNullDesC8(), 	_L8(" = 0")}, 			//auto_vacuum
		{KCacheSize(),			  KNullDesC8(), 	_L8(" = 32")},			//cache_size
		{KCaseSensitiveLike(), 	  KNullDesC8(), 	_L8(" = 0")},			//case_sensitive_like
		{KCountChanges(), 	   	  KNullDesC8(), 	_L8(" = 1")},			//count_changes
		{KDefaultCacheSize(), 	  KNullDesC8(), 	_L8(" = 32")},			//DefaultAccess_cache_size	
		{KEmptyResultCallbacks(), KNullDesC8(), 	_L8(" = 0")},			//empty_result_callbacks
		{KEncoding(), 			  KNullDesC8(), 	_L8(" = \"UTF-8\"")},	//encoding
		{KFullColumnNames(), 	  KNullDesC8(), 	_L8(" = 0")},			//full_column_names
		{KFullfsync(), 			  KNullDesC8(), 	_L8(" = 1")},			//fullfsync
		{KIncrementalVacuum(), 	  KNullDesC8(), 	_L8(" = 0")},			//incremental_vacuum
		{KJournalMode(), 		  KNullDesC8(), 	_L8(" = DELETE")},		//journal_mode
		{KJournalSizeLimit(),	  KNullDesC8(), 	_L8(" = 1000000")},		//journal_size_limit
		{KLegacyFileFormat(), 	  KNullDesC8(), 	_L8(" = ON")},			//legacy_file_format
		{KLockingMode(), 		  KNullDesC8(), 	_L8(" = Normal")},		//locking_mode
		{KPageSize(), 			  KNullDesC8(), 	_L8(" = 2048")},		//page_size		
		{KMaxPageCount(), 		  KNullDesC8(), 	_L8(" = 32")},			//max_page_count
		{KReadUncommitted(), 	  KNullDesC8(), 	_L8(" = 1")},			//read_uncommitted
		{KShortColumnNames(), 	  KNullDesC8(), 	_L8(" = 0")},			//short_column_names
		{KSynchronousFlag(), 	  KNullDesC8(), 	_L8(" = NORMAL")}, 		//synchronous
		{KTempStore(), 			  KNullDesC8(), 	_L8(" = MEMORY")},		//temp_store	
		{KTempStoreDirectory(),   KNullDesC8(), 	_L8(" = TEMP")}, 		//temp_store_directory
		{KDatabaseList(), 		  KNullDesC8(), 	KNullDesC8()},			//database_list
		{KForeignKeyList(), 	  _L8("(B)"), 		KNullDesC8()},			//foreign_key_list
		{KFreelistCount(), 		  KNullDesC8(), 	KNullDesC8()},			//freelist_count
		{KIndexInfo(), 			  _L8("(Index1)"), 	KNullDesC8()},			//index_info		
		{KIndexIist(), 			  _L8("(B)"), 		KNullDesC8()},			//index_list
		{KPageCount(), 			  KNullDesC8(), 	KNullDesC8()},			//page_count
		{KTableInfo(), 			  _L8("(B)"), 		KNullDesC8()},			//table_info
		{KSchemaVersion(), 		  KNullDesC8(), 	_L8(" = 10")},			//schema_version
		{KUserVersion(), 		  KNullDesC8(), 	_L8(" = 10")},			//user_version	
		{KIntegrityCheck(), 	  KNullDesC8(), 	_L8(" = 1")},			//integrity_check
		{KParserTrace(), 		  KNullDesC8(), 	_L8(" = ON")},			//parser_trace
		{KVdbeTrace(), 			  KNullDesC8(), 	_L8(" = ON")},			//vdbe_trace
		{KdbeListing(), 		  KNullDesC8(), 	_L8(" = ON")},			//vdbe_listing
	};

//////////////////////////////////////////////// Expected results ///////////////////////////////////////////////////////////

enum TAccessType
	{
	EReadParam,
	EWriteParam,
	};

enum TDatabaseType
	{
	ENonSecure,
	ESecure,
	};

enum TAccessResult
	{
	EOk = KErrNone,
	EIgnore,
	EDeny,
	ENoCheck
	};


// Table listing the expected for each pragma command for the following access conditions:-
// 1) Pragma Read with non-secure database
// 2) Pragma Write with non-secure database
// 3) Pragma Read with secure database
// 4) Pragma Write with secure database
const TInt KResultsTable[KNumPragma][4] = 
	{
		////////////////////////////////////////////////////////////////////////////////////
		//		NON_SECURE	  	|			SECURE		|
		//W/out Pram |With Param|W/out Pram |With Param |Pragma Command 
		///////////////////////////////////////////////////////////////////////////////////
		{EOk,		EIgnore,	EDeny, 		EDeny }, 	//auto_vacuum
		{EOk,		EIgnore,	EDeny,		EDeny }, 	//cache_size
		{EOk,		ENoCheck,	EDeny,		EDeny },	//case_sensitive_like  
		{EOk,		EOk,		EDeny,		EDeny }, 	//count_changes
		{EOk,		EIgnore,	EDeny,		EDeny }, 	//cache_size
		{EOk,		EIgnore,	EDeny,		EDeny }, 	//empty_result_callbacks
		{EOk,		EIgnore,	EDeny,		EDeny },  	//encoding
		{EOk,		EOk,		EDeny,		EDeny },	//full_column_names
		{EOk,		EIgnore,	EDeny,		EDeny },	//fullfsync
		{EIgnore,	EIgnore,	EDeny,		EDeny },	//incremental_vacuum
		{EIgnore,	EIgnore,	EDeny,		EDeny },	//journal_mode
		{EIgnore,	EIgnore,	EDeny,		EDeny }, 	//journal_size_limit
		{EOk,		EIgnore,	EDeny,		EDeny }, 	//legacy_file_format
		{EOk,		EIgnore,	EDeny,		EDeny },	//locking_mode
		{EOk,		EIgnore,	EDeny,		EDeny },	//page_size
		{EIgnore,	EIgnore,	EDeny,		EDeny },	//max_page_count
		{EOk,		EIgnore,	EDeny,		EDeny },	//read_uncommitted
		{EOk,		EOk,		EDeny,		EDeny },	//short_column_names
		{EOk,		EIgnore,	EDeny,		EDeny },	//synchronous
		{EOk,		EIgnore,	EDeny,		EDeny },	//temp_store
		{EOk,		ENoCheck,	EDeny,		EDeny },	//temp_store_directory
		{EOk,		EOk,		EDeny,		EDeny },	//database_list
		{ENoCheck,	EOk,		EDeny,		EDeny },	//foreign_key_list
		{EOk,		EIgnore,	EDeny,		EDeny },	//freelist_count
		{ENoCheck,	EOk,		EDeny,		EDeny },	//index_info
		{ENoCheck,	EOk,		EDeny,		EDeny },	//index_list
		{EOk,		EIgnore,	EDeny,		EDeny },	//page_count
		{ENoCheck,	EOk,		EDeny,		EDeny },	//table_info
		{EOk,		EIgnore,	EDeny,		EDeny },	//schema_version
		{EOk,		EIgnore,	EDeny,		EDeny },	//user_version
		{EOk,		EIgnore,	EDeny,		EDeny },	//integrity_check
		{EOk,		EIgnore,	EDeny,		EDeny },	//parser_trace
		{EOk,		EIgnore,	EDeny,		EDeny },	//vdbe_trace
		{EOk,		EIgnore,	EDeny,		EDeny },	//vdbe_trace
	};

///////////////////////////////////////////////////////////////////////////////////////
//Deletes all created test files.
void DeleteTestFiles()
	{	
	(void)RSqlDatabase::Delete(KPrivateDbName);
	(void)RSqlDatabase::Delete(KSecureDbName);
	(void)RSqlDatabase::Delete(KPublicDbName);
	}

///////////////////////////////////////////////////////////////////////////////////////
//Test macros and functions
void Check1(TInt aValue, TInt aLine)
	{
	if(!aValue)
		{
		DeleteTestFiles();
		RDebug::Print(_L("*** Line %d\r\n"), aLine);
		TheTest(EFalse, aLine);
		}
	}
void Check2(TInt aValue, TInt aExpected, TInt aLine)
	{
	if(aValue != aExpected)
		{
		DeleteTestFiles();
		RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);
		TheTest(EFalse, aLine);
		}
	}
#define TEST(arg) ::Check1((arg), __LINE__)
#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)

///////////////////////////////////////////////////////////////////////////////////////////////////////////
//Creates file session instance and the test directory
void CreateTestEnv()
    {
	TInt err = TheFs.Connect();
	TEST2(err, KErrNone);

	err = TheFs.MkDir(KPublicDir);
	TEST(err == KErrNone || err == KErrAlreadyExists);
	
	err = TheFs.MkDir(KPrivateDir);
	TEST(err == KErrNone || err == KErrAlreadyExists);
	}
///////////////////////////////////////////////////////////////////////////////////////////////////////////
//Create and setup all the database test files

//Perform common setup steps for all databases
void SetupTestDb()
	{
	TInt err = TheDb.Exec(KCreateTable1);
	TEST(err >= KErrNone);

	err = TheDb.Exec(KCreateTable2);
	TEST(err >= KErrNone);

	err = TheDb.Exec(KCreateIndex);
	TEST(err >= KErrNone);

	err = TheDb.Exec(KInsertTable);
	TEST(err >= KErrNone);	
	}

void CreateTestDBs()
	{
	RSqlSecurityPolicy policy; //required for secure database
	
	//Create Private Database
	TInt err = TheDb.Create(KPublicDbName);
	TEST2(err, KErrNone);
	
	SetupTestDb();
	
	TheDb.Close();

	//Create Public Database
	err = TheDb.Create(KPrivateDbName);
	TEST2 (err, KErrNone);
	
	SetupTestDb();
	
	TheDb.Close();
	
	//Create Secure Database
	err = policy.Create(TSecurityPolicy(TSecurityPolicy::EAlwaysPass));
	TEST2 (err, KErrNone);
	err = policy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, KPolicy1);
	TEST2 (err, KErrNone);
	err = policy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, KPolicy2);
	TEST2 (err, KErrNone);
	err = TheDb.Create(KSecureDbName,policy);
	TEST2 (err, KErrNone);
	
	SetupTestDb();
	
	policy.Close();
	TheDb.Close();	
	}

void PragmaTests(const TAccessType aAccessType, TDatabaseType aDbType, TBool aAttached)
	{
	TBuf8<10> databaseName;
	TPtrC8 param;
	TInt index = 0;
	//Depending if we are 
	aAttached ? databaseName.Copy(_L8("AttachedDB")) : databaseName.Copy(_L8("main"));
	
	if(aDbType == ENonSecure)
		{
		index = (aAccessType == EReadParam) ? 0 : 1;
		}
	else
		{
		index = (aAccessType == EReadParam) ? 2 : 3;
		}
	
	for(TInt i=0;i<KNumPragma;i++)
		{
//////////////////////////////////// Formatting the pragma string ////////////////////////////////////////
//Check to see if a parameter value is needed for input
		
		(aAccessType == EReadParam) ? param.Set(KInputList[i].iReadParam) : param.Set(KInputList[i].iWriteParam);
		if (param != KNullDesC8)
			{
			//Formatting Pragma Strings with Parameters
			TheSql.Format(KPragmaWithParam, &databaseName, &KInputList[i].iPragmaName, &param);
			}
		else
			{
			//Formatting Pragma Strings without Parameters
			TheSql.Format(KPragma, &databaseName, &KInputList[i].iPragmaName);
			}

//////////////////// Executing the pragma and checking the results against the "ResultsTable" ////////////
					
			RSqlStatement stmt;
			TInt err = stmt.Prepare(TheDb, TheSql);
			RDebug::Printf("Testing the following pragma command - %s",TheSql.Ptr());
			switch (KResultsTable[i][index])
				{
				case EOk:
				case EIgnore:
					TEST2(err, KErrNone);
					break;
				case EDeny:
					TEST2(err, KErrPermissionDenied);
					break;
				case ENoCheck:
					break;
				default:
					TEST(KErrNone);
				}
			stmt.Close();
		}
	}

//This function will perform the following to test authorizer:-
// 1) Setup the connection - either using a single or attached database
// 2) Test the authorizer using pragma 'writes'
// 3) Test the authorizer using pragma 'reads'  
void PerformPragmaTest(const TDesC16& aDatabaseName, TDatabaseType aDbType, TBool aAttached)
	{
	TInt err = 0;
	
	if(aAttached)
		{
		if (aDatabaseName.Compare(KSecureDbName) == 0)
			{
			TheDb.Open(KPublicDbName);
			TEST2(err, KErrNone);
			}
		else
			{
			TheDb.Open(KSecureDbName);
			TEST2(err, KErrNone);
			}
		
		err = TheDb.Attach(aDatabaseName,KAttachDb);
		TEST2(err, KErrNone);
		}
	else
		{
		err = TheDb.Open(aDatabaseName);
		TEST2(err, KErrNone);
		}
	
	//Testing Pragma Reads
	PragmaTests(EReadParam, aDbType, aAttached);

	//Testing Pragma Writes
	PragmaTests(EWriteParam, aDbType, aAttached);
	
	TheDb.Close();
	}

/**
@SYMTestCaseID			PDS-SQL-UT-4122
@SYMTestCaseDesc		Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
						Execute all SQL pragmas to test the permissions returned from the CSqlSrvDatabase::AuthorizeCallback
						function is correct.
						The test attempts to execute pragmas for the following cases:-
						1) Without paramter (also known as 'Read' access)
						2) With parameter (also known as 'Write' access)
						The database tested in this case is a public database. 
@SYMTestPriority		High
@SYMTestActions			Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
@SYMTestExpectedResults Test must not fail
@SYMDEF					DEF129581
*/
void PublicDbPragmaTest()
	{
	PerformPragmaTest(KPublicDbName(), ENonSecure, EFalse);
	}

/**
@SYMTestCaseID			PDS-SQL-UT-4123
@SYMTestCaseDesc		Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
						Execute all SQL pragmas to test the permissions returned from the CSqlSrvDatabase::AuthorizeCallback
						function is correct.
						The test attempts to execute pragmas for the following cases:-
						1) Without paramter (also known as 'Read' access)
						2) With parameter (also known as 'Write' access)
						The database tested in this case is a private database. 
@SYMTestPriority		High
@SYMTestActions			Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
@SYMTestExpectedResults Test must not fail
@SYMDEF					DEF129581
*/
void PrivateDbPragmaTest()
	{
	PerformPragmaTest(KPrivateDbName(), ENonSecure, EFalse);
	}

/**
@SYMTestCaseID			PDS-SQL-UT-4124
@SYMTestCaseDesc		Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
						Execute all SQL pragmas to test the permissions returned from the CSqlSrvDatabase::AuthorizeCallback
						function is correct.
						The test attempts to execute pragmas for the following cases:-
						1) Without paramter (also known as 'Read' access)
						2) With parameter (also known as 'Write' access)
						The database tested in this case is a secure database. 
@SYMTestPriority		High
@SYMTestActions			Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
@SYMTestExpectedResults Test must not fail
@SYMDEF					DEF129581
*/
void SecureDbPragmaTest()
	{
	PerformPragmaTest(KSecureDbName(), ESecure, EFalse);
	}

/**
@SYMTestCaseID			PDS-SQL-UT-4125
@SYMTestCaseDesc		Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
						Execute all SQL pragmas to test the permissions returned from the CSqlSrvDatabase::AuthorizeCallback
						function is correct.
						The test attempts to execute pragmas for the following cases:-
						1) Without paramter (also known as 'Read' access)
						2) With parameter (also known as 'Write' access)
						The database tested in this case is a public attached database.  
@SYMTestPriority		High
@SYMTestActions			Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
@SYMTestExpectedResults Test must not fail
@SYMDEF					DEF129581
*/
void PublicAttDbPragmaTest()
	{
	PerformPragmaTest(KPublicDbName(), ENonSecure, ETrue);
	}

/**
@SYMTestCaseID			PDS-SQL-UT-4126
@SYMTestCaseDesc		Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
						Execute all SQL pragmas to test the permissions returned from the CSqlSrvDatabase::AuthorizeCallback
						function is correct.
						The test attempts to execute pragmas for the following cases:-
						1) Without paramter (also known as 'Read' access)
						2) With parameter (also known as 'Write' access)
						The database tested in this case is a private attached database. 
@SYMTestPriority		High
@SYMTestActions			Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
@SYMTestExpectedResults Test must not fail
@SYMDEF					DEF129581
*/
void PrivateAttDbPragmaTest()
	{
	PerformPragmaTest(KPrivateDbName(), ENonSecure, ETrue);
	}

/**
@SYMTestCaseID			PDS-SQL-UT-4127
@SYMTestCaseDesc		Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
						Execute all SQL pragmas to test the permissions returned from the CSqlSrvDatabase::AuthorizeCallback
						function is correct.
						The test attempts to execute pragmas for the following cases:-
						1) Without paramter (also known as 'Read' access)
						2) With parameter (also known as 'Write' access)
						The database tested in this case is a secure attached database. 
@SYMTestPriority		High
@SYMTestActions			Test for DEF129581: All Pragmas are allowed to be executed on non-secure SQL databases.
@SYMTestExpectedResults Test must not fail
@SYMDEF					DEF129581
*/
void SecureAttDbPragmaTest()
	{
	PerformPragmaTest(KSecureDbName(), ESecure, ETrue);
	}

void DoTests()
	{
	TheTest.Start(_L("@SYMTestCaseID:PDS-SQL-UT-4122 Pragma Testing with public databases"));
	PublicDbPragmaTest();
	
	TheTest.Next(_L("@SYMTestCaseID:PDS-SQL-UT-4123 Pragma Testing with private databases"));
	PrivateDbPragmaTest();
	
	TheTest.Next(_L("@SYMTestCaseID:PDS-SQL-UT-4124 Pragma Testing with secure databases"));
	SecureDbPragmaTest();
	
	TheTest.Next(_L("@SYMTestCaseID:PDS-SQL-UT-4125 Pragma Testing with attached public databases"));
	PublicAttDbPragmaTest();
	
	TheTest.Next(_L("@SYMTestCaseID:PDS-SQL-UT-4126 Pragma Testing with attached private databases"));
	PrivateAttDbPragmaTest();
	
	TheTest.Next(_L("@SYMTestCaseID:PDS-SQL-UT-4127 Pragma Testing with attached secure databases"));
	SecureAttDbPragmaTest();
	}

TInt E32Main()
	{
	TheTest.Title();

	CTrapCleanup* tc = CTrapCleanup::New();
	TheTest(tc != NULL);
	
	__UHEAP_MARK;
	
	CreateTestEnv();
	DeleteTestFiles();
	CreateTestDBs();
	DoTests();
	DeleteTestFiles();
	TheFs.Close();

	__UHEAP_MARKEND;

	TheTest.End();
	TheTest.Close();

	delete tc;

	User::Heap().Check();
	return KErrNone;
	}