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

 	}