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

// Test code for bugs that have been fixed, to help prevent regression

// 

//

#include <d32dbms.h>

#include <f32file.h>

#include <e32test.h>

#include <s32mem.h>

#include "crccheck.h"

#undef __UHEAP_MARK

#undef __UHEAP_MARKEND

#define __UHEAP_MARK

#define __UHEAP_MARKEND

LOCAL_D TDBMS_CRCChecks TheCrcChecker;

#ifndef __linux__ //No CRC test on LINUX

#ifdef __TOOLS2__

const TPtrC	KCrcRecord=_L("\\epoc32\\winscw\\c\\dbms-tst\\T_BUG.CRC");

#else

const TPtrC	KCrcRecord=_L("C:\\dbms-tst\\T_BUG.CRC");

#endif

#endif

LOCAL_D RTest test(_L("T_BUG"));

LOCAL_D CTrapCleanup* TheTrapCleanup;

LOCAL_D RFs TheFs;

LOCAL_D RDbNamedDatabase TheDatabase;

const TInt KTestCleanupStack=0x40;

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

static void Print(const TText* aString)

	{

	test.Printf(_L("%s\n"),aString);

	}

////////////////////////////////////////////

#ifdef __TOOLS2__

const TPtrC KTestDatabase=_L(".\\dbms-tst\\t_bug.db");

#else

const TPtrC KTestDatabase=_L("C:\\dbms-tst\\t_bug.db");

#endif

_LIT(KTableA,"A");

_LIT(KTableB,"B");

_LIT(KTableC,"C");

class Defect_590829

	{

public:

	static void TestL();

	static const TDesC& Name();

	};

const TDesC& Defect_590829::Name()

	{

	_LIT(KName,"590829");

	return KName;

	}

/////////////////////////////////////////////////

// Length of text data used for each entry. This will be

// equivalent to 400 bytes for ansi characters. The number of

// bytes must not be less than 256 (or 128 for this const).

// If it is a stream will not be used for transfer of data.

const TInt KTextDataLength = 200;

// max column size

const TInt KMaxColLength = 1000;

// Buffer size to cause HDbsBuf::DoReadL() ipc check to be executed

const TInt KBufSizeDoReadL = 1000;

// Buffer size to cause HDbsBuf::UnderflowL() ipc check to be executed

const TInt KBufSizeUnderflowL = 500;

class Defect_071149

	{

public:

	static void TestL();

	static const TDesC& Name();

	};

const TDesC& Defect_071149::Name()

	{

	_LIT(KName,"071149");

	return KName;

	}

/**

HDbsBuf did not handle case when iIpc.iHandle is 0 causing IPC calls to panic.

The handle is 0 when opening a stream and all data is retrieved in this request.

@SYMTestCaseID			SYSLIB-DBMS-CT-1491

@SYMTestCaseDesc		Tests for defect number 590829

@SYMTestPriority			High

@SYMTestActions			Tests by setting up failure conditions.

@SYMTestExpectedResults	Test must not fail

@SYMDEF				INC071149

*/

