// 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 <s32file.h>

#include <e32test.h>

#if defined(__VC32__) && !defined(_DEBUG)

#pragma warning(disable : 4710)			// function not expanded. MSVC 4.0 is stupid

#endif

LOCAL_D RTest test(_L("t_dbapi : Test DBMS API"));

LOCAL_D CTrapCleanup* TheTrapCleanup;

LOCAL_D RDbs TheDbs;

LOCAL_D RDbNamedDatabase TheDatabase;

LOCAL_D RDbTable TheTable;

LOCAL_D RDbView TheView;

LOCAL_D RFs TheFs;

LOCAL_D TBuf8<0x200> TheBuf8;

LOCAL_D TBuf16<0x100> TheBuf16;

const TInt KTestCleanupStack=0x40;

const TPtrC KTestDatabase=_L("C:\\DBMS-TST\\T_DBMS.DB");

const TPtrC8 KTestText8(_S8("Text used for test columns when testing"));

const TPtrC8 KTestShortText8(_S8("a"));

const TPtrC8 KTestLongText8(_S8("Text which is used to set Long ASCII Text columns and ensure they are not inlined, and therefore needs to be very long indeed............." \

							"Text which is used to set Long ASCII Text columns and ensure they are not inlined, and therefore needs to be very long indeed............."));

const TPtrC16 KTestText16(_S16("Text used for test columns when testing"));

const TPtrC16 KTestShortText16(_S16("a"));

const TPtrC16 KTestLongText16(_S16("Text which is used to set Long UNICODE Text columns and ensure they are not inlined, and therefore needs to be very long indeed............."));

const TPtrC KTableName(_S("TestTable"));

const TPtrC KTableName2(_S("TestTable2"));

const TPtrC KTestViewTable(_L("TestViewTable"));

const TPtrC KTestTypesTable(_L("TestTypesTable"));

const TPtrC KTestFindTable(_L("TestFindTable"));

const TPtrC KTestMultiTable(_L("TestMultiTable"));

const TPtrC KIndexName(_S("Index1"));

const TPtrC KIndexName2(_S("Index2"));

const TPtrC KIndexName3(_S("Index3"));

const TInt KBlobItems=1000;

const TPtrC KNull=TPtrC();

const TPtrC KPass1(_S("wibble"));

const TPtrC KPass2(_S("wobble"));

const TReal32 KMinTReal32=(TReal32)1.2345e-37;

const TReal32 KMaxTReal32=(TReal32)9.8765e37;

const TReal64 KMinTReal64=1.23456789e-300;

const TReal64 KMaxTReal64=9.87654321e300;

const TTime KMinTTime=Time::MinTTime();

const TTime KMaxTTime=Time::MaxTTime();

struct SColDef

	{

	const TText* iName;

	TDbColType iType;

	TInt iAttributes;

	};

LOCAL_D SColDef const SingleColumn[]=

	{

	{_S("Column1"),EDbColInt32,0},

	{0}

	};

LOCAL_D SColDef const DoubleColumn[]=

	{

	{_S("Column1"),EDbColInt32,0},

	{_S("c2"),EDbColInt64,0},

	{0}

	};

LOCAL_D SColDef const ViewTestColumns[]=

	{

	{_S("Int"),EDbColInt32,0},

	{_S("Long1"),EDbColLongText8,0},

	{_S("Long2"),EDbColLongText8,0},

	{_S("Long3"),EDbColLongText8,0},

	{_S("Long4"),EDbColLongText8,0},

	{_S("Long5"),EDbColLongText8,0},

	{0}

	};

LOCAL_D SColDef const AllColumns[]=

	{

	{_S("counter"),EDbColInt32,TDbCol::ENotNull|TDbCol::EAutoIncrement},

	{_S("bit"),EDbColBit,TDbCol::ENotNull},

	{_S("int8"),EDbColInt8,TDbCol::ENotNull},

	{_S("uint8"),EDbColUint8,TDbCol::ENotNull},

	{_S("int16"),EDbColInt16,TDbCol::ENotNull},

	{_S("uint16"),EDbColUint16,TDbCol::ENotNull},

	{_S("int32"),EDbColInt32,TDbCol::ENotNull},

	{_S("uint32"),EDbColUint32,TDbCol::ENotNull},

	{_S("int64"),EDbColInt64,TDbCol::ENotNull},

	{_S("real32"),EDbColReal32,TDbCol::ENotNull},

	{_S("real64"),EDbColReal64,TDbCol::ENotNull},

	{_S("date_time"),EDbColDateTime,TDbCol::ENotNull},

	{_S("text8"),EDbColText8,TDbCol::ENotNull},

	{_S("text16"),EDbColText16,TDbCol::ENotNull},

	{_S("binary"),EDbColBinary,TDbCol::ENotNull},

	{_S("longtext8"),EDbColLongText8,TDbCol::ENotNull},

	{_S("longtext16"),EDbColLongText16,TDbCol::ENotNull},

	{_S("longbinary"),EDbColLongBinary,TDbCol::ENotNull},

	{_S("bit_null"),EDbColBit,0},

	{_S("int8_null"),EDbColInt8,0},

	{_S("uint8_null"),EDbColUint8,0},

	{_S("int16_null"),EDbColInt16,0},

	{_S("uint16_null"),EDbColUint16,0},

	{_S("int32_null"),EDbColInt32,0},

	{_S("uint32_null"),EDbColUint32,0},

	{_S("int64_null"),EDbColInt64,0},

	{_S("real32_null"),EDbColReal32,0},

	{_S("real64_null"),EDbColReal64,0},

	{_S("date_time_null"),EDbColDateTime,0},

	{_S("text8_null"),EDbColText8,0},

	{_S("text16_null"),EDbColText16,0},

	{_S("binary_null"),EDbColBinary,0},

	{_S("longtext8_null"),EDbColLongText8,0},

	{_S("longtext16_null"),EDbColLongText16,0},

	{_S("longbinary_null"),EDbColLongBinary,0},

	{_S("force_null"),EDbColInt32,0},

	{0}

	};

