// Copyright (c) 2008-2010 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 <f32file.h>

#include <e32test.h>

#include <hal.h>

#include <stdlib.h>

#include <sqldb.h>

#include "sqlite3.h"

#include "SqliteSymbian.h"

#include "SqlSrvStatementUtil.h"

#include "SqlPanic.h"

#include "SqlCompact.h"

#include "SqlCompactConn.h"

#include "SqlCompactEntry.h"

const TInt KOperationCount = 20;

const TInt KFreePageThresholdKb = 5;

const TInt KFreePageThreshold = 5;

const TInt KCompactStepInterval = 5;//ms

TSqlCompactSettings TheCompactionSettings;

static RTest 			TheTest(_L ("t_sqlcompact2.exe"));

static CTrapCleanup*	TheTrapCleanup = NULL;

static RFs 				TheFs;

static TBuf<KMaxFileName + 1> TheFileNameZ;

static TBuf8<KMaxFileName + 1> TheFileNameZ8;

const TInt KBlobMaxSize = 1024 * 32;

static TBuf8<KBlobMaxSize> TheBlob;

static sqlite3* 		TheDbHandle = NULL;

_LIT8(KFreePageCountPragma, "PRAGMA freelist_count\x0");

TBuf<256>  TheCmd;

TDriveName TheDriveName;

TParse     TheParse;

TFileName  TheDbName;

class CSqlCompactTestActive;

CSqlCompactTestActive* TheTestActive = NULL;

const TTimeIntervalMicroSeconds32 KInterval(200000);

static TInt TheProcessHandleCount = 0;

static TInt TheThreadHandleCount = 0;

static TInt TheAllocatedCellsCount = 0;

#ifdef _DEBUG

const TInt KBurstRate = 100;

#endif

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

void DeleteTestFiles()

	{

	::CloseDbHandle(TheDbHandle);

	(void)TheFs.Delete(TheDbName);

	}

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

//Test macros and functions

void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		DeleteTestFiles();

		TheTest(EFalse, aLine);

		}

	}

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

	{

	if(aValue != aExpected)

		{

		DeleteTestFiles();

		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

		TheTest(EFalse, aLine);

		}

	}

#define TEST(arg) ::Check((arg), __LINE__)

#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

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

void TestEnvCreate()

	{	

	TInt err = sqlite3SymbianLibInit();

	__ASSERT_ALWAYS(err == KErrNone, User::Invariant());

	TheFs = sqlite3SymbianFs();

	for(TInt i=0;i<('Z'-'A');++i)

		{

		TheFs.CreatePrivatePath(i);

		}

	err = TheFs.MkDir(TheDbName);

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

	DeleteTestFiles();

	}

void TestEnvDestroy()

	{

	DeleteTestFiles();

	sqlite3SymbianLibFinalize();

	CloseSTDLIB();

	}

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

void MarkHandles()

	{

	RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);

	}

void MarkAllocatedCells()

	{

	TheAllocatedCellsCount = User::CountAllocCells();

	}

void CheckHandles()

	{

	TInt processHandleCount = 0;

	TInt threadHandleCount = 0;

	RThread().HandleCount(processHandleCount, threadHandleCount);

	TEST(processHandleCount == TheProcessHandleCount);

	TEST(threadHandleCount == TheThreadHandleCount);

	}

void CheckAllocatedCells()

	{

	TInt allocatedCellsCount = User::CountAllocCells();

	TEST(allocatedCellsCount == TheAllocatedCellsCount);

	}

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

const TDesC& FileNameZ(const TDesC& aFileName)

	{

	TheFileNameZ.Copy(aFileName);

	TheFileNameZ.ZeroTerminate();

	return TheFileNameZ;

	}

const TDesC8& FileNameZ8(const TDesC& aFileName)

	{

	TheFileNameZ8.Copy(aFileName);

	TheFileNameZ8.ZeroTerminate();

	return TheFileNameZ8;

	}

TInt FreePageCount()

	{

	sqlite3_stmt* stmtHandle = NULL;

	TInt err = ::StmtPrepare8(TheDbHandle, KFreePageCountPragma, stmtHandle);

	TEST2(err, KErrNone);

	TEST(stmtHandle != NULL);

	err = ::StmtNext(stmtHandle);

	TEST2(err, KSqlAtRow);

	TInt pageCount = sqlite3_column_int(stmtHandle, 0);

	TEST(pageCount >= 0);

	::FinalizeStmtHandle(stmtHandle);

	return pageCount;

	}