void Defect_071149::TestL()

	{

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

	Print(_S("Creating test database"));

	// Connect to dbms and open db

	RDbs dbs;

	RDbNamedDatabase db;

	test2 (db.Replace(TheFs,KTestDatabase),KErrNone);

	db.Close();

	TheCrcChecker.GenerateCrcL(KTestDatabase);

#ifndef __TOOLS2__

	test2(dbs.Connect(), KErrNone);

#endif

	test2(db.Open(dbs,KTestDatabase), KErrNone);

	// creating column to hold LongText

	CDbColSet *colSet = CDbColSet::NewL();

	CleanupStack::PushL(colSet);

	colSet->AddL(TDbCol(_L("Id"), EDbColLongText, KMaxColLength));

	// create table

	test2(db.CreateTable(KTableA, *colSet), KErrNone);

	CleanupStack::PopAndDestroy(colSet);

	// create text data to add to table	

	HBufC* testText = HBufC::New(KTextDataLength);

	test(testText !=NULL );

	TPtr ptr = testText->Des();

	for(TInt y=0;y<KTextDataLength;++y)

		{

		ptr.Append(TChar('A'));

		}

	// add data to table

	RDbTable newTable;

	test2 (newTable.Open(db,KTableA),KErrNone);

	db.Begin();

	newTable.InsertL();

	newTable.SetColL(1, ptr);

	newTable.PutL();

	test2 (db.Commit(),KErrNone);

	test2 (newTable.CountL(), 1);

	newTable.Close();

	// cleanup

	delete testText;

	// disconnect from db and dbms

	db.Close();

	TheCrcChecker.GenerateCrcL(KTestDatabase);

#ifndef __TOOLS2__

	dbs.Close();

#endif

//

	// Connect to dbms and open db

#ifndef __TOOLS2__

	test2(dbs.Connect(), KErrNone);

#endif

	test2(db.Open(dbs,KTestDatabase), KErrNone);

	// Test handle check in HDbsBuf::DoReadL() - See defect

	// If the handle check did not exist in the production code then

	// it would panic.

	// create test table

	RDbTable testTable;

	test2 (testTable.Open(db,KTableA),KErrNone);

	db.Begin();

	testTable.FirstL();

	testTable.GetL();

	// Open stream

	RDbColReadStream rs;

    	rs.OpenLC( testTable, 1);

	// Read data

	TBuf<KBufSizeDoReadL> buf;

	TRAPD(err, rs.ReadL( buf, buf.MaxLength()));

	if(err != KErrNone)

		{

		test2(err, KErrEof);

		}

	CleanupStack::PopAndDestroy();  // Close rs

	testTable.Close();

//

	// Test handle check in HDbsBuf::UnderflowL() - additional error not in defect

	// If the handle check did not exist in the production code then

	// it would panic.

	// create test table

	test2 (testTable.Open(db,KTableA),KErrNone);

	testTable.NextL();

	testTable.GetL();

	// Open stream

	RDbColReadStream rs2;

    	rs2.OpenLC( testTable, 1);

	// Read data

	TBuf<KBufSizeUnderflowL> buf2;

	TRAP(err, rs2.ReadL( buf2, buf2.MaxLength()));

	if(err != KErrNone)

		{

		test2(err, KErrEof);

		}

	CleanupStack::PopAndDestroy();  // Close rs

	// tidy up

	testTable.Close();

	db.Close();

#ifndef __TOOLS2__

	dbs.Close();

#endif

	}

/////////////////////////////////////////////////

