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