// Copyright (c) 2005-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 <s32buf.h>				//MStreamBuf

#include <sqldb.h>

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

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

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

_LIT(KTestDbName1, "c:\\test\\t_sqlapi1.db");

_LIT(KTestDbName2, "c:[1111CCCC]t_sqlapi2.db");

_LIT(KTestDbName3, "C:\\TEST\\t_sqlapi3.db");

_LIT(KTestDbName4, "C:[1111CCCC]D012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.db");

_LIT(KTestDbName5, "C:\\TEST\\D012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.db");

_LIT(KTestDbName6, "C:[1111CCCC]t_sqlapi6.db");

_LIT(KTestDbName7, "C:[1111CCCC]t_sqlapi7.db");

_LIT(KTestDbName8, "c:\\test\\t_sqlapi8.db");

_LIT(KTestDbName9, "c:\\private\\1111CCCC\\t_sqlapi9.db");

_LIT(KTestCfgDbName, "c:\\test\\t_sqlapi_cfg.db");

_LIT(KTestCfgDbName2, "c:[1111CCCC]t_sqlapi_cfg.db");

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

_LIT(KDbName7, "C:\\TEST\\t_sqlapi7_2.db");

// used for the config test

_LIT8(KServerConfigString1, "   ;  cache_size =  1024 ; page_size =1024 ;encoding =  \"UTF-8\"   ");

_LIT8(KServerConfigString2, " badconfigstring ");

