// Copyright (c) 1998-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 <d32dbms.h>

 #include <e32math.h>

 #include <s32file.h>

 #include <e32test.h>

 #include "t_dbfail.h"

 _LIT(KTestTitle,"t_dbfail: DBMS Failure mode test");

 GLDEF_D RTest test(KTestTitle);

 GLDEF_D RDbs TheDbs;

 GLDEF_D RDbNamedDatabase TheDatabase;

 GLDEF_D TClientHeap KClientHeap;

 GLDEF_D TServerHeap KServerHeap;

 LOCAL_D CTrapCleanup* TheTrapCleanup;

 LOCAL_D RFs TheFs;

 LOCAL_D RDbView TheView;

 LOCAL_D RDbTable TheTable;

 LOCAL_D RDbRowSet::TAccess Access;

 LOCAL_D CDbColSet* TheColSet;

 LOCAL_D CDbKey* TheKey;

 LOCAL_D const TDesC* TheSql;

 LOCAL_D TBuf<64> TheFormat;

 const TInt KTestCleanupStack=0x20;

 _LIT(KTestDatabase,"C:\\DBMS-TST\\t_fail.db");

 _LIT(TableName,"Table1");

 _LIT(TableName2,"Table_two");

 _LIT(TableNameX,"Bad Table Name");

 _LIT(IndexName,"Index1");

 _LIT(IndexName2,"Index2");

 _LIT(Column1,"column_one");

 _LIT(Column1Fold,"COLUMN_ONE");

 _LIT(Column2,"column_2");

 _LIT(Column2X,"column_2%");

 _LIT(SimpleSql,"select * from Table1");

 _LIT(UpdateSql,"update Table1 SET column_2='hello'");

 //const TPtrC ComplexSql(_S("select * from Table1 where column_one<0 and not column_one is null or column_2 not like '*fred*' and column_2>'m' order by column_one desc"));

 const TPtrC ComplexSql[]=

 	{

 	_S("select * from Table1 where column_one<0 and column_one is null"),

 	_S("select * from Table1 where column_one<0 and (column_one is null and column_2 like '')"),

 	_S("select * from Table1 where (column_one<0 and column_one is null) and column_2 like ''"),

 	_S("select * from Table1 where (column_one<0 and column_one is null) and (column_2 like '' and column_one>0)"),

 	_S("select * from Table1 where (column_one<0 and column_one is null) and (column_2 like '' and column_one>0 and column_one is null)"),

 	_S("select * from Table1 where (column_one<0 and column_one is null and column_one = 10) and (column_2 like '' and column_one>0 and column_one is null)"),

 	_S("select * from Table1 where column_one<0 and column_one is null and column_one = 10 and column_2 like '' and column_one>0 and column_one is null")

 	};

 struct SSqlErrors

 	{

 	const TText* iSql;

 	TInt iError;

 	};

 LOCAL_D SSqlErrors const BadSql[]=

 	{

 		{_S("sponge"),KErrArgument},

 		{_S("select * from widget"),KErrNotFound},

 		{_S("select * from Table1 where x = 0"),KErrNotFound},

 		{_S("select * from Table1 where x 0 like"),KErrArgument},

 		{_S("select * from Table1 where column_2>'a' and column_one<'z'"),KErrGeneral},

 		{_S("select from Table1"),KErrArgument},

 		{_S("select x, from Table1"),KErrArgument},

 		{_S("select x from Table1"),KErrNotFound},

 		{_S("select column_2 column_one from Table1"),KErrArgument},

 		{_S("select * from Table1 order by x"),KErrNotFound},

 		{_S("select * from Table1 order column_one"),KErrArgument},

 		{_S("select * from Table1 order by column_one down"),KErrArgument}

 	};

 GLDEF_C void Connect()

 	{

 	TInt r=TheDbs.Connect();

 	test (r==KErrNone);

 	TheDbs.ResourceMark();

 	}

 GLDEF_C void Disconnect()

 	{

 	TheDbs.ResourceCheck();

 	TheDbs.Close();

 	}

 //SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version

 LOCAL_C void DbCreateL()

 	{

 	User::LeaveIfError(TheDatabase.Replace(TheFs,KTestDatabase,TheFormat));

 	}

 //SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version

 LOCAL_C void DbOpenL()

 	{

 	User::LeaveIfError(TheDatabase.Open(TheFs,KTestDatabase,TheFormat));

 	CleanupClosePushL(TheDatabase);

 	delete TheDatabase.TableNamesL();	// force a schema load

 	CleanupStack::Pop();

 	}

 //SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version

 LOCAL_C void DbShareL()

 	{

 	User::LeaveIfError(TheDatabase.Open(TheDbs,KTestDatabase,TheFormat));

 	CleanupClosePushL(TheDatabase);

 	delete TheDatabase.TableNamesL();	// force a schema load

 	CleanupStack::Pop();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0612

 @SYMTestCaseDesc        Database validity test

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for opening and closing of database

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestOpenL()

 	{

 	_LIT(KFileNotFound,"not a database");

 	TInt r=TheDatabase.Open(TheFs,KFileNotFound);

 	test (r==KErrNotFound || r==KErrPathNotFound);

 //

 	_LIT(KPathNotFound,"C:\\not a path\\database.db");

 	r=TheDatabase.Open(TheFs,KPathNotFound);

 	test (r==KErrPathNotFound);

 //

 	_LIT(KNotFormat,"not.a.dbx");

 	r=TheDatabase.Open(TheFs,KFileNotFound,KNotFormat);

 	test (r==KErrNotFound || r==KErrPathNotFound);

 //

 	DbCreateL();

 	TheDatabase.Close();

 	r=TheDatabase.Open(TheFs,KTestDatabase,TUid::Uid(0x01234567).Name());

 	test (r==KErrNone); // New code has no loadable drivers, it is irrelevant to expect error here

 	TheDatabase.Close(); // We have added it here because previous statement does not return error anymore

 //

 	RFile f;

 	r=f.Replace(TheFs,KTestDatabase,EFileWrite);

 	test (r==KErrNone);

 	TCheckedUid type(KDirectFileStoreLayoutUid);

 	r=f.Write(type.Des());

 	test (r==KErrNone);

 	f.Close();

 	r=TheDatabase.Open(TheFs,KTestDatabase);

 	test (r==KErrNotSupported);

 //

 	_LIT(KDefaultFormat,"epoc");

 	r=TheDatabase.Open(TheFs,KTestDatabase,KDefaultFormat);

 	test (r==KErrNotSupported); // We expect not supported db here

 	}

 class TClient : public TContext

 	{

 public:

 	TClient() {}

 private:

 	void OpenDbL() const

 		{DbOpenL();}

 	};

 class TServer : public TContext

 	{

 public:

 	TServer() {}

 private:

 	void OpenDbL() const

 		{DbShareL();}

 	};

 const TClient KClient;

 const TServer KServer;

 void TFail::Test(const THeapFail& aHeap,const TContext* aContext)

 	{

 	TInt ii;

 	TInt errCode;

 	for (ii=1;;++ii)

 		{

 		if (aContext)

 			{

 			TRAP(errCode, aContext->OpenDbL());

 			if(errCode != KErrNone)

 				return;

 			}

 		aHeap.Fail(ii);

 		aHeap.Mark();

 		TRAPD(r,RunL());

 		aHeap.Reset();

 		if (r==KErrNone)

 			break;

 		test(r==KErrNoMemory);

 		if (aContext)

 			TheDatabase.Close();

 		aHeap.Check();

 		}

 	End();

 	if (aContext)

 		TheDatabase.Close();

 	aHeap.Check();

 	}

 class TFailCreateDatabase : public TFail

 	{

 	void RunL()

 		{DbCreateL();}

 	void End()

 		{TheDatabase.Close();}

 	};

 class TFailOpenDatabase : public TFail

 	{

 	void RunL()

 		{DbOpenL();}

 	void End()

 		{TheDatabase.Close();}

 	};

 class TFailShareDatabase : public TFail

 	{

 	void RunL()

 		{DbShareL();}

 	void End()

 		{TheDatabase.Close();}

 	};

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0613

 @SYMTestCaseDesc        Tests for allocation failures on creating a database

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for allocation failure for differently sourced databases

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void OriginsL()

 	{

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0613 Allocation failures on Creating a database "));

 	TFailCreateDatabase t1;

 	t1.Test(KClientHeap);

 //

 	test.Next(_L("Fail to create existing database"));

 	TUint att;

 	TInt r=TheFs.Att(KTestDatabase,att);

 	test (r==KErrNone);

 	r=TheDatabase.Create(TheFs,KTestDatabase,TheFormat);

 	test (r==KErrAlreadyExists);

 	r=TheFs.Att(KTestDatabase,att);

 	test (r==KErrNone);

 //

 	test.Next(_L("Allocation failures on Open"));

 	TFailOpenDatabase t2;

 	t2.Test(KClientHeap);

 //

 	test.Next(_L("Allocation failures on 1st Share"));

 	Connect();

 	TFailShareDatabase t3;

 	t3.Test(KClientHeap);

 	t3.Test(KServerHeap);

 //

 	test.Next(_L("Allocation failures on 2nd Share"));

 	DbShareL();

 	RDbNamedDatabase temp=TheDatabase;TheDatabase=RDbNamedDatabase();

 	t3.Test(KClientHeap);

 	t3.Test(KServerHeap);

 	temp.Close();

 	Disconnect();

 	test.End();

 	}

 class TFailCreateTable : public TFail

 	{

 	void RunL()

 		{User::LeaveIfError(TheDatabase.CreateTable(TableName,*TheColSet));}

 	};

 class TFailAlterTable : public TFail

 	{

 	void RunL()

 		{User::LeaveIfError(TheDatabase.AlterTable(TableName,*TheColSet));}

 	};

 class TFailDropTable : public TFail

 	{

 	void RunL()

 		{User::LeaveIfError(TheDatabase.DropTable(TableName));}

 	};

 class TFailCreateIndex : public TFail

 	{

 	void RunL()

 		{User::LeaveIfError(TheDatabase.CreateIndex(IndexName,TableName,*TheKey));}

 	};

 class TFailDropIndex : public TFail

 	{

 	void RunL()

 		{User::LeaveIfError(TheDatabase.DropIndex(IndexName,TableName));}

 	};

 class TFailGetObject : public TFail

 	{

 protected:

 	void End()

 		{delete iObject;}

 protected:

 	CBase* iObject;

 	};

 class TFailDatabaseTables : public TFailGetObject

 	{

 	void RunL()

 		{iObject=TheDatabase.TableNamesL();}

 	};

 class TFailDatabaseColSet : public TFailGetObject

 	{

 	void RunL()

 		{iObject=TheDatabase.ColSetL(TableName);}

 	};

 class TFailDatabaseIndexes : public TFailGetObject

 	{

 	void RunL()

 		{iObject=TheDatabase.IndexNamesL(TableName);}

 	};

 class TFailDatabaseKeys : public TFailGetObject

 	{

 	void RunL()

 		{iObject=TheDatabase.KeyL(IndexName,TableName);}

 	};

 const TInt KRowCount=60;

 LOCAL_C void WriteTableL()

 	{

 	DbOpenL();

 	TInt r=TheTable.Open(TheDatabase,TableName);

 	test (r==KErrNone);

 	TheDatabase.Begin();

 	for (TInt ii=0;ii<KRowCount;++ii)

 		{

 		TheTable.InsertL();

 		TheTable.SetColL(1,TUint((ii*17)%KRowCount));

 		TheTable.PutL();

 		}

 	r=TheDatabase.Commit();

 	test (r==KErrNone);

 	TheTable.Close();

 	TheDatabase.Close();

 	}

 LOCAL_C void DatabaseL()

 	{

 	test.Start(_L("Adding and dropping tables"));

 	DbCreateL();

 // ensure the database locking list has been allocated

 	TheDatabase.Begin();

 	TheDatabase.Commit();

 //

 	CDbColSet *col=CDbColSet::NewLC();

 //

 	test.Next(_L("Empty Column Set"));

 	__UHEAP_MARK;

 	test(TheDatabase.CreateTable(TableName,*col)!=KErrNone);

 	__UHEAP_MARKEND;

 //

 	test.Next(_L("Invalid table name"));

 	col->AddL(TDbCol(Column1,EDbColInt32));

 	__UHEAP_MARK;

 	test(TheDatabase.CreateTable(TableNameX,*col)!=KErrNone);

 	__UHEAP_MARKEND;

 //

 	test.Next(_L("Invalid column name"));

 	col->AddL(TDbCol(Column2X,EDbColBit));

 	__UHEAP_MARK;

 	test(TheDatabase.CreateTable(TableName,*col)!=KErrNone);

 	__UHEAP_MARKEND;

 //

 	test.Next(_L("Duplicate column name"));

 	col->Remove(Column2X);

 	col->AddL(TDbCol(Column1Fold,EDbColBit));

 	__UHEAP_MARK;

 	test(TheDatabase.CreateTable(TableName,*col)!=KErrNone);

 	__UHEAP_MARKEND;

 //

 	test.Next(_L("Invalid column type"));

 	col->Remove(Column1);

 	col->AddL(TDbCol(Column2,TDbColType(-1)));

 	__UHEAP_MARK;

 	test(TheDatabase.CreateTable(TableName,*col)!=KErrNone);

 	__UHEAP_MARKEND;

 //

 	test.Next(_L("Invalid maximum length"));

 	col->Remove(Column2);

 	col->AddL(TDbCol(Column2,EDbColInt32,0));

 	__UHEAP_MARK;

 	test(TheDatabase.CreateTable(TableName,*col)!=KErrNone);

 	__UHEAP_MARKEND;

 //

 	test.Next(_L("Invalid attributes"));

 	col->Remove(Column2);

 	TDbCol cc(Column2,EDbColInt32);

 	cc.iAttributes=13;

 	col->AddL(cc);

 	__UHEAP_MARK;

 	test(TheDatabase.CreateTable(TableName,*col)!=KErrNone);

 	__UHEAP_MARKEND;

 //

 	test.Next(_L("Adding/dropping a table name twice"));

 	col->Remove(Column2);

 	col->AddL(TDbCol(Column2,EDbColText8));

 	__UHEAP_MARK;

 	test(TheDatabase.CreateTable(TableName,*col)==KErrNone);

 	test(TheDatabase.CreateTable(TableName,*col)==KErrAlreadyExists);

 	test(TheDatabase.DropTable(TableNameX)!=KErrNone);

 	test(TheDatabase.DropTable(TableName)==KErrNone);

 	test(TheDatabase.DropTable(TableName)==KErrNotFound);

 	__UHEAP_MARKEND;

 //

 	test.Next(_L("Adding and dropping indexes"));

 	test(TheDatabase.CreateTable(TableName,*col)==KErrNone);

 	TheDatabase.Close();

 	CDbKey *key=CDbKey::NewLC();

 	__UHEAP_MARK;

 	DbOpenL();

 	test(TheDatabase.CreateIndex(IndexName,TableName,*key)!=KErrNone);

 	TheDatabase.Close();

 	__UHEAP_MARKEND;

 	key->AddL(Column2X());

 	__UHEAP_MARK;

 	DbOpenL();

 	test(TheDatabase.CreateIndex(IndexName,TableName,*key)!=KErrNone);

 	TheDatabase.Close();

 	__UHEAP_MARKEND;

 	key->Clear();

 	key->AddL(Column1());

 	__UHEAP_MARK;

 	DbOpenL();

 	test(TheDatabase.CreateIndex(TableNameX,TableName,*key)!=KErrNone);

 	TheDatabase.Close();

 	__UHEAP_CHECK(0);

 	DbOpenL();

 	test(TheDatabase.CreateIndex(IndexName,TableNameX,*key)!=KErrNone);

 	TheDatabase.Close();

 	__UHEAP_MARKEND;

 	__UHEAP_MARK;

 	DbOpenL();

 	test(TheDatabase.CreateIndex(IndexName,TableName,*key)==KErrNone);

 	test(TheDatabase.CreateIndex(IndexName,TableName,*key)==KErrAlreadyExists);

 	test(TheDatabase.DropIndex(TableNameX,TableName)!=KErrNone);

 	test(TheDatabase.DropIndex(IndexName,TableNameX)!=KErrNone);

 	test(TheDatabase.DropIndex(IndexName,TableName)==KErrNone);

 	test(TheDatabase.DropIndex(IndexName,TableName)==KErrNotFound);

 	test(TheDatabase.DropTable(TableName)==KErrNone);

 	test(TheDatabase.DropIndex(IndexName,TableName)==KErrNotFound);

 	TheDatabase.Close();

 	__UHEAP_MARKEND;

 //

 	test.Next(_L("Allocation failure during DDL"));

 	TFailCreateTable fct;

 	TFailAlterTable fat;

 	TFailDropTable fdt;

 	TFailCreateIndex fci;

 	TFailDropIndex fdi;

 	TheColSet=CDbColSet::NewL();

 	TheColSet->AddL(TDbCol(Column1,EDbColUint16));

 	TheKey=CDbKey::NewL();

 	TheKey->AddL(Column1());

 	fct.Test(KClientHeap,KClient);

 	WriteTableL();

 	TheColSet->AddL(TDbCol(Column2,EDbColText));

 	fat.Test(KClientHeap,KClient);

 	fci.Test(KClientHeap,KClient);

 	fdi.Test(KClientHeap,KClient);

 	fdt.Test(KClientHeap,KClient);

 //

 	test.Next(_L("Allocation failure during server DDL"));

 	Connect();

 	TheColSet->Remove(Column2);

 	fct.Test(KClientHeap,KServer);

 	WriteTableL();

 	TheColSet->AddL(TDbCol(Column2,EDbColText));

 	fat.Test(KClientHeap,KServer);

 	fci.Test(KClientHeap,KServer);

 	fdi.Test(KClientHeap,KServer);

 	fdt.Test(KClientHeap,KServer);

 //

 	TheColSet->Remove(Column2);

 	fct.Test(KServerHeap,KServer);

 	WriteTableL();

 	TheColSet->AddL(TDbCol(Column2,EDbColText));

 	fat.Test(KServerHeap,KServer);

 	fci.Test(KServerHeap,KServer);

 	fdi.Test(KServerHeap,KServer);

 	fdt.Test(KServerHeap,KServer);

 	Disconnect();

 //

 	delete TheColSet;

 	delete TheKey;

 //

 	test.Next(_L("Allocation failure on schema enquiry"));

 	DbCreateL();

 	test(TheDatabase.CreateTable(TableName,*col)==KErrNone);

 	test(TheDatabase.CreateIndex(IndexName,TableName,*key)==KErrNone);

 	CleanupStack::PopAndDestroy(2);	// columns set and key

 	TheDatabase.Close();

 	TFailDatabaseTables t4;

 	TFailDatabaseColSet t5;

 	TFailDatabaseIndexes t6;

 	TFailDatabaseKeys t7;

 	t4.Test(KClientHeap,KClient);

 	t5.Test(KClientHeap,KClient);

 	t6.Test(KClientHeap,KClient);

 	t7.Test(KClientHeap,KClient);

 //

 	test.Next(_L("Allocation failure on server schema enquiry"));

 	Connect();

 	t4.Test(KClientHeap,KServer);

 	t4.Test(KServerHeap,KServer);

 	t5.Test(KClientHeap,KServer);

 	t5.Test(KServerHeap,KServer);

 	t6.Test(KClientHeap,KServer);

 	t6.Test(KServerHeap,KServer);

 	t7.Test(KClientHeap,KServer);

 	t7.Test(KServerHeap,KServer);

 	Disconnect();

 	test.End();

 	}

 class TFailOpenTable : public TFail

 	{

 	void RunL()

 		{User::LeaveIfError(TheTable.Open(TheDatabase,TableName,Access));}

 	void End()

 		{TheTable.Close();}

 	};

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0614

 @SYMTestCaseDesc        Tests for allocation failure on opening and closing of database

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for opening and closing of database

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestTableL(const THeapFail& aHeap,const TContext& aContext)

 	{

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0614 Allocation failure on Open "));

 	TFailOpenTable fot;

 	Access=RDbRowSet::EUpdatable;

 	fot.Test(aHeap,aContext);

 	Access=RDbRowSet::EReadOnly;

 	fot.Test(aHeap,aContext);

 	Access=RDbRowSet::EInsertOnly;

 	fot.Test(aHeap,aContext);

 //

 	test.Next(_L("Open invalid table"));

 	aContext.OpenDbL();

 	__UHEAP_MARK;

 	TInt r=TheTable.Open(TheDatabase,TableNameX);

 	test (r!=KErrNone);

 	__UHEAP_MARKEND;

 //

 	test.Next(_L("Set invalid index"));

 	r=TheTable.Open(TheDatabase,TableName);

 	test (r==KErrNone);

 	__UHEAP_MARK;

 	r=TheTable.SetIndex(IndexName2);

 	test (r!=KErrNone);

 	__UHEAP_MARKEND;

 //

 	test.Next(_L("Allocation failure on 2nd Open"));

 	RDbTable table(TheTable);

 	Access=RDbRowSet::EUpdatable;

 	fot.Test(aHeap);

 	Access=RDbRowSet::EReadOnly;

 	fot.Test(aHeap);

 	Access=RDbRowSet::EInsertOnly;

 	fot.Test(aHeap);

 	table.Close();

 	TheDatabase.Close();

 	test.End();

 	}

 LOCAL_C void TestTableDDL(const TContext& aContext)

 	{

 	test.Start(_L("DDL while open"));

 	aContext.OpenDbL();

 	TInt r=TheTable.Open(TheDatabase,TableName);

 	test (r==KErrNone);

 	CDbColSet* set=CDbColSet::NewLC();

 	set->AddL(TDbCol(Column1,EDbColText));

 	r=TheDatabase.CreateTable(TableName2,*set);

 	test (r==KErrNone);

 	TRAP(r,TheTable.CountL(TheTable.EQuick));

 	test (r==KErrNone);

 	TheTable.Close();

 	r=TheTable.Open(TheDatabase,TableName2);

 	test (r==KErrNone);

 //

 	set->AddL(TDbCol(Column2,EDbColUint32));

 	r=TheDatabase.AlterTable(TableName2,*set);

 	test (r==KErrNone);

 	CleanupStack::PopAndDestroy();		// set

 	TRAP(r,TheTable.CountL(TheTable.EQuick));

 	test (r==KErrDisconnected);

 	TheTable.Reset();

 	TRAP(r,TheTable.CountL(TheTable.EQuick));

 	test (r==KErrDisconnected);

 	TheTable.Close();

 	r=TheTable.Open(TheDatabase,TableName2);

 	test (r==KErrNone);

 //

 	CDbKey* key=CDbKey::NewLC();

 	key->AddL(Column2());

 	r=TheDatabase.CreateIndex(IndexName2,TableName,*key);

 	test (r==KErrNone);

 	TRAP(r,TheTable.CountL(TheTable.EQuick));

 	test (r==KErrNone);

 	r=TheDatabase.DropIndex(IndexName2,TableName);

 	test (r==KErrNone);

 	TRAP(r,TheTable.CountL(TheTable.EQuick));

 	test (r==KErrNone);

 //

 	r=TheDatabase.CreateIndex(IndexName,TableName2,*key);

 	test (r==KErrNone);

 	CleanupStack::PopAndDestroy();	// key

 	TRAP(r,TheTable.CountL(TheTable.EQuick));

 	test (r==KErrDisconnected);

 	TheTable.Close();

 	r=TheTable.Open(TheDatabase,TableName2);

 	test (r==KErrNone);

 //

 	r=TheDatabase.DropIndex(IndexName,TableName2);

 	test (r==KErrNone);

 	TRAP(r,TheTable.CountL(TheTable.EQuick));

 	test (r==KErrDisconnected);

 	TheTable.Close();

 	r=TheTable.Open(TheDatabase,TableName2);

 	test (r==KErrNone);

 //

 	r=TheDatabase.DropTable(TableName2);

 	test (r==KErrNone);

 	TRAP(r,TheTable.CountL(TheTable.EQuick));

 	test (r==KErrDisconnected);

 	TheTable.Close();

 	TheDatabase.Close();

 	test.End();

 	}

 LOCAL_C void TableL()

 	{

 	test.Start(_L("Testing Client-side"));

 	TestTableL(KClientHeap,KClient);

 	TestTableDDL(KClient);

 	test.Next(_L("Testing Client-Server"));

 	Connect();

 	TestTableL(KClientHeap,KServer);

 	TestTableL(KServerHeap,KServer);

 	TestTableDDL(KServer);

 	Disconnect();

 	test.End();

 	}

 class TFailExecuteSQL : public TFail

 	{

 	void RunL()

 		{User::LeaveIfError(TheDatabase.Execute(*TheSql));}

 	void End()

 		{}

 	};

 class TFailPrepareView : public TFail

 	{

 	void RunL()

 		{User::LeaveIfError(TheView.Prepare(TheDatabase,*TheSql,Access));}

 	void End()

 		{TheView.Close();}

 	};

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0615

 @SYMTestCaseDesc        Tests for allocation failure on prepare

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for error on updating a row set data

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestView(const THeapFail& aHeap,const TContext& aContext)

 	{

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0615 Allocation failure on Prepare "));

 	TFailPrepareView fpv;

 	TheSql=&SimpleSql;

 	Access=RDbRowSet::EUpdatable;

 	fpv.Test(aHeap,aContext);

 	Access=RDbRowSet::EReadOnly;

 	fpv.Test(aHeap,aContext);

 	Access=RDbRowSet::EInsertOnly;

 	fpv.Test(aHeap,aContext);

 //

 	test.Next(_L("Allocation failure on Prepare (complex SQL)"));

 	for (TUint ii=0;ii<sizeof(ComplexSql)/sizeof(ComplexSql[0]);++ii)

 		{

 		TheSql=&ComplexSql[ii];

 		Access=RDbRowSet::EUpdatable;

 		fpv.Test(aHeap,aContext);

 		}

 	test.End();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0616

 @SYMTestCaseDesc        Bad SQL query test

 @SYMTestPriority        Medium

 @SYMTestActions         Test for bad query

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestSQLL(const TContext& aContext)

 	{

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0616 Bad SQL "));

 	aContext.OpenDbL();

 	for (TUint ii=0;ii<sizeof(BadSql)/sizeof(BadSql[0]);++ii)

 		test(TheView.Prepare(TheDatabase,TPtrC(BadSql[ii].iSql))==BadSql[ii].iError);

 	TheDatabase.Close();

 	test.End();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0617

 @SYMTestCaseDesc        Tests for updation of an SQL statement

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for update SQL statement

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestUpdateSQL(const THeapFail& aHeap,const TContext& aContext)

 	{

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0617 Test for UPDATE SQL statement "));

 	TFailExecuteSQL fsql;

 	TheSql=&UpdateSql;

 	fsql.Test(aHeap,aContext);

 	test.End();

 	}

 LOCAL_C void ViewL()

 	{

 	test.Start(_L("Client side"));

 	TestView(KClientHeap,KClient);

 	TestSQLL(KClient);

 	test.Next(_L("Client-Server"));

 	Connect();

 	TestView(KClientHeap,KServer);

 	TestView(KServerHeap,KServer);

 	TestSQLL(KServer);

 	TestUpdateSQL(KClientHeap,KClient);

 	TestUpdateSQL(KServerHeap,KClient);

 	Disconnect();

 	test.End();

 	}

 //TFailIncrementalUpdate implements the base class' virtual methods - RunL() and End().

 //TFailIncrementalUpdate::RunL() is called by the base class' Test() method, which simulates

 //OOM failures and checks the behaviour of the "incremental update" statement used by RunL().

 class TFailIncrementalUpdate : public TFail

 	{

 	virtual void RunL()

 		{

 		RDbUpdate dbUpdate;

 		CleanupClosePushL(dbUpdate);

 		User::LeaveIfError(dbUpdate.Execute(TheDatabase, _L("UPDATE A SET Name = 'ModifiedNameString' WHERE Id2 > 10")));

 		TInt step = 0;

 		for(TInt err=1;err>0;++step)

 			{

 			err = dbUpdate.Next();

 			User::LeaveIfError(err);

 			}

 		test(step > 1);//just to be sure that the test executes dbUpdate.Next() more than once

 		CleanupStack::PopAndDestroy(&dbUpdate);

 		}

 	virtual void End()

 		{

 		TheDatabase.Close();

 		}

 	};

 /**

 @SYMTestCaseID          SYSLIB-DBMS-UT-3414

 @SYMTestCaseDesc        "Incremental update" operations - OOM test.

 @SYMTestPriority        High

 @SYMTestActions         Create a test database with one table and insert some records there (> 100).

 						Run an "incremental update" operation in OOM loop.

 @SYMTestExpectedResults The test should not fail or panic.

 @SYMDEF INC101720

 */

 LOCAL_C void IncrementalUpdateTest(const THeapFail& aHeap)

 	{

 	//Create a test shared database with a table

 	TheDatabase.Close();

 	TheDbs.Close();

 	TInt err = TheDbs.Connect();

 	test(err == KErrNone);

 	err = TheDatabase.Replace(TheFs, KTestDatabase);

 	test(err == KErrNone);

 	TheDatabase.Close();

 	err = TheDatabase.Open(TheDbs, KTestDatabase);

 	test(err == KErrNone);

 	//Create a test table and fill the table with enough test records (> 100)

 	err = TheDatabase.Execute(_L("CREATE TABLE A(Id COUNTER, Id2 INTEGER, Name LONG VARCHAR)"));

 	test(err == KErrNone);

 	const TInt KTestRecCount = 110;

 	err = TheDatabase.Begin();

 	test(err == KErrNone);

 	for(TInt i=0;i<KTestRecCount;++i)

 		{

 		_LIT(KSqlFmtStr, "INSERT INTO A(Id2, Name) VALUES(%d, 'TestNameString')");

 		TBuf<100> sql;

 		TUint32 id = Math::Random() % KTestRecCount;

 		sql.Format(KSqlFmtStr, id + 1);

 		err = TheDatabase.Execute(sql);

 		test(err == 1);

 		}

 	err = TheDatabase.Commit();

 	test(err == KErrNone);

 	//The OOM test

 	TFailIncrementalUpdate testObj;

 	testObj.Test(aHeap);

 	//Cleanup

 	TheDatabase.Close();

 	TheDbs.Close();

 	}

 //

 // Testing the DBMS for failure modes

 //

 LOCAL_C void doMainL()

 	{

 	test.Start(_L("Class RDbNamedDatabase"));

 	__UHEAP_MARK;

 	OriginsL();

 	__UHEAP_CHECK(0);

 	__UHEAP_MARK;

 	Origins2();

 	__UHEAP_CHECK(0);

 	test.Next(_L("Class RDbDatabase"));

 	DatabaseL();

 	__UHEAP_CHECK(0);

 	test.Next(_L("Class RDbTable"));

 	TableL();

 	__UHEAP_CHECK(0);

 	test.Next(_L("Class RDbView"));

 	ViewL();

 	__UHEAP_MARKEND;

 	test.End();

 	}

 //

 // Prepare the test directory.

 //

 LOCAL_C void setupTestDirectory()

     {

 	TInt r=TheFs.Connect();

 	test(r==KErrNone);

 //

 	r=TheFs.MkDir(KTestDatabase);

 	test(r==KErrNone || r==KErrAlreadyExists);

 	}

 //

 // Initialise the cleanup stack.

 //

 LOCAL_C void setupCleanup()

     {

 	TheTrapCleanup=CTrapCleanup::New();

 	test(TheTrapCleanup!=NULL);

 	TRAPD(r,\

 		{\

 		for (TInt i=KTestCleanupStack;i>0;i--)\

 			CleanupStack::PushL((TAny*)0);\

 		CleanupStack::Pop(KTestCleanupStack);\

 		});

 	test(r==KErrNone);

 	}

 LOCAL_C void DeleteDataFile(const TDesC& aFullName)

 	{

 	RFs fsSession;

 	TInt err = fsSession.Connect();

 	if(err == KErrNone)

 		{

 		TEntry entry;

 		if(fsSession.Entry(aFullName, entry) == KErrNone)

 			{

 			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

 			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

 			if(err != KErrNone)

 				{

 				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

 				}

 			err = fsSession.Delete(aFullName);

 			if(err != KErrNone)

 				{

 				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

 				}

 			}

 		fsSession.Close();

 		}

 	else

 		{

 		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

 		}

 	}

 GLDEF_C TInt E32Main()

 	{

 	test.Title();

 	setupTestDirectory();

 	setupCleanup();

 	__UHEAP_MARK;

 //

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0612 Locating a database "));

 	TRAPD(r,TestOpenL());

 	test(r==KErrNone);

 	PrepareDbFmtString();

 	TRAP(r,TestOpen2());

 	test(r==KErrNone);

 	test.Next(_L("Standard database"));

 	TRAP(r,doMainL());

 	test(r==KErrNone);

 	test.Next(_L("Secure database"));

 	TRAP(r,doMainL());

 	test(r==KErrNone);

 	test.Next(_L("ISAM database"));

 	TheFormat=_S("epoc[12345678]");

 	TRAP(r,OriginsL());

 	test(r==KErrNone);

 	TRAP(r,Origins2());

 	test(r==KErrNone);

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3414 \"Incremental update\" - client test "));

 	IncrementalUpdateTest(KClientHeap);

 	test.End();

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-UT-3414 \"Incremental update\" - client-server test "));

 	IncrementalUpdateTest(KServerHeap);

 	test.End();

 	::DeleteDataFile(KTestDatabase);		// clean up data file used by this test - must be done before call to End() - DEF047652

 	test.End();

 //

 	__UHEAP_MARKEND;

 	delete TheTrapCleanup;

 	TheFs.Close();

 	test.Close();

 	return 0;

 	}