// Copyright (c) 2008-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:

// t_msv_dbadapter_step.cpp

//

#include "t_msv_dbadapter_step.h"

#include "msvcachevisiblefolder.h"

#include "msvindexadapter.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "msvconsts.h"

#endif

#define DEFAULT_RETURN KErrNone

#define MY_ASSERT_TRUE(a)  \

		INFO_PRINTF1(KFunction);   \

		ASSERT_TRUE(a);

#define MY_ASSERT_FALSE(a)  \

		INFO_PRINTF1(KFunction);   \

		ASSERT_FALSE(a);

#define MY_ASSERT_EQUALS(a,b)  \

		INFO_PRINTF1(KFunction);   \

		ASSERT_EQUALS(a,b);

//Database used for testing

_LIT(KSTDMSGINI, "C:\\private\\1000484b\\msgcache.ini");

_LIT(KMSGINI_2, "C:\\private\\1000484b\\msgcache2.ini");

_LIT8(KId, "id ");

_LIT8(KBetween, "between ");

_LIT8(KAnd, " and ");

_LIT8(KOr, " or ");

_LIT8(KIn, " in ");

_LIT8(KRtBrace, ") ");

_LIT8(KLtBrace, "( ");

_LIT8(KComma, ", ");

_LIT8(KSemiColon, ";");

_LIT8(KOrder, " order by id ASC");

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	_LIT(KTestDbFileName, "\\messaging.db");

	_LIT(KMainDummyDBName, "\\messaging_master.db");

#else

	_LIT(KTestDbFileName, "C:\\messaging.db");

#endif

//Test msv id values

#define KTestMsvId1Value	0x3039

#define KTestMsvId2Value	0x303A

#define KTestMsvId3Value	0x303B

#define KTestMsvId4Value	0x303C

/**

 * CTestDbAdapter

 *

 * Class used for unit testing of CMsvDBAdapter.

 *  - Preq1189 - The test class dealt with only a single database. This database

 *				 was created in SetupL() and deleted in TearDownL() after iMsvDbAdaptor

 *				 was destroyed.

 *  - Preq557 - The test class deals with multiple databases in simulated drives.

 *				SetupL() creates the dummy database (main.db) in the system

 *				default drive and also the messaging database (messaging.db) with

 *				the Root entry as per the design. Wherever other databases are

 *				required, they must be checked for existence in the test function

 *				and deleted if required.

 */

CTestDbAdapter::CTestDbAdapter()

	{

	}

CTestDbAdapter::~CTestDbAdapter()

	{

	}

void CTestDbAdapter::SetupL()

	{

	_LIT(KFunction, "SetupL");

	INFO_PRINTF1(KFunction);

    __UHEAP_MARK;

	//Create and open the database	

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)	

	TParse parse;

	TPtrC drive = TDriveUnit(RFs::GetSystemDrive()).Name();

	parse.Set(KTestDbFileName, &drive, NULL);

	TFileName dbName = parse.FullName();

	RSqlDatabase::Delete(dbName);

	iMsvDbAdaptor = CMsvDBAdapter::NewL();

	TInt sysDrive = (TInt)RFs::GetSystemDrive();

	TMsvId maxId = 0;

	TRAPD(error, CMsvDBAdapter::CreateDBL(TDriveNumber(sysDrive)));

	ASSERT_EQUALS(error, KErrNone);

	//Let driveId for system drive be 1.

	TRAP(error, iMsvDbAdaptor->AttachDBL(TDriveUnit(sysDrive), 1, maxId));

	ASSERT_EQUALS(error, KErrNone);

	ASSERT_EQUALS(maxId, KMsvRootIndexEntryId); //root

#else

	TFileName dbName(KTestDbFileName);

	RSqlDatabase::Delete(dbName);

	iMsvDbAdaptor = CMsvDBAdapter::NewL(dbName);

