// 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 "t_dbstress.h"

//#define __DUMP_STATE

#if defined(__WINS__)

//#define _INSTALL_FILE_SYSTEM

#endif

GLDEF_D RTest TheTest(_L("t_dbstress: Stress testing DBMS"));

GLDEF_D TPtrC KTestDir=_S("\\DBMS-TST\\");

GLDEF_D TPtrC KLogFile=_L("T_STRESS.LOG");

GLDEF_D TPtrC KTestDatabase=_S("T_STRESS.DB");

GLDEF_D TInt NewCount,OldCount;

GLDEF_D TInt TransId;

GLDEF_D Timer RunTimer;

LOCAL_D RFs TheFs;

LOCAL_D RThread TheThread;

LOCAL_D TRequestStatus TheStatus;

LOCAL_D RDbStoreDatabase TheDatabase;

LOCAL_D RDbView Accs;

LOCAL_D RDbView Trans;

LOCAL_D RDbTable TheTable;

LOCAL_D TInt Shot,ShotDuringCommit;

LOCAL_D TInt64 RunningTime(1);

LOCAL_D Timer Stopwatch;

#ifdef __DUMP_STATE

const TPtrC KDumpFile=_S("T_STRESS.DMP");

#endif

const TInt KTestCleanupStack=0x20;

void Timer::Start()

	{

	iTime.UniversalTime();

	}

TInt64 Timer::Stop()

	{

	TTime t;

	t.UniversalTime();

	return ((t.MicroSecondsFrom(iTime).Int64()) + 500)/1000;

	}

void Timer::Print()

	{

	TInt64 milli=Stop();

	TheTest.Printf(_L("  %u milliseconds\n"), I64LOW(milli) );

	}

class Set

	{

public:

	struct SColDef

		{

		const TDesC* iName;

		TDbColType iType;

		TInt iAttributes;

		};

public:

	static CDbColSet* CreateL(const SColDef* aDef);

	};

CDbColSet* Set::CreateL(const SColDef* aDef)

	{

	CDbColSet *set=CDbColSet::NewLC();

	for (;aDef->iName!=NULL;++aDef)

		{

		TDbCol col(*aDef->iName,aDef->iType);

		col.iAttributes=aDef->iAttributes;

		set->AddL(col);

		}

	CleanupStack::Pop();

	return set;

	}

// Accounts table

const TPtrC KAccounts=_S("ACCOUNTS");

const TPtrC KAccountsID=_S("ID");

const TPtrC KAccountsBalance=_S("BALANCE");

const TPtrC KAccountsStatement=_S("STATEMENT_BALANCE");

Set::SColDef const AccountsDef[]=

	{

	{&KAccountsID,EDbColInt32,TDbCol::ENotNull},

	{&KAccountsBalance,EDbColInt32,TDbCol::ENotNull},

	{&KAccountsStatement,EDbColInt32,TDbCol::ENotNull},

	{0}

	};

const TInt KInitialCash=100000;

const TInt KInitialBalance=1000;

// Transaction table

const TPtrC KTransactions=_S("TRANSACTIONS");

const TPtrC KTransactionDate=_S("T_DATE");

const TPtrC KTransactionFrom=_S("FROM_ID");

const TPtrC KTransactionTo=_S("TO_ID");

const TPtrC KTransactionAmount=_S("AMOUNT");

Set::SColDef const TransactionsDef[]=

	{

//	{&KTransactionDate,EDbColDateTime,TDbCol::ENotNull},

	{&KTransactionDate,EDbColInt32,TDbCol::ENotNull},

	{&KTransactionFrom,EDbColInt32,TDbCol::ENotNull},

	{&KTransactionTo,EDbColInt32,TDbCol::ENotNull},

	{&KTransactionAmount,EDbColInt32,TDbCol::ENotNull},

	{0}

	};

LOCAL_D TInt32 TotalMonies;

LOCAL_D TBuf<100> Buf;

GLDEF_C TInt Random(TInt aRange)

	{

	return (Math::Random()>>11)%aRange;

	}

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

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

TPtrC FileName(const TText* aFile)

    {

    TPtrC p(aFile);

    TInt ix=p.LocateReverse('\\');

    if (ix<0)

        ix=p.LocateReverse('/');

    if (ix>=0)

        p.Set(p.Mid(1+ix));

    return p;

    }

