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

#include "D32DBAS.H"

LOCAL_D RTest test(_L("t_dbsrv: Test DBMS server"));

LOCAL_D CTrapCleanup* TheTrapCleanup;

LOCAL_D RFs TheFs;

LOCAL_D RDbs TheDbs;

LOCAL_D RDbNamedDatabase TheDatabase;

LOCAL_D RDbTable TheTable;

LOCAL_D RDbView TheView;

const TInt KTestCleanupStack=0x40;

const TPtrC KTestDatabase(_S("c:\\dbms-tst\\share.db"));

const TPtrC KTestFormat(_S(""));

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

const TPtrC KTable2(_S("Table2"));

const TInt KRowCount=1000;

const TUint KExitDelay=6*0x100000;	// ~6 seconds

const TPtrC KCreateTable1=_S("CREATE TABLE Table1 (Id INTEGER,Name CHAR(200),Memo LONG VARCHAR,Memo2 LONG VARBINARY)");

const TPtrC KCreateTable2=_S("CREATE TABLE Table2 (Id INTEGER,Name CHAR(200),Memo LONG VARCHAR)");

const TPtrC KDropTable1=_S("DROP TABLE Table1");

const TPtrC KDropTable2=_S("DROP TABLE Table2");

_LIT(KTestSpdFile1, "c:\\dbms-tst\\11335577.spd");

_LIT(KTestSpdFile2, "c:\\dbms-tst\\11335578.spd");

_LIT(KTestSpdFile3, "c:\\dbms-tst\\11335579.spd");

_LIT(KTestSpdFile4, "c:\\dbms-tst\\1133557A.spd");

const TInt KReturnValueForCompare = 10;

const TInt KReturnValueForFind = 20;

class TTimer

	{

public:

	void Start(const TDesC& aDes);

	void Stop();

private:

	TUint iTicks;

	};

static TTimer TheTimer;

void TTimer::Start(const TDesC& aDes)

	{

	test.Printf(_L("  %S: "),&aDes);

	iTicks=User::FastCounter();

	}

void TTimer::Stop()

	{

	TUint ticks = User::FastCounter() - iTicks;

	TInt freq = 0;

	test(HAL::Get(HAL::EFastCounterFrequency, freq) == KErrNone);

	const TInt KMicroSecIn1Sec = 1000000;

	const TInt KMsIn1Sec = 1000;

	double v = ((double)ticks * KMicroSecIn1Sec) / (double)freq; TInt v2 = (TInt)v;

	test.Printf(_L("%d ms\r\n"),v2/KMsIn1Sec);

	}

void DeleteTestFiles()

	{

	(void)TheFs.Delete(KTestDatabase);

	(void)TheFs.Delete(KTestSpdFile1); 

	(void)TheFs.Delete(KTestSpdFile2); 

	(void)TheFs.Delete(KTestSpdFile3); 

	(void)TheFs.Delete(KTestSpdFile4); 

	}

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

	{

	if (aValue!=aExpected)

		{

		DeleteTestFiles();

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

		test.operator()(EFalse,aLine);

		}

	}

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

LOCAL_C void Connect()

	{

	test2(TheDbs.Connect(),KErrNone);

	TheDbs.ResourceMark();

	}

LOCAL_C void Disconnect()

	{

	TheDbs.ResourceCheck();

	TheDbs.Close();

	}

LOCAL_C void Execute(const TDesC& aSql)

	{

	test2 (TheDatabase.Execute(aSql),KErrNone);

	}

LOCAL_C void WriteRecordsL(TInt aCount)

	{

	TheTimer.Start(_L("writing"));

	TheDatabase.Begin();

	TBuf<10> text;

	TInt jj=0;

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

		{

		TheTable.InsertL();

		jj=(jj+23);

		if (jj>=aCount)

			jj-=aCount;

		TheTable.SetColL(1,jj);

		text.Num(jj);

		TheTable.SetColL(2,text);

		TheTable.PutL();

		}

	test2 (TheDatabase.Commit(),KErrNone);

	TheTimer.Stop();

	}

