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

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

	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:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.ColumnInt64(1);//panic here

		}

	};

static TSqlStatement_NotCreated_ColumnInt64 TheSqlStatement_NotCreated_ColumnInt64;

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

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

class TSqlStatement_NotCreated_ColumnReal : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.ColumnReal(1);//panic here

		}

	};

static TSqlStatement_NotCreated_ColumnReal TheSqlStatement_NotCreated_ColumnReal;

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

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

class TSqlStatement_NotCreated_ColumnText : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		TPtrC ptr;

		(void)stmt.ColumnText(1, ptr);//panic here

		}

	};

static TSqlStatement_NotCreated_ColumnText TheSqlStatement_NotCreated_ColumnText;

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

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

class TSqlStatement_NotCreated_ColumnText2 : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		TBuf<10> buf;

		stmt.ColumnText(1, buf);//panic here

		}

	};

static TSqlStatement_NotCreated_ColumnText2 TheSqlStatement_NotCreated_ColumnText2;

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

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

class TSqlStatement_NotCreated_ColumnBinary : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		TPtrC8 ptr;

		(void)stmt.ColumnBinary(1, ptr);//panic here

		}

	};

static TSqlStatement_NotCreated_ColumnBinary TheSqlStatement_NotCreated_ColumnBinary;

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

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

class TSqlStatement_NotCreated_ColumnBinary2 : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		TBuf8<10> buf;

		stmt.ColumnBinary(1, buf);//panic here

		}

	};

static TSqlStatement_NotCreated_ColumnBinary2 TheSqlStatement_NotCreated_ColumnBinary2;

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

//Panic when calling RSqlStatement::Prepare() giving an invalid RSqlDatabase object.

class TSqlStatement_DbNotCreated_Prepare : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		RSqlStatement stmt;

		stmt.Prepare(db, _L("CREATE TABLE A(d INTEGER)"));//panic here

		}

	};

static TSqlStatement_DbNotCreated_Prepare TheSqlStatement_DbNotCreated_Prepare;

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

//Panic when calling RSqlStatement::Prepare() giving an invalid RSqlDatabase object.

class TSqlStatement_DbNotCreated_Prepare8 : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

		RSqlStatement stmt;

		stmt.Prepare(db, _L8("CREATE TABLE A(d INTEGER)"));//panic here

		}

	};

static TSqlStatement_DbNotCreated_Prepare8 TheSqlStatement_DbNotCreated_Prepare8;

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

/*

//Panic when an attempt is made to call RSqlStatement::Prepare() twice on the same RSqlStatement object.

class TSqlStatement_CreateTwice : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		RSqlStatement stmt;

		TEST2(stmt.Prepare(db, _L("CREATE TABLE A(d INTEGER)")), KErrNone);

		stmt.Prepare(db, _L("CREATE TABLE A(d INTEGER)"));//panic here

		stmt.Close();

		db.Close();

		}

	};

static TSqlStatement_CreateTwice TheSqlStatement_CreateTwice;

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

//Panic when an attempt is made to call RSqlStatement::Prepare() twice on the same RSqlStatement object.

class TSqlStatement_CreateTwice8 : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		RSqlStatement stmt;

		TEST2(stmt.Prepare(db, _L8("CREATE TABLE A(d INTEGER)")), KErrNone);

		stmt.Prepare(db, _L8("CREATE TABLE A(d INTEGER)"));//panic here

		stmt.Close();

		db.Close();

		}

	};

static TSqlStatement_CreateTwice8 TheSqlStatement_CreateTwice8;

*/		

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

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

class TSqlStatement_OutOfBounds_ColumnType : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);

		RSqlStatement stmt;

		TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D")), KErrNone);

		stmt.ColumnType(12);//panic here

		stmt.Close();

		db.Close();

		}

	};

static TSqlStatement_OutOfBounds_ColumnType TheSqlStatement_OutOfBounds_ColumnType;

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

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

class TSqlStatement_OutOfBounds_ColumnSize : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);

		RSqlStatement stmt;

		TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D")), KErrNone);

		stmt.ColumnSize(-25);//panic here

		stmt.Close();

		db.Close();

		}

	};

static TSqlStatement_OutOfBounds_ColumnSize TheSqlStatement_OutOfBounds_ColumnSize;

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

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

class TSqlStatement_OutOfBounds_Bind : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);

		RSqlStatement stmt;

		TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D WHERE A = :V")), KErrNone);

		stmt.BindNull(2);//panic here

		stmt.Close();

		db.Close();

		}

	};

static TSqlStatement_OutOfBounds_Bind TheSqlStatement_OutOfBounds_Bind;

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

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

class TSqlStatement_OutOfBounds_ColumnValue : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);

		RSqlStatement stmt;

		TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D")), KErrNone);

		stmt.ColumnInt(56);//panic here

		stmt.Close();

		db.Close();

		}

	};

static TSqlStatement_OutOfBounds_ColumnValue TheSqlStatement_OutOfBounds_ColumnValue;

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

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

class TSqlStatement_NotCreated_ColumnCount : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		stmt.ColumnCount();//panic here

		}

	};

static TSqlStatement_NotCreated_ColumnCount TheSqlStatement_NotCreated_ColumnCount;

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

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

class TSqlStatement_NotCreated_DeclaredColumnType : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		TSqlColumnType colType;

		stmt.DeclaredColumnType(0, colType);//panic here

		}

	};

static TSqlStatement_NotCreated_DeclaredColumnType TheSqlStatement_NotCreated_DeclaredColumnType;

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

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

class TSqlStatement_OutOfBounds_DeclaredColumnType : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);

		RSqlStatement stmt;

		TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D")), KErrNone);

		TSqlColumnType colType;

		stmt.DeclaredColumnType(8, colType);//panic here

		stmt.Close();

		db.Close();

		}

	};