//Test macros and functions

void Check1(TInt aValue, const TText* aFile, TInt aLine)

    {

    if(!aValue)

        {

        TPtrC fname(FileName(aFile));

        TheTest.Printf(_L("*** Expression evaluated to false. %S-%d\r\n"), &fname, aLine);

        TheTest(EFalse, aLine);

        }

    }

void Check2(TInt aValue, TInt aExpected, const TText* aFile, TInt aLine)

    {

    if(aValue != aExpected)

        {

        TPtrC fname(FileName(aFile));

        TheTest.Printf(_L("*** Expected %d, got %d. %S-%d\r\n"), aExpected, aValue, &fname, aLine);

        TheTest(EFalse, aLine);

        }

    }

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

LOCAL_C void CreateIndexL(RDbDatabase& aDatabase,const TDesC& aTable,const TDesC& aColumn,TBool aUnique)

	{

	CDbKey* key=CDbKey::NewLC();

	key->AddL(aColumn);

	if (aUnique)

		key->MakeUnique();

	TEST2(aDatabase.CreateIndex(aColumn,aTable,*key),KErrNone);

	CleanupStack::PopAndDestroy();

	}

//

// Create the database

//

LOCAL_C void CreateDatabaseL()

	{

	CFileStore* store=CPermanentFileStore::ReplaceLC(TheFs,KTestDatabase,EFileRead|EFileWrite);

	store->SetTypeL(KPermanentFileStoreLayoutUid);

	store->SetRootL(TheDatabase.CreateL(store));

//	create the tables

	TheDatabase.Begin();

	CDbColSet* set=Set::CreateL(AccountsDef);

	TEST2(TheDatabase.CreateTable(KAccounts,*set),KErrNone);

	delete set;

	CreateIndexL(TheDatabase,KAccounts,KAccountsID,ETrue);

	CreateIndexL(TheDatabase,KAccounts,KAccountsBalance,EFalse);

	set=Set::CreateL(TransactionsDef);

	TEST2(TheDatabase.CreateTable(KTransactions,*set),KErrNone);

	delete set;

	CreateIndexL(TheDatabase,KTransactions,KTransactionDate,EFalse);

	TEST2(TheDatabase.Commit(),KErrNone);

	OldCount=NewCount=0;

// prepare Accs table

	TheDatabase.Begin();

	TEST2(Accs.Prepare(TheDatabase,_L("select * from accounts"),Accs.EInsertOnly),KErrNone);

	Accs.InsertL();

	Accs.SetColL(1,TInt32(ECash));

	Accs.SetColL(2,KInitialCash);

	Accs.SetColL(3,KInitialCash);

	Accs.PutL();

	TotalMonies=KInitialCash;

	for (TInt ii=EJohn;ii<=EPenny;++ii)

		{

		Accs.InsertL();

		Accs.SetColL(1,ii);

		Accs.SetColL(2,KInitialBalance);

		Accs.SetColL(3,KInitialBalance);

		Accs.PutL();

		TotalMonies+=KInitialBalance;

		}

	TEST2(TheDatabase.Commit(),KErrNone);

	Accs.Close();

	TheDatabase.Close();

	CleanupStack::PopAndDestroy();	// store

	}

#ifdef __DUMP_STATE