#endif

	TInt err =	iFileHandle.Connect();

	MY_ASSERT_EQUALS(err, KErrNone);

	CFileMan* file = CFileMan::NewL(iFileHandle);

	file->Copy(KMSGINI_2, KSTDMSGINI);

	delete file;

	//Create entry free pool.

	TDblQue<CMsvCacheVisibleFolder> iEntryCache;

	iMsvEntryFreePool = CMsvEntryFreePool::CreateL(&iEntryCache);

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)	

	//Create the preferred drive list.

	iDriveList = CMsvPreferredDriveList::CreateL();

	//Simulate a filled drive list.

	TMsvPreferredDrive driveEntry;

	driveEntry.driveNum = RFs::GetSystemDrive();

	driveEntry.driveId = 1;

	driveEntry.status = EMsvMessageStoreAvailableStatus;

	iDriveList->Insert(driveEntry, 0);

	driveEntry.driveNum = EDriveE;

	driveEntry.driveId = 2;

	driveEntry.status = EMsvMessageStoreAvailableStatus;

	iDriveList->Insert(driveEntry, 1);

	iDriveList->SetCurrentDriveIndex(0); //C: is default.

#endif

	}

void CTestDbAdapter::TearDownL()

	{

	_LIT(KFunction, "TearDownL");

	INFO_PRINTF1(KFunction);

	if(iMsvDbAdaptor)

		{

		delete iMsvDbAdaptor;

		}

	iMsvDbAdaptor = NULL;

	//Delete database

	TFileName dbName(KTestDbFileName);

	TInt err = RSqlDatabase::Delete(dbName);

	CFileMan* file = CFileMan::NewL(iFileHandle);

	file->Copy(KSTDMSGINI, KMSGINI_2);

	delete file;

	iFileHandle.Close();

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)	

	delete iDriveList;

#endif

	// Delete entry free pool.

#ifdef _DEBUG

	CMsvEntryFreePool::Destroy(iMsvEntryFreePool);

	iMsvEntryFreePool = NULL;

#else

	delete iMsvEntryFreePool;

	iMsvEntryFreePool = NULL;

#endif

	__UHEAP_MARKEND;

	}

void CTestDbAdapter::TestDatabaseBasics()

	{

	_LIT(KFunction, "TestDatabaseBasics");

	INFO_PRINTF1(KFunction);

	// 1. Creation of new database.

	// Already tested in SetupL(). Close the database.	

	delete iMsvDbAdaptor;

	iMsvDbAdaptor = NULL;

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	// 2. Test creation of already created database adapter.

	//TFileName dbName(KTestDbFileName);

	TRAPD(err, iMsvDbAdaptor = CMsvDBAdapter::NewL());

	MY_ASSERT_EQUALS(err, KErrNone);

	/*// 2.1 Attempt creating database in a drive that already has one.

	//ISSUE*/

	delete iMsvDbAdaptor;

	iMsvDbAdaptor = NULL;

	// 3. Test creation of a database, and attaching of another database to it.

	// 3.0 Cleanup: deleting the DB if it was created in an earlier test.

	TParse parse;

	TPtrC drive = TDriveUnit(EDriveE).Name();

	parse.Set(KTestDbFileName, &drive, NULL);

	TFileName dbName = parse.FullName();

	RSqlDatabase::Delete(dbName);

	TInt sysDrive = RFs::GetSystemDrive();

	drive.Set(TDriveUnit(sysDrive).Name());

	parse.Set(KTestDbFileName, &drive, NULL);

	dbName = parse.FullName();

	RSqlDatabase::Delete(dbName);

	// 3.1 Create the databases.

	TRAP(err, iMsvDbAdaptor = CMsvDBAdapter::NewL());

	MY_ASSERT_EQUALS(err, KErrNone);

	// 3.2 Attach default drive's database.

	TMsvId maxId = 0;

	TInt driveId = 1;

	TRAPD(error, CMsvDBAdapter::CreateDBL(TDriveNumber(sysDrive)));

	MY_ASSERT_EQUALS(error, KErrNone);

	TRAP(err, iMsvDbAdaptor->AttachDBL(TDriveUnit(sysDrive), driveId, maxId));

	MY_ASSERT_EQUALS(err, KErrNone);

	MY_ASSERT_EQUALS(maxId, KMsvRootIndexEntryId); //root

	// 3.3 Attach external drive's database.

	maxId = 0;

	driveId = 2;

	TRAP(err, CMsvDBAdapter::CreateDBL(TDriveNumber(EDriveE)));

	MY_ASSERT_EQUALS(err, KErrNone);

	TRAP(err, iMsvDbAdaptor->AttachDBL(TDriveUnit(EDriveE), driveId, maxId));

	MY_ASSERT_EQUALS(err, KErrNone);

	// 3.4 Detach a database.

	driveId = 2;

	TRAP(err, iMsvDbAdaptor->DetachDBL(driveId));

	MY_ASSERT_EQUALS(err, KErrNone);

#else

	// 2. Test creation of already created database.

	TInt err;

	TFileName dbName(KTestDbFileName);

	TRAP(err, iMsvDbAdaptor = CMsvDBAdapter::NewL(dbName));

	MY_ASSERT_EQUALS(err, KErrAlreadyExists);

	delete iMsvDbAdaptor;

	iMsvDbAdaptor = NULL;

	// 3. Test opening of already created database.

	TRAP(err, iMsvDbAdaptor = CMsvDBAdapter::OpenL(dbName));

	MY_ASSERT_EQUALS(err, KErrNone);

	// 4. Test opening of already opened database.

	/*

	CMsvDBAdapter* msvDBAdaptor = NULL;

	TRAP(err, msvDBAdaptor = CMsvDBAdapter::OpenL(dbName));

	MY_ASSERT_EQUALS(err, KErrInUse);

	delete msvDBAdaptor;

	msvDBAdaptor = NULL;

	*/

	delete iMsvDbAdaptor;

	iMsvDbAdaptor = NULL;

	// 5. Test Deleting database and reopening.

	// The testcase also test opening non-existent DB.

	CMsvDBAdapter::DeleteDB(dbName);

	TRAP(err, iMsvDbAdaptor = CMsvDBAdapter::OpenL(dbName));

	MY_ASSERT_EQUALS(err, KErrNotFound);

	delete iMsvDbAdaptor;

	iMsvDbAdaptor = NULL;

#endif

	}

