// 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 <e32test.h>

#include <bautils.h>

#include <sqldb.h>

#include <stdlib.h>

#include "sqlite3.h"

#include "SqliteSymbian.h"

#include "SqlResourceTester.h"

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

RTest TheTest(_L("t_sqlcompact4 test"));

TParse TheParse;

TDriveName TheDrive;

RSqlDatabase TheDb;

sqlite3* TheSqliteDb = NULL;

TBuf<256> TheCmd;

const TInt KTextLen = 1000;

const TInt KRecLen = 2000;

TBuf<KTextLen> TheText;

TBuf8<KRecLen> TheSqlQuery;

TBuf8<KRecLen> TheSqlFmt;

TBuf<KTextLen + 50> TheSqlTexLen;

_LIT(KDefaultDriveName, "c:");

_LIT(KTestDir, "c:\\test\\");

_LIT(KTestDbTemplate8, "c:\\test\\t_sqlcompact4_tmpl8.dat");

_LIT(KTestDbTemplate16, "c:\\test\\t_sqlcompact4_tmpl16.dat");

_LIT(KDbName, "c:\\test\\t_sqlcompact4_1.db");

_LIT(KDbName2, "c:\\test\\t_sqlcompact4_2.db");

_LIT(KRoDbName, "z:\\test\\testdb1.db");//Created outside the test app

TFileName TheTestDbName;

const TInt KMaxThreadCount = 100;

TInt32 TheTestThreadCount = 8;

const TInt KTestDbPageSize = 1024;

TInt TheOriginalDbSize8 = -1;

TInt TheCompactedDbSize8 = -1;

TInt TheOriginalDbSize16 = -1;

TInt TheCompactedDbSize16 = -1;

//In order to be able to compile the test, the following variables are defined (used inside the OS porting layer, when _SQLPROFILER macro is defined)

#ifdef _SQLPROFILER

TInt TheSqlSrvProfilerFileRead = 0;

TInt TheSqlSrvProfilerFileWrite = 0;

TInt TheSqlSrvProfilerFileSync = 0;

TInt TheSqlSrvProfilerFileSetSize = 0;

#endif

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

void DestroyTestEnv()

	{

	if(TheSqliteDb)

		{

		sqlite3_close(TheSqliteDb);

		TheSqliteDb = NULL;

		}

	TheDb.Close();

	(void)RSqlDatabase::Delete(KDbName2);

	(void)RSqlDatabase::Delete(TheTestDbName);

	(void)RSqlDatabase::Delete(KTestDbTemplate16);

	(void)RSqlDatabase::Delete(KTestDbTemplate8);

	sqlite3SymbianLibFinalize();

	CloseSTDLIB();

	}

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

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

//Test macros and functions

