diff -r 000000000000 -r bde4ae8d615e os/persistentdata/persistentstorage/sql/TEST/t_sqlpanic.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqlpanic.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,1739 @@
+// 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()()
+		{
+		RSqlStatement stmt;
+		RSqlParamWriteStream strm;
+		strm.BindBinary(stmt, 0);//panic here
+		strm.Close();
+		}
+	};
+static TParamWriteStream_BindBinary_Statement TheParamWriteStream_BindBinary_Statement;
+		
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlParamWriteStream::BindText() with an invalid parameter index.
+class TParamWriteStream_BindText_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 WHERE A = :Val")), KErrNone);
+		
+		RSqlParamWriteStream strm;
+		strm.BindText(stmt, 8);//panic here
+		
+		strm.Close();
+		stmt.Close();
+		db.Close();
+		}
+	};
+static TParamWriteStream_BindText_Column TheParamWriteStream_BindText_Column;
+		
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlParamWriteStream::BindBinary() with an invalid parameter index.
+class TParamWriteStream_BindBinary_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 WHERE A = :Val")), KErrNone);
+		
+		RSqlParamWriteStream strm;
+		strm.BindBinary(stmt, 3);//panic here
+		
+		strm.Close();
+		stmt.Close();
+		db.Close();
+		}
+	};
+static TParamWriteStream_BindBinary_Column TheParamWriteStream_BindBinary_Column;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlSecurityPolicy::DefaultPolicy() on an invalid object.
+class TSqlSecurity_DefaultPolicy : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		RSqlSecurityPolicy securityPolicy;
+		TSecurityPolicy policy = securityPolicy.DefaultPolicy();//panic here
+		UNUSED_VAR(policy);
+		}
+	};
+static TSqlSecurity_DefaultPolicy TheSqlSecurity_DefaultPolicy;
+		
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlSecurityPolicy::SetDbPolicy() with an invalid policy type.
+class TSqlSecurity_Set1 : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
+		RSqlSecurityPolicy securityPolicy;
+		TInt err = securityPolicy.Create(defaultPolicy);
+		TEST2(err, KErrNone);
+		RSqlSecurityPolicy::TPolicyType policyType = static_cast <RSqlSecurityPolicy::TPolicyType> (12345);
+		TSecurityPolicy policy(TSecurityPolicy::EAlwaysFail);
+		securityPolicy.SetDbPolicy(policyType, policy);//panic here
+		securityPolicy.Close();
+		}
+	};
+static TSqlSecurity_Set1 TheSqlSecurity_Set1;
+		
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlSecurityPolicy::SetPolicy() with an invalid database object type.
+class TSqlSecurity_Set2 : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
+		RSqlSecurityPolicy securityPolicy;
+		TInt err = securityPolicy.Create(defaultPolicy);
+		TEST2(err, KErrNone);
+		RSqlSecurityPolicy::TObjectType objectType = static_cast <RSqlSecurityPolicy::TObjectType> (-113);
+		TSecurityPolicy policy(TSecurityPolicy::EAlwaysFail);
+		securityPolicy.SetPolicy(objectType, _L("ATbl"), RSqlSecurityPolicy::EWritePolicy, policy);//panic here
+		securityPolicy.Close();
+		}
+	};
+static TSqlSecurity_Set2 TheSqlSecurity_Set2;
+		
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlSecurityPolicy::SetPolicy() with an invalid database object name.
+class TSqlSecurity_Set3 : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
+		RSqlSecurityPolicy securityPolicy;
+		TInt err = securityPolicy.Create(defaultPolicy);
+		TEST2(err, KErrNone);
+		TSecurityPolicy policy(TSecurityPolicy::EAlwaysFail);
+		securityPolicy.SetPolicy(RSqlSecurityPolicy::ETable, KNullDesC, RSqlSecurityPolicy::EReadPolicy, policy);//panic here
+		securityPolicy.Close();
+		}
+	};
+static TSqlSecurity_Set3 TheSqlSecurity_Set3;
+		
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlSecurityPolicy::DbPolicy() with an invalid policy type.
+class TSqlSecurity_Get1 : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
+		RSqlSecurityPolicy securityPolicy;
+		TInt err = securityPolicy.Create(defaultPolicy);
+		TEST2(err, KErrNone);
+		RSqlSecurityPolicy::TPolicyType policyType = static_cast <RSqlSecurityPolicy::TPolicyType> (12345);
+		securityPolicy.DbPolicy(policyType);//panic here
+		securityPolicy.Close();
+		}
+	};
+static TSqlSecurity_Get1 TheSqlSecurity_Get1;
+		
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlSecurityPolicy::Policy() with an invalid database object type.
+class TSqlSecurity_Get2 : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
+		RSqlSecurityPolicy securityPolicy;
+		TInt err = securityPolicy.Create(defaultPolicy);
+		TEST2(err, KErrNone);
+		RSqlSecurityPolicy::TObjectType objectType = static_cast <RSqlSecurityPolicy::TObjectType> (-113);
+		securityPolicy.Policy(objectType, _L("BTbl"), RSqlSecurityPolicy::EReadPolicy);//panic here
+		securityPolicy.Close();
+		}
+	};
+static TSqlSecurity_Get2 TheSqlSecurity_Get2;
+		
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlSecurityPolicy::Policy() with an invalid database object name.
+class TSqlSecurity_Get3 : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
+		RSqlSecurityPolicy securityPolicy;
+		TInt err = securityPolicy.Create(defaultPolicy);
+		TEST2(err, KErrNone);
+		securityPolicy.Policy(RSqlSecurityPolicy::ETable, KNullDesC, RSqlSecurityPolicy::EWritePolicy);//panic here
+		securityPolicy.Close();
+		}
+	};
+static TSqlSecurity_Get3 TheSqlSecurity_Get3;
+		
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/*
+//Panic when an attempt is made to call RSqlSecurityPolicy::Create() on an already created object.
+class TSqlSecurity_CreateTwice : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
+		RSqlSecurityPolicy securityPolicy;
+		TInt err = securityPolicy.Create(defaultPolicy);
+		TEST2(err, KErrNone);
+		securityPolicy.Create(defaultPolicy);//panic here
+		securityPolicy.Close();
+		}
+	};
+static TSqlSecurity_CreateTwice TheSqlSecurity_CreateTwice;
+*/		
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlSecurityPolicy::ExternalizeL() on an invalid object.
+class TSqlSecurity_Externalize : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		RSqlSecurityPolicy securityPolicy;
+		RWriteStream stream;
+		TRAPD(err, securityPolicy.ExternalizeL(stream));//panic here
+		IGNORE_ERR(err);
+		}
+	};
+static TSqlSecurity_Externalize TheSqlSecurity_Externalize;
+		
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call TSqlScalarFullSelectQuery method and the database is not set.
+class TSqlScalarFullSelectQuery_InvalidDatabase : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		TSqlScalarFullSelectQuery query;
+		TRAP_IGNORE((void)query.SelectIntL(_L("SELECT Id FROM A WHERE Name = 'AAA'")));
+		}
+	};
+static TSqlScalarFullSelectQuery_InvalidDatabase TheSqlScalarFullSelectQuery_InvalidDatabase;
+		
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlBlobReadStream::OpenL() with an invalid RSqlDatabase object.
+class TBlobReadStream_Open_Database1 : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		CTrapCleanup* tc = CTrapCleanup::New();
+		
+		RSqlDatabase db;
+		RSqlBlobReadStream strm;
+		TRAP_IGNORE(strm.OpenL(db, _L("Tbl"),_L("Col"), 1));//panic here
+		strm.Close();
+		
+		delete tc;
+		}
+	};
+static TBlobReadStream_Open_Database1 TheBlobReadStream_Open_Database1;
+		
+class TBlobReadStream_Open_Database2 : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		CTrapCleanup* tc = CTrapCleanup::New();
+		
+		RSqlDatabase db;
+		RSqlBlobReadStream strm;
+		TRAP_IGNORE(strm.OpenL(db, _L("Tbl"),_L("Col"), 1, _L("Db")));//panic here
+		strm.Close();
+		
+		delete tc;
+		}
+	};
+static TBlobReadStream_Open_Database2 TheBlobReadStream_Open_Database2;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlBlobReadStream::SizeL() on a unitialized RSqlBlobReadStream object.
+class TBlobReadStream_Size_Stream : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		CTrapCleanup* tc = CTrapCleanup::New();
+		
+		RSqlBlobReadStream strm;
+		TRAP_IGNORE(strm.SizeL());//panic here
+		strm.Close();
+		
+		delete tc;
+		}
+	};
+TBlobReadStream_Size_Stream TheBlobReadStream_Size_Stream;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlBlobWriteStream::OpenL() with an invalid RSqlDatabase object.
+class TBlobWriteStream_Open_Database1 : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		CTrapCleanup* tc = CTrapCleanup::New();
+		
+		RSqlDatabase db;
+		RSqlBlobWriteStream strm;
+		TRAP_IGNORE(strm.OpenL(db, _L("Tbl"),_L("Col"), 1));//panic here
+		strm.Close();
+		
+		delete tc;
+		}
+	};
+static TBlobWriteStream_Open_Database1 TheBlobWriteStream_Open_Database1;
+		
+class TBlobWriteStream_Open_Database2 : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		CTrapCleanup* tc = CTrapCleanup::New();
+		
+		RSqlDatabase db;
+		RSqlBlobWriteStream strm;
+		TRAP_IGNORE(strm.OpenL(db, _L("Tbl"),_L("Col"), 1, _L("Db")));//panic here
+		strm.Close();
+		
+		delete tc;
+		}
+	};
+static TBlobWriteStream_Open_Database2 TheBlobWriteStream_Open_Database2;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Panic when an attempt is made to call RSqlBlobWriteStream::SizeL() on a unitialized RSqlBlobWriteStream object.
+class TBlobWriteStream_Size_Stream : public TFunctor
+	{
+private:		
+	virtual void operator()()
+		{
+		CTrapCleanup* tc = CTrapCleanup::New();
+		
+		RSqlBlobWriteStream strm;
+		TRAP_IGNORE(strm.SizeL());//panic here
+		strm.Close();
+		
+		delete tc;
+		}
+	};
+TBlobWriteStream_Size_Stream TheBlobWriteStream_Size_Stream;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-CT-1619
+@SYMTestCaseDesc		RSqlDatabase panic tests
+						Run a second thread. The second thread executes given RSqlDatabase method calling
+						it with wrong arguments, or in a bad context,...The method panics the second thread. 
+						The main thread captures and checks the panic code.
+@SYMTestPriority		High
+@SYMTestActions			RSqlDatabase panic tests
+@SYMTestExpectedResults Test must not fail
+@SYMREQ					REQ5792
+                        REQ5793
+                        REQ10405
+                        REQ10407
+*/	
+void DatabaseTests()
+	{
+	TheTest.Printf(_L("'RSqlDatabase object not created - Exec 8' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_Exec8, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlDatabase object not created - Exec' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_Exec, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlDatabase object not created - GetSecuritySettings' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_SecuritySettings, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlDatabase object not created - Attach' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_Attach, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlDatabase object not created - Detach' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_Detach, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlDatabase object not created - SetIsolationLevel' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_SetIsolationLevel, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlDatabase object not created - LastErrorMessage' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_LastErrorMessage, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlDatabase object not created - LastInsertedRowId' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_LastInsertedRowId, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlDatabase object not created - Size' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_Size, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlDatabase object not created - Size(TSize&)' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_Size2, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlDatabase object not created - InTransaction' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_InTransaction, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlDatabase object not created - Compact' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_Compact, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlDatabase object not created - async Compact' panic\r\n"));
+	PanicTest(TheSqlDatabase_NotCreated_Compact2, EExitPanic, KCategory, 2);
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-CT-1620
+@SYMTestCaseDesc		RSqlStatement panic tests
+						Run a second thread. The second thread executes given RSqlStatement method calling
+						it with wrong arguments, or in a bad context,...The method panics the second thread. 
+						The main thread captures and checks the panic code.
+@SYMTestPriority		High
+@SYMTestActions			RSqlStatement panic tests
+@SYMTestExpectedResults Test must not fail
+@SYMREQ					REQ5792
+                        REQ5793
+*/	
+void StatementTests()
+	{
+	TheTest.Printf(_L("'RSqlStatement object not created - Reset' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_Reset, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlStatement object not created - Exec' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_Exec, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlStatement object not created - Next' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_Next, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlStatement object not created - ParameterIndex' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ParameterIndex, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlStatement object not created - ColumnIndex' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnIndex, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlStatement object not created - ColumnType' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnType, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlStatement object not created - ColumnSize' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnSize, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlStatement object not created - BindNull' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_BindNull, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlStatement object not created - BindInt' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_BindInt, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlStatement object not created - BindInt64' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_BindInt64, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement object not created - BindReal' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_BindReal, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement object not created - BindText' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_BindText, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement object not created - BindBinary' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_BindBinary, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlStatement object not created - BindZeroBlob' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_BindZeroBlob, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlStatement::BindZeroBlob() - invalid parameter index' panic\r\n"));
+	PanicTest(TheSqlStatement_OutOfBounds_BindZeroBlob, EExitPanic, KCategory, 5);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+
+	TheTest.Printf(_L("'RSqlStatement object not created - ColumnInt' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnInt, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement object not created - IsNull' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnInt, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement object not created - ColumnInt64' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnInt64, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement object not created - ColumnReal' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnReal, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement object not created - ColumnText' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnText, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement object not created - ColumnText2' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnText2, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement object not created - ColumnBinary' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnBinary, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement object not created - ColumnBinary2' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnBinary2, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement - database not created - Prepare' panic\r\n"));
+	PanicTest(TheSqlStatement_DbNotCreated_Prepare, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement - database not created - Prepare 8' panic\r\n"));
+	PanicTest(TheSqlStatement_DbNotCreated_Prepare8, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement - ColumnType - Column index out of bounds' panic\r\n"));
+	PanicTest(TheSqlStatement_OutOfBounds_ColumnType, EExitPanic, KCategory, 5);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+	
+	TheTest.Printf(_L("'RSqlStatement - ColumnSize - Column index out of bounds' panic\r\n"));
+	PanicTest(TheSqlStatement_OutOfBounds_ColumnSize, EExitPanic, KCategory, 5);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+	
+	TheTest.Printf(_L("'RSqlStatement - Bind - Parameter index out of bounds' panic\r\n"));
+	PanicTest(TheSqlStatement_OutOfBounds_Bind, EExitPanic, KCategory, 5);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+	
+	TheTest.Printf(_L("'RSqlStatement - Column value - Parameter index out of bounds' panic\r\n"));
+	PanicTest(TheSqlStatement_OutOfBounds_ColumnValue, EExitPanic, KCategory, 5);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+	
+	TheTest.Printf(_L("'RSqlStatement object not created - ColumnCount' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnCount, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlStatement object not created - DeclaredColumnType' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_DeclaredColumnType, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlStatement - DeclaredColumnType - Column index out of bounds' panic\r\n"));
+	PanicTest(TheSqlStatement_OutOfBounds_DeclaredColumnType, EExitPanic, KCategory, 5);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+
+	TheTest.Printf(_L("'RSqlStatement - ColumnName' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ColumnName, EExitPanic, KCategory, 2);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+
+	TheTest.Printf(_L("'RSqlStatement - ParameterName' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ParameterName, EExitPanic, KCategory, 2);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+	
+	TheTest.Printf(_L("'RSqlStatement - ParamName' panic\r\n"));
+	PanicTest(TheSqlStatement_NotCreated_ParamName, EExitPanic, KCategory, 2);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-CT-1625
+@SYMTestCaseDesc		RSqlColumnReadStream panic tests
+						Run a second thread. The second thread executes given RSqlColumnReadStream method calling
+						it with wrong arguments, or in a bad context,...The method panics the second thread. 
+						The main thread captures and checks the panic code.
+@SYMTestPriority		High
+@SYMTestActions			RSqlColumnReadStream panic tests
+@SYMTestExpectedResults Test must not fail
+@SYMREQ					REQ5792
+                        REQ5793
+*/	
+void ColumnStreamTests()
+	{
+	TheTest.Printf(_L("'RSqlColumnReadStream - ColumnText - invalid statement' panic\r\n"));
+	PanicTest(TheColumnReadStream_ColumnText_Statement, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlColumnReadStream - ColumnBinary - invalid statement' panic\r\n"));
+	PanicTest(TheColumnReadStream_ColumnBinary_Statement, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlColumnReadStream - ColumnText - invalid column index' panic\r\n"));
+	PanicTest(TheColumnReadStream_ColumnText_Column, EExitPanic, KCategory, 5);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+	
+	TheTest.Printf(_L("'RSqlColumnReadStream - ColumnBinary - invalid column index' panic\r\n"));
+	PanicTest(TheColumnReadStream_ColumnBinary_Column, EExitPanic, KCategory, 5);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+
+	TheTest.Printf(_L("'RSqlColumnReadStream - ColumnText - not at row' panic\r\n"));
+	PanicTest(TheColumnReadStream_ColumnText_AtRow, EExitPanic, KCategory, 11);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+
+	TheTest.Printf(_L("'RSqlColumnReadStream - ColumnBinary - not at row' panic\r\n"));
+	PanicTest(TheColumnReadStream_ColumnBinary_AtRow, EExitPanic, KCategory, 11);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-CT-1626
+@SYMTestCaseDesc		RSqlParamWriteStream panic tests
+						Run a second thread. The second thread executes given RSqlParamWriteStream method calling
+						it with wrong arguments, or in a bad context,...The method panics the second thread. 
+						The main thread captures and checks the panic code.
+@SYMTestPriority		High
+@SYMTestActions			RSqlParamWriteStream panic tests
+@SYMTestExpectedResults Test must not fail
+@SYMREQ					REQ5792
+                        REQ5793
+*/	
+void ParameterStreamTests()
+	{
+	TheTest.Printf(_L("'RSqlParamWriteStream - BindText - invalid statement' panic\r\n"));
+	PanicTest(TheParamWriteStream_BindText_Statement, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlParamWriteStream - BindBinary - invalid statement' panic\r\n"));
+	PanicTest(TheParamWriteStream_BindBinary_Statement, EExitPanic, KCategory, 2);
+	
+	TheTest.Printf(_L("'RSqlParamWriteStream - BindText - invalid parameter index' panic\r\n"));
+	PanicTest(TheParamWriteStream_BindText_Column, EExitPanic, KCategory, 5);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+	
+	TheTest.Printf(_L("'RSqlParamWriteStream - BindBinary - invalid parameter index' panic\r\n"));
+	PanicTest(TheParamWriteStream_BindBinary_Column, EExitPanic, KCategory, 5);
+	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-CT-1638
+@SYMTestCaseDesc		RSqlSecurityPolicy panic tests
+						Run a second thread. The second thread executes given RSqlSecurityPolicy method calling
+						it with wrong arguments, or in a bad context,...The method panics the second thread. 
+						The main thread captures and checks the panic code.
+@SYMTestPriority		High
+@SYMTestActions			RSqlSecurityPolicy panic tests
+@SYMTestExpectedResults Test must not fail
+@SYMREQ					REQ5792
+                        REQ5793
+*/	
+void SecuritySettingsTests()
+	{
+	TheTest.Printf(_L("'RSqlSecurityPolicy::SetDbPolicy - invalid policy type' panic\r\n"));
+	PanicTest(TheSqlSecurity_Set1, EExitPanic, KCategory, 4);
+	
+	TheTest.Printf(_L("'RSqlSecurityPolicy::SetPolicy - invalid database object type' panic\r\n"));
+	PanicTest(TheSqlSecurity_Set2, EExitPanic, KCategory, 4);
+	
+	TheTest.Printf(_L("'RSqlSecurityPolicy::SetPolicy - invalid database object name' panic\r\n"));
+	PanicTest(TheSqlSecurity_Set3, EExitPanic, KCategory, 4);
+
+	TheTest.Printf(_L("'RSqlSecurityPolicy::DbPolicy - invalid policy type' panic\r\n"));
+	PanicTest(TheSqlSecurity_Get1, EExitPanic, KCategory, 4);
+	
+	TheTest.Printf(_L("'RSqlSecurityPolicy::Policy - invalid database object type' panic\r\n"));
+	PanicTest(TheSqlSecurity_Get2, EExitPanic, KCategory, 4);
+	
+	TheTest.Printf(_L("'RSqlSecurityPolicy::Policy - invalid database object name' panic\r\n"));
+	PanicTest(TheSqlSecurity_Get3, EExitPanic, KCategory, 4);
+
+	TheTest.Printf(_L("'RSqlSecurityPolicy::DefaultPolicy - invalid object' panic\r\n"));
+	PanicTest(TheSqlSecurity_DefaultPolicy, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlSecurityPolicy::Externalize - panic\r\n"));
+	PanicTest(TheSqlSecurity_Externalize, EExitPanic, KCategory, 2);
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-CT-1812
+@SYMTestCaseDesc		TSqlScalarFullSelectQuery panic tests
+						Run a second thread. The second thread executes given TSqlScalarFullSelectQuery method calling
+						it with wrong arguments, or in a bad context,...The method panics the second thread. 
+						The main thread captures and checks the panic code.
+@SYMTestPriority		High
+@SYMTestActions			TSqlScalarFullSelectQuery panic tests
+@SYMTestExpectedResults Test must not fail
+@SYMREQ					REQ5792
+                        REQ5793
+*/
+void ScalarFullSelectTests()
+	{
+	TheTest.Printf(_L("'TheSqlScalarFullSelectQuery, invalid database' - panic\r\n"));
+	PanicTest(TheSqlScalarFullSelectQuery_InvalidDatabase, EExitPanic, KCategory, 2);
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-UT-4092
+@SYMTestCaseDesc		RSqlBlobReadStream panic tests
+						Run a second thread. The second thread executes a given RSqlBlobReadStream method calling
+						the method with wrong arguments, or in a bad context,...The method panics the second thread. 
+						The main thread captures and checks the panic code.
+@SYMTestPriority		High
+@SYMTestActions			RSqlBlobReadStream panic tests
+@SYMTestExpectedResults Test must not fail
+@SYMREQ					REQ5792
+                        REQ5793
+                        REQ10410
+                        REQ10411
+*/
+void BlobReadStreamTests()
+	{
+	TheTest.Printf(_L("'RSqlBlobReadStream::OpenL(), invalid database' - panic test 1\r\n"));
+	PanicTest(TheBlobReadStream_Open_Database1, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlBlobReadStream::OpenL(), invalid database' - panic test 2\r\n"));
+	PanicTest(TheBlobReadStream_Open_Database2, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlBlobReadStream::SizeL(), invalid stream' - panic test\r\n"));
+	PanicTest(TheBlobReadStream_Size_Stream, EExitPanic, KCategory, 2);
+	}
+
+/**
+@SYMTestCaseID			SYSLIB-SQL-UT-4093
+@SYMTestCaseDesc		RSqlBlobWriteStream panic tests
+						Run a second thread. The second thread executes a given RSqlBlobWriteStream method calling
+						the method with wrong arguments, or in a bad context,...The method panics the second thread. 
+						The main thread captures and checks the panic code.
+@SYMTestPriority		High
+@SYMTestActions			RSqlBlobWriteStream panic tests
+@SYMTestExpectedResults Test must not fail
+@SYMREQ					REQ5792
+                        REQ5793
+                        REQ10418
+*/
+void BlobWriteStreamTests()
+	{
+	TheTest.Printf(_L("'RSqlBlobWriteStream::OpenL(), invalid database' - panic test 1\r\n"));
+	PanicTest(TheBlobWriteStream_Open_Database1, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlBlobWriteStream::OpenL(), invalid database' - panic test 2\r\n"));
+	PanicTest(TheBlobWriteStream_Open_Database2, EExitPanic, KCategory, 2);
+
+	TheTest.Printf(_L("'RSqlBlobWriteStream::SizeL(), invalid stream' - panic test\r\n"));
+	PanicTest(TheBlobWriteStream_Size_Stream, EExitPanic, KCategory, 2);
+	}
+
+void DoTests()
+	{
+	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1619 RSqlDatabase - panic tests"));
+	DatabaseTests();
+
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1620 RSqlStatement - panic tests"));
+	StatementTests();
+	
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1625 RSqlColumnReadStream - panic tests"));
+	ColumnStreamTests();
+	
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1626 RSqlParamWriteStream - panic tests"));
+	ParameterStreamTests();
+	
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1638 RSqlSecurityPolicy - panic tests"));
+	SecuritySettingsTests();
+	
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1812 TheSqlScalarFullSelectQuery - panic tests"));
+	ScalarFullSelectTests();
+	
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4092 RSqlBlobReadStream - panic tests"));
+	BlobReadStreamTests();
+	
+	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4093 RSqlBlobWriteStream - panic tests"));
+	BlobWriteStreamTests();
+	}
+
+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;
+	}