sl@0: // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include <e32test.h>
sl@0: #include <bautils.h>
sl@0: #include <sqldb.h>
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: #define UNUSED_VAR(a) (a) = (a)
sl@0: #define IGNORE_ERR(a) (a) = (a)
sl@0: 
sl@0: RTest TheTest(_L("t_sqlpanic test"));
sl@0: 
sl@0: _LIT(KTestDir, "c:\\test\\");
sl@0: _LIT(KTestDbName, "c:\\test\\t_sqlpanic.db");
sl@0: 
sl@0: _LIT(KCategory, "SqlDb");
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void DeleteTestFiles()
sl@0: 	{
sl@0: 	RSqlDatabase::Delete(KTestDbName);
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: //Test macros and functions
sl@0: void Check(TInt aValue, TInt aLine)
sl@0: 	{
sl@0: 	if(!aValue)
sl@0: 		{
sl@0: 		DeleteTestFiles();
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: void Check(TInt aValue, TInt aExpected, TInt aLine)
sl@0: 	{
sl@0: 	if(aValue != aExpected)
sl@0: 		{
sl@0: 		DeleteTestFiles();
sl@0: 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: #define TEST(arg) ::Check((arg), __LINE__)
sl@0: #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void CreateTestDir()
sl@0:     {
sl@0:     RFs fs;
sl@0: 	TInt err = fs.Connect();
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	err = fs.MkDir(KTestDir);
sl@0: 	TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0: 	
sl@0: 	fs.Close();
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //Panic thread function. 
sl@0: //It will cast aData parameter to a TFunctor pointer and call it.
sl@0: //The expectation is that the called function will panic and kill the panic thread.
sl@0: TInt ThreadFunc(void* aData)
sl@0: 	{
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 	TEST(tc != NULL);
sl@0: 	
sl@0: 	User::SetJustInTime(EFalse);	// disable debugger panic handling
sl@0: 	
sl@0: 	TFunctor* obj = reinterpret_cast<TFunctor*> (aData);
sl@0: 	TEST(obj != NULL);
sl@0: 	(*obj)();//call the panic function
sl@0: 	
sl@0: 	delete tc;
sl@0: 	
sl@0: 	return KErrNone;		
sl@0: 	}
sl@0: 
sl@0: //Panic test.
sl@0: //PanicTest function will create a new thread - panic thread, giving it a pointer to the function which has to
sl@0: //be executed and the expectation is that the function will panic and kill the panic thread.
sl@0: //PanicTest function will check the panic thread exit code, exit category and the panic code.
sl@0: void PanicTest(TFunctor& aFunctor, TExitType aExpectedExitType, const TDesC& aExpectedCategory, TInt aExpectedPanicCode)
sl@0: 	{
sl@0: 	RThread thread;
sl@0: 	_LIT(KThreadName,"SqlDbPanicThread");
sl@0: 	TEST2(thread.Create(KThreadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, (void*)&aFunctor, EOwnerThread), KErrNone);
sl@0: 	
sl@0: 	TRequestStatus status;
sl@0: 	thread.Logon(status);
sl@0: 	TEST2(status.Int(), KRequestPending);
sl@0: 	thread.Resume();
sl@0: 	User::WaitForRequest(status);
sl@0: 	User::SetJustInTime(ETrue);	// enable debugger panic handling
sl@0: 
sl@0: 	TEST2(thread.ExitType(), aExpectedExitType);
sl@0: 	TEST(thread.ExitCategory() == aExpectedCategory);
sl@0: 	TEST2(thread.ExitReason(), aExpectedPanicCode);
sl@0: 	
sl@0: 	CLOSE_AND_WAIT(thread);
sl@0: 	}
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //////////////////////////////     Panic test functions    /////////////////////////////////////////////////
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //Panic when calling RSqlDatabase::Exec() on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_Exec8 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		db.Exec(_L8("CREATE TABLE A(f integer)"));//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_Exec8 TheSqlDatabase_NotCreated_Exec8;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlDatabase::Exec() on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_Exec : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		db.Exec(_L("CREATE TABLE A(f integer)"));//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_Exec TheSqlDatabase_NotCreated_Exec;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlDatabase::GetSecuritySettings() on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_SecuritySettings : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		RSqlSecurityPolicy securityPolicy;
sl@0: 		(void)db.GetSecurityPolicy(securityPolicy);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_SecuritySettings TheSqlDatabase_NotCreated_SecuritySettings;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlDatabase::SetIsolationLevel() on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_SetIsolationLevel : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		db.SetIsolationLevel(RSqlDatabase::EReadUncommitted);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_SetIsolationLevel TheSqlDatabase_NotCreated_SetIsolationLevel;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlDatabase::LastErrorMessage() on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_LastErrorMessage : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		db.LastErrorMessage();//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_LastErrorMessage TheSqlDatabase_NotCreated_LastErrorMessage;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlDatabase::LastInsertedRowId() on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_LastInsertedRowId : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		db.LastInsertedRowId();//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_LastInsertedRowId TheSqlDatabase_NotCreated_LastInsertedRowId;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlDatabase::Size() on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_Size : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		(void)db.Size();//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_Size TheSqlDatabase_NotCreated_Size;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlDatabase::Size(TSize&) on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_Size2 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		RSqlDatabase::TSize size;
sl@0: 		(void)db.Size(size);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_Size2 TheSqlDatabase_NotCreated_Size2;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlDatabase::InTransaction() on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_InTransaction : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		(void)db.InTransaction();//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_InTransaction TheSqlDatabase_NotCreated_InTransaction;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlDatabase::Attach() on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_Attach : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		db.Attach(_L("C:\\TEST\\A.DB"), _L("A"));//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_Attach TheSqlDatabase_NotCreated_Attach;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlDatabase::Detach() on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_Detach : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		db.Detach(_L("A"));//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_Detach TheSqlDatabase_NotCreated_Detach;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlDatabase::Compact() on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_Compact : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		db.Compact(2048);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_Compact TheSqlDatabase_NotCreated_Compact;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling async RSqlDatabase::Compact() on an invalid RSqlDatabase object.
sl@0: class TSqlDatabase_NotCreated_Compact2 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TRequestStatus stat;
sl@0: 		db.Compact(2048, stat);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlDatabase_NotCreated_Compact2 TheSqlDatabase_NotCreated_Compact2;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::Reset() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_Reset : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.Reset();//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_Reset TheSqlStatement_NotCreated_Reset;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::Exec() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_Exec : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.Exec();//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_Exec TheSqlStatement_NotCreated_Exec;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::Next() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_Next : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.Next();//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_Next TheSqlStatement_NotCreated_Next;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::ParameterIndex() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ParameterIndex : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.ParameterIndex(_L("ABV"));//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ParameterIndex TheSqlStatement_NotCreated_ParameterIndex;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::ColumnIndex() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ColumnIndex : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.ColumnIndex(_L("ABV"));//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ColumnIndex TheSqlStatement_NotCreated_ColumnIndex;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::ColumnType() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ColumnType : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.ColumnType(1);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ColumnType TheSqlStatement_NotCreated_ColumnType;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::ColumnSize() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ColumnSize : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.ColumnSize(1);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ColumnSize TheSqlStatement_NotCreated_ColumnSize;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::BindNull() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_BindNull : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.BindNull(1);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_BindNull TheSqlStatement_NotCreated_BindNull;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::BindInt() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_BindInt : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.BindInt(1, 2);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_BindInt TheSqlStatement_NotCreated_BindInt;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::BindInt64() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_BindInt64 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.BindInt64(1, TInt64(2));//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_BindInt64 TheSqlStatement_NotCreated_BindInt64;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::BindReal() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_BindReal : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.BindReal(1, 2.5);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_BindReal TheSqlStatement_NotCreated_BindReal;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::BindText() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_BindText : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.BindText(1, _L("ABV"));//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_BindText TheSqlStatement_NotCreated_BindText;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::BindBinary() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_BindBinary : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.BindBinary(1, _L8("ABV"));//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_BindBinary TheSqlStatement_NotCreated_BindBinary;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::BindZeroBlob() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_BindZeroBlob : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.BindZeroBlob(1, 100);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_BindZeroBlob TheSqlStatement_NotCreated_BindZeroBlob;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlStatement::BindZeroBlob() giving an invalid parameter index.
sl@0: class TSqlStatement_OutOfBounds_BindZeroBlob : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		TEST2(db.Exec(_L8("CREATE TABLE D(A INTEGER, B BLOB)")), 1);
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("INSERT INTO D VALUES(1, :Prm1)")), KErrNone);
sl@0: 		stmt.BindZeroBlob(12, 100);//panic here
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_OutOfBounds_BindZeroBlob TheSqlStatement_OutOfBounds_BindZeroBlob;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::IsNull() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_IsNull : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.IsNull(1);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_IsNull TheSqlStatement_NotCreated_IsNull;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::ColumnInt() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ColumnInt : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.ColumnInt(1);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ColumnInt TheSqlStatement_NotCreated_ColumnInt;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::ColumnInt64() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ColumnInt64 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.ColumnInt64(1);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ColumnInt64 TheSqlStatement_NotCreated_ColumnInt64;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::ColumnReal() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ColumnReal : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.ColumnReal(1);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ColumnReal TheSqlStatement_NotCreated_ColumnReal;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::ColumnText() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ColumnText : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		TPtrC ptr;
sl@0: 		(void)stmt.ColumnText(1, ptr);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ColumnText TheSqlStatement_NotCreated_ColumnText;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::ColumnText() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ColumnText2 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		TBuf<10> buf;
sl@0: 		stmt.ColumnText(1, buf);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ColumnText2 TheSqlStatement_NotCreated_ColumnText2;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::ColumnBinary() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ColumnBinary : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		TPtrC8 ptr;
sl@0: 		(void)stmt.ColumnBinary(1, ptr);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ColumnBinary TheSqlStatement_NotCreated_ColumnBinary;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::ColumnBinary() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ColumnBinary2 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		TBuf8<10> buf;
sl@0: 		stmt.ColumnBinary(1, buf);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ColumnBinary2 TheSqlStatement_NotCreated_ColumnBinary2;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::Prepare() giving an invalid RSqlDatabase object.
sl@0: class TSqlStatement_DbNotCreated_Prepare : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.Prepare(db, _L("CREATE TABLE A(d INTEGER)"));//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_DbNotCreated_Prepare TheSqlStatement_DbNotCreated_Prepare;
sl@0: 	
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::Prepare() giving an invalid RSqlDatabase object.
sl@0: class TSqlStatement_DbNotCreated_Prepare8 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.Prepare(db, _L8("CREATE TABLE A(d INTEGER)"));//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_DbNotCreated_Prepare8 TheSqlStatement_DbNotCreated_Prepare8;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: /*
sl@0: //Panic when an attempt is made to call RSqlStatement::Prepare() twice on the same RSqlStatement object.
sl@0: class TSqlStatement_CreateTwice : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L("CREATE TABLE A(d INTEGER)")), KErrNone);
sl@0: 		stmt.Prepare(db, _L("CREATE TABLE A(d INTEGER)"));//panic here
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_CreateTwice TheSqlStatement_CreateTwice;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlStatement::Prepare() twice on the same RSqlStatement object.
sl@0: class TSqlStatement_CreateTwice8 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("CREATE TABLE A(d INTEGER)")), KErrNone);
sl@0: 		stmt.Prepare(db, _L8("CREATE TABLE A(d INTEGER)"));//panic here
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_CreateTwice8 TheSqlStatement_CreateTwice8;
sl@0: */		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlStatement::ColumnType() giving an invalid column index.
sl@0: class TSqlStatement_OutOfBounds_ColumnType : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D")), KErrNone);
sl@0: 		stmt.ColumnType(12);//panic here
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_OutOfBounds_ColumnType TheSqlStatement_OutOfBounds_ColumnType;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlStatement::ColumnSize() giving an invalid column index.
sl@0: class TSqlStatement_OutOfBounds_ColumnSize : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D")), KErrNone);
sl@0: 		stmt.ColumnSize(-25);//panic here
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_OutOfBounds_ColumnSize TheSqlStatement_OutOfBounds_ColumnSize;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlStatement::BindNull() giving an invalid parameter index.
sl@0: class TSqlStatement_OutOfBounds_Bind : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D WHERE A = :V")), KErrNone);
sl@0: 		stmt.BindNull(2);//panic here
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_OutOfBounds_Bind TheSqlStatement_OutOfBounds_Bind;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlStatement::ColumnInt() giving an invalid column index.
sl@0: class TSqlStatement_OutOfBounds_ColumnValue : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D")), KErrNone);
sl@0: 		stmt.ColumnInt(56);//panic here
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_OutOfBounds_ColumnValue TheSqlStatement_OutOfBounds_ColumnValue;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::ColumnCount() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ColumnCount : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		stmt.ColumnCount();//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ColumnCount TheSqlStatement_NotCreated_ColumnCount;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when calling RSqlStatement::DeclaredColumnType() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_DeclaredColumnType : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		TSqlColumnType colType;
sl@0: 		stmt.DeclaredColumnType(0, colType);//panic here
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_DeclaredColumnType TheSqlStatement_NotCreated_DeclaredColumnType;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlStatement::DeclaredColumnType() giving an invalid column index.
sl@0: class TSqlStatement_OutOfBounds_DeclaredColumnType : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		TEST(db.Exec(_L8("CREATE TABLE D(A INTEGER, B INTEGER, C INTEGER)")) >= 0);
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("SELECT A, B, C FROM D")), KErrNone);
sl@0: 		TSqlColumnType colType;
sl@0: 		stmt.DeclaredColumnType(8, colType);//panic here
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_OutOfBounds_DeclaredColumnType TheSqlStatement_OutOfBounds_DeclaredColumnType;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlStatement::ColumnName() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ColumnName : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		RSqlStatement stmt;
sl@0: 		TPtrC columnName;
sl@0: 		(void)stmt.ColumnName(0, columnName);//panic here
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ColumnName TheSqlStatement_NotCreated_ColumnName;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlStatement::ParameterName() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ParameterName : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		RSqlStatement stmt;
sl@0: 		TPtrC parameterName;
sl@0: 		(void)stmt.ParameterName(0, parameterName);//panic here
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ParameterName TheSqlStatement_NotCreated_ParameterName;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlStatement::ParamName() on an invalid RSqlStatement object.
sl@0: class TSqlStatement_NotCreated_ParamName : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		RSqlStatement stmt;
sl@0: 		TPtrC paramName;
sl@0: 		(void)stmt.ParamName(0, paramName);//panic here
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlStatement_NotCreated_ParamName TheSqlStatement_NotCreated_ParamName;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlColumnReadStream::ColumnText() with an invalid RSqlStatement object.
sl@0: class TColumnReadStream_ColumnText_Statement : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		RSqlColumnReadStream strm;
sl@0: 		strm.ColumnText(stmt, 0);//panic here
sl@0: 		strm.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TColumnReadStream_ColumnText_Statement TheColumnReadStream_ColumnText_Statement;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlColumnReadStream::ColumnBinary() with an invalid RSqlStatement object.
sl@0: class TColumnReadStream_ColumnBinary_Statement : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		RSqlColumnReadStream strm;
sl@0: 		strm.ColumnBinary(stmt, 0);//panic here
sl@0: 		strm.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TColumnReadStream_ColumnBinary_Statement TheColumnReadStream_ColumnBinary_Statement;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlColumnReadStream::ColumnText() with an invalid column index.
sl@0: class TColumnReadStream_ColumnText_Column : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		TEST(db.Exec(_L8("CREATE TABLE D(A TEXT)")) >= 0);
sl@0: 		
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("SELECT * FROM D")), KErrNone);
sl@0: 		
sl@0: 		RSqlColumnReadStream strm;
sl@0: 		strm.ColumnText(stmt, 8);//panic here
sl@0: 		
sl@0: 		strm.Close();
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TColumnReadStream_ColumnText_Column TheColumnReadStream_ColumnText_Column;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlColumnReadStream::ColumnBinary() with an invalid column index.
sl@0: class TColumnReadStream_ColumnBinary_Column : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		TEST(db.Exec(_L8("CREATE TABLE D(A BLOB)")) >= 0);
sl@0: 		
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("SELECT * FROM D")), KErrNone);
sl@0: 		
sl@0: 		RSqlColumnReadStream strm;
sl@0: 		strm.ColumnBinary(stmt, 3);//panic here
sl@0: 		
sl@0: 		strm.Close();
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TColumnReadStream_ColumnBinary_Column TheColumnReadStream_ColumnBinary_Column;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlColumnReadStream::ColumnText() when the statement object is not at row.
sl@0: class TColumnReadStream_ColumnText_AtRow : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		TEST(db.Exec(_L8("CREATE TABLE D(A TEXT)")) >= 0);
sl@0: 		
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("SELECT * FROM D")), KErrNone);
sl@0: 		
sl@0: 		RSqlColumnReadStream strm;
sl@0: 		strm.ColumnText(stmt, 0);//panic here
sl@0: 		
sl@0: 		strm.Close();
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TColumnReadStream_ColumnText_AtRow TheColumnReadStream_ColumnText_AtRow;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlColumnReadStream::ColumnBinary() when the statement object is not at row.
sl@0: class TColumnReadStream_ColumnBinary_AtRow : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		TEST(db.Exec(_L8("CREATE TABLE D(A BLOB)")) >= 0);
sl@0: 		
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("SELECT * FROM D")), KErrNone);
sl@0: 		
sl@0: 		RSqlColumnReadStream strm;
sl@0: 		strm.ColumnBinary(stmt, 0);//panic here
sl@0: 		
sl@0: 		strm.Close();
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TColumnReadStream_ColumnBinary_AtRow TheColumnReadStream_ColumnBinary_AtRow;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlParamWriteStream::BindText() with an invalid RSqlStatement object.
sl@0: class TParamWriteStream_BindText_Statement : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		RSqlParamWriteStream strm;
sl@0: 		strm.BindText(stmt, 0);//panic here
sl@0: 		strm.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TParamWriteStream_BindText_Statement TheParamWriteStream_BindText_Statement;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlParamWriteStream::BindBinary() with an invalid RSqlStatement object.
sl@0: class TParamWriteStream_BindBinary_Statement : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlStatement stmt;
sl@0: 		RSqlParamWriteStream strm;
sl@0: 		strm.BindBinary(stmt, 0);//panic here
sl@0: 		strm.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TParamWriteStream_BindBinary_Statement TheParamWriteStream_BindBinary_Statement;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlParamWriteStream::BindText() with an invalid parameter index.
sl@0: class TParamWriteStream_BindText_Column : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		TEST(db.Exec(_L8("CREATE TABLE D(A TEXT)")) >= 0);
sl@0: 		
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("SELECT * FROM D WHERE A = :Val")), KErrNone);
sl@0: 		
sl@0: 		RSqlParamWriteStream strm;
sl@0: 		strm.BindText(stmt, 8);//panic here
sl@0: 		
sl@0: 		strm.Close();
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TParamWriteStream_BindText_Column TheParamWriteStream_BindText_Column;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlParamWriteStream::BindBinary() with an invalid parameter index.
sl@0: class TParamWriteStream_BindBinary_Column : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlDatabase db;
sl@0: 		TEST2(db.Create(KTestDbName), KErrNone);
sl@0: 		TEST(db.Exec(_L8("CREATE TABLE D(A BLOB)")) >= 0);
sl@0: 		
sl@0: 		RSqlStatement stmt;
sl@0: 		TEST2(stmt.Prepare(db, _L8("SELECT * FROM D WHERE A = :Val")), KErrNone);
sl@0: 		
sl@0: 		RSqlParamWriteStream strm;
sl@0: 		strm.BindBinary(stmt, 3);//panic here
sl@0: 		
sl@0: 		strm.Close();
sl@0: 		stmt.Close();
sl@0: 		db.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TParamWriteStream_BindBinary_Column TheParamWriteStream_BindBinary_Column;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlSecurityPolicy::DefaultPolicy() on an invalid object.
sl@0: class TSqlSecurity_DefaultPolicy : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlSecurityPolicy securityPolicy;
sl@0: 		TSecurityPolicy policy = securityPolicy.DefaultPolicy();//panic here
sl@0: 		UNUSED_VAR(policy);
sl@0: 		}
sl@0: 	};
sl@0: static TSqlSecurity_DefaultPolicy TheSqlSecurity_DefaultPolicy;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlSecurityPolicy::SetDbPolicy() with an invalid policy type.
sl@0: class TSqlSecurity_Set1 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
sl@0: 		RSqlSecurityPolicy securityPolicy;
sl@0: 		TInt err = securityPolicy.Create(defaultPolicy);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		RSqlSecurityPolicy::TPolicyType policyType = static_cast <RSqlSecurityPolicy::TPolicyType> (12345);
sl@0: 		TSecurityPolicy policy(TSecurityPolicy::EAlwaysFail);
sl@0: 		securityPolicy.SetDbPolicy(policyType, policy);//panic here
sl@0: 		securityPolicy.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlSecurity_Set1 TheSqlSecurity_Set1;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlSecurityPolicy::SetPolicy() with an invalid database object type.
sl@0: class TSqlSecurity_Set2 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
sl@0: 		RSqlSecurityPolicy securityPolicy;
sl@0: 		TInt err = securityPolicy.Create(defaultPolicy);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		RSqlSecurityPolicy::TObjectType objectType = static_cast <RSqlSecurityPolicy::TObjectType> (-113);
sl@0: 		TSecurityPolicy policy(TSecurityPolicy::EAlwaysFail);
sl@0: 		securityPolicy.SetPolicy(objectType, _L("ATbl"), RSqlSecurityPolicy::EWritePolicy, policy);//panic here
sl@0: 		securityPolicy.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlSecurity_Set2 TheSqlSecurity_Set2;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlSecurityPolicy::SetPolicy() with an invalid database object name.
sl@0: class TSqlSecurity_Set3 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
sl@0: 		RSqlSecurityPolicy securityPolicy;
sl@0: 		TInt err = securityPolicy.Create(defaultPolicy);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		TSecurityPolicy policy(TSecurityPolicy::EAlwaysFail);
sl@0: 		securityPolicy.SetPolicy(RSqlSecurityPolicy::ETable, KNullDesC, RSqlSecurityPolicy::EReadPolicy, policy);//panic here
sl@0: 		securityPolicy.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlSecurity_Set3 TheSqlSecurity_Set3;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlSecurityPolicy::DbPolicy() with an invalid policy type.
sl@0: class TSqlSecurity_Get1 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
sl@0: 		RSqlSecurityPolicy securityPolicy;
sl@0: 		TInt err = securityPolicy.Create(defaultPolicy);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		RSqlSecurityPolicy::TPolicyType policyType = static_cast <RSqlSecurityPolicy::TPolicyType> (12345);
sl@0: 		securityPolicy.DbPolicy(policyType);//panic here
sl@0: 		securityPolicy.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlSecurity_Get1 TheSqlSecurity_Get1;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlSecurityPolicy::Policy() with an invalid database object type.
sl@0: class TSqlSecurity_Get2 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
sl@0: 		RSqlSecurityPolicy securityPolicy;
sl@0: 		TInt err = securityPolicy.Create(defaultPolicy);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		RSqlSecurityPolicy::TObjectType objectType = static_cast <RSqlSecurityPolicy::TObjectType> (-113);
sl@0: 		securityPolicy.Policy(objectType, _L("BTbl"), RSqlSecurityPolicy::EReadPolicy);//panic here
sl@0: 		securityPolicy.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlSecurity_Get2 TheSqlSecurity_Get2;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlSecurityPolicy::Policy() with an invalid database object name.
sl@0: class TSqlSecurity_Get3 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
sl@0: 		RSqlSecurityPolicy securityPolicy;
sl@0: 		TInt err = securityPolicy.Create(defaultPolicy);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		securityPolicy.Policy(RSqlSecurityPolicy::ETable, KNullDesC, RSqlSecurityPolicy::EWritePolicy);//panic here
sl@0: 		securityPolicy.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlSecurity_Get3 TheSqlSecurity_Get3;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: /*
sl@0: //Panic when an attempt is made to call RSqlSecurityPolicy::Create() on an already created object.
sl@0: class TSqlSecurity_CreateTwice : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		TSecurityPolicy defaultPolicy(TSecurityPolicy::EAlwaysPass);
sl@0: 		RSqlSecurityPolicy securityPolicy;
sl@0: 		TInt err = securityPolicy.Create(defaultPolicy);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		securityPolicy.Create(defaultPolicy);//panic here
sl@0: 		securityPolicy.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlSecurity_CreateTwice TheSqlSecurity_CreateTwice;
sl@0: */		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlSecurityPolicy::ExternalizeL() on an invalid object.
sl@0: class TSqlSecurity_Externalize : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RSqlSecurityPolicy securityPolicy;
sl@0: 		RWriteStream stream;
sl@0: 		TRAPD(err, securityPolicy.ExternalizeL(stream));//panic here
sl@0: 		IGNORE_ERR(err);
sl@0: 		}
sl@0: 	};
sl@0: static TSqlSecurity_Externalize TheSqlSecurity_Externalize;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call TSqlScalarFullSelectQuery method and the database is not set.
sl@0: class TSqlScalarFullSelectQuery_InvalidDatabase : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		TSqlScalarFullSelectQuery query;
sl@0: 		TRAP_IGNORE((void)query.SelectIntL(_L("SELECT Id FROM A WHERE Name = 'AAA'")));
sl@0: 		}
sl@0: 	};
sl@0: static TSqlScalarFullSelectQuery_InvalidDatabase TheSqlScalarFullSelectQuery_InvalidDatabase;
sl@0: 		
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlBlobReadStream::OpenL() with an invalid RSqlDatabase object.
sl@0: class TBlobReadStream_Open_Database1 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 		
sl@0: 		RSqlDatabase db;
sl@0: 		RSqlBlobReadStream strm;
sl@0: 		TRAP_IGNORE(strm.OpenL(db, _L("Tbl"),_L("Col"), 1));//panic here
sl@0: 		strm.Close();
sl@0: 		
sl@0: 		delete tc;
sl@0: 		}
sl@0: 	};
sl@0: static TBlobReadStream_Open_Database1 TheBlobReadStream_Open_Database1;
sl@0: 		
sl@0: class TBlobReadStream_Open_Database2 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 		
sl@0: 		RSqlDatabase db;
sl@0: 		RSqlBlobReadStream strm;
sl@0: 		TRAP_IGNORE(strm.OpenL(db, _L("Tbl"),_L("Col"), 1, _L("Db")));//panic here
sl@0: 		strm.Close();
sl@0: 		
sl@0: 		delete tc;
sl@0: 		}
sl@0: 	};
sl@0: static TBlobReadStream_Open_Database2 TheBlobReadStream_Open_Database2;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlBlobReadStream::SizeL() on a unitialized RSqlBlobReadStream object.
sl@0: class TBlobReadStream_Size_Stream : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 		
sl@0: 		RSqlBlobReadStream strm;
sl@0: 		TRAP_IGNORE(strm.SizeL());//panic here
sl@0: 		strm.Close();
sl@0: 		
sl@0: 		delete tc;
sl@0: 		}
sl@0: 	};
sl@0: TBlobReadStream_Size_Stream TheBlobReadStream_Size_Stream;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlBlobWriteStream::OpenL() with an invalid RSqlDatabase object.
sl@0: class TBlobWriteStream_Open_Database1 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 		
sl@0: 		RSqlDatabase db;
sl@0: 		RSqlBlobWriteStream strm;
sl@0: 		TRAP_IGNORE(strm.OpenL(db, _L("Tbl"),_L("Col"), 1));//panic here
sl@0: 		strm.Close();
sl@0: 		
sl@0: 		delete tc;
sl@0: 		}
sl@0: 	};
sl@0: static TBlobWriteStream_Open_Database1 TheBlobWriteStream_Open_Database1;
sl@0: 		
sl@0: class TBlobWriteStream_Open_Database2 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 		
sl@0: 		RSqlDatabase db;
sl@0: 		RSqlBlobWriteStream strm;
sl@0: 		TRAP_IGNORE(strm.OpenL(db, _L("Tbl"),_L("Col"), 1, _L("Db")));//panic here
sl@0: 		strm.Close();
sl@0: 		
sl@0: 		delete tc;
sl@0: 		}
sl@0: 	};
sl@0: static TBlobWriteStream_Open_Database2 TheBlobWriteStream_Open_Database2;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //Panic when an attempt is made to call RSqlBlobWriteStream::SizeL() on a unitialized RSqlBlobWriteStream object.
sl@0: class TBlobWriteStream_Size_Stream : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 		
sl@0: 		RSqlBlobWriteStream strm;
sl@0: 		TRAP_IGNORE(strm.SizeL());//panic here
sl@0: 		strm.Close();
sl@0: 		
sl@0: 		delete tc;
sl@0: 		}
sl@0: 	};
sl@0: TBlobWriteStream_Size_Stream TheBlobWriteStream_Size_Stream;
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1619
sl@0: @SYMTestCaseDesc		RSqlDatabase panic tests
sl@0: 						Run a second thread. The second thread executes given RSqlDatabase method calling
sl@0: 						it with wrong arguments, or in a bad context,...The method panics the second thread. 
sl@0: 						The main thread captures and checks the panic code.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlDatabase panic tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0:                         REQ10405
sl@0:                         REQ10407
sl@0: */	
sl@0: void DatabaseTests()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - Exec 8' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_Exec8, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - Exec' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_Exec, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - GetSecuritySettings' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_SecuritySettings, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - Attach' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_Attach, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - Detach' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_Detach, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - SetIsolationLevel' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_SetIsolationLevel, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - LastErrorMessage' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_LastErrorMessage, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - LastInsertedRowId' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_LastInsertedRowId, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - Size' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_Size, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - Size(TSize&)' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_Size2, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - InTransaction' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_InTransaction, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - Compact' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_Compact, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlDatabase object not created - async Compact' panic\r\n"));
sl@0: 	PanicTest(TheSqlDatabase_NotCreated_Compact2, EExitPanic, KCategory, 2);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1620
sl@0: @SYMTestCaseDesc		RSqlStatement panic tests
sl@0: 						Run a second thread. The second thread executes given RSqlStatement method calling
sl@0: 						it with wrong arguments, or in a bad context,...The method panics the second thread. 
sl@0: 						The main thread captures and checks the panic code.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlStatement panic tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0: */	
sl@0: void StatementTests()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - Reset' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_Reset, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - Exec' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_Exec, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - Next' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_Next, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - ParameterIndex' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ParameterIndex, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - ColumnIndex' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnIndex, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - ColumnType' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnType, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - ColumnSize' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnSize, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - BindNull' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_BindNull, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - BindInt' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_BindInt, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - BindInt64' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_BindInt64, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - BindReal' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_BindReal, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - BindText' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_BindText, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - BindBinary' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_BindBinary, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - BindZeroBlob' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_BindZeroBlob, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement::BindZeroBlob() - invalid parameter index' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_OutOfBounds_BindZeroBlob, EExitPanic, KCategory, 5);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - ColumnInt' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnInt, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - IsNull' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnInt, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - ColumnInt64' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnInt64, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - ColumnReal' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnReal, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - ColumnText' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnText, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - ColumnText2' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnText2, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - ColumnBinary' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnBinary, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - ColumnBinary2' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnBinary2, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement - database not created - Prepare' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_DbNotCreated_Prepare, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement - database not created - Prepare 8' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_DbNotCreated_Prepare8, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement - ColumnType - Column index out of bounds' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_OutOfBounds_ColumnType, EExitPanic, KCategory, 5);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement - ColumnSize - Column index out of bounds' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_OutOfBounds_ColumnSize, EExitPanic, KCategory, 5);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement - Bind - Parameter index out of bounds' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_OutOfBounds_Bind, EExitPanic, KCategory, 5);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement - Column value - Parameter index out of bounds' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_OutOfBounds_ColumnValue, EExitPanic, KCategory, 5);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - ColumnCount' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnCount, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement object not created - DeclaredColumnType' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_DeclaredColumnType, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement - DeclaredColumnType - Column index out of bounds' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_OutOfBounds_DeclaredColumnType, EExitPanic, KCategory, 5);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement - ColumnName' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ColumnName, EExitPanic, KCategory, 2);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlStatement - ParameterName' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ParameterName, EExitPanic, KCategory, 2);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlStatement - ParamName' panic\r\n"));
sl@0: 	PanicTest(TheSqlStatement_NotCreated_ParamName, EExitPanic, KCategory, 2);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1625
sl@0: @SYMTestCaseDesc		RSqlColumnReadStream panic tests
sl@0: 						Run a second thread. The second thread executes given RSqlColumnReadStream method calling
sl@0: 						it with wrong arguments, or in a bad context,...The method panics the second thread. 
sl@0: 						The main thread captures and checks the panic code.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlColumnReadStream panic tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0: */	
sl@0: void ColumnStreamTests()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("'RSqlColumnReadStream - ColumnText - invalid statement' panic\r\n"));
sl@0: 	PanicTest(TheColumnReadStream_ColumnText_Statement, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlColumnReadStream - ColumnBinary - invalid statement' panic\r\n"));
sl@0: 	PanicTest(TheColumnReadStream_ColumnBinary_Statement, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlColumnReadStream - ColumnText - invalid column index' panic\r\n"));
sl@0: 	PanicTest(TheColumnReadStream_ColumnText_Column, EExitPanic, KCategory, 5);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlColumnReadStream - ColumnBinary - invalid column index' panic\r\n"));
sl@0: 	PanicTest(TheColumnReadStream_ColumnBinary_Column, EExitPanic, KCategory, 5);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlColumnReadStream - ColumnText - not at row' panic\r\n"));
sl@0: 	PanicTest(TheColumnReadStream_ColumnText_AtRow, EExitPanic, KCategory, 11);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlColumnReadStream - ColumnBinary - not at row' panic\r\n"));
sl@0: 	PanicTest(TheColumnReadStream_ColumnBinary_AtRow, EExitPanic, KCategory, 11);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1626
sl@0: @SYMTestCaseDesc		RSqlParamWriteStream panic tests
sl@0: 						Run a second thread. The second thread executes given RSqlParamWriteStream method calling
sl@0: 						it with wrong arguments, or in a bad context,...The method panics the second thread. 
sl@0: 						The main thread captures and checks the panic code.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlParamWriteStream panic tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0: */	
sl@0: void ParameterStreamTests()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("'RSqlParamWriteStream - BindText - invalid statement' panic\r\n"));
sl@0: 	PanicTest(TheParamWriteStream_BindText_Statement, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlParamWriteStream - BindBinary - invalid statement' panic\r\n"));
sl@0: 	PanicTest(TheParamWriteStream_BindBinary_Statement, EExitPanic, KCategory, 2);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlParamWriteStream - BindText - invalid parameter index' panic\r\n"));
sl@0: 	PanicTest(TheParamWriteStream_BindText_Column, EExitPanic, KCategory, 5);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlParamWriteStream - BindBinary - invalid parameter index' panic\r\n"));
sl@0: 	PanicTest(TheParamWriteStream_BindBinary_Column, EExitPanic, KCategory, 5);
sl@0: 	TEST2(RSqlDatabase::Delete(KTestDbName), KErrNone);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1638
sl@0: @SYMTestCaseDesc		RSqlSecurityPolicy panic tests
sl@0: 						Run a second thread. The second thread executes given RSqlSecurityPolicy method calling
sl@0: 						it with wrong arguments, or in a bad context,...The method panics the second thread. 
sl@0: 						The main thread captures and checks the panic code.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlSecurityPolicy panic tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0: */	
sl@0: void SecuritySettingsTests()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("'RSqlSecurityPolicy::SetDbPolicy - invalid policy type' panic\r\n"));
sl@0: 	PanicTest(TheSqlSecurity_Set1, EExitPanic, KCategory, 4);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlSecurityPolicy::SetPolicy - invalid database object type' panic\r\n"));
sl@0: 	PanicTest(TheSqlSecurity_Set2, EExitPanic, KCategory, 4);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlSecurityPolicy::SetPolicy - invalid database object name' panic\r\n"));
sl@0: 	PanicTest(TheSqlSecurity_Set3, EExitPanic, KCategory, 4);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlSecurityPolicy::DbPolicy - invalid policy type' panic\r\n"));
sl@0: 	PanicTest(TheSqlSecurity_Get1, EExitPanic, KCategory, 4);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlSecurityPolicy::Policy - invalid database object type' panic\r\n"));
sl@0: 	PanicTest(TheSqlSecurity_Get2, EExitPanic, KCategory, 4);
sl@0: 	
sl@0: 	TheTest.Printf(_L("'RSqlSecurityPolicy::Policy - invalid database object name' panic\r\n"));
sl@0: 	PanicTest(TheSqlSecurity_Get3, EExitPanic, KCategory, 4);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlSecurityPolicy::DefaultPolicy - invalid object' panic\r\n"));
sl@0: 	PanicTest(TheSqlSecurity_DefaultPolicy, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlSecurityPolicy::Externalize - panic\r\n"));
sl@0: 	PanicTest(TheSqlSecurity_Externalize, EExitPanic, KCategory, 2);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-CT-1812
sl@0: @SYMTestCaseDesc		TSqlScalarFullSelectQuery panic tests
sl@0: 						Run a second thread. The second thread executes given TSqlScalarFullSelectQuery method calling
sl@0: 						it with wrong arguments, or in a bad context,...The method panics the second thread. 
sl@0: 						The main thread captures and checks the panic code.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			TSqlScalarFullSelectQuery panic tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0: */
sl@0: void ScalarFullSelectTests()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("'TheSqlScalarFullSelectQuery, invalid database' - panic\r\n"));
sl@0: 	PanicTest(TheSqlScalarFullSelectQuery_InvalidDatabase, EExitPanic, KCategory, 2);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4092
sl@0: @SYMTestCaseDesc		RSqlBlobReadStream panic tests
sl@0: 						Run a second thread. The second thread executes a given RSqlBlobReadStream method calling
sl@0: 						the method with wrong arguments, or in a bad context,...The method panics the second thread. 
sl@0: 						The main thread captures and checks the panic code.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlBlobReadStream panic tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0:                         REQ10410
sl@0:                         REQ10411
sl@0: */
sl@0: void BlobReadStreamTests()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("'RSqlBlobReadStream::OpenL(), invalid database' - panic test 1\r\n"));
sl@0: 	PanicTest(TheBlobReadStream_Open_Database1, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlBlobReadStream::OpenL(), invalid database' - panic test 2\r\n"));
sl@0: 	PanicTest(TheBlobReadStream_Open_Database2, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlBlobReadStream::SizeL(), invalid stream' - panic test\r\n"));
sl@0: 	PanicTest(TheBlobReadStream_Size_Stream, EExitPanic, KCategory, 2);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4093
sl@0: @SYMTestCaseDesc		RSqlBlobWriteStream panic tests
sl@0: 						Run a second thread. The second thread executes a given RSqlBlobWriteStream method calling
sl@0: 						the method with wrong arguments, or in a bad context,...The method panics the second thread. 
sl@0: 						The main thread captures and checks the panic code.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlBlobWriteStream panic tests
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ5793
sl@0:                         REQ10418
sl@0: */
sl@0: void BlobWriteStreamTests()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("'RSqlBlobWriteStream::OpenL(), invalid database' - panic test 1\r\n"));
sl@0: 	PanicTest(TheBlobWriteStream_Open_Database1, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlBlobWriteStream::OpenL(), invalid database' - panic test 2\r\n"));
sl@0: 	PanicTest(TheBlobWriteStream_Open_Database2, EExitPanic, KCategory, 2);
sl@0: 
sl@0: 	TheTest.Printf(_L("'RSqlBlobWriteStream::SizeL(), invalid stream' - panic test\r\n"));
sl@0: 	PanicTest(TheBlobWriteStream_Size_Stream, EExitPanic, KCategory, 2);
sl@0: 	}
sl@0: 
sl@0: void DoTests()
sl@0: 	{
sl@0: 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1619 RSqlDatabase - panic tests"));
sl@0: 	DatabaseTests();
sl@0: 
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1620 RSqlStatement - panic tests"));
sl@0: 	StatementTests();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1625 RSqlColumnReadStream - panic tests"));
sl@0: 	ColumnStreamTests();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1626 RSqlParamWriteStream - panic tests"));
sl@0: 	ParameterStreamTests();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1638 RSqlSecurityPolicy - panic tests"));
sl@0: 	SecuritySettingsTests();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1812 TheSqlScalarFullSelectQuery - panic tests"));
sl@0: 	ScalarFullSelectTests();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4092 RSqlBlobReadStream - panic tests"));
sl@0: 	BlobReadStreamTests();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4093 RSqlBlobWriteStream - panic tests"));
sl@0: 	BlobWriteStreamTests();
sl@0: 	}
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	TheTest.Title();
sl@0: 	
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 	
sl@0: 	__UHEAP_MARK;
sl@0: 	
sl@0: 	CreateTestDir();
sl@0: 	DeleteTestFiles();
sl@0: 	DoTests();
sl@0: 	DeleteTestFiles();
sl@0: 
sl@0: 	__UHEAP_MARKEND;
sl@0: 	
sl@0: 	TheTest.End();
sl@0: 	TheTest.Close();
sl@0: 	
sl@0: 	delete tc;
sl@0: 
sl@0: 	User::Heap().Check();
sl@0: 	return KErrNone;
sl@0: 	}