void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		DestroyTestEnv();

		RDebug::Print(_L("*** Test failure. Boolean expression evaluates to false.\r\n"));

		TheTest(EFalse, aLine);

		}

	}

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

	{

	if(aValue != aExpected)

		{

		DestroyTestEnv();

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

    {

    RFs fs;

	TInt err = fs.Connect();

	TEST2(err, KErrNone);

	err = fs.MkDir(KTestDir);

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

	TheParse.Set(TheDrive, &KTestDir, 0);

	err = fs.MkDir(TheParse.DriveAndPath());

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

	fs.Close();

	sqlite3SymbianLibInit();

	}

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

void CreateTestDatabase8()

	{

	TheTest.Printf(_L("Create UTF8 test database: %S\r\n"), &KTestDbTemplate8);

	(void)RSqlDatabase::Delete(KTestDbTemplate8);

	TBuf8<KMaxFileName> fname;

	fname.Copy(KTestDbTemplate8);

	TheSqliteDb = NULL;

	TInt rc = sqlite3_open((const char*)fname.PtrZ(), &TheSqliteDb);

	TEST2(rc, SQLITE_OK);

	TBuf8<100> sql;

	_LIT8(KSql, "PRAGMA page_size=%d\x0");

	sql.Format(KSql, KTestDbPageSize);

	rc = sqlite3_exec(TheSqliteDb, (const char*)sql.Ptr(), 0, 0, 0);

	TEST2(rc, SQLITE_OK);

	rc = sqlite3_exec(TheSqliteDb, "CREATE TABLE A(Id INTEGER,Data BLOB)", 0, 0, 0);

	TEST2(rc, SQLITE_OK);

	//Insert records

	rc = sqlite3_exec(TheSqliteDb, "BEGIN", 0, 0, 0);

	TEST2(rc, SQLITE_OK);

	TheSqlQuery.Copy(_L8("INSERT INTO A VALUES(%d,x'"));

	for(TInt j=0;j<(KRecLen-50);++j)

		{

		TheSqlQuery.Append(_L8("A"));

		}

	TheSqlQuery.Append(_L8("')"));

	const TInt KRecCount = 100;	

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

		{

		TheSqlFmt.Format(TheSqlQuery, i + 1);

		rc = sqlite3_exec(TheSqliteDb, (const char*)TheSqlFmt.PtrZ(), 0, 0, 0);

		TEST2(rc, SQLITE_OK);

		}

	rc = sqlite3_exec(TheSqliteDb, "COMMIT", 0, 0, 0);

	TEST2(rc, SQLITE_OK);

	//Free some space

	rc = sqlite3_exec(TheSqliteDb, "DELETE FROM A WHERE Id > 10", 0, 0, 0);

	TEST2(rc, SQLITE_OK);

	sqlite3_close(TheSqliteDb);

	TheSqliteDb = NULL;

	}

void CreateTestDatabase16()

	{

	TheTest.Printf(_L("Create UTF16 test database: %S\r\n"), &KTestDbTemplate16);

	(void)RSqlDatabase::Delete(KTestDbTemplate16);

	TBuf<KMaxFileName> fname;

	fname.Copy(KTestDbTemplate16);

	TheSqliteDb = NULL;

	TInt rc = sqlite3_open16(fname.PtrZ(), &TheSqliteDb);

	TEST2(rc, SQLITE_OK);

	TBuf8<100> sql;

	_LIT8(KSql, "PRAGMA page_size=%d\x0");

	sql.Format(KSql, KTestDbPageSize);

	rc = sqlite3_exec(TheSqliteDb, (const char*)sql.Ptr(), 0, 0, 0);

	TEST2(rc, SQLITE_OK);

	rc = sqlite3_exec(TheSqliteDb, "CREATE TABLE A(Id INTEGER,Data BLOB)", 0, 0, 0);

	TEST2(rc, SQLITE_OK);

	//Insert records

	rc = sqlite3_exec(TheSqliteDb, "BEGIN", 0, 0, 0);

	TEST2(rc, SQLITE_OK);

	TheSqlQuery.Copy(_L8("INSERT INTO A VALUES(%d,x'"));

	for(TInt j=0;j<(KRecLen-50);++j)

		{

		TheSqlQuery.Append(_L8("A"));

		}

	TheSqlQuery.Append(_L8("')"));

	const TInt KRecCount = 100;	

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

		{

		TheSqlFmt.Format(TheSqlQuery, i + 1);

		rc = sqlite3_exec(TheSqliteDb, (const char*)TheSqlFmt.PtrZ(), 0, 0, 0);

		TEST2(rc, SQLITE_OK);

		}

	rc = sqlite3_exec(TheSqliteDb, "COMMIT", 0, 0, 0);

	TEST2(rc, SQLITE_OK);

	//Free some space

	rc = sqlite3_exec(TheSqliteDb, "DELETE FROM A WHERE Id > 10", 0, 0, 0);

	TEST2(rc, SQLITE_OK);

	sqlite3_close(TheSqliteDb);

	TheSqliteDb = NULL;

	}

void CreateDatabase8(const TDesC& aTargetDbName)

	{

	RFs fs;

	TInt err = fs.Connect();

	TEST2(err, KErrNone);		

	CFileMan* fm = NULL;

	TRAP(err, fm = CFileMan::NewL(fs));

	TEST2(err, KErrNone);

	err = fm->Copy(KTestDbTemplate8, aTargetDbName);

	delete fm;

	fs.Close();

	TEST2(err, KErrNone);

	}

void CreateDatabase16(const TDesC& aTargetDbName)

	{

	RFs fs;

	TInt err = fs.Connect();

	TEST2(err, KErrNone);		

	CFileMan* fm = NULL;

	TRAP(err, fm = CFileMan::NewL(fs));

	TEST2(err, KErrNone);

	err = fm->Copy(KTestDbTemplate16, aTargetDbName);

	delete fm;

	fs.Close();

	TEST2(err, KErrNone);

	}

void CalculateMaxCompaction8()

	{

	TheTest.Printf(_L("UTF8 test database - calculate max compaction\r\n"));

	(void)RSqlDatabase::Delete(TheTestDbName);

	CreateDatabase8(TheTestDbName);

	TInt err = TheDb.Open(TheTestDbName);

	TEST2(err, KErrNone);

	RSqlDatabase::TSize size1;

	err = TheDb.Size(size1);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("UTF8.Database before compaction: size %ld, free space %ld\r\n"), size1.iSize, size1.iFree);

	err = TheDb.Compact(RSqlDatabase::EMaxCompaction);

	TEST2(err, size1.iFree);

	RSqlDatabase::TSize size2;

	err = TheDb.Size(size2);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("UTF8.Database after compaction: size %ld, free space %ld\r\n"), size2.iSize, size2.iFree);

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheTestDbName);

	TheOriginalDbSize8 = size1.iSize;

	TheCompactedDbSize8 = size2.iSize;

	TEST(TheOriginalDbSize8 > 0);

	TEST(TheCompactedDbSize8 > 0 && TheCompactedDbSize8 < TheOriginalDbSize8);

	}

