// 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 UNUSED_VAR(a) (a) = (a)

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

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

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

void DeleteTestFiles()
	{
	RSqlDatabase::Delete(KTestDbName);
	}

///////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
//Test macros and functions
void Check1(TInt aValue, TInt aLine, TBool aPrintThreadName = EFalse)
	{
	if(!aValue)
		{
		DeleteTestFiles();
		if(aPrintThreadName)
			{
			RThread th;
			TName name = th.Name();
			RDebug::Print(_L("*** Thread %S, Line %d\r\n"), &name, aLine);
			}
		else
			{
			RDebug::Print(_L("*** Line %d\r\n"), aLine);
			}
		TheTest(EFalse, aLine);
		}
	}
void Check2(TInt aValue, TInt aExpected, TInt aLine, TBool aPrintThreadName = EFalse)
	{
	if(aValue != aExpected)
		{
		DeleteTestFiles();
		if(aPrintThreadName)
			{
			RThread th;
			TName name = th.Name();
			RDebug::Print(_L("*** Thread %S, Line %d Expected error: %d, got: %d\r\n"), &name, aLine, aExpected, aValue);
			}
		else
			{
			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__)
#define TTEST(arg) ::Check1((arg), __LINE__, ETrue)
#define TTEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__, ETrue)

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

void CreateTestDir()
    {
    RFs fs;
	TInt err = fs.Connect();
	TEST2(err, KErrNone);

	err = fs.MkDir(KTestDir);
	TEST(err == KErrNone || err == KErrAlreadyExists);
	
	fs.Close();
	}

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

_LIT8(KTestSql1, "INSERT INTO A(Id) VALUES(1); INSERT INTO A(Id) VALUES(2);");

const TPtrC8 KSqls[] = {KTestSql1()};

static RCriticalSection ThreadCritSect;
static RCriticalSection MainCritSect;

static TInt TheSqlIdx = 0;

_LIT(KPanicCategory, "TransFail");
const TInt KPanicCode = 0x1234;

//Test thread function
TInt ThreadFunc1(void*)
	{
	__UHEAP_MARK;
	
	CTrapCleanup* tc = CTrapCleanup::New();
	TTEST(tc != NULL);

	__ASSERT_ALWAYS(TheSqlIdx >= 0 && TheSqlIdx < (TInt)(sizeof(KSqls) / sizeof(KSqls[0])), User::Invariant());
	const TPtrC8 sql = KSqls[TheSqlIdx];

	//Open test database
	RSqlDatabase db;
	TInt err = db.Open(KTestDbName);
	TTEST2(err, KErrNone);

	RDebug::Print(_L("---:WorkThread: Begin transaction. Exec SQL...\r\n"));
	
	//Begin a transaction
	_LIT8(KBeginTrans, "BEGIN");
	err = db.Exec(KBeginTrans);
	TTEST(err >= 0);	

	//Execute the SQL statement(s)
	err = db.Exec(sql);
	TTEST(err >= 0);	

	RDebug::Print(_L("---:WorkThread: Notify the main thread about the SQL statement execution\r\n"));
	MainCritSect.Signal();

	RDebug::Print(_L("---:WorkThread: Wait for permisson to continue...\r\n"));
	ThreadCritSect.Wait();

	User::SetJustInTime(EFalse);	// disable debugger panic handling

	//Panic current thread without commiting the transaction
	RDebug::Print(_L("---:WorkThread: Panic!\r\n"));
	User::Panic(KPanicCategory, KPanicCode);

	delete tc;	
	
	__UHEAP_MARKEND;
	
	return KErrNone;		
	}

/**
@SYMTestCaseID			SYSLIB-SQL-CT-1623
@SYMTestCaseDesc		Transaction atomicity test.
						Create a test database with a table. 
						Create a worker thread and make some "insert record" operations in a transaction from 
						that thread. Before commiting the transaction notify the main thread that the
						insert operation completed and wait for a notification from the main thread.
						The main thread notifies the worker thread to panic and checks the test table 
						content. No records should be found there.
@SYMTestPriority		High
@SYMTestActions			Transaction atomicity test.
@SYMTestExpectedResults Test must not fail
@SYMREQ					REQ5792
                        REQ5793
*/	
void TransactionTest1()
	{
	RDebug::Print(_L("+++:MainThread: Create critical sections\r\n"));
	TEST2(ThreadCritSect.CreateLocal(), KErrNone);
	ThreadCritSect.Wait();
	TEST2(MainCritSect.CreateLocal(), KErrNone);
	MainCritSect.Wait();
	
	RDebug::Print(_L("+++:MainThread: Create test database\r\n"));
	(void)RSqlDatabase::Delete(KTestDbName);
	RSqlDatabase db;
	TInt err = db.Create(KTestDbName);
	TEST2(err, KErrNone);

	RDebug::Print(_L("+++:MainThread: Create a table in the test database\r\n"));
	_LIT8(KCreateSql, "CREATE TABLE A(Id INTEGER)");
	err = db.Exec(KCreateSql);
	TEST(err >= 0);	
	
	db.Close();

	RDebug::Print(_L("+++:MainThread: Create the worker thread\r\n"));
	_LIT(KThreadName, "WorkThrd");
	RThread thread;
	TheSqlIdx = 0;
	TEST2(thread.Create(KThreadName, &ThreadFunc1, 0x2000, 0x1000, 0x10000, NULL, EOwnerProcess), KErrNone);
	TRequestStatus status;
	thread.Logon(status);
	TEST2(status.Int(), KRequestPending);
	thread.Resume();

	RDebug::Print(_L("+++:MainThread: Wait SQL statement(s) to be executed...\r\n"));
	MainCritSect.Wait();

	RDebug::Print(_L("+++:MainThread: Notify the worker thread to panic...\r\n"));
	ThreadCritSect.Signal();
	
	User::WaitForRequest(status);
	User::SetJustInTime(ETrue);	// enable debugger panic handling

	TEST2(thread.ExitType(), EExitPanic);
	TEST2(thread.ExitReason(), KPanicCode);
	
	thread.Close();

	RDebug::Print(_L("+++:MainThread: Check the database content...\r\n"));
	err = db.Open(KTestDbName);
	TEST2(err, KErrNone);
	_LIT8(KSelectSql, "SELECT COUNT(*) AS CNT FROM A");
	RSqlStatement stmt;
	err = stmt.Prepare(db, KSelectSql);
	TEST2(err, KErrNone);
	err = stmt.Next();
	TEST2(err, KSqlAtRow);
	TInt val = stmt.ColumnInt(0);
	TEST(val == 0);
	stmt.Close();
	db.Close();

	err = RSqlDatabase::Delete(KTestDbName);
	TEST2(err, KErrNone);
	}

/**
@SYMTestCaseID			SYSLIB-SQL-CT-1624
@SYMTestCaseDesc		Transaction consistency test.
						Create a test database with a table with a field with a CHECK constraint. 
						Try to insert some records in a transaction violating the CHECK constraint.
						The transaction should fail.
						No records should be found in the test table.
@SYMTestPriority		High
@SYMTestActions			Transaction atomicity test.
@SYMTestExpectedResults Test must not fail
@SYMREQ					REQ5792
                        REQ5793
*/	
void TransactionTest2()
	{
	//Create a test database
	(void)RSqlDatabase::Delete(KTestDbName);
	RSqlDatabase db;
	TInt err = db.Create(KTestDbName);
	TEST2(err, KErrNone);

	//Create a test table
	_LIT8(KCreateSql, "CREATE TABLE A(Id INTEGER, CHECK(Id > 10 AND Id <= 20))");
	err = db.Exec(KCreateSql);
	TEST(err >= 0);	

	//Begin a transaction
	_LIT8(KBeginTrans, "BEGIN");
	err = db.Exec(KBeginTrans);
	TEST(err >= 0);	
	
	//Exec SQL, viloate constraint.
	_LIT8(KInsertSql, "INSERT INTO A(Id) VALUES(15); INSERT INTO A(Id) VALUES(38);");
	err = db.Exec(KInsertSql);
	TEST2(err, KSqlErrConstraint);

	//Rollback transaction
	_LIT8(KRollbackTrans, "ROLLBACK");
	err = db.Exec(KRollbackTrans);
	TEST(err >= 0);	

	//Check the database content
	_LIT8(KSelectSql, "SELECT COUNT(*) AS CNT FROM A");
	RSqlStatement stmt;
	err = stmt.Prepare(db, KSelectSql);
	TEST2(err, KErrNone);
	err = stmt.Next();
	TEST2(err, KSqlAtRow);
	TInt val = stmt.ColumnInt(0);
	TEST2(val, 0);
	stmt.Close();
	
	db.Close();

	err = RSqlDatabase::Delete(KTestDbName);
	TEST2(err, KErrNone);
	}

void DoTests()
	{
	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1623 Transaction test 1 "));
	TransactionTest1();

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1624 Transaction test 2 "));
	TransactionTest2();
	}

TInt E32Main()
	{
	TheTest.Title();
	
	CTrapCleanup* tc = CTrapCleanup::New();
	
	__UHEAP_MARK;
	
	CreateTestDir();
	DeleteTestFiles();
	DoTests();
	DeleteTestFiles();

	__UHEAP_MARKEND;
	
	TheTest.End();
	TheTest.Close();
	
	delete tc;

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