LOCAL_C void DumpStateL()

	{

	RFile file;

	CleanupClosePushL(file);

	User::LeaveIfError(file.Replace(TheFs,KLogFile,EFileWrite|EFileStreamText));

	RDbRowSet::RConstraint match;

	CleanupClosePushL(match);

	for (TInt id=ECash;id<=EPenny;++id)

		{

		Buf.Format(_L("id=%d"),id);

		Accs.FirstL();

		TEST(Accs.FindL(Accs.EForwards,Buf)>=0);

		Accs.GetL();

		TInt balance=Accs.ColInt(2);

		Buf.Format(_L("\nStatement for account %d: Previous balance %d\n"),id,balance);

		User::LeaveIfError(file.Write(Buf));

		Buf.Format(_L("from_id=%d or to_id=%d"),id,id);

		User::LeaveIfError(match.Open(Trans,Buf));

		for (Trans.BeginningL();Trans.NextL();)

			{

			if (Trans.MatchL(match))

				{

				Trans.GetL();

				TInt from=Trans.ColInt(2);

				TInt amount=Trans.ColInt(4);

				Buf.Format(_L("%04d: %6s %5d\n"),Trans.ColInt(1),from==id?_S("debit"):_S("credit"),amount);

				User::LeaveIfError(file.Write(Buf));

				if (from==id)

					balance-=amount;

				else

					balance+=amount;

				}

			}

		Buf.Format(_L("Closing balance %d\n"),balance);

		User::LeaveIfError(file.Write(Buf));

		Buf.Format(_L("Account balance %d\n"),Accs.ColInt(3));

		User::LeaveIfError(file.Write(Buf));

		}

	CleanupStack::PopAndDestroy(2);

	TEST(0);

	}

#endif

//

// Check that the database structure is fully intact

//

LOCAL_C void VerifyDatabaseL(CPersistentStore& aStore)

	{

	TheDatabase.OpenL(&aStore,aStore.Root());

// check any indexes

	TEST2(TheTable.Open(TheDatabase,KAccounts,TheTable.EReadOnly),KErrNone);

	TEST2(TheTable.CountL(),KAccountIDs);

	TInt r=TheTable.SetIndex(KAccountsID);

	if (r!=KErrCorrupt)

		{

		TEST2(r,KErrNone);

		TEST2(TheTable.CountL(),KAccountIDs);

		for (TInt id=ECash;id<=EPenny;++id)

			{

			TEST(TheTable.NextL());

			TheTable.GetL();

			TEST2(TheTable.ColInt(1),id);

			}

		TEST(!TheTable.NextL());

		}

	r=TheTable.SetIndex(KAccountsBalance);

	if (r!=KErrCorrupt)

		{

		TEST2(r,KErrNone);

		TEST2(TheTable.CountL(),KAccountIDs);

		TEST(TheTable.FirstL());

		TheTable.GetL();

		TInt last=TheTable.ColInt(2);

		for (TInt ii=1;ii<KAccountIDs;++ii)

			{

			TEST(TheTable.NextL());

			TheTable.GetL();

			TInt bal=TheTable.ColInt(2);

			TEST(bal>=last);

			last=bal;

			}

		TEST(!TheTable.NextL());

		}

	TheTable.Close();

	TEST2(TheTable.Open(TheDatabase,KTransactions,TheTable.EReadOnly),KErrNone);

	TInt count=TheTable.CountL();

	r=TheTable.SetIndex(KTransactionDate);

	if (r!=KErrCorrupt)

		{

		TEST2(r,KErrNone);

		TEST2(TheTable.CountL(),count);

		if (count)

			{

			TEST(TheTable.FirstL());

			TheTable.GetL();

			TInt last=TheTable.ColInt(1);

			while (--count!=0)

				{

				TEST(TheTable.NextL());

				TheTable.GetL();

				TInt date=TheTable.ColInt(1);

				TEST(date>last);

				last=date;

				}

			TEST(!TheTable.NextL());

			}

		else

			TEST(!TheTable.FirstL());

		}

	TheTable.Close();

// verify database integrity

	TInt balance[KAccountIDs];

	TEST2(Accs.Prepare(TheDatabase,_L("select id,statement_balance,balance from accounts"),Accs.EReadOnly),KErrNone);

	TEST2(Accs.CountL(),KAccountIDs);

	while (Accs.NextL())

		{

		Accs.GetL();

		TInt id=Accs.ColInt(1);

		balance[id]=Accs.ColInt(2);

		}

	TEST2(Trans.Prepare(TheDatabase,_L("select t_date,from_id,to_id,amount from Transactions"),Trans.EReadOnly),KErrNone);

	TInt transact=0;

	while (Trans.NextL())

		{

		++transact;

		Trans.GetL();

		TInt from=Trans.ColInt(2);

		TInt to=Trans.ColInt(3);

		TInt amount=Trans.ColInt(4);

		balance[from]-=amount;

		balance[to]+=amount;

		}

	TEST2(transact,Trans.CountL());

	if (NewCount!=-1 && transact!=NewCount)

		{

		TEST2(transact,OldCount);

		++ShotDuringCommit;

		}

	OldCount=NewCount=transact;

	TInt total=0;

	for (Accs.BeginningL();Accs.NextL();)

		{

		Accs.GetL();

		TInt id=Accs.ColInt(1);

#ifdef __DUMP_STATE

		if (balance[id]!=Accs.ColInt(3))

			DumpStateL();

#else

		TEST(balance[id]==Accs.ColInt(3));

#endif

		total+=balance[id];

		}

	TEST2(total,TotalMonies);

	Trans.Close();

	Accs.Close();

	TheDatabase.Close();

	}

LOCAL_C TInt Verify(CPersistentStore& aStore)

	{

	TRAPD(r,VerifyDatabaseL(aStore));

	return r;

	}

LOCAL_C TInt Recover(CPersistentStore& aStore)

	{

	TRAPD(r,TheDatabase.OpenL(&aStore,aStore.Root()));

	if (r==KErrNone)

		{

		r=TheDatabase.Recover();

		TheDatabase.Close();

		}

	return r;

	}

LOCAL_C void CompactL(CStreamStore& aStore)

	{

	TInt t=aStore.ReclaimL();

	Stopwatch.Start();

	t-=aStore.CompactL();

	TheTest.Printf(_L("  compacted %d byte(s) in"),t);

	Stopwatch.Print();

	aStore.CommitL();

	}

LOCAL_C TInt Compact(CStreamStore& aStore)

	{

	TRAPD(r,CompactL(aStore));

	return r;

	}

LOCAL_C TInt EndThread()

	{

	RunningTime+=RunTimer.Stop();

	if (TheStatus==KRequestPending)

		TheThread.Kill(1);

	User::WaitForRequest(TheStatus);

	TInt r;

	if (TheThread.ExitType()==EExitKill)

		r=TheThread.ExitReason();

	else

		r=TheStatus.Int();

	TheThread.Close();

	return r;

	}

//aTestExecutionTime - desired test execution time in minutes

LOCAL_C void RunTestL(TInt aTestExecutionTime = 0)

	{

	__ASSERT_ALWAYS(aTestExecutionTime >= 0, User::Invariant());

	RThread().SetPriority(EPriorityMore);

	TheTest.Start(_L("Create the database"));

	CreateDatabaseL();

	TTimeIntervalMinutes timeInterval(aTestExecutionTime);

	TTime timeCurrent;

	timeCurrent.UniversalTime();

	TTime timeEnd(timeCurrent);

	timeEnd += timeInterval;

	for (TBool condition=ETrue; condition; condition = aTestExecutionTime > 0 ? (timeCurrent < timeEnd) : ETrue)

		{

		TheTest.Next(_L("Main loop"));

		TheTest.Start(_L("Kick off the thread"));

		TEST2 (StartThread(TheThread,TheStatus),KErrNone);

		// random delay

		for (;;)

			{

			User::After(95000);

			if (TheStatus!=KRequestPending)

				break;

			if (Random(1000)<30)

				break;

			}

		TheTest.Next(_L("End the thread"));

		TInt exit=EndThread();

		if (exit!=1)

		    TheTest.Printf(_L("  thread failed with error %d\n"),exit);

//

		++Shot;

		CFileStore* store=NULL;

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

			{

			TheTest.Printf(_L("Opening %d\r"),ii);

			TRAPD(r,store=CFileStore::OpenL(TheFs,KTestDatabase,EFileRead|EFileWrite|EFileWriteDirectIO));

			if (r==KErrNone)

				break;

			TEST2(r, KErrInUse);

			User::After(100000);

			}

		TheTest.Next(_L("Verify & Recover"));

		TEST2 (Verify(*store),KErrNone);

		TInt64 tps(TransId);

		tps*=1000u;

		tps/=RunningTime;

		TheTest.Printf(_L("    Iteration %d, TPS %d, during commit %d%%\n"),Shot,I64LOW(tps),(100*ShotDuringCommit)/Shot);

		TInt r=Recover(*store);

		if (r==KErrNoMemory || r==KErrDiskFull)

			{	// need to compact before completing recovery

			TheTest.Next(_L("No space, compacting"));

			TEST2 (Compact(*store),KErrNone);

			TheTest.Next(_L("Verify & Recover again"));

			TEST2 (Verify(*store),KErrNone);

			r=Recover(*store);

			}

		TEST2 (r,KErrNone);

		TheTest.Next(_L("Verify & Compact"));

//		TEST2 (Verify(*store),KErrNone);

		TEST2 (Compact(*store),KErrNone);

		TheTest.Next(_L("Verify"));

		TEST2 (Verify(*store),KErrNone);

//

		delete store;

		TheTest.End();

		timeCurrent.UniversalTime();

		}

	TheTest.End();

	}

