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

 #include <e32math.h>

 #include "D32TABLE.H"

 // MSVC++ up to 5.0 has problems with expanding inline functions

 // This disables the mad warnings for the whole project

 #if defined(NDEBUG) && defined(__VC32__) && _MSC_VER<=1100

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

 #endif

 LOCAL_D RTest test(_L("t_dbindex - Test DBMS indexing and ordering"));

 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 TBuf<0x200> TheBuf;

 const TInt KTestCleanupStack=0x20;

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

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

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

 const TPtrC KIndexTwo(_S("index_two"));

 const TPtrC KColumnName(_S("column"));

 const TPtrC KColumnTwo(_S("column2"));

 const TPtrC KTableName1(_S("Table1"));

 const TPtrC KColumnName1(_S("column1"));

 const TPtrC KIndexName1(_S("index1"));

 const TPtrC KSelectOrdered(_L("select column from table order by column"));

 #define elementsof(array) (sizeof(array)/sizeof(array[0]))

 void Check(TInt aValue,TInt aExpected,TInt aLine)

 	{

 	if (aValue!=aExpected)

 		{

 		test.Printf(_L("*** Expected %d: got %d\r\n"),aExpected,aValue);

 		test.operator()(EFalse,aLine);

 		}

 	}

 #define test2(a,b) Check(a,b,__LINE__)

 //

 // Open the database (shared access) (SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version)

 //

 LOCAL_C void OpenDatabase()

 	{

 	TInt r=TheDatabase.Open(TheDbs,KTestDatabase);

 	test (r==KErrNone);

 	}

 //

 // Create the database (SYMBIAN_REMOVE_TRIVIAL_ENCRYPTION version)

 //

 LOCAL_C void CreateDatabase()

 	{

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

 	test (r==KErrNone);

 	TheDatabase.Close();

 	OpenDatabase();

 	}

 LOCAL_C void CloseDatabase()

 	{

 	TheDatabase.Close();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0618

 @SYMTestCaseDesc        Tests for RDbNamedDatabase functionality

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for RDbNamedDatabase::CreateIndex()

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestIndexBuildL()

 	{

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

 	TheDatabase.Begin();

 	CDbColSet *cs=CDbColSet::NewLC();

 	cs->AddL(TDbCol(KColumnName,EDbColInt32));

 	cs->AddL(TDbCol(KColumnTwo,EDbColInt32));

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

 	CleanupStack::PopAndDestroy();

 	test.Next(_L("create indices"));

 	CDbKey *key=CDbKey::NewLC();

 	key->AddL(TDbKeyCol(KColumnName));

 	key->MakeUnique();

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

 	key->Clear();

 	key->AddL(TDbKeyCol(KColumnTwo));

 	key->MakeUnique();

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

 	CleanupStack::PopAndDestroy();

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

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

 	TheTable.InsertL();

 	TheTable.SetColL(1,1);

 	TheTable.SetColL(2,-1);

 	TheTable.PutL();

 	TheTable.InsertL();

 	TheTable.SetColL(1,2);

 	TheTable.SetColL(2,-2);

 	TheTable.PutL();

 	test(TheDatabase.Commit()==KErrNone);

 	test.Next(_L("Check order"));

 	test(TheTable.SetNoIndex()==KErrNone);

 	test(TheTable.SetIndex(KIndexName)==KErrNone);

 	test(TheTable.CountL()==2);

 	test(TheTable.NextL());

 	TheTable.GetL();

 	test(TheTable.ColInt(1)==1);

 	test(TheTable.NextL());

 	TheTable.GetL();

 	test(TheTable.ColInt(1)==2);

 	test(!TheTable.NextL());

 	test(TheTable.SetIndex(KIndexTwo)==KErrNone);

 	test(TheTable.CountL()==2);

 	test(TheTable.NextL());

 	TheTable.GetL();

 	test(TheTable.ColInt(1)==2);

 	test(TheTable.NextL());

 	TheTable.GetL();

 	test(TheTable.ColInt(1)==1);

 	test(!TheTable.NextL());

  	test(TheTable.SetNoIndex()==KErrNone);

 	test(TheTable.CountL()==2);

 	test(TheTable.NextL());

 	test(TheTable.NextL());

 	test(!TheTable.NextL());

 	TheTable.Close();

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

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

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

 	test(TheTable.SetIndex(KIndexName)==KErrNone);

 	test(TheTable.SetIndex(KIndexTwo)!=KErrNone);

 	TheTable.Close();

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

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

 	test(TheTable.SetIndex(KIndexName)!=KErrNone);

 	test(TheTable.SetIndex(KIndexTwo)!=KErrNone);

 	TheTable.Close();

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

 	test.End();

 	}

 LOCAL_C TInt CountRowsL()

 	{

 	TInt count=0;

 	while (TheTable.NextL())

 		++count;

 	return count;

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0619

 @SYMTestCaseDesc        RDbNamedDatabase::Execute() function test

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for CREATE TABLE,CREATE INDEX and CREATE UNIQUE INDEX query

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestPersistenceL()

 	{

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

 	TheDatabase.Begin();

 	test(TheDatabase.Execute(_L("CREATE TABLE Table (column CHAR(120) NOT NULL)"))==KErrNone);

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

 	TheTable.InsertL();

 	TheTable.SetColL(1,_L("a"));

 	TheTable.PutL();

 	TheTable.InsertL();

 	TheTable.SetColL(1,_L("b"));

 	TheTable.PutL();

 	TheTable.InsertL();

 	TheTable.SetColL(1,_L("c"));

 	TheTable.PutL();

 	TheTable.InsertL();

 	TheTable.SetColL(1,_L("d"));

 	TheTable.PutL();

 	TheTable.InsertL();

 	TheTable.SetColL(1,_L("e"));

 	TheTable.PutL();

 	TheTable.Close();

 	test(TheDatabase.Commit()==KErrNone);

 	test.Next(_L("Build indices"));

 	test (TheDatabase.Execute(_L("CREATE INDEX index ON table (column ASC)"))==KErrNone);

 	test (TheDatabase.Execute(_L("CREATE UNIQUE INDEX index_two ON table (column DESC)"))==KErrNone);

 	test.Next(_L("Close and re-open database"));

 	CloseDatabase();

 	OpenDatabase();

 	test.Next(_L("Check indices"));

 	CDbKey* key=TheDatabase.KeyL(KIndexName,KTableName);

 	test (key->Count()==1);

 	test (key->Comparison()==EDbCompareNormal);

 	test (!key->IsUnique());

 	test ((*key)[0].iName.CompareF(KColumnName)==0);

 	test ((*key)[0].iOrder==TDbKeyCol::EAsc);

 	delete key;

 	key=TheDatabase.KeyL(KIndexTwo,KTableName);

 	test (key->Count()==1);

 	test (key->Comparison()==EDbCompareNormal);

 	test (key->IsUnique());

 	test ((*key)[0].iName.CompareF(KColumnName)==0);

 	test ((*key)[0].iOrder==TDbKeyCol::EDesc);

 	delete key;

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

 	test(TheTable.SetNoIndex()==KErrNone);

 	test(CountRowsL()==5);

 	test(TheTable.CountL()==5);

 	test(TheTable.SetIndex(KIndexName)==KErrNone);

 	test(TheTable.CountL()==5);

 	test(CountRowsL()==5);

 	test(TheTable.SetIndex(KIndexTwo)==KErrNone);

 	test(TheTable.CountL()==5);

 	test(CountRowsL()==5);

 	TheTable.Close();

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

 	TheDatabase.Begin();

 	test (TheDatabase.Execute(_L("DROP INDEX index_two FROM table"))==KErrNone);

 	test (TheDatabase.Execute(_L("DROP INDEX index FROM table"))==KErrNone);

 	test (TheDatabase.Execute(_L("DROP TABLE table"))==KErrNone);

 	test(TheDatabase.Commit()==KErrNone);

 	test.End();

 	}

 LOCAL_C void BuildTablePrologL(TDbColType aType,TInt aAttribs=0)

 	{

 	TheDatabase.Begin();

 	CDbColSet *cs=CDbColSet::NewLC();

 	TDbCol col(KColumnName,aType);

 	col.iAttributes=aAttribs;

 	cs->AddL(col);

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

 	CleanupStack::PopAndDestroy();

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

 	}

 inline void SetColL(RDbRowSet& aSet,TDbColNo col,const TInt& aValue)

 	{aSet.SetColL(col,aValue);}

 inline void SetColL(RDbRowSet& aSet,TDbColNo col,const TUint& aValue)

 	{aSet.SetColL(col,aValue);}

 inline void SetColL(RDbRowSet& aSet,TDbColNo col,const TInt64& aValue)

 	{aSet.SetColL(col,aValue);}

 inline void SetColL(RDbRowSet& aSet,TDbColNo col,const TReal32& aValue)

 	{aSet.SetColL(col,aValue);}

 inline void SetColL(RDbRowSet& aSet,TDbColNo col,const TReal64& aValue)

 	{aSet.SetColL(col,aValue);}

 inline void SetColL(RDbRowSet& aSet,TDbColNo col,const TTime& aValue)

 	{aSet.SetColL(col,aValue);}

 inline void SetColL(RDbRowSet& aSet,TDbColNo col,const TPtrC& aValue)

 	{aSet.SetColL(col,aValue);}

 template <class T>

 void BuildTableL(TDbColType aType,TInt aAttribs,T aValues[],TInt aCount)

 	{

 	BuildTablePrologL(aType,aAttribs);

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

 		{

 		TheTable.InsertL();

 		SetColL(TheTable,1,aValues[ii]);

 		TheTable.PutL();

 		}

 	test(TheDatabase.Commit()==KErrNone);

 	test (TheTable.CountL()==aCount);

 	TheTable.Close();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0620

 @SYMTestCaseDesc        Setting the specified index as the active index for a table test

 @SYMTestPriority        Medium

 @SYMTestActions         Create an index and set as active index for the table.

                         Tests for RDbNamedDatabase::CreateIndex(),RDbNamedDatabase::Commit()

 						RDbTable::Open(),RDbTable::SetIndex() functions.

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void BuildIndexL(TDbTextComparison aComparison=EDbCompareNormal,TInt aLength=KDbUndefinedLength)

 	{

 	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0620 Test index order "));

 	TheDatabase.Begin();

 	CDbKey *key=CDbKey::NewLC();

 	key->AddL(TDbKeyCol(KColumnName,aLength));

 	key->MakeUnique();

 	key->SetComparison(aComparison);

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

 	CleanupStack::PopAndDestroy();

 	test (TheDatabase.Commit()==KErrNone);

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

 	test(TheTable.SetIndex(KIndexName)==KErrNone);

 	}

 inline void GetCol(RDbRowSet& aSet,TDbColNo col,TInt& aValue)

 	{aValue=aSet.ColInt(col);}

 inline void GetCol(RDbRowSet& aSet,TDbColNo col,TUint& aValue)

 	{aValue=aSet.ColUint(col);}

 inline void GetCol(RDbRowSet& aSet,TDbColNo col,TInt64& aValue)

 	{aValue=aSet.ColInt64(col);}

 inline void GetCol(RDbRowSet& aSet,TDbColNo col,TReal32& aValue)

 	{aValue=aSet.ColReal32(col);}

 inline void GetCol(RDbRowSet& aSet,TDbColNo col,TReal64& aValue)

 	{aValue=aSet.ColReal64(col);}

 inline void GetCol(RDbRowSet& aSet,TDbColNo col,TTime& aValue)

 	{aValue=aSet.ColTime(col);}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0621

 @SYMTestCaseDesc        RDbRowSet ordering test

 @SYMTestPriority        Medium

 @SYMTestActions         Reorder the row set data with RDbRowSet::GetL(),SetL() functions.

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 template <class T>

 void TestOrderingL(RDbRowSet& aSet,T,TInt aCount)

 	{

 	test.Next( _L( " @SYMTestCaseID:SYSLIB-DBMS-CT-0621 " ) );

 	test(aSet.CountL()==aCount);

 	TInt count=0;

 	if (aSet.FirstL())

 		{

 		++count;

 		aSet.GetL();

 		T last;

 		GetCol(aSet,1,last);

 		while (aSet.NextL())

 			{

 			++count;

 			aSet.GetL();

 			T current;

 			GetCol(aSet,1,current);

 			test(last<current);

 			last=current;

 			}

 		}

 	test(count==aCount);

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0622

 @SYMTestCaseDesc        RDbTable::SeekL() function test

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for the retrieved column value

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 template <class T>

 void TestSeekL(RDbTable& aTable,T,const T aValues[],TInt aCount)

 	{

 	test.Next( _L( " @SYMTestCaseID:SYSLIB-DBMS-CT-0622 Test index seeking " ) );

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

 		{

 		test(aTable.SeekL(aValues[ii]));

 		aTable.GetL();

 		T val;

 		GetCol(aTable,1,val);

 		test(aValues[ii]==val);

 		}

 	}

 /**

 aVal argument is used in the test functions (TestType & TestOrdering) and has no meaning outside them.

 It is used only to avoid some compiler varnings and to determine the correct template type

 @SYMTestCaseID          SYSLIB-DBMS-CT-0623

 @SYMTestCaseDesc        Tests for RDbTable,RDbRowSet classes

 @SYMTestPriority        Medium

 @SYMTestActions         Call up Test for table ordering and index seeking functions

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 template <class T>

 void TestTypeL( TDbColType aType, TInt aAttribs, const T aValues[], TInt aCount )

 	{

 	test.Start( _L( " @SYMTestCaseID:SYSLIB-DBMS-CT-0623 Build table " ) );

 	BuildTableL( aType, aAttribs, aValues, aCount );

 	T t(0);

 //

 	test.Next( _L( "Test ORDER BY ordering" ) );

 	test( TheView.Prepare( TheDatabase, KSelectOrdered ) == KErrNone );

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

 	TestOrderingL( TheView, t, aCount );

 	TheView.Close();

 //

 	BuildIndexL();

 	TestOrderingL( TheTable, t, aCount );

 //

 	TestSeekL( TheTable, t, aValues, aCount );

 	TheTable.Close();

 //

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

 	test.End();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-1322

 @SYMTestCaseDesc        Text ordering test

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for RDbRowSet::Next(),RDbRowSet::GetL(),RDbRowSet::ColDes() functions

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 void TestTextOrderingL(RDbRowSet& aSet,TInt aCount,const TTextOps& aComp)

 	{

 	test.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-1322 "));

 	test(aSet.CountL()==aCount);

 	TInt count=0;

 	while (aSet.NextL())

 		{

 		aSet.GetL();

 		TPtrC current=aSet.ColDes(1);

 		if (count++>0)

 			test(aComp.Compare(TheBuf,current)<0);

 		TheBuf=current;

 		}

 	test(count==aCount);

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-1323

 @SYMTestCaseDesc        Tests for RDbView,RDbTable classes

 @SYMTestPriority        Medium

 @SYMTestActions         Wrapper function to call up for text ordering and text indexing tests

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 void TestTextL(const TPtrC aValues[],TInt aCount,TDbTextComparison aComparison,TInt aLength=KDbUndefinedLength)

 	{

 	const TTextOps& comp=TTextOps::Ops(aComparison);

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-1323 Build table "));

 	BuildTableL(EDbColText,0,aValues,aCount);

 //

 	test.Next(_L("Test ORDER BY ordering"));

 	test (TheView.Prepare(TheDatabase,TDbQuery(KSelectOrdered,aComparison))==KErrNone);

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

 	TestTextOrderingL(TheView,aCount,comp);

 	TheView.Close();

 //

 	BuildIndexL(aComparison,aLength);

 	test(TheTable.SetIndex(KIndexName)==KErrNone);

 	TestTextOrderingL(TheTable,aCount,comp);

 //

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

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

 		{

 		test(TheTable.SeekL(aValues[ii]));

 		TheTable.GetL();

 		test(comp.Compare(aValues[ii],TheTable.ColDes(1))==0);

 		}

 //

 	TheTable.Close();

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

 	test.End();

 	}

 void TestLongTextOrderingL(RDbRowSet& aSet,TInt aCount,const TTextOps& aComp)

 	{

 	test(aSet.CountL()==aCount);

 	TInt count=0;

 	HBufC* prev=0;

 	while (aSet.NextL())

 		{

 		aSet.GetL();

 		TInt len=aSet.ColLength(1);

 		HBufC* buf=HBufC::NewL(len);

 		RDbColReadStream s;

 		s.OpenLC(aSet,1);

 		TPtr des(buf->Des());

 		s.ReadL(des,len);

 		CleanupStack::PopAndDestroy();

 		if (count++)

 			test (aComp.Compare(*buf,*prev)>=0);

 		delete prev;

 		prev=buf;

 		}

 	delete prev;

 	test(count==aCount);

 	}

 LOCAL_C void OrderByLongTextL(TInt aCount,TDbTextComparison aComparison)

 	{

 	test (TheView.Prepare(TheDatabase,TDbQuery(KSelectOrdered,aComparison))==KErrNone);

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

 	TestLongTextOrderingL(TheView,aCount,TTextOps::Ops(aComparison));

 	TheView.Close();

 	}

 LOCAL_C void TestLongTextL(const TPtrC aValues[],TInt aCount,TDbTextComparison aComparison,TInt aLength=KDbUndefinedLength)

 	{

 	const TTextOps& comp=TTextOps::Ops(aComparison);

 	test.Start(_L("Build table"));

 	BuildTableL(EDbColLongText,0,aValues,aCount);

 //

 	test.Next(_L("Test ORDER BY ordering"));

 	OrderByLongTextL(aCount,aComparison);

 //

 	BuildIndexL(aComparison,aLength);

 	test(TheTable.SetIndex(KIndexName)==KErrNone);

 	TestLongTextOrderingL(TheTable,aCount,comp);

 //

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

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

 		{

 		test(TheTable.SeekL(aValues[ii]));

 		TheTable.GetL();

 		RDbColReadStream strm;

 		strm.OpenLC(TheTable,1);

 		strm.ReadL(TheBuf,TheTable.ColLength(1));

 		CleanupStack::PopAndDestroy();

 		test(comp.Compare(aValues[ii],TheBuf)==0);

 		}

 	TheTable.Close();

 //

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

 	test.End();

 	}

 TUint const KBitValues[]={0,1};

 TInt const KInt8Values[]={0,KMinTInt8+1,1,KMaxTInt8,2,-3,-1,KMaxTInt8-1,KMinTInt8,-40};

 TInt const KInt16Values[]={0,KMinTInt16+1,1,KMaxTInt16,2,-3,-1,KMaxTInt16-1,KMinTInt16,-4000};

 TInt const KInt32Values[]={0,KMinTInt32+1,1,KMaxTInt32,2,-3,-1,KMaxTInt32-1,KMinTInt32,-40000000};

 TInt const KInt32Count=sizeof(KInt32Values)/sizeof(KInt32Values[0]);

 TUint const KUint8Values[]={0,1,KMaxTUint8,2,(KMaxTUint8+1)/2,(KMaxTUint8-1)/2,KMaxTUint8-1,40};

 TUint const KUint16Values[]={0,1,KMaxTUint16,2,(KMaxTUint16+1)/2,(KMaxTUint16-1)/2,KMaxTUint16-1,4000};

 TUint const KUint32Values[]={0,1,KMaxTUint32,2,KMaxTUint32/2+1,KMaxTUint32/2,KMaxTUint32-1,40000000};

 //TReal32 const KReal32Values[]={0.0f,1.0f,KMaxTReal32,KMinTReal32,-1.0f,-KMaxTReal32,-4e20f,-KMinTReal32};

 //TReal64 const KReal64Values[]={0.0,1.0,KMaxTReal64,KMinTReal64,-1.0,-KMaxTReal64,-4e200,-KMinTReal64};

 TReal32 const KReal32Values[]={0.0f,1.0f,1e37f,1e-37f,-1.0f,-1e37f,-4e20f,-1e-37f};

 TReal64 const KReal64Values[]={0.0,1.0,KMaxTReal64,KMinTReal64,-1.0,-KMaxTReal64,-4e200,-KMinTReal64};

 TInt64 const KInt64Values[]=

 	{

 	0,

 	MAKE_TINT64(0x80000000u,0x1u),

 	1,

 	MAKE_TINT64(0x7fffffffu,0xffffffffu),

 	2,

 	-3,

 	-1,

 	MAKE_TINT64(0x7fffffffu,0xfffffffeu),

 	MAKE_TINT64(0x80000000u,0x0u),

 	-40

 	};

 TTime const KTimeValues[]=

 	{

 	Time::MaxTTime(),

 	TInt64(0),

 	TDateTime(1970,EJanuary,0,0,0,0,0),

 	Time::MinTTime(),

 	TDateTime(2049,EDecember,30,23,59,59,999999),

 	TDateTime(1996,EJuly,8,17,45,0,0)

 	};

 TPtrC const KTextValues[]=

 	{

 	_S(""),

 	_S("10"),

 	_S("zyx"),

 	_S("0"),

 	_S("abcd"),

 	_S("abcdefg"),

 	_S("ABCDE"),

 	_S("Z")

 	};

 TPtrC const KLongTextValues[]=

 	{

 	_S("this blob will be inlined"),

 	_S(""),

 	_S("that blob was null"),

 	_S("An example of an out-of-line blob in an index! LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8-LongText8")

 	};

 const TInt KLongTextLimit=30;

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0624

 @SYMTestCaseDesc        Wrapper function testing for Indexing with different integer sizes and Text .

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for indexing

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestTypesL()

 	{

 	#define ARRAY_SIZE(a) TInt(sizeof(a)/sizeof(a[0]))

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0624 Indexing Bit "));

 	TestTypeL(EDbColBit,TDbCol::ENotNull,KBitValues,ARRAY_SIZE(KBitValues));

 	test.Next(_L("Indexing Int8"));

 	TestTypeL(EDbColInt8,TDbCol::ENotNull,KInt8Values,ARRAY_SIZE(KInt8Values));

 	test.Next(_L("Indexing Int16"));

 	TestTypeL(EDbColInt16,TDbCol::ENotNull,KInt16Values,ARRAY_SIZE(KInt16Values));

 	test.Next(_L("Indexing Int32"));

 	TestTypeL(EDbColInt32,TDbCol::ENotNull,KInt32Values,ARRAY_SIZE(KInt32Values));

 	test.Next(_L("Indexing Uint8"));

 	TestTypeL(EDbColUint8,TDbCol::ENotNull,KUint8Values,ARRAY_SIZE(KUint8Values));

 	test.Next(_L("Indexing Uint16"));

 	TestTypeL(EDbColUint16,TDbCol::ENotNull,KUint16Values,ARRAY_SIZE(KUint16Values));

 	test.Next(_L("Indexing Uint32"));

 	TestTypeL(EDbColUint32,TDbCol::ENotNull,KUint32Values,ARRAY_SIZE(KUint32Values));

 	test.Next(_L("Indexing Real32"));

 	TestTypeL(EDbColReal32,TDbCol::ENotNull,KReal32Values,ARRAY_SIZE(KReal32Values));

 	test.Next(_L("Indexing Real64"));

 	TestTypeL(EDbColReal64,TDbCol::ENotNull,KReal64Values,ARRAY_SIZE(KReal64Values));

 	test.Next(_L("Indexing Int64"));

 	TestTypeL(EDbColInt64,TDbCol::ENotNull,KInt64Values,ARRAY_SIZE(KInt64Values));

 	test.Next(_L("Indexing Time"));

 	TestTypeL(EDbColDateTime,TDbCol::ENotNull,KTimeValues,ARRAY_SIZE(KTimeValues));

 	test.Next(_L("Indexing Text (Normal)"));

 	TestTextL(KTextValues,ARRAY_SIZE(KTextValues),EDbCompareNormal);

 	test.Next(_L("Indexing Text (Folded)"));

 	TestTextL(KTextValues,ARRAY_SIZE(KTextValues),EDbCompareFolded);

 	test.Next(_L("Indexing Text (Collated)"));

 	TestTextL(KTextValues,ARRAY_SIZE(KTextValues),EDbCompareCollated);

 	test.Next(_L("Indexing Text (Normal, truncated)"));

 	TestTextL(KTextValues,ARRAY_SIZE(KTextValues),EDbCompareNormal,5);

 	test.Next(_L("Indexing LongText (Normal)"));

 	TestLongTextL(KLongTextValues,ARRAY_SIZE(KLongTextValues),EDbCompareNormal,KLongTextLimit);

 	test.Next(_L("Indexing LongText (Folded)"));

 	TestLongTextL(KLongTextValues,ARRAY_SIZE(KLongTextValues),EDbCompareFolded,KLongTextLimit);

 	test.Next(_L("Indexing LongText (Collated)"));

 	TestLongTextL(KLongTextValues,ARRAY_SIZE(KLongTextValues),EDbCompareCollated,KLongTextLimit);

 	test.End();

 	}

 const TInt KBlobKeyTruncated=32/sizeof(TText);

 const TInt KBlobKeyMaxInline=255/sizeof(TText);

 const TInt KBlobKeyCompare=512/sizeof(TText);

 const TInt KMemoTestLengths[]=

 	{

 	0,

 	1,

 	KBlobKeyTruncated-1,

 	KBlobKeyTruncated,

 	KBlobKeyTruncated+1,

 	KBlobKeyMaxInline,

 	KBlobKeyMaxInline+1,

 	KBlobKeyCompare-1,

 	KBlobKeyCompare,

 	KBlobKeyCompare+1,

 	5000

 	};

 void TestMemoTableL(CDbColSet& aBaseSet)

 	{

 	test.Start(_L("create the table"));

 	aBaseSet.AddL(TDbCol(KColumnName,EDbColLongText));

 	TheDatabase.Begin();

 	TInt r=TheDatabase.CreateTable(KTableName,aBaseSet);

 	test (r==KErrNone);

 //

 	test.Next(_L("add the rows"));

 	r=TheView.Prepare(TheDatabase,KSelectOrdered,RDbView::EInsertOnly);

 	test (r==KErrNone);

 	r=TheView.EvaluateAll();

 	test (r==KErrNone);

 	HBufC* prev=0;

 	TInt count=0;

 	for (TUint ii=0;ii<elementsof(KMemoTestLengths);++ii)

 		{

 		TInt size=KMemoTestLengths[ii];

 		HBufC* buf=HBufC::NewL(size);

 		if (size>0)

 			{

 			TPtr des(buf->Des());

 			des.Copy(*prev);

 			des.AppendFill('b',size-prev->Length());

 			delete prev;

 			TheView.InsertL();

 			TheView.SetColL(1,*buf);

 			TheView.PutL();

 			++count;

 			des[size-1]='a';

 			}

 		TheView.InsertL();

 		TheView.SetColL(1,*buf);

 		TheView.PutL();

 		++count;

 		prev=buf;

 		}

 	delete prev;

 	TheView.Close();

 	r=TheDatabase.Commit();

 	test (r==KErrNone);

 //

 	test.Next(_L("Normal order"));

 	OrderByLongTextL(count,EDbCompareNormal);

 	test.Next(_L("Folded order"));

 	OrderByLongTextL(count,EDbCompareFolded);

 	test.Next(_L("Collated order"));

 	OrderByLongTextL(count,EDbCompareCollated);

 //

 	r=TheDatabase.DropTable(KTableName);

 	test (r==KErrNone);

 	test.End();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0625

 @SYMTestCaseDesc        Tests for ordering by longtext

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for CDbColSet

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestOrderByLongTextL()

 	{

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0625 Maximum Inline Limit "));

 	CDbColSet* set=CDbColSet::NewLC();

 	TestMemoTableL(*set);

 //

 	test.Next(_L("Reduced Inline limit [<32]"));

 	set->Clear();

 	TDbCol col;

 	col.iType=EDbColText8;

 	col.iMaxLength=255;

 	col.iAttributes=0;

 	TDbColName name;

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

 		{

 		name.Format(_L("col%d"),ii);

 		col.iName=name;

 		if (ii==31)

 			col.iMaxLength=255-20;

 		set->AddL(col);

 		}

 	TestMemoTableL(*set);

 	CleanupStack::PopAndDestroy();

 	test.End();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0626

 @SYMTestCaseDesc        Tests for reverse ordering in indexes

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for reversing the indexes

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestReverseL()

 	{

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0626 Create table and index "));

 	TheDatabase.Begin();

 	CDbColSet *cs=CDbColSet::NewLC();

 	cs->AddL(TDbCol(KColumnName,EDbColInt32));

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

 	CleanupStack::PopAndDestroy();

 	CDbKey *key=CDbKey::NewLC();

 	key->AddL(TDbKeyCol(KColumnName,TDbKeyCol::EDesc));

 	key->MakeUnique();

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

 	CleanupStack::PopAndDestroy();

 	test(TheDatabase.Commit()==KErrNone);

 	test.Next(_L("Add records"));

 	TheDatabase.Begin();

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

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

 		{

 		TheTable.InsertL();

 		TheTable.SetColL(1,KInt32Values[ii]);

 		TheTable.PutL();

 		}

 	test(TheDatabase.Commit()==KErrNone);

 	test(TheTable.CountL()==KInt32Count);

 	test.Next(_L("Check order"));

 	test(TheTable.SetIndex(KIndexName)==KErrNone);

 	test(TheTable.CountL()==KInt32Count);

 	TInt count=0;

 	if (TheTable.FirstL())

 		{

 		++count;

 		TheTable.GetL();

 		TInt32 last=TheTable.ColInt(1);

 		while (TheTable.NextL())

 			{

 			++count;

 			TheTable.GetL();

 			TInt32 current=TheTable.ColInt(1);

 			test(last>current);

 			last=current;

 			}

 		}

 	test(count==KInt32Count);

 	TheTable.Close();

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

 	test.End();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0627

 @SYMTestCaseDesc        Tests for multi-column keys

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for mutliple column keys

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestMultiL()

 	{

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0627 Create table and index "));

 	TheDatabase.Begin();

 	CDbColSet *cs=CDbColSet::NewLC();

 	TDbCol col(KColumnName,EDbColInt32);

 	col.iAttributes=TDbCol::ENotNull;

 	cs->AddL(col);

 	col.iName=KColumnTwo;

 	cs->AddL(col);

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

 	CleanupStack::PopAndDestroy();

 	CDbKey *key=CDbKey::NewLC();

 	key->AddL(TDbKeyCol(KColumnTwo));

 	key->AddL(TDbKeyCol(KColumnName,TDbKeyCol::EDesc));

 	key->MakeUnique();

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

 	CleanupStack::PopAndDestroy();

 	test(TheDatabase.Commit()==KErrNone);

 	test.Next(_L("Add records"));

 	TheDatabase.Begin();

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

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

 		{

 		for (TInt jj=0;jj<KInt32Count;++jj)

 			{

 			TheTable.InsertL();

 			TheTable.SetColL(1,KInt32Values[ii]);

 			TheTable.SetColL(2,KInt32Values[jj]);

 			TheTable.PutL();

 			}

 		}

 	test(TheDatabase.Commit()==KErrNone);

 	test.Next(_L("Check order"));

 	test(TheTable.CountL()==KInt32Count*KInt32Count);

 	test(TheTable.SetIndex(KIndexName)==KErrNone);

 	test(TheTable.CountL()==KInt32Count*KInt32Count);

 	TInt count=0;

 	if (TheTable.FirstL())

 		{

 		++count;

 		TheTable.GetL();

 		TInt32 lastOne=TheTable.ColInt(1);

 		TInt32 lastTwo=TheTable.ColInt(2);

 		while (TheTable.NextL())

 			{

 			++count;

 			TheTable.GetL();

 			TInt32 currentOne=TheTable.ColInt(1);

 			TInt32 currentTwo=TheTable.ColInt(2);

 			test(lastTwo<currentTwo||(lastTwo==currentTwo&&lastOne>currentOne));

 			lastOne=currentOne;

 			lastTwo=currentTwo;

 			}

 		}

 	test(count==KInt32Count*KInt32Count);

 	TheTable.Close();

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

 	test.End();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0628

 @SYMTestCaseDesc        Tests duplicates/unique constraints

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for adding duplicate entries

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestDuplicatesL()

 	{

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0628 Create table and indices "));

 	BuildTableL(EDbColInt32,TDbCol::ENotNull,KInt32Values,KInt32Count);

 	BuildIndexL();

 	TheTable.Close();

 	CDbKey* key=CDbKey::NewLC();

 	key->AddL(KColumnName);

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

 	CleanupStack::PopAndDestroy();

 	test.Next(_L("Attempt to add/update duplicate entry"));

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

 	TheTable.InsertL();

 	TheTable.SetColL(1,0);

 	TRAPD(r,TheTable.PutL());

 	test(r!=KErrNone);

 	TheTable.Cancel();

 	TheTable.LastL();

 	TheTable.UpdateL();

 	TheTable.SetColL(1,0);

 	TRAP(r,TheTable.PutL());

 	test(r!=KErrNone);

 	TheTable.Cancel();

 	test.Next(_L("Remove unique index"));

 	TheTable.Close();

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

 	test.Next(_L("Attempt to update/add duplicate entry"));

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

 	TheTable.LastL();

 	TheTable.UpdateL();

 	TheTable.SetColL(1,0);

 	TRAP(r,TheTable.PutL());

 	test(r==KErrNone);

 	TheTable.InsertL();

 	TheTable.SetColL(1,0);

 	TRAP(r,TheTable.PutL());

 	test(r==KErrNone);

 	test.Next(_L("Check order"));

 	test(TheTable.CountL()==KInt32Count+1);

 	test(TheTable.SetIndex(KIndexTwo)==KErrNone);

 	test(TheTable.CountL()==KInt32Count+1);

 	TInt count=0;

 	if (TheTable.FirstL())

 		{

 		++count;

 		TheTable.GetL();

 		TInt32 last=TheTable.ColInt(1);

 		while (TheTable.NextL())

 			{

 			++count;

 			TheTable.GetL();

 			TInt32 current=TheTable.ColInt(1);

 			test(last<=current);	// duplicates present

 			last=current;

 			}

 		}

 	test(count==KInt32Count+1);

 	test.Next(_L("Try to create unique index"));

 	TheTable.Close();

 	key=CDbKey::NewLC();

 	key->AddL(KColumnName);

 	key->MakeUnique();

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

 	CleanupStack::PopAndDestroy();

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

 	test.End();

 	}

 struct Pair { TInt i1,i2; };

 struct TSeekingTest

 	{

 	Pair iSeek;

 	Pair iResults[5];

 	};

 // seek pair: results for <,<=,=,>=,>

 static TSeekingTest const SeekingTests[]=

 	{

 	{{0,0},{{-1,-1},{-1,-1},{-1,-1},{100,10},{100,10}}},

 	{{0,-1},{{-1,-1},{-1,-1},{-1,-1},{100,10},{100,10}}},

 	{{100,0},{{-1,-1},{-1,-1},{-1,-1},{100,10},{100,10}}},

 	{{100,10},{{-1,-1},{100,10},{100,10},{100,10},{100,20}}},

 	{{100,55},{{100,50},{100,50},{-1,-1},{100,60},{100,60}}},

 	{{100,60},{{100,50},{100,60},{100,60},{100,60},{100,70}}},

 	{{100,100},{{100,90},{100,100},{100,100},{100,100},{200,10}}},

 	{{100,110},{{100,100},{100,100},{-1,-1},{200,10},{200,10}}},

 	{{100,-1},{{-1,-1},{100,100},{100,10},{100,10},{200,10}}},

 	{{500,-1},{{400,100},{500,100},{500,10},{500,10},{600,10}}},

 	{{550,50},{{500,100},{500,100},{-1,-1},{600,10},{600,10}}},

 	{{550,-1},{{500,100},{500,100},{-1,-1},{600,10},{600,10}}},

 	{{1000,0},{{900,100},{900,100},{-1,-1},{1000,10},{1000,10}}},

 	{{1000,10},{{900,100},{1000,10},{1000,10},{1000,10},{1000,20}}},

 	{{1000,100},{{1000,90},{1000,100},{1000,100},{1000,100},{-1,-1}}},

 	{{1000,110},{{1000,100},{1000,100},{-1,-1},{-1,-1},{-1,-1}}},

 	{{1000,-1},{{900,100},{1000,100},{1000,10},{1000,10},{-1,-1}}},

 	{{1100,0},{{1000,100},{1000,100},{-1,-1},{-1,-1},{-1,-1}}},

 	{{1100,-1},{{1000,100},{1000,100},{-1,-1},{-1,-1},{-1,-1}}}

 	};

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0629

 @SYMTestCaseDesc        Tests for seeking on indexes

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for SeekL and GetL functions

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestSeekingL()

 	{

 	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0629 Create table and index "));

 	TheDatabase.Begin();

 	CDbColSet *cs=CDbColSet::NewLC();

 	TDbCol col(KColumnName,EDbColInt32);

 	col.iAttributes=TDbCol::ENotNull;

 	cs->AddL(col);

 	col.iName=KColumnTwo;

 	cs->AddL(col);

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

 	CleanupStack::PopAndDestroy();

 	CDbKey *key=CDbKey::NewLC();

 	key->AddL(KColumnName).AddL(KColumnTwo);

 	key->MakeUnique();

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

 	CleanupStack::PopAndDestroy();

 	test(TheDatabase.Commit()==KErrNone);

 	test.Next(_L("Add records"));

 	TheDatabase.Begin();

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

 	for (TInt ii=100;ii<=1000;ii+=100)

 		{

 		for (TInt jj=10;jj<=100;jj+=10)

 			{

 			TheTable.InsertL();

 			TheTable.SetColL(1,ii);

 			TheTable.SetColL(2,jj);

 			TheTable.PutL();

 			}

 		}

 	test(TheDatabase.Commit()==KErrNone);

 	test(TheTable.CountL()==100);

 	test(TheTable.SetIndex(KIndexName)==KErrNone);

 	test(TheTable.CountL()==100);

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

 	const TSeekingTest* stest=SeekingTests;

 	const TSeekingTest* const end=stest+sizeof(SeekingTests)/sizeof(SeekingTests[0])-1;

 	for (;stest<=end;++stest)

 		{

 		TDbSeekMultiKey<2> key;

 		key.Add(stest->iSeek.i1);

 		if (stest->iSeek.i2>=0)

 			key.Add(stest->iSeek.i2);

 		const Pair* results=stest->iResults;

 		for (TInt ii=RDbTable::ELessThan;ii<=RDbTable::EGreaterThan;++results,++ii)

 			{

 			if (TheTable.SeekL(key,RDbTable::TComparison(ii)))

 				{

 				test(results->i1>=0);

 				TRAPD(errCode, TheTable.GetL());

 				test(errCode==KErrNone);

 				test(TheTable.ColInt(1)==results->i1);

 				test(TheTable.ColInt(2)==results->i2);

 				}

 			else

 				test(results->i1<0);

 			}

 		}

 	TheTable.Close();

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

 	test.End();

 	}

 /**

 @SYMTestCaseID          SYSLIB-DBMS-CT-0630

 @SYMTestCaseDesc        Tests for defect,index creation and set index operations

 @SYMTestPriority        Medium

 @SYMTestActions         Tests for creating and setting index operations

 @SYMTestExpectedResults Test must not fail

 @SYMREQ                 REQ0000

 */

 LOCAL_C void TestInequalityErrorL()

 	{

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

 	TheDatabase.Begin();

 	CDbColSet *cs=CDbColSet::NewLC();

 	cs->AddL(TDbCol(KColumnName,EDbColInt32));

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

 	CleanupStack::PopAndDestroy();

 //

 	test.Next(_L("create indices"));

 	CDbKey *key=CDbKey::NewLC();

 	key->AddL(TDbKeyCol(KColumnName));

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

 	CleanupStack::PopAndDestroy();

 //

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

 	test(TheTable.Open(TheDatabase,KTableName)==KErrNone);

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

 		{

 		TheTable.InsertL();

 		TheTable.SetColL(1,ii);

 		TheTable.PutL();

 		}

 //

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

 	test(TheTable.SetIndex(KIndexName)==KErrNone);

 //

 // We need to delete a row in this node to get to the correct inequality condition

 	test.Next(_L("Delete row 90"));

 	test(TheTable.SeekL(TDbSeekKey(90)));

 	TheTable.GetL();

 	TheTable.DeleteL();

 // Now delete last row on node which should be 94

 	test.Next(_L("Delete row 94"));

 	test(TheTable.SeekL(TDbSeekKey(94)));

 	TheTable.GetL();

 	TheTable.DeleteL();

 	TheTable.EndL();

 	test(!TheTable.SeekL(TDbSeekKey(94)));

 //

 	test.Next(_L("Insert row 94"));

 	TheTable.InsertL();

 	TheTable.SetColL(1,94);

 	TheTable.PutL();

 //

 	test.Next(_L("now try and find it"));

 	test(TheTable.SeekL(TDbSeekKey(94))); //prior to defect fix this line failed.

 //

 	TheDatabase.Commit();

 	TheTable.Close();

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

 	test.End();

 	}

 /**

 @SYMTestCaseID          PDS-DBMS-CT-4006

 @SYMTestCaseDesc        Tests for add dbseekkey operations

 @SYMTestPriority        High

 @SYMTestActions         Create a DbSeekKey then add an index to it

 @SYMTestExpectedResults Verify that seeking with key works

 @SYMDEF                 DEF135710

 */

 LOCAL_C void TestAddSeekKeyL()

 	{

 	test.Start(_L(" @SYMTestCaseID:PDS-DBMS-CT-4006 Tests for add dbseekkey operations"));

 	CreateDatabase();

 	TInt err = TheDatabase.Begin();

 	test2(err, KErrNone);

 	CDbColSet *cs=CDbColSet::NewLC();

 	cs->AddL(TDbCol(KColumnName1,EDbColText8));

 	err = TheDatabase.CreateTable(KTableName1,*cs);

 	test2(err , KErrNone);

 	CleanupStack::PopAndDestroy();

 	test.Next(_L("Create Indices"));

 	CDbKey *key=CDbKey::NewLC();

 	key->AddL(TDbKeyCol(KColumnName1));

 	err = TheDatabase.CreateIndex(KIndexName1,KTableName1,*key);

 	test2(err, KErrNone);

 	CleanupStack::PopAndDestroy();

 	test.Next(_L("Populate Table"));

 	TBuf8<7> buf(_L8("testKey"));

 	err = TheTable.Open(TheDatabase,KTableName1);

 	test2(err, KErrNone);

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

 		{

 		TheTable.InsertL();

 		TheTable.SetColL(1,buf);

 		TheTable.PutL();

 		}

 	test.Next(_L("Set Index"));

 	err = TheTable.SetIndex(KIndexName1);

 	test2(err, KErrNone);

 	test.Next(_L("Testing Add Function"));

 	TDbSeekKey testkey;

 	testkey.Add(buf);

 	TBool r = TheTable.SeekL(testkey);

 	test2(r, ETrue);

 	err = TheDatabase.Commit();

 	test2(err, KErrNone);

 	TheTable.Close();

 	test.End();

 	}

 //

 // Test the database definition and enquiry functions

 //

 LOCAL_C void TestIndexesL()

 	{

 	test.Start(_L("Create Database"));

 	CreateDatabase();

 	test.Next(_L("Test index build and drop"));

 	TestIndexBuildL();

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

 	TestPersistenceL();

 	test.Next(_L("Testing index key types"));

 	TestTypesL();

 	test.Next(_L("Testing LongText ORDER BY"));

 	TestOrderByLongTextL();

 	test.Next(_L("Testing reverse ordering"));

 	TestReverseL();

 	test.Next(_L("Testing multi column keys"));

 	TestMultiL();

 	test.Next(_L("Testing duplicate/unqiue"));

 	TestDuplicatesL();

 	test.Next(_L("Testing seeking"));

 	TestSeekingL();

 	test.Next(_L("Testing incorrect inequaltiy condition in store btree"));

 	TestInequalityErrorL();

 	CloseDatabase();

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

 		}

 	}

 //

 // Test streaming conversions.

 //

 GLDEF_C TInt E32Main()

     {

 	test.Title();

 	setupTestDirectory();

 	setupCleanup();

 	__UHEAP_MARK;

 //

 	TInt r=TheDbs.Connect();

 	test (r==KErrNone);

 	TheDbs.ResourceMark();

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

 	TRAP(r,TestIndexesL();)

 	test(r==KErrNone);

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

 	TRAP(r,TestIndexesL();)

 	test(r==KErrNone);

 	TRAP(r, TestAddSeekKeyL());

 	test(r==KErrNone);

 	CloseDatabase();

 	::DeleteDataFile(KTestDatabase);	//deletion of data files must be before call to end - DEF047652

 	test.End();

 	TheDbs.ResourceCheck();

 	TheDbs.Close();

 	__UHEAP_MARKEND;

 	delete TheTrapCleanup;

 	TheFs.Close();

 	test.Close();

 	return 0;

     }