/**

Cached, unused tables were breaking the iterator in CDbTableDatabase::CheckIdle

The latter function has been re-written to restart the iteration when tables are Idle()'d

@SYMTestCaseID          SYSLIB-DBMS-CT-0582

@SYMTestCaseDesc        Tests for defect number 590829

@SYMTestPriority        Medium

@SYMTestActions        	Tests by setting up failure conditions.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

void Defect_590829::TestL()

	{

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

	Print(_S("Creating test database"));

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

	TheDatabase.Begin();

	test2 (TheDatabase.Execute(_L("create table A (id counter)")),KErrNone);

	test2 (TheDatabase.Execute(_L("create table B (id counter)")),KErrNone);

	test2 (TheDatabase.Execute(_L("create table C (id counter)")),KErrNone);

	test2 (TheDatabase.Commit(),KErrNone);

//

	Print(_S("Setting up failure"));

	RDbTable tA,tB,tC;

	test2 (tA.Open(TheDatabase,KTableA),KErrNone);

	test2 (tB.Open(TheDatabase,KTableB),KErrNone);

	tB.Close();

	test2 (tC.Open(TheDatabase,KTableC),KErrNone);

	tC.Close();

	TheDatabase.Begin();

	tA.Close();

//

	Print(_S("Testing fix"));

	test2 (TheDatabase.Commit(),KErrNone);

	TheDatabase.Destroy();

	}

/////////////////////////////////////////////////

#ifndef TOOLS2_VARIANT

class Defect_394751

	{

public:

	static void TestL();

	static const TDesC& Name();

private:

	static TInt Thread(TAny*);

	static void ThreadL();

	};

const TDesC& Defect_394751::Name()

	{

	_LIT(KName,"394751");

	return KName;

	}

void Defect_394751::ThreadL()

	{

	RDbs dbs;

	RDbNamedDatabase db;

	User::LeaveIfError(dbs.Connect());

	User::LeaveIfError(db.Open(dbs,KTestDatabase));

	db.Begin();

	db.Begin();	/// panic now

	User::Panic(_L("T_BUG failure"),0);

	}

TInt Defect_394751::Thread(TAny*)

	{

	User::SetJustInTime(EFalse);	// disable debugger panic handling

	CTrapCleanup* cleanup=CTrapCleanup::New();

	if (!cleanup)

		return KErrNoMemory;

	TRAPD(r,ThreadL());

	delete cleanup;

	return r;

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-0583

@SYMTestCaseDesc        Tests for defect number 394751 

@SYMTestPriority        Medium

@SYMTestActions        	Tests for thread exit status.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

void Defect_394751::TestL()

//

//

	{

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

	Print(_S("Creating test database"));

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

	TheDatabase.Close();

	TheCrcChecker.GenerateCrcL(KTestDatabase);

//

	RDbs dbs;

	test2 (dbs.Connect(),KErrNone);

//

	Print(_S("Running test thread"));

	RThread t;

	_LIT(KTestThread,"Defect Fix 394751");

	test2 (t.Create(KTestThread,&Thread,0x2000,0x1000,0x10000,0,EOwnerThread),KErrNone);

	TRequestStatus s;

	t.Logon(s);

	test2 (s.Int(),KRequestPending);

	t.Resume();

	Print(_S("Awaiting completion"));

	User::WaitForRequest(s);

	_LIT(KCategory,"DBMS-Table");

	test2 (t.ExitType(),EExitPanic);

	test (t.ExitCategory()==KCategory);

	test2 (t.ExitReason(),11);		// begin nested transaction

	User::SetJustInTime(ETrue);	// enable debugger panic handling

	t.Close();

//

	test2 (dbs.ResourceCount(),0);

	dbs.Close();

	}

#endif

///////////////////////////////////////////////////////////

#ifndef TOOLS2_VARIANT

class Defect_COMBBAR_463J5D

	{

public:

	static void TestL();

	static const TDesC& Name();

private:

	static void WaitForServerExit();

	static TInt Thread(TAny*);

	};

const TDesC& Defect_COMBBAR_463J5D::Name()

	{

	_LIT(KName,"COMBBAR_463J5D");

	return KName;

	}

void Defect_COMBBAR_463J5D::WaitForServerExit()

	{

	_LIT(KDbmsServer,"*!DBMS server");

	TFullName n;

	TFindThread ft(KDbmsServer);

	if (ft.Next(n)==KErrNone)

		{

		RThread t;

		if (t.Open(ft)==KErrNone)

			{

			TRequestStatus s;

			t.Logon(s);

			User::WaitForRequest(s);

			t.Close();

			}

		}

	}

TInt Defect_COMBBAR_463J5D::Thread(TAny*)

//

// Just try to start the server

//

	{

	RDbs dbs;

	return dbs.Connect();

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-0584

@SYMTestCaseDesc        Tests for defect number COMBBAR_463J5D  

@SYMTestPriority        Medium

@SYMTestActions        	Testing that defect COMBBAR_463J5D in ER5 Defects database has been fixed

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

void Defect_COMBBAR_463J5D::TestL()

	{

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

	Print(_S("Wait for the server to exit"));

	WaitForServerExit();

//

	Print(_S("Create the launching threads"));

	RThread t1,t2;

	TRequestStatus s1,s2;

	_LIT(KThread1,"t1");

	test2 (t1.Create(KThread1,&Thread,0x2000,0,0,EOwnerThread),KErrNone);

	t1.SetPriority(EPriorityLess);

	t1.Logon(s1);

	_LIT(KThread2,"t2");

	test2 (t2.Create(KThread2,&Thread,0x2000,0,0,EOwnerThread),KErrNone);

	t2.SetPriority(EPriorityLess);

	t2.Logon(s2);

//

	Print(_S("Run the threads and wait"));

	t1.Resume();

	t2.Resume();

	User::WaitForRequest(s1,s2);

	if (s1==KRequestPending)

		User::WaitForRequest(s1);

	else

		User::WaitForRequest(s2);

//

	test2 (t1.ExitType(),EExitKill);

	if (s1.Int()!=KErrNotFound)

		test2 (s1.Int(),KErrNone);

	test2 (t2.ExitType(),EExitKill);

	if (s2.Int()!=KErrNotFound)

		test2 (s2.Int(),KErrNone);

	t1.Close();

	t2.Close();

	}

#endif

/////////////////////////////////////////////////////////

class Defect_EDNATHE_48AEZW

	{

public:

	static void TestL();

	static const TDesC& Name();

	};

const TDesC& Defect_EDNATHE_48AEZW::Name()

	{

	_LIT(KName,"EDNATHE_48AEZW");

	return KName;

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-0585

@SYMTestCaseDesc        Tests for defect number EDNATHE_48AEZW  

@SYMTestPriority        Medium

@SYMTestActions        	Tests for navigation and deletion 

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

void Defect_EDNATHE_48AEZW::TestL()

	{

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

	Print(_S("Set up database"));

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

	test2 (TheDatabase.Begin(),KErrNone);

	test2 (TheDatabase.Execute(_L("create table A (id counter)")),KErrNone);

	RDbView v1;

	test2 (v1.Prepare(TheDatabase,_L("select * from A"),v1.EInsertOnly),KErrNone);

	test2 (v1.EvaluateAll(),KErrNone);

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

		{

		v1.InsertL();

		v1.PutL();

		}

	test2 (TheDatabase.Commit(),KErrNone);

	v1.Close();

//

	Print(_S("test navigation"));

	test2 (v1.Prepare(TheDatabase,_L("select * from A where id=0")),KErrNone);

	test2 (v1.EvaluateAll(),KErrNone);

	v1.FirstL();

	RDbView v2;

	test2 (v2.Prepare(TheDatabase,_L("select * from A where id=1")),KErrNone);

	test2 (v2.EvaluateAll(),KErrNone);

	v2.FirstL();

	v2.DeleteL();

	TRAPD(r, v1.NextL());

	test2 (r,KErrNone);

	test (v1.AtEnd());

	v2.Close();

//

	Print(_S("test deletion"));

	v1.FirstL();

	test2 (v2.Prepare(TheDatabase,_L("select * from A where id=2")),KErrNone);

	test2 (v2.EvaluateAll(),KErrNone);

	v2.FirstL();

	v2.DeleteL();

	TRAP(r,v1.DeleteL());

	test2 (r,KErrNone);

	TRAP(r, v1.NextL());

	test2 (r,KErrNone);

	test (v1.AtEnd());

//

	v1.Close();

	v2.Close();

	TheDatabase.Close();

	TheCrcChecker.GenerateCrcL(KTestDatabase);

	}

/////////////////////////////////////////////////////////

static void NextTest(const TDesC& aName)

	{

	TBuf<80> buf;

	buf=_S("Checking Defect ");

	buf+=aName;

	test.Next(buf);

	}

template <typename T>

struct RunTest

	{

	RunTest()

		{

		const TDesC& name = T::Name();

		NextTest(name);

		TRAPD(r,T::TestL());

		test2 (r,KErrNone);

		Print(_S("Defect fixed"));

		}

	};

LOCAL_C void setupTestDirectory()

//

// Prepare the test directory.

//

    {

	TInt r=TheFs.Connect();

	test(r==KErrNone);

//

	r=TheFs.MkDir(KTestDatabase);

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

	}

LOCAL_C void setupCleanup()

//

// Initialise the cleanup stack.

//

    {

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

    {

	__UHEAP_MARK;

	test.Title();

	setupTestDirectory();

	setupCleanup();

	test.Start(_L("Verifying defect fixes"));

#ifndef TOOLS2_VARIANT

	RunTest<Defect_COMBBAR_463J5D>();

#else

	test.Printf(_L("Skipping defect test Defect_COMBBAR_463J5D\n"));

#endif

// The following short delay is needed for ccover builds only.

// Without the pause, the kernel scheduler would intermittently 

// crash 0.3s after the last test ended.

	User::After(500000);

	test.Printf(_L("Resume test after delay.\n"));

#ifndef TOOLS2_VARIANT

	RunTest<Defect_394751>();

	User::After(500000);

	test.Printf(_L("Resume test after delay.\n"));

#else

	test.Printf(_L("Skipping defect test of Defect_394751\n"));

#endif

	RunTest<Defect_590829>();

	User::After(500000);

	test.Printf(_L("Resume test after delay.\n"));

	RunTest<Defect_071149>();

	User::After(500000);

	test.Printf(_L("Resume test after delay.\n"));

	RunTest<Defect_EDNATHE_48AEZW>();

	test.Next(_L("Waiting for server exit"));

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

	User::After(KExitDelay);

	// clean up data files used by this test - must be done before call to End() - DEF047652

	::DeleteDataFile(KTestDatabase);

#ifndef __linux__

	TInt err;

#ifndef __TOOLS2__

	TRAPD(lc, err = TheCrcChecker.DumpCrcRecordsL(KCrcRecord));

	test(err==KErrNone);

	test(lc==KErrNone);

#else

	TRAPD(lc, err = TheCrcChecker.ValidateCrcRecordsL(KCrcRecord));

	TPtrC errmsg;

	TheCrcChecker.ErrorReportL(err, errmsg);

	RDebug::Print(errmsg);

	test(err==KErrNone || err==TDBMS_CRCChecks::ECrcCheckOk);

#endif // Tools2

#endif // Linux

	test.End();

//

	delete TheTrapCleanup;

	TheFs.Close();

	test.Close();

	__UHEAP_MARKEND;

	return 0;

    }