void PrintInfo(TInt aProcessedPages, const TDesC& aMediaTypeName, TUint32 aStartTicks, TUint32 aEndTicks)

	{

	static TInt freq = 0;

	if(freq == 0)

		{

		TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone);

		}

	TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;

	if(diffTicks < 0)

		{

		diffTicks = KMaxTUint32 + diffTicks + 1;

		}

	const TInt KMicroSecIn1Sec = 1000000;

	TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;

	TheTest.Printf(_L("####Media type: %S. Processed pages: %d. Ticks: %ld. Execution time: %d ms\r\n"), 

							&aMediaTypeName, aProcessedPages, diffTicks, us / 1000);

	}

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

//////////////////////////////        CSqlCompactTestActive declaration              /////////////////////////////////////////////

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

class CSqlCompactTestActive : public CActive

	{

private:

	enum TCommand

		{

		ECmdInvalidTest,	

		ECmdBeginTest1,

		ECmdEndTest1,

		ECmdBeginTest2,

		ECmdEndTest2,

		ECmdBeginTest3,

		ECmdEndTest3,

		ECmdStopTests	

		};

public:

	static void New();

	virtual ~CSqlCompactTestActive();

	void OomTest();

	void FileIoErrTest();

	void PerformanceTest();

protected:		

	virtual void DoCancel();

	virtual void RunL();

	virtual TInt RunError(TInt aError);

private:

	CSqlCompactTestActive();

	void Complete(TCommand aNextCommand);

	void Schedule(TCommand aNextCommand, TTimeIntervalMicroSeconds32 aInterval);

	void CreateTestDatabase();

	void InsertTestRecords(TInt aOpCount = KOperationCount);

	void UpdateTestRecords(TInt aOpCount = KOperationCount);

	void DeleteTestRecords(TInt aOpCount = KOperationCount);

	void DeleteTestRecords2();

	void TestEnd();

	void UpdateTestBegin();

	void UpdateTestEnd();

	void DeleteTestBegin();

	void DeleteTestEnd();

	void SingleOpCompactTestBegin();

	void SingleOpCompactTestEnd();

	void DoOomTest1();

	void DoOomTest2();

	void DoOomTest3();

	void DoOomTest4();

	void DoOomTest5();

private:

	TInt			iCommand;

	CSqlCompactor*	iCompactor;

	RTimer			iTimer;

	};

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

//////////////////////////////        CSqlCompactTestActive implementation             ///////////////////////////////////////////

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

void CSqlCompactTestActive::New()

	{

	TheTestActive = new CSqlCompactTestActive;

	TEST(TheTestActive != NULL);

	}

CSqlCompactTestActive::~CSqlCompactTestActive()

	{

	Cancel();

	iTimer.Close();

	delete iCompactor;

	}

void CSqlCompactTestActive::DoCancel()

	{

	iTimer.Cancel();

	TRequestStatus* stat = &iStatus;

	User::RequestComplete(stat, KErrNone);

	}

void CSqlCompactTestActive::RunL()

	{

	switch(iCommand)

		{

		case CSqlCompactTestActive::ECmdBeginTest1:

			TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4053 Update test"));

			UpdateTestBegin();

			Schedule(CSqlCompactTestActive::ECmdEndTest1, KInterval);

			break;

		case CSqlCompactTestActive::ECmdEndTest1:

			UpdateTestEnd();

			Complete(CSqlCompactTestActive::ECmdBeginTest2);

			break;

		case CSqlCompactTestActive::ECmdBeginTest2:

			TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4054 Delete test"));

			DeleteTestBegin();

			Schedule(CSqlCompactTestActive::ECmdEndTest2, KInterval);

			break;

		case CSqlCompactTestActive::ECmdEndTest2:

			DeleteTestEnd();

			Complete(CSqlCompactTestActive::ECmdBeginTest3);

			break;

		case CSqlCompactTestActive::ECmdBeginTest3:

			TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4055 Single operation - compaction test"));

			SingleOpCompactTestBegin();

			Schedule(CSqlCompactTestActive::ECmdEndTest3, KInterval);

			break;

		case CSqlCompactTestActive::ECmdEndTest3:

			SingleOpCompactTestEnd();

			Complete(CSqlCompactTestActive::ECmdStopTests);

			break;

		case CSqlCompactTestActive::ECmdStopTests:

			CActiveScheduler::Stop();

			break;

		case CSqlCompactTestActive::ECmdInvalidTest:

		default:

			TEST(0);

			break;

		}

	}

