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

#include "SqlUtil.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();

	void FreePageUpdateTest();

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

	void PrepareDb(TBool aNewDb);

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

		}

	}

//Creates a test database (with KDbName name). 

void CSqlCompactTestActive::CreateTestDatabase2()

    {

    //Create the database

    const TInt KPageSize = 1024;

    _LIT8(KConfigStr, "page_size=");

    TBuf8<100> config;

    config.Copy(KConfigStr);

    config.AppendNum(KPageSize);

    TInt err = KErrNone;

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

    TEST2(err, KErrNone);  

    _LIT8(KCreateTableSql, "CREATE TABLE A(I INTEGER, T TEXT)\x0");

    err = ::DbExecStmt8(TheDbHandle, KCreateTableSql);

    TEST2(err, KErrNone);

    }

//Insert 1000 records. The record size is such that there is only two records per page.

void CSqlCompactTestActive::PrepareDb(TBool aDeleteRecords)

    {

    //Insert records

    const TInt KRecordCount = 1000;

    const TInt KTextLen = 400;

    TBuf<KTextLen> TheText;

    TBuf<KTextLen + 100> TheSqlBuf;

    TheText.SetLength(TheText.MaxLength());

    TheText.Fill(TChar('A'));

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

        {

        TheSqlBuf.Format(_L("INSERT INTO A VALUES(%d, '%S')"), i + 1, &TheText);

        _LIT(KZero, "\x0");

        TheSqlBuf.Append(KZero);

        TInt err = ::DbExecStmt16(TheDbHandle, TheSqlBuf);

        TEST2(err, KErrNone);

        }

    if(aDeleteRecords)

        {   

        //Delete all records to make a lot of free pages. 

        _LIT(KDeleteAll, "DELETE FROM A WHERE 1\x0");

        TheSqlBuf = KDeleteAll;

        TInt err = ::DbExecStmt16(TheDbHandle, TheSqlBuf);

        TEST2(err, KErrNone);

        }

    }

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