// 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 <sqldb.h>

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

#define UNUSED_VAR(a) (a) = (a)

#define IGNORE_ERR(a) (a) = (a)

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

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

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

_LIT(KCategory, "SqlDb");

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

void DeleteTestFiles()

	{

	RSqlDatabase::Delete(KTestDbName);

	}

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

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

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

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

	fs.Close();

	}

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

//Panic thread function. 

//It will cast aData parameter to a TFunctor pointer and call it.

//The expectation is that the called function will panic and kill the panic thread.

TInt ThreadFunc(void* aData)

	{

	CTrapCleanup* tc = CTrapCleanup::New();

	TEST(tc != NULL);

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

	TFunctor* obj = reinterpret_cast<TFunctor*> (aData);

	TEST(obj != NULL);

	(*obj)();//call the panic function

	delete tc;

	return KErrNone;		

	}

//Panic test.

//PanicTest function will create a new thread - panic thread, giving it a pointer to the function which has to

//be executed and the expectation is that the function will panic and kill the panic thread.

//PanicTest function will check the panic thread exit code, exit category and the panic code.

void PanicTest(TFunctor& aFunctor, TExitType aExpectedExitType, const TDesC& aExpectedCategory, TInt aExpectedPanicCode)

	{

	RThread thread;

	_LIT(KThreadName,"SqlDbPanicThread");

	TEST2(thread.Create(KThreadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, (void*)&aFunctor, EOwnerThread), KErrNone);

	TRequestStatus status;

	thread.Logon(status);

	TEST2(status.Int(), KRequestPending);

	thread.Resume();

	User::WaitForRequest(status);

	User::SetJustInTime(ETrue);	// enable debugger panic handling

	TEST2(thread.ExitType(), aExpectedExitType);

	TEST(thread.ExitCategory() == aExpectedCategory);

	TEST2(thread.ExitReason(), aExpectedPanicCode);

	CLOSE_AND_WAIT(thread);

	}

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

//////////////////////////////     Panic test functions    /////////////////////////////////////////////////

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

//Panic when calling RSqlDatabase::Exec() on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_Exec8 : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		db.Exec(_L8("CREATE TABLE A(f integer)"));//panic here

		}

	};

static TSqlDatabase_NotCreated_Exec8 TheSqlDatabase_NotCreated_Exec8;

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

//Panic when calling RSqlDatabase::Exec() on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_Exec : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		db.Exec(_L("CREATE TABLE A(f integer)"));//panic here

		}

	};

static TSqlDatabase_NotCreated_Exec TheSqlDatabase_NotCreated_Exec;

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

//Panic when calling RSqlDatabase::GetSecuritySettings() on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_SecuritySettings : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		RSqlSecurityPolicy securityPolicy;

		(void)db.GetSecurityPolicy(securityPolicy);//panic here

		}

	};

static TSqlDatabase_NotCreated_SecuritySettings TheSqlDatabase_NotCreated_SecuritySettings;

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

//Panic when calling RSqlDatabase::SetIsolationLevel() on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_SetIsolationLevel : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		db.SetIsolationLevel(RSqlDatabase::EReadUncommitted);//panic here

		}

	};

static TSqlDatabase_NotCreated_SetIsolationLevel TheSqlDatabase_NotCreated_SetIsolationLevel;

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

//Panic when calling RSqlDatabase::LastErrorMessage() on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_LastErrorMessage : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		db.LastErrorMessage();//panic here

		}

	};

static TSqlDatabase_NotCreated_LastErrorMessage TheSqlDatabase_NotCreated_LastErrorMessage;

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

//Panic when calling RSqlDatabase::LastInsertedRowId() on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_LastInsertedRowId : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		db.LastInsertedRowId();//panic here

		}

	};

static TSqlDatabase_NotCreated_LastInsertedRowId TheSqlDatabase_NotCreated_LastInsertedRowId;

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

//Panic when calling RSqlDatabase::Size() on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_Size : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		(void)db.Size();//panic here

		}

	};

static TSqlDatabase_NotCreated_Size TheSqlDatabase_NotCreated_Size;

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

//Panic when calling RSqlDatabase::Size(TSize&) on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_Size2 : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		RSqlDatabase::TSize size;

		(void)db.Size(size);//panic here

		}

	};

static TSqlDatabase_NotCreated_Size2 TheSqlDatabase_NotCreated_Size2;

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

//Panic when calling RSqlDatabase::InTransaction() on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_InTransaction : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		(void)db.InTransaction();//panic here

		}

	};

static TSqlDatabase_NotCreated_InTransaction TheSqlDatabase_NotCreated_InTransaction;

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

//Panic when calling RSqlDatabase::Attach() on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_Attach : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		db.Attach(_L("C:\\TEST\\A.DB"), _L("A"));//panic here

		}

	};

static TSqlDatabase_NotCreated_Attach TheSqlDatabase_NotCreated_Attach;

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

//Panic when calling RSqlDatabase::Detach() on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_Detach : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		db.Detach(_L("A"));//panic here

		}

	};

static TSqlDatabase_NotCreated_Detach TheSqlDatabase_NotCreated_Detach;

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

//Panic when calling RSqlDatabase::Compact() on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_Compact : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		db.Compact(2048);//panic here

		}

	};