LOCAL_C void Ipc(TInt aCount)

	{

	TheTimer.Start(_L("ipc"));

	while (--aCount>=0)

		TheDatabase.InTransaction();

	TheTimer.Stop();

	}

LOCAL_C void LoopL(RDbTable::TPosition aDirection)

	{

	TheTimer.Start(_L("loop"));

	TInt cc=0;

	while (TheTable.GotoL(aDirection))

		++cc;

	test2 (cc,TheTable.CountL());

	TheTimer.Stop();

	}

LOCAL_C void IterateL(RDbTable::TPosition aDirection)

	{

	TheTimer.Start(_L("iterate"));

	TInt cc=0;

	while (TheTable.GotoL(aDirection))

		{

		++cc;

		TheTable.GetL();

		TBuf<10> text;

		text.Num(TheTable.ColInt(1));

		test (text==TheTable.ColDes(2));

		}

	test2 (cc,TheTable.CountL());

	TheTimer.Stop();

	}

LOCAL_C void LocateL(const TDesC& aSql)

	{

	test2 (TheView.Prepare(TheDatabase,aSql),KErrNone);

	test2 (TheView.EvaluateAll(),KErrNone);

	TheTimer.Start(_L("locate"));

	test (!TheView.NextL());

	TheTimer.Stop();

	TheView.Close();

	}

LOCAL_C void Locate1L()

	{

	LocateL(_L("select * from Table1 where id is null"));

	}

LOCAL_C void Locate2L()

	{

	LocateL(_L("select * from Table1 where id = -12345"));

	}

LOCAL_C TInt DeleteL()

	{

	TheTimer.Start(_L("deleting"));

	TheDatabase.Begin();

	TInt cc=0;

	TheTable.BeginningL();

	while (TheTable.NextL())

		{

		++cc;

		TheTable.DeleteL();

		}

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

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

	TheTimer.Stop();

	return cc;

	}

LOCAL_C TInt DeleteSQL()

	{

	TheTimer.Start(_L("deleting [SQL]"));

	TInt cc=TheDatabase.Execute(_L("delete from Table1"));

	test (cc>=KErrNone);

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

	TheTimer.Stop();

	return cc;

	}

LOCAL_C void BenchmarkL()

	{

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

	TheTable.LastL();

	test (r==KErrNone);

	Ipc(KRowCount);

	TheTable.Reset();

	LoopL(TheTable.ENext);

	TheTable.Reset();

	IterateL(TheTable.ENext);

	Locate1L();

	Locate2L();

	TheTable.Close();

	}

const TPtrC KSemaphore(_S("Connect-test"));