void CalculateMaxCompaction16()

	{

	TheTest.Printf(_L("UTF16 test database - calculate max compaction\r\n"));

	(void)RSqlDatabase::Delete(TheTestDbName);

	CreateDatabase16(TheTestDbName);

	TInt err = TheDb.Open(TheTestDbName);

	TEST2(err, KErrNone);

	RSqlDatabase::TSize size1;

	err = TheDb.Size(size1);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("UTF16.Database before compaction: size %ld, free space %ld\r\n"), size1.iSize, size1.iFree);

	err = TheDb.Compact(RSqlDatabase::EMaxCompaction);

	TEST2(err, size1.iFree);

	RSqlDatabase::TSize size2;

	err = TheDb.Size(size2);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("UTF16.Database after compaction: size %ld, free space %ld\r\n"), size2.iSize, size2.iFree);

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheTestDbName);

	TheOriginalDbSize16 = size1.iSize;

	TheCompactedDbSize16 = size2.iSize;

	TEST(TheOriginalDbSize16 > 0);

	TEST(TheCompactedDbSize16 > 0 && TheCompactedDbSize16 < TheOriginalDbSize16);

	}

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

enum TCompactionType {ESyncCompaction, EAsyncCompaction, EMaxCompactionType};

TInt DoCompact(TCompactionType aType, TInt aSize, const TDesC& aAttachDbName = KNullDesC)

	{

	TInt err = KErrGeneral;

	switch(aType)

		{

		case ESyncCompaction:

			err = TheDb.Compact(aSize, aAttachDbName);

			break;

		case EAsyncCompaction:

			{

			TRequestStatus stat;				

			TheDb.Compact(aSize, stat, aAttachDbName);

			User::WaitForRequest(stat);

			TEST(stat != KRequestPending);

			err = stat.Int();

			break;

			}

		default:

			TEST(0);

			break;	

		}

	return err;

	}

TInt DoManualCompaction(TCompactionType aType, const TDesC& aMainDb, TInt aSize, TBool aRoFlag = EFalse)

	{

	if(!aRoFlag)

		{

		(void)RSqlDatabase::Delete(aMainDb);

		CreateDatabase8(aMainDb);

		}

	TInt err = TheDb.Open(aMainDb);

	TEST2(err, KErrNone);

	err = DoCompact(aType, aSize);

	TheDb.Close();

	if(!aRoFlag)

		{

		(void)RSqlDatabase::Delete(aMainDb);

		}

	return err;

	}

TInt DoManualCompaction(TCompactionType aType, TInt aSize, const TDesC& aAttachDbName)

	{

	return DoCompact(aType, aSize, aAttachDbName);

	}

void DoManualCompaction(TCompactionType aType, TInt aSize, TInt aCompactedSize)

	{

	(void)RSqlDatabase::Delete(TheTestDbName);

	CreateDatabase8(TheTestDbName);

	TInt err = TheDb.Open(TheTestDbName);

	TEST2(err, KErrNone);

	err = DoCompact(aType, aSize);

	TEST(err >= 0);

	RSqlDatabase::TSize size;

	err = TheDb.Size(size);

	TEST2(err, KErrNone);

	TEST2(size.iSize, aCompactedSize);

	TheDb.Close();

	(void)RSqlDatabase::Delete(TheTestDbName);

	}

void DoManualCompaction(TCompactionType aType, TInt aSize, TInt aCompactedSize, const TDesC& aAttachDbName)

	{

	TInt err = DoCompact(aType, aSize, aAttachDbName);

	TEST(err >= 0);

	RSqlDatabase::TSize size;

	err = TheDb.Size(size, aAttachDbName);

	TEST2(err, KErrNone);

	TEST2(size.iSize, aCompactedSize);

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4064

@SYMTestCaseDesc		Manual compaction - negative tests.

						The test creates a database with a manual compaction mode.

						Then the test executes the following negative tests using both synchronous and

						asynchronous Compact() methods:

							- RSqlDatabase::Compact() called with aSize parameter value = KMinTInt;

							- RSqlDatabase::Compact() called with negative aSize parameter value;

							- RSqlDatabase::Compact() called on a read-only database;

							- RSqlDatabase::Compact() called on an attached read-only database;

							- RSqlDatabase::Compact() called on a nonexisting attached database with very long name;

							- RSqlDatabase::Compact() called with aSize = 0;

							- RSqlDatabase::Compact() called on a read-only database where the version number of symbian_settings table is 3;

@SYMTestPriority		Medium

@SYMTestActions			Manual compaction - negative tests.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ10273

                        REQ10274

                        REQ10402

*/

void ManualCompactionNegativeTest()

	{

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

		{

		//Specifying KMaxTInt as aSize argument value.

		TInt err = DoManualCompaction((TCompactionType)i, TheTestDbName, KMaxTInt);

		TEST(err > 0);

		//Specifying KMinTInt as aSize argument value.

		err = DoManualCompaction((TCompactionType)i, TheTestDbName, KMinTInt);

		TEST2(err, KErrArgument);

		//Specifying another negative value as aSize argument value.

		err = DoManualCompaction((TCompactionType)i, TheTestDbName, -357);

		TEST2(err, KErrArgument);

		//Specifying zero as aSize argument value.

		err = DoManualCompaction((TCompactionType)i, TheTestDbName, 0);

		TEST2(err, 0);

		//Read-only database - old format (version 3 of symbian_settings table)

		err = DoManualCompaction((TCompactionType)i, KRoDbName, RSqlDatabase::EMaxCompaction, ETrue);

		TEST2(err, KSqlErrReadOnly);

		//

		(void)RSqlDatabase::Delete(TheTestDbName);

		CreateDatabase16(TheTestDbName);

		err = TheDb.Open(TheTestDbName);

		TEST2(err, KErrNone);

		_LIT(KAttachDbName, "Db");

		//Attached read-only database

		err = TheDb.Attach(KRoDbName, KAttachDbName);

		TEST2(err, KErrNone);

		err = DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, KAttachDbName);

		TEST2(err, KSqlErrReadOnly);

		err = TheDb.Detach(KAttachDbName);

		TEST2(err, KErrNone);

		//Nonexisting attached database 

		err = DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, _L("aaa"));

		TEST2(err, KSqlErrGeneral);

        //Very long name of a  nonexisting attached database 

        TBuf<KMaxFileName + 10> fname;

        fname.SetLength(fname.MaxLength());

        fname.Fill(0xDD);

        err = DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, fname);

        TEST2(err, KErrBadName);

        //Invalid attached database name 

        fname.Copy(_L("c:\\|aaa|.db"));

        err = DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, fname);

        TEST2(err, KSqlErrGeneral);

        //

		TheDb.Close();

		(void)RSqlDatabase::Delete(TheTestDbName);

		}

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4065

@SYMTestCaseDesc		Manual compaction - functional tests.

						The test creates a database with a manual compaction mode.

						Then the test executes the following functional tests using both synchronous and

						asynchronous Compact() methods:

							- RSqlDatabase::Compact() called with aSize parameter value = RSqlDatabase::EMaxCompaction;

							- RSqlDatabase::Compact() called with aSize parameter value = 0. No pages should be removed;

							- RSqlDatabase::Compact() called with aSize parameter value = 1. 1 page should be removed;

							- RSqlDatabase::Compact() called with aSize parameter value = "db page size - 1". 1 page should be removed;

							- RSqlDatabase::Compact() called with aSize parameter value = "db page size * <cnt>". <cnt> pages should be removed;

							- RSqlDatabase::Compact() called with aSize parameter value > the free db space. All free pages should be removed;

						The same functional tests are repeated with an attached database.