TInt CSqlCompactTestActive::RunError(TInt aError)

	{

	TEST2(aError, KErrNone);

	return aError;

	}

CSqlCompactTestActive::CSqlCompactTestActive() :

	CActive(CActive::EPriorityStandard),

	iCommand(CSqlCompactTestActive::ECmdInvalidTest),

	iCompactor(NULL)

	{

	TInt err = sqlite3_enable_shared_cache(1);

	TEST2(err, SQLITE_OK);

	TRAP(err, iCompactor = CSqlCompactor::NewL(&SqlCreateCompactConnL, KCompactStepInterval));

	TEST2(err, KErrNone);

	err = iTimer.CreateLocal();

	TEST2(err, KErrNone);

	CActiveScheduler::Add(this);

	Complete(CSqlCompactTestActive::ECmdBeginTest1);

	}

void CSqlCompactTestActive::Complete(CSqlCompactTestActive::TCommand aNextCommand)

	{

	TEST(!IsActive());

	iCommand = aNextCommand;

	TRequestStatus* stat = &iStatus;

	User::RequestComplete(stat, KErrNone);

	SetActive();	

	}

void CSqlCompactTestActive::Schedule(TCommand aNextCommand, TTimeIntervalMicroSeconds32 aInterval)

	{

	TEST(!IsActive());

	iCommand = aNextCommand;

	iTimer.After(iStatus, aInterval);

	TEST2(iStatus.Int(), KRequestPending);

	SetActive();

	}

void CSqlCompactTestActive::CreateTestDatabase()

	{

	TInt err = ::CreateDbHandle8(::FileNameZ8(TheDbName), TheDbHandle);

	TEST2(err, KErrNone);

	_LIT8(KCreateTableSql, "CREATE TABLE A(I INTEGRER, B BLOB)\x0");

	err = ::DbExecStmt8(TheDbHandle, KCreateTableSql);

	TEST2(err, KErrNone);

	}

void CSqlCompactTestActive::InsertTestRecords(TInt aOpCount)

	{

	TheBlob.SetLength(SQLITE_DEFAULT_PAGE_SIZE);

	for(TInt i=0;i<aOpCount;++i)

		{

		_LIT8(KInsertSql, "INSERT INTO A VALUES(%d, :Prm)\x0");

		TBuf8<sizeof(KInsertSql) + 10> sqlBuf1;

		sqlBuf1.Format(KInsertSql, i + 1);

		sqlite3_stmt* stmtHandle = NULL;

		TInt err = ::StmtPrepare8(TheDbHandle, sqlBuf1, stmtHandle);

		TEST2(err, KErrNone);

		TEST(stmtHandle != NULL);

		err = sqlite3_bind_blob(stmtHandle, 1, TheBlob.Ptr(), SQLITE_DEFAULT_PAGE_SIZE, SQLITE_STATIC);

		TEST2(err, SQLITE_OK);

		err = ::StmtExec(stmtHandle);

		TEST2(err, KErrNone);

		::FinalizeStmtHandle(stmtHandle);

		}

	}

void CSqlCompactTestActive::UpdateTestRecords(TInt aOpCount)

	{

	for(TInt i=0;i<aOpCount;++i)

		{

		_LIT8(KUpdateSql, "UPDATE A SET B=x'1122' WHERE I=%d\x0");

		TBuf8<sizeof(KUpdateSql) + 10> sqlBuf2;

		sqlBuf2.Format(KUpdateSql, i + 1);

		TInt err = ::DbExecStmt8(TheDbHandle, sqlBuf2);

		TEST2(err, KErrNone);

		}

	}