const TInt KColumns=sizeof(AllColumns)/sizeof(AllColumns[0])-1;

enum TColumns

	{

	ECounter,

	EBit,EInt8,EUint8,EInt16,EUint16,EInt32,EUint32,EInt64,

	EReal32,EReal64,ETime,EText8,EText16,ETBinary,

	ELongText8,ELongText16,ELongBinary,

	EBitNull,EInt8Null,EUint8Null,EInt16Null,EUint16Null,EInt32Null,EUint32Null,EInt64Null,

	EReal32Null,EReal64Null,ETimeNull,EText8Null,EText16Null,ETBinaryNull,

	ELongText8Null,ELongText16Null,ELongBinaryNull,EForceNull

	};

LOCAL_D TDbColNo TheMap[KColumns];

CDbColSet* ColumnSetL(const SColDef* aDef)

	{

	CDbColSet *set=CDbColSet::NewLC();

	for (;aDef->iName;++aDef)

		{

		TDbCol col(TPtrC(aDef->iName),aDef->iType);

		col.iAttributes=aDef->iAttributes;

		set->AddL(col);

		}

	CleanupStack::Pop();

	return set;

	}

enum TColSet {EAllTypes,ESingleColumn,EDoubleColumn,EViewTestTable};

LOCAL_D const SColDef* const ColSetDef[]=

	{

	AllColumns,

	SingleColumn,

	DoubleColumn,

	ViewTestColumns

	};

LOCAL_C CDbColSet* CreateColSetL(TColSet aType)

	{

	return ColumnSetL(ColSetDef[aType]);

	}

inline TPtrC ColName(const SColDef* aSet,TInt aColumn)

	{return TPtrC(aSet[aColumn].iName);}

enum TKeySet {EKeyAsc,EKeyDesc,EKeyMulti,EKeySingle};

LOCAL_C CDbKey* CreateKeyL(TKeySet aType)

	{

	CDbKey *k=CDbKey::NewLC();

	switch(aType)

		{

	case EKeyAsc:

		k->AddL(ColName(AllColumns,EInt32));

		break;

	case EKeyDesc:

		k->AddL(TDbKeyCol(ColName(AllColumns,EInt32),TDbKeyCol::EDesc));

		k->MakeUnique();

		break;

	case EKeyMulti:

		k->AddL(ColName(AllColumns,EInt32)).AddL(ColName(AllColumns,EText8));

		k->SetComparison(EDbCompareFolded);

		break;

	case EKeySingle:

		k->AddL(ColName(SingleColumn,0));

		break;

		}

	CleanupStack::Pop();

	return k;

	}

LOCAL_C void CloseDatabase()

	{

	TheDatabase.Close();

	}

//

// Open a shared database (SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version)

//

LOCAL_C TInt OpenSharedDatabase()

	{

	return TheDatabase.Open(TheDbs,KTestDatabase);

	}

//

// Create a local database (SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version)

//

LOCAL_C void CreateClientDatabase()

	{

	TInt r=TheDatabase.Replace(TheFs,KTestDatabase);

	test (r==KErrNone);

	}

//

// Create a shared database (SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version)

//

LOCAL_C void CreateSharedDatabase()

	{

	CreateClientDatabase();

	CloseDatabase();

	TInt r=OpenSharedDatabase();

	test (r==KErrNone);

	}

//

// Open a shared database (SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version)

//

LOCAL_C void OpenDatabase()

	{

	TInt r=OpenSharedDatabase();

	test (r==KErrNone);

	}

//

// Create a shared database (SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version)

//

LOCAL_C void CreateDatabase()

	{

	CreateSharedDatabase();

	}

LOCAL_C void DestroyDatabase()

	{

	TInt r=TheDatabase.Destroy();

	test (r==KErrNone);

	}

//

// Check the database has this many tables

//

LOCAL_C void CountTablesL(TInt aCount)

	{

	CDbNames* names=TheDatabase.TableNamesL();

	test (names->Count()==aCount);

	delete names;

	}

//

// Compare two column sets

//

LOCAL_C void CompareL(const TDesC& aTable,const CDbColSet& aSet)

	{

	CDbColSet* set=TheDatabase.ColSetL(aTable);

	test(set->Count()==aSet.Count());

	for (TDbColSetIter iter(*set);iter;++iter)

		{

		const TDbCol* pRight=aSet.Col(iter->iName);

		test(pRight!=NULL);

		test(iter->iType==pRight->iType);

		test(iter->iMaxLength==KDbUndefinedLength || pRight->iMaxLength==KDbUndefinedLength || iter->iMaxLength==pRight->iMaxLength);

		test((iter->iAttributes&pRight->iAttributes)==iter->iAttributes);

		}

	delete set;

	}

//

// Check the database has this many tables

//

LOCAL_C void CountIndexesL(const TDesC& aTable,TInt aCount)

	{

	CDbNames* names=TheDatabase.IndexNamesL(aTable);

	test (names->Count()==aCount);

	delete names;

	}

//

// Compare index definition

//