static TSqlDatabase_NotCreated_Compact TheSqlDatabase_NotCreated_Compact;

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

//Panic when calling async RSqlDatabase::Compact() on an invalid RSqlDatabase object.

class TSqlDatabase_NotCreated_Compact2 : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		TRequestStatus stat;

		db.Compact(2048, stat);//panic here

		}

	};

static TSqlDatabase_NotCreated_Compact2 TheSqlDatabase_NotCreated_Compact2;

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

//Panic when calling RSqlStatement::Reset() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_Reset : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.Reset();//panic here

		}

	};

static TSqlStatement_NotCreated_Reset TheSqlStatement_NotCreated_Reset;

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

//Panic when calling RSqlStatement::Exec() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_Exec : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.Exec();//panic here

		}

	};

static TSqlStatement_NotCreated_Exec TheSqlStatement_NotCreated_Exec;

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

//Panic when calling RSqlStatement::Next() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_Next : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.Next();//panic here

		}

	};

static TSqlStatement_NotCreated_Next TheSqlStatement_NotCreated_Next;

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

//Panic when calling RSqlStatement::ParameterIndex() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_ParameterIndex : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.ParameterIndex(_L("ABV"));//panic here

		}

	};

static TSqlStatement_NotCreated_ParameterIndex TheSqlStatement_NotCreated_ParameterIndex;

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

//Panic when calling RSqlStatement::ColumnIndex() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_ColumnIndex : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.ColumnIndex(_L("ABV"));//panic here

		}

	};

static TSqlStatement_NotCreated_ColumnIndex TheSqlStatement_NotCreated_ColumnIndex;

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

//Panic when calling RSqlStatement::ColumnType() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_ColumnType : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.ColumnType(1);//panic here

		}

	};

static TSqlStatement_NotCreated_ColumnType TheSqlStatement_NotCreated_ColumnType;

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

//Panic when calling RSqlStatement::ColumnSize() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_ColumnSize : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.ColumnSize(1);//panic here

		}

	};

static TSqlStatement_NotCreated_ColumnSize TheSqlStatement_NotCreated_ColumnSize;

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

//Panic when calling RSqlStatement::BindNull() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_BindNull : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.BindNull(1);//panic here

		}

	};

static TSqlStatement_NotCreated_BindNull TheSqlStatement_NotCreated_BindNull;

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

//Panic when calling RSqlStatement::BindInt() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_BindInt : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.BindInt(1, 2);//panic here

		}

	};

static TSqlStatement_NotCreated_BindInt TheSqlStatement_NotCreated_BindInt;

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

//Panic when calling RSqlStatement::BindInt64() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_BindInt64 : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.BindInt64(1, TInt64(2));//panic here

		}

	};

static TSqlStatement_NotCreated_BindInt64 TheSqlStatement_NotCreated_BindInt64;

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

//Panic when calling RSqlStatement::BindReal() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_BindReal : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.BindReal(1, 2.5);//panic here

		}

	};

static TSqlStatement_NotCreated_BindReal TheSqlStatement_NotCreated_BindReal;

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

//Panic when calling RSqlStatement::BindText() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_BindText : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.BindText(1, _L("ABV"));//panic here

		}

	};

static TSqlStatement_NotCreated_BindText TheSqlStatement_NotCreated_BindText;

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

//Panic when calling RSqlStatement::BindBinary() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_BindBinary : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.BindBinary(1, _L8("ABV"));//panic here

		}

	};

static TSqlStatement_NotCreated_BindBinary TheSqlStatement_NotCreated_BindBinary;

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

//Panic when calling RSqlStatement::BindZeroBlob() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_BindZeroBlob : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.BindZeroBlob(1, 100);//panic here

		}

	};

static TSqlStatement_NotCreated_BindZeroBlob TheSqlStatement_NotCreated_BindZeroBlob;

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

//Panic when an attempt is made to call RSqlStatement::BindZeroBlob() giving an invalid parameter index.

class TSqlStatement_OutOfBounds_BindZeroBlob : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		TEST2(db.Create(KTestDbName), KErrNone);

		TEST2(db.Exec(_L8("CREATE TABLE D(A INTEGER, B BLOB)")), 1);

		RSqlStatement stmt;

		TEST2(stmt.Prepare(db, _L8("INSERT INTO D VALUES(1, :Prm1)")), KErrNone);

		stmt.BindZeroBlob(12, 100);//panic here

		stmt.Close();

		db.Close();

		}

	};

static TSqlStatement_OutOfBounds_BindZeroBlob TheSqlStatement_OutOfBounds_BindZeroBlob;

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

//Panic when calling RSqlStatement::IsNull() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_IsNull : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.IsNull(1);//panic here

		}

	};

static TSqlStatement_NotCreated_IsNull TheSqlStatement_NotCreated_IsNull;

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

//Panic when calling RSqlStatement::ColumnInt() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_ColumnInt : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.ColumnInt(1);//panic here

		}

	};

static TSqlStatement_NotCreated_ColumnInt TheSqlStatement_NotCreated_ColumnInt;

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

//Panic when calling RSqlStatement::ColumnInt64() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_ColumnInt64 : public TFunctor

	{

private: