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