// Create a new entry into DB.

// Does not test anything.

void CTestDbAdapter::CreateEntryL(TMsvId aId, TMsvId aParentId, TUid aUid, TMsvId& aVisibleFolder, TBool aIsVisible /* (Default = EFalse)*/, TBool isPreparationFlag /*(Default=EFalse)*/)

	{

	TMsvEntry sampleTMsvEntry;

	sampleTMsvEntry.SetId(aId);

	sampleTMsvEntry.SetParent(aParentId);

	sampleTMsvEntry.iDate.UniversalTime();

	sampleTMsvEntry.iType = aUid;

	sampleTMsvEntry.SetVisible(aIsVisible);

	sampleTMsvEntry.SetVisibleFolderFlag(aIsVisible);

	// Extra Information (Needed only in TestGetEntry()

	sampleTMsvEntry.SetUnread(ETrue);

	sampleTMsvEntry.iServiceId = aId+10;		// Some Random Id.

	sampleTMsvEntry.iRelatedId = aId+20;		// Some Random Id.

	sampleTMsvEntry.iMtm = aUid;		

	sampleTMsvEntry.iSize = 32;

	sampleTMsvEntry.iError = NULL;		

	sampleTMsvEntry.iBioType = 64;		

	sampleTMsvEntry.iMtmData1 = 64;		

	sampleTMsvEntry.iMtmData2 = 64;		

	sampleTMsvEntry.iMtmData3 = 64;	

	sampleTMsvEntry.SetInPreparation(isPreparationFlag);

	/*

	_LIT(KName, "Hello World");

	HBufC* data = HBufC::NewL(15); 

	TPtr ptr(data->Des());

	ptr.Copy(KName);

	sampleTMsvEntry.iDescription.Set(ptr);

	*/

	_LIT8(KName, "Hello World");

	sampleTMsvEntry.iDescription.Set(_L("Hello World"));

	iMsvDbAdaptor->CreateEntryL(sampleTMsvEntry, aVisibleFolder);	

	}