void CSqlCompactTestActive::DeleteTestRecords(TInt aOpCount)

	{

	for(TInt i=0;i<aOpCount;++i)

		{

		_LIT8(KDeleteSql, "DELETE FROM A WHERE I=%d\x0");

		TBuf8<sizeof(KDeleteSql) + 10> sqlBuf2;

		sqlBuf2.Format(KDeleteSql, i + 1);

		TInt err = ::DbExecStmt8(TheDbHandle, sqlBuf2);

		TEST2(err, KErrNone);

		}

	}

void CSqlCompactTestActive::DeleteTestRecords2()

	{

	_LIT8(KDeleteSql, "DELETE FROM A\x0");

	TInt err = ::DbExecStmt8(TheDbHandle, KDeleteSql);

	TEST2(err, KErrNone);

	}

void CSqlCompactTestActive::TestEnd()

	{

	TInt freePageCount = ::FreePageCount();

	TEST2(freePageCount, 0);

	iCompactor->ReleaseEntry(TheDbName);

	::CloseDbHandle(TheDbHandle);

	TheDbHandle = NULL;

	(void)TheFs.Delete(TheDbName);

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4053

@SYMTestCaseDesc		Background compaction scheduled by a set of UPDATE operations.

						The test uses the server background compaction classes directly.

						The test creates a database, inserts records and updates the records.

						The update operations free enough disk space to kick-off the background compaction.

						The test active object, that simulates the SQL server, is activated and the

						background compaction - executed.

						The test checks at the end that the background compaction really happened - in

						CSqlCompactTestActive::UpdateTestEnd().

@SYMTestPriority		Medium

@SYMTestActions			Background compaction scheduled by a set of UPDATE operations.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ10271

                        REQ10272

*/

void CSqlCompactTestActive::UpdateTestBegin()

	{

	CreateTestDatabase();

	TRAPD(err, iCompactor->AddEntryL(TheDbName, TheCompactionSettings));

	TEST2(err, KErrNone);

	InsertTestRecords();

	UpdateTestRecords();

	TInt freePageCount = ::FreePageCount();

	TEST(freePageCount > KFreePageThreshold);

	}

void CSqlCompactTestActive::UpdateTestEnd()

	{

	TestEnd();

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4054

@SYMTestCaseDesc		Background compaction scheduled by a set of DELETE operations.

						The test uses the server background compaction classes directly.

						The test creates a database, inserts records and deletes the records.

						The delete operations free enough disk space to kick-off the background compaction.

						The test active object, that simulates the SQL server, is activated and the

						background compaction - executed.

						The test checks at the end that the background compaction really happened - in

						CSqlCompactTestActive::DeleteTestEnd().

@SYMTestPriority		Medium

@SYMTestActions			Background compaction scheduled by a set of DELETE operations.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ10271

                        REQ10272

*/

void CSqlCompactTestActive::DeleteTestBegin()

	{

	CreateTestDatabase();

	TRAPD(err, iCompactor->AddEntryL(TheDbName, TheCompactionSettings));

	TEST2(err, KErrNone);

	InsertTestRecords();

	DeleteTestRecords();

	TInt freePageCount = ::FreePageCount();

	TEST(freePageCount >= KFreePageThreshold);

	}

void CSqlCompactTestActive::DeleteTestEnd()

	{

	TestEnd();

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4055

@SYMTestCaseDesc		Background compaction, initiated by a single operation.

						The test uses the server background compaction classes directly.

						The test creates a database, inserts records and deletes the records using just

						a single DELETE SQL statement.

						The test active object, that simulates the SQL server, schedules 

						CSqlCompactTestActive::SingleOpCompactTestEnd() for execution. The code in

						SingleOpCompactTestEnd() checks that the background compaction has been activated and closes the

						database connection. The "database close" operation should start the compaction

						because the total size of free pages is above the "free pages" threshold (in Kb).

@SYMTestPriority		Medium

@SYMTestActions			Background compaction, initiated by a single operation.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ10271

                        REQ10272

*/

void CSqlCompactTestActive::SingleOpCompactTestBegin()

	{

	CreateTestDatabase();

	TRAPD(err, iCompactor->AddEntryL(TheDbName, TheCompactionSettings));

	TEST2(err, KErrNone);

	InsertTestRecords();

	DeleteTestRecords2();

	TInt freePageCount = ::FreePageCount();

	TEST(freePageCount >= KFreePageThreshold);

	}

void CSqlCompactTestActive::SingleOpCompactTestEnd()

	{