_LIT8(KServerConfigString3, " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

_LIT8(KServerConfigString4, "");

const TUid KSecureUid = {0x1111CCCC};//The same as the UID in the MMP file

_LIT(KCreateDbScript, "z:\\test\\contacts_schema_to_vendors.sql");

_LIT(KFillDbScript, "z:\\test\\add_simple_contacts.sql");

_LIT8(KCommitStr8, "COMMIT;");

_LIT16(KCommitStr16, "COMMIT;");

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

void DeleteTestFiles()

	{

	RSqlDatabase::Delete(KTestDbName1);

	RSqlDatabase::Delete(KTestDbName2);

	RSqlDatabase::Delete(KTestDbName3);

	RSqlDatabase::Delete(KTestDbName4);

	RSqlDatabase::Delete(KTestDbName5);

	RSqlDatabase::Delete(KTestDbName6);

	RSqlDatabase::Delete(KTestDbName7);

	RSqlDatabase::Delete(KTestDbName8);

	RSqlDatabase::Delete(KTestDbName9);

	RSqlDatabase::Delete(KTestCfgDbName);

	RSqlDatabase::Delete(KTestCfgDbName2);

	RSqlDatabase::Delete(KDbName7);

	}

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

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

//Test macros and functions

void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		DeleteTestFiles();

		TheTest(EFalse, aLine);

		}

	}

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

	{

	if(aValue != aExpected)

		{

		DeleteTestFiles();

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

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

void CreateTestDir()

    {

    RFs fs;

	TInt err = fs.Connect();

	TEST2(err, KErrNone);

	err = fs.MkDir(KTestDir);

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

	err = fs.CreatePrivatePath(EDriveC);	

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

	fs.Close();

	}

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

template <class DES, class BUF> void ExecSqlStmtOnDb(RSqlDatabase& aDb, const TDesC8& aSqlString, 

												     TInt aExpectedError)

	{

	BUF sqlBuf;

	sqlBuf.Copy(aSqlString);

	TInt rc = aDb.Exec(sqlBuf);

	if(rc < 0 && SqlRetCodeClass(rc) == ESqlDbError)

		{

		TPtrC msg = aDb.LastErrorMessage();

		RDebug::Print(_L("Execute SQL error - '%S'\r\n"), &msg);

		}

	if(aExpectedError < 0)

		{

		TEST2(rc, aExpectedError);

		}

	else

		{

		TEST(rc >= 0);

		}

	}

template <class DES, class BUF>  RSqlStatement PrepareSqlStmt(RSqlDatabase& aDb, const TDesC8& aSqlString,

															  TInt aExpectedError)

	{

	BUF sqlBuf;

	sqlBuf.Copy(aSqlString);

	RSqlStatement stmt;

	TInt rc = stmt.Prepare(aDb, sqlBuf);

	if(rc != KErrNone && SqlRetCodeClass(rc) == ESqlDbError)

		{

		TPtrC msg = aDb.LastErrorMessage();

		RDebug::Print(_L("Execute SQL error - '%S'\r\n"), &msg);

		}

	TEST2(rc, aExpectedError);

	return stmt;

	}

void ExecSqlStmt(RSqlDatabase& aDb, RSqlStatement& aStmt, TInt aExpectedError)

	{

	TInt rc = aStmt.Exec();

	if(rc < 0 && SqlRetCodeClass(rc) == ESqlDbError)

		{

		TPtrC msg = aDb.LastErrorMessage();

		RDebug::Print(_L("Execute SQL error - '%S'\r\n"), &msg);

		}

	if(aExpectedError < 0)

		{

		TEST2(rc, aExpectedError);

		}

	else

		{

		TEST(rc >= 0);

		}

	}

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

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

/**

@SYMTestCaseID			SYSLIB-SQL-CT-1601

@SYMTestCaseDesc		Create/Open/Close database tests. Invalid database names, very long database names,

						private databases, public databases, open twice database, create already

						existing database, open non-exisitng database, open corrupted database.

@SYMTestPriority		High

@SYMTestActions			Tests for RSqlDatabase::Create(), RSqlDatabase::Open() methods.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ5792

                        REQ5793

*/	

void OpenCloseDatabaseTest()

	{

	RSqlDatabase db;

	TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);

	RSqlSecurityPolicy securityPolicy;

	TInt rc = securityPolicy.Create(defaultPolicy);

	TEST2(rc, KErrNone);

	//Secure shared database file on a non-existing drive (A:)

	_LIT(KDbPath1, "A:[1111CCCC]db1.db");

	rc = db.Create(KDbPath1, securityPolicy);

	TEST2(rc, KErrNotReady);

	db.Close();

	//Attempt to open a non-existing file.

	_LIT(KDbFName, "c:\\test\\nofile.db");

	rc = db.Open(KDbFName);

	TEST2(rc, KErrNotFound);

	//Zero length database file name.

	rc = db.Create(_L(""));

	TEST2(rc,  KErrBadName);

	db.Close();

	//Database file name containing only the drive name

	rc = db.Create(_L("C:"));

	TEST2(rc, KErrBadName);

	db.Close();

	//Database file name containing only the path, without the file name

	rc = db.Create(_L("C:\\TEST\\"));

	TEST2(rc, KErrBadName);

	db.Close();

	//Public shared database file on a non-existing drive (A:)	

	_LIT(KDbPath2, "A:\\test\\db1.db");

	rc = db.Create(KDbPath2);

	TEST2(rc, KErrNotReady);

	db.Close();

	// create database with good config specified

	rc = db.Create(KTestCfgDbName,&KServerConfigString1);

	TEST2(rc, KErrNone);

	db.Close();

	TInt rc2 = RSqlDatabase::Delete(KTestCfgDbName);

	TEST2(rc2, KErrNone);

	// create database with bad config specified

	rc = db.Create(KTestCfgDbName,&KServerConfigString2);

	TEST2(rc, KErrArgument);

	db.Close();

	// create database with long config specified

	rc = db.Create(KTestCfgDbName,&KServerConfigString3);

	TEST2(rc, KErrArgument);

	db.Close();

	// create database with empty config specified - not an error

	rc = db.Create(KTestCfgDbName,&KServerConfigString4);

	TEST2(rc, KErrNone);

	db.Close();

	rc2 = RSqlDatabase::Delete(KTestCfgDbName);

	TEST2(rc2, KErrNone);

	//Secure shared database file on an existing drive (C:). 

	//Very long database file name (> 90 characters) but still a valid name.

	rc = db.Create(KTestDbName4, securityPolicy);

	db.Close();

	rc2 = RSqlDatabase::Delete(KTestDbName4);

	TEST2(rc, KErrNone);

	TEST2(rc2, KErrNone);

	//Secure shared database file on an existing drive (C:). 

	//Very long database file name (> 90 characters) but still a valid name.

	//With config

	rc = db.Create(KTestCfgDbName2, securityPolicy, &KServerConfigString1);

	db.Close();

	rc2 = RSqlDatabase::Delete(KTestCfgDbName2);

	TEST2(rc, KErrNone);

	TEST2(rc2, KErrNone);

	//Public shared database file on an existing drive (C:). 

	//Very long database file name (> 90 characters) but still a valid name.

	rc = db.Create(KTestDbName5);

	db.Close();

	rc2 = RSqlDatabase::Delete(KTestDbName5);

	TEST2(rc, KErrNone);

	TEST2(rc2, KErrNone);

	RFs fs;

	TEST2(fs.Connect(), KErrNone);

	TFileName privatePath;

	TEST2(fs.PrivatePath(privatePath), KErrNone);

	fs.Close();

	//Private shared database file on an existing drive (C:). 

	//Very long database file name.

	const TInt KMaxFileName2 = KMaxFileName - 40;//"-40" because the SQLITE engine creates a journal file if begins

	                                             //a transaction. The name of the journal file is 

	                                             //"<dbFileName>-journal.<ext>". It is obvious that if the 

	                                             //database file name is too long but still valid and its creation

	                                             //succeeds, the journal file creation may fail because the journal

	                                             //file name becomes too long

	TBuf<KMaxFileName2> dbPath;

	_LIT(KExt, ".DB");

	dbPath.Copy(_L("C:"));

	dbPath.Append(KSecureUid.Name());

	TInt len = KMaxFileName2 + 1 - (dbPath.Length() + KExt().Length() + privatePath.Length());

	while(--len)

		{

		dbPath.Append(TChar('A'));	

		}

	dbPath.Append(KExt);	

	TEST(dbPath.Length() == (KMaxFileName2 - privatePath.Length()));

	rc = db.Create(dbPath, securityPolicy);

	db.Close();

	rc2 = RSqlDatabase::Delete(dbPath);

	TEST2(rc, KErrNone);

	TEST2(rc2, KErrNone);

	// Private database with config

	TBuf<KMaxFileName> cfgPath;

	cfgPath.Copy(_L("C:"));

	cfgPath.Append(KSecureUid.Name());

	cfgPath.Append(KExt);

	rc = db.Create(cfgPath,securityPolicy,&KServerConfigString1);

	db.Close();

	rc2 = RSqlDatabase::Delete(cfgPath);

	TEST2(rc, KErrNone);

	TEST2(rc2, KErrNone);

	//Public shared database file on an existing drive (C:). 

	//Very long database file name.

	dbPath.Copy(_L("C:\\TEST\\D"));

	len = KMaxFileName2 + 1 - (dbPath.Length() + KExt().Length());

	while(--len)

		{

		dbPath.Append(TChar('A'));	

		}

	dbPath.Append(KExt);	

	TEST(dbPath.Length() == KMaxFileName2);

	rc = db.Create(dbPath);

	db.Close();

	rc2 = RSqlDatabase::Delete(dbPath);

	TEST2(rc, KErrNone);

	TEST2(rc2, KErrNone);

	//Create/Close/Open/Close secure shared database test

	rc = db.Create(KTestDbName6, securityPolicy);

	db.Close();

	rc2 = db.Open(KTestDbName6);

	db.Close();

	TInt rc3 = RSqlDatabase::Delete(KTestDbName6);

	TEST2(rc, KErrNone);

	TEST2(rc2, KErrNone);

	TEST2(rc3, KErrNone);

	//An attempt to create already existing secure shared file.	

	rc = db.Create(KTestDbName6, securityPolicy);

	db.Close();

	rc2 = db.Create(KTestDbName6, securityPolicy);

	db.Close();

	rc3 = RSqlDatabase::Delete(KTestDbName6);

	TEST2(rc, KErrNone);

	TEST2(rc2, KErrAlreadyExists);

	TEST2(rc3, KErrNone);

	//An attempt to open twice the same database file using different RSqlDatabase objects

	rc = db.Create(KTestDbName6, securityPolicy);

	RSqlDatabase db2;	

	rc2 = db2.Open(KTestDbName6);

	db2.Close();

	db.Close();

	rc3 = RSqlDatabase::Delete(KTestDbName6);

	TEST2(rc, KErrNone);

	TEST2(rc2, KErrNone);//-- KErrInUse -- in case EFileRead | EFileWrite file open mode!

	TEST2(rc3, KErrNone);

	//An attempt to create secure shared database file on a read-only drive (Z:)

	_LIT(KDbPath8, "Z:[1111CCCC]db1.db");

	rc = db.Create(KDbPath8, securityPolicy);

	TEST2(rc, KErrAccessDenied);

	db.Close();

	//An attempt to create non-secure shared database file on a read-only drive (Z:)

	_LIT(KDbPath8a, "Z:\\db1.db");

	rc = db.Create(KDbPath8a);

	TEST2(rc, KErrAccessDenied);

	db.Close();

	//An attempt to open non-existing secure shared database file on a read-only drive (Z:)

	rc = db.Open(KDbPath8);

	TEST(rc == KErrNotFound || rc == KErrPathNotFound);

	db.Close();

	//An attempt to open existing public shared database file on a read-only drive (Z:)

	_LIT(KDbPath9, "Z:\\TEST\\TestDb1.db");

	rc = db.Open(KDbPath9);

	TEST2(rc, KErrNone);

	db.Close();

	//An attempt to open corrupted public shared database file on a read-only drive (Z:)

	_LIT(KDbPath10, "Z:\\TEST\\CorruptDb.db");

	rc = db.Open(KDbPath10);

	// it will be KErrNotDb if SqlServer.cfg exists, else KErrNone if it doesn't

	// this is because we can detect a corrupt database when we attempt to

	// set the configuration. If there is no cfg file, then there will be no

	// attempt to set the pragmas and so the corrupt file is undetected

	TEST(rc==KSqlErrNotDb || rc==KErrNone);

	db.Close();

	//Copy the corrupted database file on drive C:

	TEST2(fs.Connect(), KErrNone);

	rc = BaflUtils::CopyFile(fs, KDbPath10, KTestDbName3);

	TEST2(rc, KErrNone);

	(void)fs.SetAtt(KTestDbName3, 0, KEntryAttReadOnly);

	fs.Close();

	//An attempt to open corrupted public shared database file on a drive (C:)

	rc = db.Open(KTestDbName3);

	TEST(rc == KSqlErrNotDb || rc == KErrNone);//Note: but it may be a different error code as well

	db.Close();

	(void)RSqlDatabase::Delete(KTestDbName3);

	//Create, Close, Open, Close and again Open database test

	rc = db.Create(KTestDbName2, securityPolicy);

	TEST2(rc, KErrNone);

	db.Close();

	rc = db.Open(KTestDbName2);

	TEST2(rc, KErrNone);

	db.Close();

	rc = db.Open(KTestDbName2);

	TEST2(rc, KErrNone);

	db.Close();

	//Open two connections to the same database.

	rc = db.Open(KTestDbName2);

	TEST2(rc, KErrNone);

	rc = db2.Open(KTestDbName2);

	TEST2(rc, KErrNone);

	db2.Close();

	db.Close();

	rc = RSqlDatabase::Delete(KTestDbName2);

	TEST2(rc, KErrNone);

	securityPolicy.Close();

	}

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

/**

@SYMTestCaseID			SYSLIB-SQL-CT-1602

@SYMTestCaseDesc		Setting database isolation level tests.

@SYMTestPriority		High

@SYMTestActions			Tests for RSqlDatabase::SetIsolationLevel() method.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ5792

                        REQ5793

*/	

void SetIsolationLevelTest()

	{

	(void)RSqlDatabase::Delete(KTestDbName1);

	RSqlDatabase db;		

	TInt err = db.Create(KTestDbName1);

	TEST2(err, KErrNone);

	err = db.SetIsolationLevel(RSqlDatabase::EReadCommitted);

	TEST2(err, KErrNotSupported);

	err = db.SetIsolationLevel(RSqlDatabase::ERepeatableRead);

	TEST2(err, KErrNotSupported);

	err = db.SetIsolationLevel(RSqlDatabase::EReadUncommitted);

	TEST2(err, KErrNone);

	err = db.SetIsolationLevel(RSqlDatabase::ESerializable);

	TEST2(err, KErrNone);

	db.Close();

	(void)RSqlDatabase::Delete(KTestDbName1);

	}

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

/**

@SYMTestCaseID			SYSLIB-SQL-CT-1603

@SYMTestCaseDesc		Deleting database tests. Deleting non-existing database, opened database, 

						database on non-existing drive, zero-length database name, only path (no file name),

						rom drive based database.

@SYMTestPriority		High

@SYMTestActions			Tests for RSqlDatabase::Delete() method.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ5792

                        REQ5793

*/	

void DeleteDatabaseTest()

	{

	//An attempt to delete non-existing secure shared database

	_LIT(KDbName1, "C:[1111CCCC]EE__900000.adb");

	TInt err = RSqlDatabase::Delete(KDbName1);

	TEST2(err, KErrNotFound);

	//An attempt to delete non-existing public database

	_LIT(KDbName2, "C:\\TEST\\__900000.adb");

	err = RSqlDatabase::Delete(KDbName2);

	TEST2(err, KErrNotFound);

	//Zero length database file name.

	_LIT(KDbName3, "");

	err = RSqlDatabase::Delete(KDbName3);

	TEST2(err,  KErrBadName);

	//Database file name containing only the drive name

	_LIT(KDbName4, "C:");

	err = RSqlDatabase::Delete(KDbName4);

	TEST2(err, KErrBadName);

	//Database file name containing only the path, without the file name

	_LIT(KDbName5, "C:");

	err = RSqlDatabase::Delete(KDbName5);

	TEST2(err, KErrBadName);

	//Public shared database file on a non-existing drive (A:)	

	_LIT(KDbName6, "A:\\test\\db1.db");

	err = RSqlDatabase::Delete(KDbName6);

	TEST2(err, KErrNotReady);

	//An attempt to delete opened database.

	RSqlDatabase db;	

	err = db.Create(KDbName7);

	TEST2(err, KErrNone);

	err = RSqlDatabase::Delete(KDbName7);

	TEST2(err, KErrInUse);

	db.Close();

	err = RSqlDatabase::Delete(KDbName7);

	TEST2(err, KErrNone);

	//An attempt to delete existing public shared database file on a read-only drive (Z:)

	_LIT(KDbName8, "Z:\\TEST\\TestDb1.db");

	err = RSqlDatabase::Delete(KDbName8);

	TEST2(err, KErrAccessDenied);