LOCAL_C TInt ConnectThread(TAny*)

	{

	RSemaphore s;

	s.OpenGlobal(KSemaphore,EOwnerThread);

	RDbs dbs;

	dbs.Connect();

	s.Signal();

	User::After(0x100000);

	s.Wait();

	dbs.Close();

	s.Signal();

	s.Close();

	return KErrNone;

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-0605

@SYMTestCaseDesc        Single and multiple database connection tests

@SYMTestPriority        Medium

@SYMTestActions         Setup a DBMS server session Search the server for pattern matching

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestConnect()

	{

	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0605 Single connection "));

	test (TheDbs.Connect()==KErrNone);

	TheDbs.Close();

	test.Next(_L("Deferred exit"));

	TFindServer find(_L("!DBMS server"));

	TFullName result;

	test2 (find.Next(result),KErrNone);

	test.Next(_L("Multiple connection"));

	Connect();

	RDbs dbs;

	test2 (dbs.Connect(),KErrNone);

	Disconnect();

	dbs.Close();

	test.Next(_L("Deferred exit"));

	find.Find(_L("!DBMS server"));

	test2 (find.Next(result),KErrNone);

	User::After(KExitDelay);

	find.Find(_L("!DBMS server"));

	test2 (find.Next(result),KErrNotFound);

	test.Next(_L("multiple thread connections"));

	RSemaphore s;

	test2 (s.CreateGlobal(KSemaphore,0,EOwnerThread),KErrNone);

	RThread t;

	test2 (t.Create(KSemaphore,ConnectThread,0x2000,0x1000,0x10000,0,EOwnerThread),KErrNone);

	t.Resume();

	TRequestStatus st;

	t.Logon(st);

	t.Close();

	s.Wait();

	Connect();

	s.Signal();

	s.Close();

	User::WaitForRequest(st);

	test2 (TheDbs.ResourceCount(),0);

	Disconnect();

	test.Next(_L("Deferred exit"));

	find.Find(_L("!DBMS server"));

	test2 (find.Next(result),KErrNone);

	User::After(KExitDelay);

	find.Find(_L("!DBMS server"));

	test2 (find.Next(result),KErrNotFound);

	test.End();

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-0606

@SYMTestCaseDesc        Tests for benchmark

@SYMTestPriority        Medium

@SYMTestActions         Tests for creating database and writing a table.Test for no error conditions.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestBenchL()

	{

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

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

	test (r==KErrNone);

	Execute(KCreateTable1);

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

	r=TheTable.Open(TheDatabase,KTable1);

	test (r==KErrNone);

	WriteRecordsL(KRowCount);

	TheTable.Close();

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

	TRAPD(errCode, BenchmarkL());

	test(errCode == KErrNone);

	test.Next(_L("Open server-side"));

	TheDatabase.Close();

	Connect();

	r=TheDatabase.Open(TheDbs,KTestDatabase);

	test (r==KErrNone);

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

	TRAP(errCode, BenchmarkL());

	test(errCode == KErrNone);

	test.Next(_L("Wrap up"));

	TheDatabase.Close();

	Disconnect();

	test.End();

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-0607

@SYMTestCaseDesc        Tests for opening a shared database

@SYMTestPriority        Medium

@SYMTestActions         Tests for database open,column type,write and drop table

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestOpenL()

	{

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

	test2 (TheDatabase.Replace(TheFs,KTestDatabase,KTestFormat),KErrNone);

	TheDatabase.Close();

	test.Next(_L("Open as shared"));

	Connect();

	test2 (TheDatabase.Open(TheDbs,KTestDatabase),KErrNone);

	Execute(KCreateTable1);

	test2 (TheTable.Open(TheDatabase,KTable1),KErrNone);

	test2 (TheTable.ColCount(),4);

	test2 (TheTable.ColType(1),EDbColInt32);

	test2 (TheTable.ColType(2),EDbColText);

	test2 (TheTable.ColType(3),EDbColLongText);

	test2 (TheTable.ColType(4),EDbColLongBinary);

	delete TheTable.ColSetL();

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

	WriteRecordsL(KRowCount);

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

	TheTable.Reset();

	test (TheTable.AtBeginning());

	test (!TheTable.AtRow());

	test (!TheTable.AtEnd());

	test2 (TheTable.CountL(),KRowCount);

	IterateL(TheTable.ENext);

	test (!TheTable.AtBeginning());

	test (!TheTable.AtRow());

	test (TheTable.AtEnd());

	test.Next(_L("Delete rows"));

	test2 (DeleteL(),KRowCount);

	TheTable.Close();

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

	Execute(KDropTable1);

	TheDatabase.Close();

	Disconnect();

	test.End();

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-0608

@SYMTestCaseDesc        Tests for database locking

@SYMTestPriority        Medium

@SYMTestActions         Tests for shared,exclusive locks on database

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestLocking()

	{

	TInt r;

	RDbNamedDatabase db;

	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0608 Open databases "));

	Connect();

	test2 (TheDatabase.Open(TheDbs,KTestDatabase),KErrNone);

	test2 (db.Open(TheDbs,KTestDatabase,KTestFormat),KErrNone);

	RDbNotifier ob;

	test2 (ob.Open(TheDatabase),KErrNone);

//

	test.Next(_L("Shared locks"));

	TRequestStatus stat;

	ob.NotifyUnlock(stat);

	test2 (TheDatabase.Begin(),KErrNone);

	test2 (db.Begin(),KErrNone);

	test2 (TheDatabase.Commit(),KErrNone);

	User::After(1);

	test2 (stat.Int(),KRequestPending);		// should not report yet

	test2 (db.Commit(),KErrNone);

	User::WaitForRequest(stat);

	test2 (stat.Int(),ob.EUnlock);

//

	test.Next(_L("Exclusive locks"));

	ob.NotifyUnlock(stat);

	test2 (TheDatabase.Begin(),KErrNone);

	test2 (db.Begin(),KErrNone);

	test2 (TheDatabase.Execute(KCreateTable1),KErrLocked);	// cannot acquire

	test2 (db.Commit(),KErrNone);	// release lock

	test2 (TheDatabase.Execute(KCreateTable1),KErrNone);	// upgrade to X-lock

	test2 (db.Begin(),KErrLocked);	// cannot share

	test2 (TheTable.Open(db,KTable1),KErrNone);

	TRAP(r,TheTable.InsertL());		// cannot lock

	test2 (r,KErrLocked);

	TheTable.Close();

	test2 (db.Execute(KDropTable1),KErrLocked);	// cannot lock

	test2 (TheTable.Open(TheDatabase,KTable1),KErrNone);

	TRAP(r,TheTable.InsertL());		// we own the lock

	test2 (r,KErrNone);

	TheTable.Cancel();

	TheTable.Close();

	test2 (TheDatabase.Execute(KDropTable1),KErrNone);

	test2 (stat.Int(),KRequestPending);	// no NotifyUnlock yet

	test2 (TheDatabase.Commit(),KErrNone);

	User::WaitForRequest(stat);

	test2 (stat.Int(),ob.ECommit);

//

	ob.Close();

	db.Close();

	TheDatabase.Close();

	Disconnect();

	test.End();

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-0609

@SYMTestCaseDesc        Tests for sharing a database

@SYMTestPriority        Medium

@SYMTestActions         Tests for opening a database more than once.

                        Tests the integrity of the table data

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestShareL()

	{

	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0609 Open database "));

	Connect();

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

	test (r==KErrNone);

	Execute(KCreateTable1);

	test.Next(_L("Open it again"));

	RDbNamedDatabase db;

	test (db.Open(TheDbs,KTestDatabase,KTestFormat)==KErrNone);

	test (TheTable.Open(db,KTable1)==KErrNone);

	test2 (TheTable.ColCount(),4);

	test2 (TheTable.ColType(1),EDbColInt32);

	test2 (TheTable.ColType(2),EDbColText);

	test2 (TheTable.ColType(3),EDbColLongText);

	test2 (TheTable.ColType(4),EDbColLongBinary);

	delete TheTable.ColSetL();

	TheTable.Close();

//

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

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

	WriteRecordsL(KRowCount);

	TheTable.Close();

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

	TheDatabase.Close();

	TheDatabase=db;

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

	test (TheTable.AtBeginning());

	test (!TheTable.AtRow());

	test (!TheTable.AtEnd());

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

	IterateL(TheTable.ENext);

	test (!TheTable.AtBeginning());

	test (!TheTable.AtRow());

	test (TheTable.AtEnd());

	test.Next(_L("Delete rows"));

	test (DeleteSQL()==KRowCount);

	TheTable.Close();

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

	Execute(KDropTable1);

	TheDatabase.Close();

	Disconnect();

	test.End();

	}

LOCAL_C void TestScenario1L()

	{

	test.Start(_L("Take stream-lock on client 2"));

	test (TheView.FirstL());

	TheView.GetL();

	RDbColReadStream rcol;

	rcol.OpenLC(TheView,3);

	test2 (rcol.ReadUint16L(),0);

	test.Next(_L("Take a [shared] transaction-lock on client 1"));

	test2 (TheDatabase.Begin(),KErrNone);

	test.Next(_L("Attempt a write-lock on client 1"));

	TRAPD(r,TheTable.InsertL());

	test2 (r,KErrLocked);

	test2 (rcol.ReadUint16L(),1);

	test.Next(_L("Release locks on client 1 and then 2"));

	TheDatabase.Rollback();

	CleanupStack::PopAndDestroy();	// rcol

	test.End();

	}

LOCAL_C void TestScenario2L()

	{

	test.Start(_L("Take stream-lock on client 2"));

	test (TheView.FirstL());

	TheView.GetL();

	RDbColReadStream rcol;