@SYMTestPriority		Medium

@SYMTestActions			Manual compaction - functional tests.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ10273

                        REQ10274

                        REQ10402

*/

void ManualCompactionTest()

	{

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

		{

		//Calling Compact() with aSize = RSqlDatabase::EMaxCompaction

		DoManualCompaction((TCompactionType)i, RSqlDatabase::EMaxCompaction, TheCompactedDbSize8);

		//Calling Compact() with aSize = 0. 0 pages expected to be removed

		DoManualCompaction((TCompactionType)i, 0, TheOriginalDbSize8);

		//Calling Compact() with aSize = 1. 1 page expected to be removed

		DoManualCompaction((TCompactionType)i, 1, TheOriginalDbSize8 - KTestDbPageSize);

		//Calling Compact() with aSize = KTestDbPageSize - 1. 1 page expected to be removed

		DoManualCompaction((TCompactionType)i, KTestDbPageSize - 1, TheOriginalDbSize8 - KTestDbPageSize);

		//Calling Compact() with aSize = KTestDbPageSize. 1 page expected to be removed

		DoManualCompaction((TCompactionType)i, KTestDbPageSize, TheOriginalDbSize8 - KTestDbPageSize);

		const TInt KPagesCnt1 = 17;

		//Calling Compact() with aSize = KTestDbPageSize * KPagesCnt1. KPagesCnt1 pages expected to be removed

		DoManualCompaction((TCompactionType)i, KTestDbPageSize * KPagesCnt1, TheOriginalDbSize8 - KTestDbPageSize * KPagesCnt1);

		//Calling Compact() with aSize > TheOriginalDbSize8. All free pages expected to be removed

		DoManualCompaction((TCompactionType)i, TheOriginalDbSize8 + 2000, TheCompactedDbSize8);

		//Attached database

		(void)RSqlDatabase::Delete(KDbName2);

		TInt err = TheDb.Create(KDbName2);

		TEST2(err, KErrNone);

		(void)RSqlDatabase::Delete(TheTestDbName);

		CreateDatabase16(TheTestDbName);

		_LIT(KAttachDbName, "Db");

		err = TheDb.Attach(TheTestDbName, KAttachDbName);

		TEST2(err, KErrNone);

		TInt newDatabaseSize = TheOriginalDbSize16;

		//Calling Compact() with aSize = 0. 0 pages expected to be removed

		DoManualCompaction((TCompactionType)i, 0, newDatabaseSize, KAttachDbName);

		//Calling Compact() with aSize = 1. 1 page expected to be removed

		DoManualCompaction((TCompactionType)i, 1, TheOriginalDbSize16 - KTestDbPageSize, KAttachDbName);

		newDatabaseSize -= KTestDbPageSize;

		//Calling Compact() with aSize = KTestDbPageSize - 1. 1 page expected to be removed

		DoManualCompaction((TCompactionType)i, KTestDbPageSize - 1, newDatabaseSize - KTestDbPageSize, KAttachDbName);

		newDatabaseSize -= KTestDbPageSize;

		//Calling Compact() with aSize = KTestDbPageSize. 1 page expected to be removed

		DoManualCompaction((TCompactionType)i, KTestDbPageSize, newDatabaseSize - KTestDbPageSize, KAttachDbName);

		newDatabaseSize -= KTestDbPageSize;

		//Calling Compact() with aSize = KTestDbPageSize * KPagesCnt1. KPagesCnt1 pages expected to be removed

		DoManualCompaction((TCompactionType)i, KTestDbPageSize * KPagesCnt1, newDatabaseSize - KTestDbPageSize * KPagesCnt1, KAttachDbName);

		newDatabaseSize -= KTestDbPageSize * KPagesCnt1;

		//Calling Compact() with aSize > newDatabaseSize. All free pages expected to be removed

		DoManualCompaction((TCompactionType)i, newDatabaseSize + 2000, TheCompactedDbSize16, KAttachDbName);

		//

		err = TheDb.Detach(KAttachDbName);

		TEST2(err, KErrNone);

		TheDb.Close();

		(void)RSqlDatabase::Delete(KDbName2);

		}

	}

enum TSizeTestType {EManualSizeTest, EAutoSizeTest};