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

//

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

#include <d32dbms.h>

#include <s32file.h>

#include <e32test.h>

#include <e32math.h>

#include "crccheck.h"

#undef __UHEAP_MARK

#define __UHEAP_MARK

#undef __UHEAP_MARKEND

#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_TRANS.CRC");

#else

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

#endif

#endif

LOCAL_D RTest test(_L("T_TRANS - Test DBMS transactions"));

LOCAL_D CTrapCleanup* TheTrapCleanup;

LOCAL_D RDbTable TheTable;

LOCAL_D RFs TheFs;

#ifndef __TOOLS2__

LOCAL_D RDbs TheDbs;

#endif

LOCAL_D RDbNamedDatabase TheDatabase;

const TInt KTestCleanupStack=0x20;

#ifdef __TOOLS2__

const TPtrC KTestDatabase=_L(".\\dbms-tst\\T_TRANS.DB");

#else

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

#endif

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

const TPtrC KIndexInt=_S("int");

const TPtrC KIndexText=_S("text");

const TPtrC KColumnInt=_S("int");

const TPtrC KColumnText=_S("text");

const TPtrC KColumnComment=_S("comment");

const TPtrC KCommentValue=_S("abcdefghijklmnopqrstuvwxyz");

const TInt KRecords=2000;

class Progress

	{

	enum {ETotal=32};

public:

	Progress(TInt aCount);

	void Next(TInt aStep);

private:

	TInt iCount;

	TInt iPos;

	};

Progress::Progress(TInt aCount)

	: iCount(aCount),iPos(0)

	{}

void Progress::Next(TInt aStep)

	{

	TInt next=(ETotal*(iCount-aStep))/iCount;

	if (next!=iPos)

		{

		test.Printf(_L("."));

		iPos=next;

		}

	if (aStep==0)

		test.Printf(_L("\n"));

	}

LOCAL_C void ProgressInc(RDbIncremental& inc,TInt aCount)

	{

	Progress progress(aCount);

	while (aCount)

		{

		inc.Next(aCount);

		progress.Next(aCount);

		}

	inc.Close();

	}

LOCAL_C void CreateDatabaseL()

//

// Create the database

//

	{

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

	test (r==KErrNone);

	}

LOCAL_C void OpenDatabase()

//

// Create the database

//

	{

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

	test (r==KErrNone);

	}

LOCAL_C void CloseDatabaseL()

	{

	TheDatabase.Close();

	TheCrcChecker.GenerateCrcL(KTestDatabase);

	}

LOCAL_C void CreateTable()

	{

	TInt r=TheDatabase.Execute(_L("create table table (int integer,text varchar(8),comment varchar)"));

	test (r==KErrNone);

	}

LOCAL_C void WriteRecords(TInt aCount)

	{

	Progress write(aCount);

	TDbColNo cInt,cText,cComment;

	CDbColSet* set=TheTable.ColSetL();

	cInt=set->ColNo(KColumnInt);

	cText=set->ColNo(KColumnText);

	cComment=set->ColNo(KColumnComment);

	delete set;

	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(cInt,jj);

		text.Num(jj);

		TheTable.SetColL(cText,text);

		TheTable.SetColL(cComment,KCommentValue);

		TheTable.PutL();

		write.Next(aCount-ii-1);

		}

	}

LOCAL_C TUint FileSize()

	{

#ifndef __TOOLS2__

	TEntry entry;

	test(TheFs.Entry(KTestDatabase,entry)==KErrNone);

	return entry.iSize;

#else

	RFile myfile;

	test(myfile.Open(TheFs, KTestDatabase, EFileRead) == KErrNone);

	TInt size;

	test(myfile.Size(size) == KErrNone);

	myfile.Close();

	return size;

#endif

	}

LOCAL_C void BuildTable(TInt aCount,TBool aTransactions,TUint& aTime,TUint& aSize)

	{

	TUint size=FileSize();

	TUint time=User::TickCount();

	CreateTable();

	if (aTransactions)

		TheDatabase.Begin();

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

	WriteRecords(aCount);

	if (aTransactions)

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

	TheTable.Close();

	aTime=User::TickCount()-time;

	aSize=FileSize()-size;

	}

LOCAL_C void Execute(const TDesC& aSql)

	{

	RDbIncremental inc;

	TInt step;

	test(inc.Execute(TheDatabase,aSql,step)==KErrNone);

	ProgressInc(inc,step);

	}

LOCAL_C void BreakIndex()

	{

	TheDatabase.Begin();

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

	TheTable.InsertL();

	TheTable.SetColL(1,-1);

	TheTable.PutL();

	TheTable.Close();

	TheDatabase.Rollback();

	test(TheDatabase.IsDamaged());

	}

LOCAL_C void Recover()

	{

	RDbIncremental rec;

	TInt step;

	test(rec.Recover(TheDatabase,step)==KErrNone);

	ProgressInc(rec,step);

	test(!TheDatabase.IsDamaged());

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-0637

@SYMTestCaseDesc        Streaming conversions test

@SYMTestPriority        Medium

@SYMTestActions         Test the database definition and enquiry functions 

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void Test()

	{

	test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0637 Build without transactions "));

	CreateDatabaseL();

	TUint time1,size1;

	BuildTable(KRecords,EFalse,time1,size1);

	CloseDatabaseL();

	test.Next(_L("Build with transactions"));

	CreateDatabaseL();

	TUint time2,size2;

	BuildTable(KRecords,ETrue,time2,size2);

	test.Printf(_L("Transaction performance: time %4.2f, size %4.2f\n"),TReal(time1)/TReal(time2),TReal(size1)/TReal(size2));

	test.Next(_L("Build Int index"));

	Execute(_L("create unique index int on table (int)"));

	test.Next(_L("Break index"));

	BreakIndex();

	test.Next(_L("Build Text index"));

	Execute(_L("create unique index text on table (text)"));

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

	test (TheDatabase.IsDamaged());

	CloseDatabaseL();

	OpenDatabase();

	test (TheDatabase.IsDamaged());

	Recover();

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

	Execute(_L("drop table table"));

	CloseDatabaseL();

	}

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

    {

	test.Title();

	setupTestDirectory();

	setupCleanup();

	__UHEAP_MARK;

	TRAPD(r,Test();)

	test(r==KErrNone);

	test.Printf(_L("Waiting for server exit\n"));

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

	User::After(KExitDelay);

	//deletion of data files 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

#endif

	test.End();

//

	__UHEAP_MARKEND;

	delete TheTrapCleanup;

	TheFs.Close();

	test.Close();

	return 0;

    }