static TSqlStatement_OutOfBounds_DeclaredColumnType TheSqlStatement_OutOfBounds_DeclaredColumnType;

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

//Panic when an attempt is made to call RSqlStatement::ColumnName() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_ColumnName : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		RSqlStatement stmt;

		TPtrC columnName;

		(void)stmt.ColumnName(0, columnName);//panic here

		stmt.Close();

		db.Close();

		}

	};

static TSqlStatement_NotCreated_ColumnName TheSqlStatement_NotCreated_ColumnName;

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

//Panic when an attempt is made to call RSqlStatement::ParameterName() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_ParameterName : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		RSqlStatement stmt;

		TPtrC parameterName;

		(void)stmt.ParameterName(0, parameterName);//panic here

		stmt.Close();

		db.Close();

		}

	};

static TSqlStatement_NotCreated_ParameterName TheSqlStatement_NotCreated_ParameterName;

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

//Panic when an attempt is made to call RSqlStatement::ParamName() on an invalid RSqlStatement object.

class TSqlStatement_NotCreated_ParamName : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		RSqlStatement stmt;

		TPtrC paramName;

		(void)stmt.ParamName(0, paramName);//panic here

		stmt.Close();

		db.Close();

		}

	};

static TSqlStatement_NotCreated_ParamName TheSqlStatement_NotCreated_ParamName;

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

//Panic when an attempt is made to call RSqlColumnReadStream::ColumnText() with an invalid RSqlStatement object.

class TColumnReadStream_ColumnText_Statement : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		RSqlColumnReadStream strm;

		strm.ColumnText(stmt, 0);//panic here

		strm.Close();

		}

	};

static TColumnReadStream_ColumnText_Statement TheColumnReadStream_ColumnText_Statement;

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

//Panic when an attempt is made to call RSqlColumnReadStream::ColumnBinary() with an invalid RSqlStatement object.

class TColumnReadStream_ColumnBinary_Statement : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		RSqlColumnReadStream strm;

		strm.ColumnBinary(stmt, 0);//panic here

		strm.Close();

		}

	};

static TColumnReadStream_ColumnBinary_Statement TheColumnReadStream_ColumnBinary_Statement;

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

//Panic when an attempt is made to call RSqlColumnReadStream::ColumnText() with an invalid column index.

class TColumnReadStream_ColumnText_Column : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		TEST(db.Exec(_L8("CREATE TABLE D(A TEXT)")) >= 0);

		RSqlStatement stmt;

		TEST2(stmt.Prepare(db, _L8("SELECT * FROM D")), KErrNone);

		RSqlColumnReadStream strm;

		strm.ColumnText(stmt, 8);//panic here

		strm.Close();

		stmt.Close();

		db.Close();

		}

	};

static TColumnReadStream_ColumnText_Column TheColumnReadStream_ColumnText_Column;

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

//Panic when an attempt is made to call RSqlColumnReadStream::ColumnBinary() with an invalid column index.

class TColumnReadStream_ColumnBinary_Column : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		TEST(db.Exec(_L8("CREATE TABLE D(A BLOB)")) >= 0);

		RSqlStatement stmt;

		TEST2(stmt.Prepare(db, _L8("SELECT * FROM D")), KErrNone);

		RSqlColumnReadStream strm;

		strm.ColumnBinary(stmt, 3);//panic here

		strm.Close();

		stmt.Close();

		db.Close();

		}

	};

static TColumnReadStream_ColumnBinary_Column TheColumnReadStream_ColumnBinary_Column;

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

//Panic when an attempt is made to call RSqlColumnReadStream::ColumnText() when the statement object is not at row.

class TColumnReadStream_ColumnText_AtRow : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		TEST(db.Exec(_L8("CREATE TABLE D(A TEXT)")) >= 0);

		RSqlStatement stmt;

		TEST2(stmt.Prepare(db, _L8("SELECT * FROM D")), KErrNone);

		RSqlColumnReadStream strm;

		strm.ColumnText(stmt, 0);//panic here

		strm.Close();

		stmt.Close();

		db.Close();

		}

	};

static TColumnReadStream_ColumnText_AtRow TheColumnReadStream_ColumnText_AtRow;

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

//Panic when an attempt is made to call RSqlColumnReadStream::ColumnBinary() when the statement object is not at row.

class TColumnReadStream_ColumnBinary_AtRow : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlDatabase db;

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

		TEST(db.Exec(_L8("CREATE TABLE D(A BLOB)")) >= 0);

		RSqlStatement stmt;

		TEST2(stmt.Prepare(db, _L8("SELECT * FROM D")), KErrNone);

		RSqlColumnReadStream strm;

		strm.ColumnBinary(stmt, 0);//panic here

		strm.Close();

		stmt.Close();

		db.Close();

		}

	};

static TColumnReadStream_ColumnBinary_AtRow TheColumnReadStream_ColumnBinary_AtRow;

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

//Panic when an attempt is made to call RSqlParamWriteStream::BindText() with an invalid RSqlStatement object.

class TParamWriteStream_BindText_Statement : public TFunctor

	{

private:		

	virtual void operator()()

		{

		RSqlStatement stmt;

		RSqlParamWriteStream strm;

		strm.BindText(stmt, 0);//panic here

		strm.Close();

		}

	};

static TParamWriteStream_BindText_Statement TheParamWriteStream_BindText_Statement;

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

//Panic when an attempt is made to call RSqlParamWriteStream::BindBinary() with an invalid RSqlStatement object.

class TParamWriteStream_BindBinary_Statement : public TFunctor

	{

private:		

	virtual void operator()()

		{