void CTestDbAdapter::TestCreateEntry()

	{

	_LIT(KFunction, "TestCreateEntry");

	INFO_PRINTF1(KFunction);

	TInt err;

	TBool ret = EFalse;

	TMsvId visibleFolder;

	// 1. Check if root entry was created when the database was created.

	visibleFolder = KMsvRootIndexEntryId;

#if (!defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	TRAP(err, CreateEntryL(KMsvRootIndexEntryId, KErrNotFound, KUidMsvRootEntry, visibleFolder, ETrue));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_EQUALS(KMsvRootIndexEntryId, visibleFolder);

#endif

	TRAP(err, ret = EntryExists(KMsvRootIndexEntryId));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_TRUE(ret);

	// 2. Creating duplicate root entry.

	TRAP(err, CreateEntryL(KMsvRootIndexEntryId, KErrNotFound, KUidMsvRootEntry, visibleFolder));

	MY_ASSERT_EQUALS(KSqlErrConstraint, err);

	// 3. Creating service folder under root.

	visibleFolder = KMsvRootIndexEntryId;

	TRAP(err, CreateEntryL(KMsvLocalServiceIndexEntryId, KMsvRootIndexEntryId, KUidMsvServiceEntry, visibleFolder));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_EQUALS(KMsvRootIndexEntryId, visibleFolder);

	TRAP(err, ret = EntryExists(KMsvLocalServiceIndexEntryId));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_TRUE(ret);

	// 4. Creating another service folder under root.

	TRAP(err, CreateEntryL(KFirstFreeEntryId, KMsvRootIndexEntryId, KUidMsvServiceEntry, visibleFolder));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_EQUALS(KMsvRootIndexEntryId, visibleFolder);

	TRAP(err, ret = EntryExists(KFirstFreeEntryId));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_TRUE(ret);

	// 5. Creating normal folder under root.

	TRAP(err, CreateEntryL(KMsvGlobalInBoxIndexEntryId, KMsvRootIndexEntryId, KUidMsvFolderEntry, visibleFolder, ETrue));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_EQUALS(KMsvRootIndexEntryId, visibleFolder);

	TRAP(err, ret = EntryExists(KMsvGlobalInBoxIndexEntryId));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_TRUE(ret);

	// 6. Creating Message entry under root.

	TRAP(err, CreateEntryL(KFirstFreeEntryId+1, KMsvRootIndexEntryId, KUidMsvMessageEntry, visibleFolder));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_EQUALS(KMsvRootIndexEntryId, visibleFolder);

	TRAP(err, ret = EntryExists(KFirstFreeEntryId+1));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_TRUE(ret);

	// 7. Creating attachment entry under root.

	TRAP(err, CreateEntryL(KFirstFreeEntryId+2, KMsvRootIndexEntryId, KUidMsvAttachmentEntry, visibleFolder));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_EQUALS(KMsvRootIndexEntryId, visibleFolder);

	TRAP(err, ret = EntryExists(KFirstFreeEntryId+2));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_TRUE(ret);

	// 8. Creating 100 message entries under Inbox.

	visibleFolder = KMsvGlobalInBoxIndexEntryId;

	for(int index=3; index<103; index++)

		{

		TRAP(err, CreateEntryL(KFirstFreeEntryId+index, KMsvGlobalInBoxIndexEntryId, KUidMsvMessageEntry, visibleFolder));

		//Avoid using MY_ASSERT_EQUALS as it will clutter the log file.

		ASSERT_EQUALS(KErrNone, err);

		ASSERT_EQUALS(KMsvGlobalInBoxIndexEntryId, visibleFolder);

		}

	MY_ASSERT_TRUE(EntryExists(KFirstFreeEntryId+3));

	MY_ASSERT_TRUE(EntryExists(KFirstFreeEntryId+4));

	MY_ASSERT_TRUE(EntryExists(KFirstFreeEntryId+40));

	MY_ASSERT_TRUE(EntryExists(KFirstFreeEntryId+70));

	MY_ASSERT_TRUE(EntryExists(KFirstFreeEntryId+101));

	MY_ASSERT_TRUE(EntryExists(KFirstFreeEntryId+102));

	MY_ASSERT_TRUE(!EntryExists(KFirstFreeEntryId+103));

	MY_ASSERT_TRUE(!EntryExists(KFirstFreeEntryId+104));

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	// 9. Attach a new database to it. Create entries in the first and the 

	//	  attached databases using appropriate TMsvId's which have appropriate

	//	  drive masks.

	// 9.0 Cleanup: deleting the DB if it was created in an earlier test.

	TParse parse;

	TPtrC drive = TDriveUnit(EDriveE).Name();

	parse.Set(KTestDbFileName, &drive, NULL);

	TFileName dbName = parse.FullName();

	RSqlDatabase::Delete(dbName);

	// 9.1 Create DB with driveId 2. System drive had driveId 1.

	TMsvId maxId = 0;

	TInt driveId = 2;

	TRAP(err, CMsvDBAdapter::CreateDBL(TDriveNumber(EDriveE)));

	MY_ASSERT_EQUALS(err, KErrNone);

	TRAP(err, iMsvDbAdaptor->AttachDBL(TDriveUnit(EDriveE), driveId, maxId));

	MY_ASSERT_EQUALS(err, KErrNone);

	// 9.2 Create an entry in the first database.

	visibleFolder = KMsvRootIndexEntryId;

	TRAP(err, CreateEntryL(KFirstFreeEntryId+150, KMsvRootIndexEntryId, KUidMsvAttachmentEntry, visibleFolder));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_EQUALS(KMsvRootIndexEntryId, visibleFolder);

	MY_ASSERT_TRUE(EntryExists(KFirstFreeEntryId+150));

	// 9.3 Create an entry in the attached database.

	visibleFolder = KMsvRootIndexEntryId;

	TRAP(err, CreateEntryL((driveId<<28)|KFirstFreeEntryId+2, KMsvRootIndexEntryId, KUidMsvAttachmentEntry, visibleFolder));

	MY_ASSERT_EQUALS(KErrNone, err);

	//Notice that the above Id also exists in the first database, and that

	//there is no conflict.

	MY_ASSERT_EQUALS(KMsvRootIndexEntryId, visibleFolder);

	MY_ASSERT_TRUE(EntryExists((driveId<<28)|KFirstFreeEntryId+2));

#endif

	}