/**

@SYMTestCaseID          SYSLIB-DBMS-CT-0636

@SYMTestCaseDesc        DBMS stess testing.

@SYMTestPriority        Medium

@SYMTestActions         Tests for verifying the database integrity.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

static void RunVerify()

	{

	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0636 Open store "));

	CFileStore* store=NULL;

	TRAPD(r,store=CFileStore::OpenL(TheFs,KTestDatabase,EFileRead|EFileWrite|EFileWriteDirectIO));

	TEST2 (r,KErrNone);

	TheTest.Next(_L("Verify"));

	NewCount=-1;

	TotalMonies=KInitialCash + (EPenny-EJohn+1)*KInitialBalance;

	TEST2 (Verify(*store),KErrNone);

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

	TEST2 (Recover(*store),KErrNone);

	TheTest.Next(_L("Verify"));

	TEST2 (Verify(*store),KErrNone);

	delete store;

	TheTest.End();

	}

//

// Prepare the test directory.

//

LOCAL_C void setupTestDirectory()

    {

	TInt r=TheFs.Connect();

	TEST2(r,KErrNone);

//

	r=TheFs.MkDir(KTestDir);

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

	r=TheFs.SetSessionPath(KTestDir);

	TEST2(r,KErrNone);

	}

//

// Initialise the cleanup stack.

//

LOCAL_C CTrapCleanup* setupCleanup()

    {

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TEST(cleanup!=NULL);

	TRAPD(r,\

		{\

		for (TInt i=KTestCleanupStack;i>0;i--)\

			CleanupStack::PushL((TAny*)0);\

		CleanupStack::Pop(KTestCleanupStack);\

		});

	TEST2(r,KErrNone);

	return cleanup;

	}

//

// entry point

//

// Parameters usage:

//	t_stress [-v]|[0]|[<positive number>]

// Where:

//	-v - a verification test will be run;

//	0  - a stress test will be run for indefinite time;

//	<positive number>  - a stress test will be run for <positive number> minutes;

// If the test is run without arguments, the test execution time will be 10 minutes

// (KDefaultTestExecutionTime constant bellow).

GLDEF_C TInt E32Main()

    {

    TheTest.Title();

	setupTestDirectory();

	CTrapCleanup* cleanup=setupCleanup();

	__UHEAP_MARK;

//

	TBuf<100> cmd;

    User::CommandLine(cmd);

	TLex lex(cmd);

	TInt err = KErrNone;

	for(;;)

		{

		TPtrC arg(lex.NextToken());

		if(arg.Length() == 0)

			{

			const TInt KDefaultTestExecutionTime = 10;//default test execution time - minutes

			TRAP(err, RunTestL(KDefaultTestExecutionTime));

			break;

			}

		else if(arg.CompareF(_L("-v")) == 0)

			{

			RunVerify();

			break;

			}

		else

			{

			TInt32 testExecutionTime = 0;

			lex.Assign(arg);

			(void)lex.Val(testExecutionTime);

			TRAP(err, RunTestL(testExecutionTime));

			break;

			}

		}

	TInt err2 = TheFs.Delete(KTestDatabase);

	if(err2 != KErrNone)

		{

		RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err2, &KTestDatabase);

		}

	err2 = TheFs.Delete(KLogFile);

	if(err2 != KErrNone)

		{

		RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err2, &KLogFile);

		}

	TEST2(err, KErrNone);

//

	__UHEAP_MARKEND;

	delete cleanup;

	TheFs.Close();

	TheTest.Close();

	return 0;

    }