LOCAL_C void CompareL(const TDesC& aIndex,const TDesC& aTable,const CDbKey& aKey)

	{

	CDbKey* key=TheDatabase.KeyL(aIndex,aTable);

	test(key->Count()==aKey.Count());

	test(key->Comparison()==aKey.Comparison());

	test(key->IsUnique()==aKey.IsUnique());

	for (TInt ii=aKey.Count();--ii>=0;)

		{

		const TDbKeyCol& left=(*key)[ii];

		const TDbKeyCol& right=aKey[ii];

		test (left.iName==right.iName);

		test (left.iOrder==right.iOrder);

		test (left.iLength==right.iLength || right.iLength==KDbUndefinedLength);

		}

	delete key;

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-0594

@SYMTestCaseDesc        Tests the database definition and enquiry functions

@SYMTestPriority        Medium

@SYMTestActions         Tests for creation and opening of a database,creation of a table

                        Tests for comparing column and table column sets

						Tests for altering a table and creation of an index.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestDDL()

	{

	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0594 Create Database "));

	CreateDatabase();

	CountTablesL(0);

	CloseDatabase();

	test.Next(_L("Open Database"));

	OpenDatabase();

	CountTablesL(0);

	test.Next(_L("CreateTable"));

	CDbColSet* cs=CreateColSetL(EAllTypes);

	test(TheDatabase.CreateTable(KTableName,*cs)==KErrNone);

	CountTablesL(1);

	test.Next(_L("Compare column sets"));

	CompareL(KTableName,*cs);

	CloseDatabase();

	test.Next(_L("Re-open database"));

	OpenDatabase();

	CountTablesL(1);

	test.Next(_L("Compare table column sets"));

	CompareL(KTableName,*cs);

	delete cs;

	test.Next(_L("Add another table"));

	cs=CreateColSetL(ESingleColumn);

	test(TheDatabase.CreateTable(KTableName2,*cs)==KErrNone);

	CompareL(KTableName2,*cs);

	delete cs;

	CountTablesL(2);

//

	test.Next(_L("Alter table"));

	cs=CreateColSetL(EDoubleColumn);

	test(TheDatabase.AlterTable(KTableName2,*cs)==KErrNone);

	CompareL(KTableName2,*cs);

	delete cs;

	CountTablesL(2);

//

	test.Next(_L("Test index creation"));

	CountIndexesL(KTableName,0);

	CountIndexesL(KTableName2,0);

	CDbKey* key=CreateKeyL(EKeyAsc);

	test (TheDatabase.CreateIndex(KIndexName,KTableName,*key)==KErrNone);

	CompareL(KIndexName,KTableName,*key);

	delete key;

	key=CreateKeyL(EKeyDesc);

	test (TheDatabase.CreateIndex(KIndexName2,KTableName,*key)==KErrNone);

	CompareL(KIndexName2,KTableName,*key);

	delete key;

	key=CreateKeyL(EKeySingle);

	test (TheDatabase.CreateIndex(KIndexName,KTableName2,*key)==KErrNone);

	CompareL(KIndexName,KTableName2,*key);

	delete key;

	key=CreateKeyL(EKeyMulti);

	test (TheDatabase.CreateIndex(KIndexName3,KTableName,*key)==KErrNone);

	CompareL(KIndexName3,KTableName,*key);

	CountIndexesL(KTableName,3);

	CountIndexesL(KTableName2,1);

	CloseDatabase();

	OpenDatabase();

	CountIndexesL(KTableName,3);

	CountIndexesL(KTableName2,1);

	CompareL(KIndexName3,KTableName,*key);

	delete key;

	test.Next(_L("Drop indexes"));

	test (TheDatabase.DropIndex(KIndexName,KTableName)==KErrNone);

	CountIndexesL(KTableName,2);

	test (TheDatabase.DropIndex(KIndexName2,KTableName)==KErrNone);

	CountIndexesL(KTableName,1);

	test (TheDatabase.DropIndex(KIndexName,KTableName2)==KErrNone);

	CountIndexesL(KTableName2,0);

	test.Next(_L("Drop table"));

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

	CountTablesL(1);

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

	CountTablesL(0);

	CloseDatabase();

	OpenDatabase();

	CountTablesL(0);

	DestroyDatabase();

	test.End();

	}

LOCAL_C void AddRowL()

	{

	test(TheView.Prepare(TheDatabase,_L("select * from testviewtable"))==KErrNone);

	test(TheView.EvaluateAll()==KErrNone);

	TheView.InsertL();

	TheView.SetColL(1,(TInt32)12345);

	TheView.PutL();

	TheView.InsertL();

	TheView.Cancel();

	TheView.FirstL();

	TheView.NextL();

	test(TheView.AtEnd());		// should be only 1 row as second insert was cancelled

	TheView.Close();

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-1318

@SYMTestCaseDesc        Tests for RDbView class

@SYMTestPriority        Medium

@SYMTestActions         Tests for navigation of the cursor in the generated row sets.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestEmptyNavigationL(const TDesC& aQuery)

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-1318 Test navigation states "));

	test(TheView.Prepare(TheDatabase,aQuery,TheView.EReadOnly)==KErrNone);

	test(TheView.EvaluateAll()==KErrNone);

	TheView.FirstL();

	test(!TheView.AtBeginning());

	test(!TheView.AtRow());

	test(TheView.AtEnd());

	TheView.PreviousL();

	test(TheView.AtBeginning());

	test(!TheView.AtRow());

	test(!TheView.AtEnd());

	TheView.NextL();

	test(!TheView.AtBeginning());

	test(!TheView.AtRow());

	test(TheView.AtEnd());

	TheView.LastL();

	test(TheView.AtBeginning());

	test(!TheView.AtRow());

	test(!TheView.AtEnd());

	TheView.NextL();

	test(TheView.AtEnd());

	TheView.Close();

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-1319

@SYMTestCaseDesc        Tests for RDbView class

@SYMTestPriority        Medium

@SYMTestActions         Tests for navigation of the cursor in the generated row sets.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestNavigationL(const TDesC& aQuery)

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-1319 Test navigation states "));

	test(TheView.Prepare(TheDatabase,aQuery,TheView.EReadOnly)==KErrNone);

	test(TheView.EvaluateAll()==KErrNone);

	TheView.FirstL();

	test(!TheView.AtBeginning());

	test(TheView.AtRow());

	test(!TheView.AtEnd());

	TheView.GetL();

	test(TheView.ColInt32(1)==12345);

	TheView.PreviousL();

	test(TheView.AtBeginning());

	test(!TheView.AtRow());

	test(!TheView.AtEnd());

	TheView.NextL();

	test(!TheView.AtBeginning());

	test(TheView.AtRow());

	test(!TheView.AtEnd());

	TheView.NextL();

	test(!TheView.AtBeginning());

	test(!TheView.AtRow());

	test(TheView.AtEnd());

	TheView.PreviousL();

	test(!TheView.AtBeginning());

	test(TheView.AtRow());

	test(!TheView.AtEnd());

	TheView.LastL();

	test(!TheView.AtBeginning());

	test(TheView.AtRow());

	test(!TheView.AtEnd());

	TheView.NextL();

	test(TheView.AtEnd());

	TheView.Close();

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-1320

@SYMTestCaseDesc        RDbView updation test

@SYMTestPriority        Medium

@SYMTestActions         Tests for updation of row sets

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

static void TestUpdateL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-1320 Update and delete the row "));

	test(TheView.Prepare(TheDatabase,_L("select * from TestViewTable"))==KErrNone);

	test(TheView.EvaluateAll()==KErrNone);

	TheView.FirstL();

	TheView.UpdateL();

	TheView.SetColL(1,(TInt32)54321);

	TheView.PutL();

	TheView.FirstL();

	TheView.GetL();

	test(TheView.ColInt32(1)==54321);

	TheView.UpdateL();

	TheView.SetColL(1,(TInt32)12345);

	TheView.Cancel();

	TheView.FirstL();

	TheView.GetL();

	test(TheView.ColInt32(1)==54321);

	TheView.DeleteL();

	TheView.PreviousL();