TBool CTestDbAdapter::EntryExists(TMsvId aId)

	{

	TBool val = EFalse;

	TRAP_IGNORE(val = iMsvDbAdaptor->EntryExistsL(aId));

	return val;

	}

void CTestDbAdapter::TestEntryExists()

	{

	_LIT(KFunction, "TestEntryExists");

	INFO_PRINTF1(KFunction);

	TInt err;

	TMsvId visibleFolder;

	TUint32 start, stop, diff1;

	CMsvEntrySelection* selection = NULL;

	TRAP_IGNORE(selection = new(ELeave) CMsvEntrySelection());

	TInt bulkCount = 100;

	visibleFolder = KMsvRootIndexEntryId;		

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	// 1. Check if root entry was created when the database was created.

#else

	// 1. Creating root entry.

	TRAP(err, CreateEntryL(KMsvRootIndexEntryId, KErrNotFound, KUidMsvRootEntry, visibleFolder, ETrue));

	MY_ASSERT_EQUALS(KErrNone, err);

	MY_ASSERT_EQUALS(KMsvRootIndexEntryId, visibleFolder);

#endif

	start = User::FastCounter(); 

	MY_ASSERT_TRUE(EntryExists(KMsvRootIndexEntryId));

	stop = User::FastCounter();

	diff1 = stop - start;

	// 2. Create in bulk and test

	TRAP(err, CreateEntryL(KFirstFreeEntryId, KMsvRootIndexEntryId, KUidMsvMessageEntry, visibleFolder));

	MY_ASSERT_EQUALS(err, KErrNone);

	TRAP_IGNORE(selection->AppendL(KFirstFreeEntryId));

	visibleFolder = KFirstFreeEntryId;

	for(TInt index = 1; index < bulkCount; ++index)

		{

		TRAP(err, CreateEntryL(KFirstFreeEntryId+index, KFirstFreeEntryId, KUidMsvMessageEntry, visibleFolder));

		TRAP_IGNORE(selection->AppendL(KFirstFreeEntryId+index));

		ASSERT_EQUALS(err, KErrNone);

		}

	// 3. Test scalar select query method

	diff1 = 0;

	for(TInt index = 0; index < bulkCount; ++index)

		{

		start = User::FastCounter(); 

		ASSERT_TRUE(EntryExists(selection->At(index)));

		stop = User::FastCounter();

		diff1 += stop - start;

		}

	diff1 = diff1 / bulkCount;

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	// 4. Create and attach a second database. Create entries in it and test.

	// 4.0 Cleanup: deleting the DB if it was created in an earlier test.

	TParse parse;

	TPtrC drive = TDriveUnit(EDriveE).Name();

	parse.Set(KTestDbFileName, &drive, NULL);

	TFileName dbName = parse.FullName();

	RSqlDatabase::Delete(dbName);

	// 4.1 Create DB with driveId 2. System drive had driveId 1.

	TMsvId maxId = 0;