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

// Name of test harness: T_MIUT07

// Component: IMCM

// Owner: EH

// Brief description of test harness:

// Tests CImOffLineOperation.

// Detailed description of test harness:

// As above.

// Input files required to run test harness:

// None

// Intermediate files produced while running test harness:

// <DRIVE>:\msgtest\T_MIUT07\T_IMCM.log

// Output files produced by running test harness:

// <DRIVE>:\msglogs\T_MIUT07.<PLATFORM>.<VARIANT>.LOG.txt

// Description of how to build test harness:

// cd \msg\imcm\

// bldmake bldfiles

// abld test build

// Description of how to run test harness:

// The following instructions are the same for all platforms:

// 1. Build T_DB test harness from COMMDB component:

// cd \commdb\group

// bldmake bldfiles

// abld test build t_db

// 2. Build the test utilities:

// cd \msg\testutils\group\

// bldmake bldfiles

// abld build

// WINS running instructions:

// 1. \epoc32\release\wins\<VARIANT>\T_MIUT07.exe can be used at the command prompt

// or executable can be run from Windows Explorer.

// All other platform running instructions:

// 1. Copy \epoc32\release\<PLATFORM>\<VARIANT>\T_MIUT07.exe onto the other platform

// 2. Copy \epoc32\release\<PLATFORM>\<VARIANT>\MSVTESTUTILS.DLL into 

// <DRIVE>:\system\libs on the other platform

// 3. Copy \epoc32\release\<PLATFORM>\<VARIANT>\EMAILTESTUTILS.DLL into 

// <DRIVE>:\system\libs on the other platform

// 4. Run T_MIUT07.exe on the other platform

// 

//

#include "emailtestutils.h"

#include <offop.h>

#include "MIUTLOG.H"  // used for Logs

#include "CFakeStoreManager.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "msvconsts.h"

#endif

//

// TestScheduler implements an error handler that doesn't panic.

class TestScheduler : public CActiveScheduler

	{

	public:

		void Error (TInt aError) const;

	};

//

// Session observer, reports stuff it is notified about

class CDummySessionObserver : public CBase , public MMsvSessionObserver

	{

	public:

		void HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1, TAny* aArg2, TAny* aArg3);

	};

//

class CDummyUndo : public MImUndoOffLineOperation 

	{

	public:

	    void UndoOffLineChangesL(const CImOffLineOperation& /*aDeleted*/, TMsvId /*aFolderId*/) {}; 

	};

//

class CDummyStoreObserver : public CBase, public MMsvStoreObserver

	{

	public:

		void HandleStoreEvent(TMsvStoreEvent /*aEvent*/, TMsvId /*aId*/) {};

	};

//

class CDerivedMsvStore : public CMsvStore

	{

	public:

		CDerivedMsvStore(MMsvStoreObserver& aObserver, RFs& aFs, TMsvId aId, MMsvStoreManager& aStoreManager)

			: CMsvStore(aObserver, aFs, aId, aStoreManager) {};

	public:

		static CMsvStore* MyOpenForReadL(MMsvStoreObserver& aObserver, RFs& aFs, MMsvStoreManager& aStoreManager, TMsvId aId)

			{

			return CMsvStore::OpenForReadL(aObserver, aFs, aStoreManager, aId);

			}

		static CMsvStore* MyOpenForWriteL(MMsvStoreObserver& aObserver, RFs& aFs, MMsvStoreManager& aStoreManager, TMsvId aId)

			{

			return CMsvStore::OpenForWriteL(aObserver, aFs, aStoreManager, aId);

			}

	};

//

// Globals needed for the test code

LOCAL_D RTest test(_L("T_OFFOP - Test CImOffLineOperation class"));

LOCAL_D CTrapCleanup* theCleanup;

LOCAL_D TMsvEntry entry; 

LOCAL_D CImLog* log;

LOCAL_D CEmailTestUtils* testUtils;

#define KtheFirstCommand	_L8("FirstCommand")

#define KtheSecondCommand	_L8("SecondCommand")

//

// Client side classes

CDummySessionObserver*  theSessionObserver = NULL;

CMsvSession*			theSession         = NULL;

TMsvId					theServiceId       = KMsvLocalServiceIndexEntryId;

CImOperationQueueList*  theQueue           = NULL;

// Folders created, to test the lists of queued operations stored within folders.

CMsvEntrySelection*		theFolders		   = NULL; 

CMsvEntrySelection*		theSubfolders	   = NULL; 

CDummyUndo				theDummyUndoer;	

//

LOCAL_D const TUid theTechnologyTypeUid   = KUidMsgTypeIMAP4;

// Nr folders to be created.

const TInt KNrFolders         = 2;

const TInt KNrSubFolders      = 2;

const TInt KNrQueuedPerFolder = 5;

const TInt KNrToDelete        = 5;

//

// Data component file name for client

// The data component file is a file belonging to the

// MTM. a class CMtmGroupData is stored in it, specifying the

// UID's of the components belonging to the MTM.

// The CMsvSession class needs it to install the MTM..

// the function CreateDataComponentFileStoreL creates the file for this MTM.

#define DataComponentFileName _L("c:\\system\\mtm\\impc.dat")  

// Service we're connected to.

TFileName theRootDir = _L("C:\\Data\\impc\\");

//

const TMsvId	KDummyMessageId		 =0x01101;

const TMsvId	KDummyTargetFolderId =0x01102;

const TInt		KDummyCommandId      =0x0123;

unsigned char *theFirstCommand  = (unsigned char *)"FirstCommand";

unsigned char *theSecondCommand = (unsigned char *)"SecondCommand";

//

void TestScheduler::Error(TInt anError) const

	{

	test.Printf(TRefByValue<const TDesC>_L("Active object left with error code %d\n"), anError);

	CActiveScheduler::Stop();

	}

//

void CDummySessionObserver::HandleSessionEventL(TMsvSessionEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)

	{

	};

//

LOCAL_C TMsvId CreateFolderEntryL(CMsvEntry& aClientEntry)

//

// Create a folder entry below aClientEntry, and see if there was an error.

//

	{

	log->AppendComment(_L8("\tCreating Folder Entry"));

	TBool result = ETrue;

	TMsvEntry folderEntry;

	folderEntry.iDescription.Set(_L("IMAP4 Folder"));

	folderEntry.iDetails.Set(_L("IMAP4"));

	folderEntry.iType = KUidMsvFolderEntry;

	folderEntry.iServiceId = theServiceId;

	folderEntry.iSize = 0;

	folderEntry.iMtm = KUidMsgTypeIMAP4;

	CMsvOperationWait* wait = CMsvOperationWait::NewLC();

	wait->Start();

	CMsvOperation*  opert = aClientEntry.CreateL(folderEntry, wait->iStatus);

	CActiveScheduler::Start(); // operation complete

	TBool result1=(opert->iStatus.Int()==KErrNone);

	if (!result1)

		log->AppendError(_L8("\t\tiStatus does not equal 0"),-1);

	result&=result1;

	TBool result2=(opert->Mtm()==KUidMsvLocalServiceMtm);

	if (!result2)

		log->AppendError(_L8("\t\tiMtm does not equal KUidMsvLocalServiceMtm"),-1);

	result&=result2;

	TMsvLocalOperationProgress details;

	TPckgC<TMsvLocalOperationProgress> package(details);	

	package.Set(opert->ProgressL());

	TBool result3=(package().iType==TMsvLocalOperationProgress::ELocalNew);

	if (!result3)

		log->AppendError(_L8("\t\tiType does not equal ELocalNew"),-1);

	result&=result3;

	TBool result4=(package().iTotalNumberOfEntries==1);

	if (!result4)

		log->AppendError(_L8("\t\tiTotalNumberOfEntries does not equal 1"),-1);

	result&=result4;

	TBool result5=(package().iError==KErrNone);

	if (!result5)

		log->AppendError(_L8("\t\tiError not equal to KErrNone"),-1);

	result&=result5;

	TBool result6=(package().iNumberCompleted==1);

	if (!result6)

		log->AppendError(_L8("\t\tiNumberCompleted not equal to 1"),-1);

	result&=result6;

	TBool result7=(package().iNumberFailed==0);

	if (!result7)

		log->AppendError(_L8("\t\tiNumberFailed not equal to 0"),-1);

	result&=result7;

	TBool result8=(package().iNumberRemaining==0);

	if (!result8)

		log->AppendError(_L8("\t\tiNumberRemaining not equal to 0()"),-1);

	result&=result8;

	delete opert; opert=NULL;

	CleanupStack::PopAndDestroy();//wait

	log->AppendComment(_L8("\tCreated Folder Entry"));

	// The Id of the service entry

	return package().iId; 

	}

LOCAL_C TBool DeleteFolderEntryL(CMsvEntry& aClientEntry, TMsvId aIdToDelete)

//

// Delete a folder entry below aClientEntry, and see if there was an error.

//

	{

	log->AppendComment(_L8("\tDeleting Folder Entry"));

	TBool result = ETrue;

	CMsvOperationWait* wait = CMsvOperationWait::NewLC();

	wait->Start();

	CMsvOperation*  opert = aClientEntry.DeleteL(aIdToDelete, wait->iStatus);

	CActiveScheduler::Start(); // operation complete

	TBool result1=(opert->iStatus.Int()==KErrNone);

	if (!result1)

		log->AppendError(_L8("\t\tiStatus does not equal 0"),-1);

	result&=result1;

	TBool result2=(opert->Mtm()==KUidMsvLocalServiceMtm);

	if (!result2)

		log->AppendError(_L8("\t\tiMtm not equal to KUidMsvLocalServiceMtm"),-1);

	result&=result2;

	TMsvLocalOperationProgress details;

	TPckgC<TMsvLocalOperationProgress> package(details);	

	package.Set(opert->ProgressL());

	TBool result3=(package().iType==TMsvLocalOperationProgress::ELocalDelete);

	if (!result3)

		log->AppendError(_L8("\t\tiType not equal to ELocalDelete"),-1);

	result&=result3;

	TBool result4=(package().iTotalNumberOfEntries==package().iNumberCompleted);

	if (!result4)

		log->AppendError(_L8("\t\tiTotalNumberOfEntries not equal to iNumberCompleted"),-1);

	result&=result4;

	TBool result5=(package().iError==KErrNone);

	if (!result5)

		log->AppendError(_L8("\t\tiError does not equal KErrNone"),-1);

	result&=result5;

	TBool result6=(package().iNumberFailed==0);

	if (!result6)

		log->AppendError(_L8("\t\tiNumberFailed does not equal 0"),-1);

	result&=result6;

	TBool result7=(package().iNumberRemaining==0);

	if (!result7)

		log->AppendError(_L8("\t\tiNumberRemaining does not equal 0"),-1);

	result&=result7;

	delete opert; opert=NULL;

	CleanupStack::PopAndDestroy();//wait

	log->AppendComment(_L8("\tDeleted Folder Entry"));

	return result;

	}

LOCAL_C CMsvEntrySelection* CreateFoldersL(TMsvId aRootId, TInt aNrFolders)

	{

	CMsvEntry* msventry=CMsvEntry::NewL(*theSession, aRootId, TMsvSelectionOrdering());

	CleanupStack::PushL(msventry);

	TInt i;

	for ( i = 0 ; i < aNrFolders ; i ++ )

		{

		CreateFolderEntryL(*msventry);

		}

	CMsvEntrySelection* folders = msventry->ChildrenWithServiceL(theServiceId) ;

	CleanupStack::PopAndDestroy();//msventry

	log->AppendComment(_L8("\tCreated Folders"));

	return folders;

	}

LOCAL_C TBool testCreateFoldersL()

	{

	log->AppendComment(_L8("\tTesting Created Folders"));

	TBool result = ETrue;

	theFolders = CreateFoldersL(KMsvGlobalInBoxIndexEntryId, KNrFolders);

	TBool result1=(theFolders->Count() == KNrFolders);

	if (!result1)

		log->AppendError(_L8("\t\tThe number of folders created is incorrect"),-1);

	result&=result1;

	theSubfolders = CreateFoldersL((*theFolders)[0], KNrSubFolders);

	TBool result2=(theSubfolders->Count() == KNrSubFolders);

	if (!result2)

		log->AppendError(_L8("\t\tThe number of subfolders created is incorrect"),-1);

	result&=result;

	return result;

	}

LOCAL_C void StoreQueuedOperationsL(CMsvEntry& aEntry, MImOffLineOperationArray& aArray)

	{

	CMsvStore* store=aEntry.EditStoreL();

	CleanupStack::PushL(store);

    CImOffLineArrayStore externaliser(aArray);

    externaliser.StoreL(*store);

    store->CommitL();

    CleanupStack::PopAndDestroy();//store

	log->AppendComment(_L8("\tStored Queued Operations"));

	}

LOCAL_C CImOffLineOperationArray* BuildOfflineOperationArrayLC()

    {

	TInt i;

    CImOffLineOperationArray* array = CImOffLineOperationArray::NewL();

    CleanupStack::PushL(array);

    CImOffLineOperation operation;

    for (i=0;i<KNrQueuedPerFolder-2;i++)

        {

        array->AppendOperationL(operation);

        }

	TBuf8<100> scrap;

    scrap = _L8(theFirstCommand);

    operation.SetMtmSpecificCommandL(KDummyMessageId, KDummyTargetFolderId, KDummyCommandId, scrap);

    array->AppendOperationL(operation);

    scrap = _L8(theSecondCommand);

    operation.SetMtmSpecificCommandL(KDummyMessageId, KDummyTargetFolderId, KDummyCommandId, scrap);

	array->AppendOperationL(operation);

    log->AppendComment(_L8("\tBuilt OffLine Operation Array"));

    return array;

    }

LOCAL_C TBool testOffLineArraysFirstFiveEqual(MImOffLineOperationArray& aArray1, MImOffLineOperationArray& aArray2)

    {

	log->AppendComment(_L8("\tTesting Offline Arrays are Equal"));

	TBool result = ETrue;

    TInt i;

    for (i=0;i<KNrQueuedPerFolder;i++)

        result &= (aArray1.Operation(i).Equals(aArray2.Operation(i)));

	if (!result)

		log->AppendError(_L8("\t\tOperations are not equal on the arrays"),-1);

	return result;

    }

LOCAL_C TBool testPopulateFoldersWithQueuedOperationsL()

	{

	log->AppendComment(_L8("\tPopulating Folders With Queued Operations"));

	TBool result = ETrue;

    TInt i;

	CMsvEntry* msventry=CMsvEntry::NewL(*theSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

	CleanupStack::PushL(msventry);

    CImOffLineOperationArray* array = BuildOfflineOperationArrayLC();

    // See to it that the operations came through ok...

    CImOffLineOperation operation;

    TBuf8<100> scrap;

    scrap = _L8(theFirstCommand);

    operation.SetMtmSpecificCommandL(KDummyMessageId, KDummyTargetFolderId, KDummyCommandId, scrap);

    TBool result1=(operation.Equals(array->Operation(KNrQueuedPerFolder-2)));

	if (!result1)

		log->AppendError(_L8("\t\tOperations are not equal"),-1);

	result&=result1;

    scrap = _L8(theSecondCommand);

    operation.SetMtmSpecificCommandL(KDummyMessageId, KDummyTargetFolderId, KDummyCommandId, scrap);

    TBool result2=(operation.Equals(array->Operation(KNrQueuedPerFolder-1)));

	if (!result2)

			log->AppendError(_L8("\t\tOperations are not equal"),-1);

	result&=result2;

    for (i=0;i<theFolders->Count();i++)

		{

		msventry->SetEntryL((*theFolders)[i]);

		StoreQueuedOperationsL(*msventry, *array);

		}

	for (i=0;i<theSubfolders->Count();i++)

		{

		msventry->SetEntryL((*theSubfolders)[i]);

		StoreQueuedOperationsL(*msventry, *array);

		}

    CleanupStack::PopAndDestroy();//array 

    CleanupStack::PopAndDestroy();//msventry

	return result;

	}

LOCAL_C TBool testReadBackOperationsL()

	{

	log->AppendComment(_L8("\tReading Back Operations"));

	TBool result = ETrue;

	CMsvEntry* msventry=CMsvEntry::NewL(*theSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

	CleanupStack::PushL(msventry);

    CImOffLineOperationArray* array = CImOffLineOperationArray::NewL();

    CleanupStack::PushL(array);

	msventry->SetEntryL((*theFolders)[0]);

	CMsvStore* store=msventry->ReadStoreL();

	CleanupStack::PushL(store);

    CImOffLineArrayStore internaliser(*array);

    internaliser.RestoreL(*store);

    CleanupStack::PopAndDestroy();//store

    CImOffLineOperationArray* built = BuildOfflineOperationArrayLC();

    result &= testOffLineArraysFirstFiveEqual(*array, *built);

    CleanupStack::PopAndDestroy();//built

    CleanupStack::PopAndDestroy();//array 

    CleanupStack::PopAndDestroy();//msventry

	return result;

	}

LOCAL_C TBool testReadBackQueuedOperationsL()

	{

	log->AppendComment(_L8("\tReading Back Queued Operations"));

	TBool result = ETrue;

	CMsvEntry* msventry=CMsvEntry::NewL(*theSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

	CleanupStack::PushL(msventry);

    CImQueuedList* array = CImQueuedList::NewL();

    CleanupStack::PushL(array);

    msventry->SetEntryL((*theFolders)[0]);

	CMsvStore* store=msventry->ReadStoreL();

    CleanupStack::PushL(store);

    CImOffLineArrayStore internaliser(*array);

    internaliser.RestoreL(*store);

    CleanupStack::PopAndDestroy();//store

    CImOffLineOperationArray* built = BuildOfflineOperationArrayLC();

    result &= testOffLineArraysFirstFiveEqual(*array, *built);

    CleanupStack::PopAndDestroy();//built

    CleanupStack::PopAndDestroy();//array 

    CleanupStack::PopAndDestroy();//msventry

	return result;

	}

LOCAL_C TBool testDeleteFoldersL()

	{

	log->AppendComment(_L8("\tDeleting Folders"));

	TBool result = ETrue;

	CMsvEntry* msventry=CMsvEntry::NewL(*theSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

	CleanupStack::PushL(msventry);

	TInt i;

	for ( i = 0 ; i < theFolders->Count() ; i ++ )

		{

		result &= DeleteFolderEntryL(*msventry, (*theFolders)[i]);

		}

	if (!result)

			log->AppendError(_L8("\t\tError in Deleting Folder Entry"),-1);

	CleanupStack::PopAndDestroy();//msventry

	delete theFolders;

	theFolders = NULL;

	delete theSubfolders;

	theSubfolders = NULL;

	return result;

	}

LOCAL_C TBool testClearInboxL()

	{

	TBool result = ETrue;

	log->AppendComment(_L8("\tClearing Inbox"));

	CMsvEntry* msventry=CMsvEntry::NewL(*theSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());

	CleanupStack::PushL(msventry);

	theFolders = msventry->ChildrenWithServiceL(theServiceId) ;

	CleanupStack::PopAndDestroy();//msventry

	result &= testDeleteFoldersL();

	return result;

	}

LOCAL_C TBool CreateDataComponentFileStoreL()

//

// Test read file handling.

//

	{

// Open file

	CMtmDllInfoArray* mtmdllinfoarray=new(ELeave) CMtmDllInfoArray();

	CleanupStack::PushL(mtmdllinfoarray);

	CMtmDllInfo* mtmdllinfo1=CMtmDllInfo::NewL(_L("IMAP4 SERVER component"),TUidType(KDynamicLibraryUid,KUidMtmServerComponent,TUid::Uid(KUidMtmDefaultSpecificVal)),KImap4ServerMtmFileName,1,TVersion(2,0,0));

	mtmdllinfoarray->AddMtmDllInfoL(mtmdllinfo1);

	CMtmDllInfo* mtmdllinfo2=CMtmDllInfo::NewL(_L("IMAP4 CLIENT component"),TUidType(KDynamicLibraryUid,KUidMtmClientComponent,TUid::Uid(KUidMtmDefaultSpecificVal)),KImap4ClientMtmFileName,1,TVersion(2,0,0));

	mtmdllinfoarray->AddMtmDllInfoL(mtmdllinfo2);

	CMtmDllInfo* mtmdllinfo3=CMtmDllInfo::NewL(_L("IMAP4 UI component"),TUidType(KDynamicLibraryUid,KUidMtmUiComponent,TUid::Uid(KUidMtmDefaultSpecificVal)),KImap4DataLayerFileName,1,TVersion(2,0,0));

	mtmdllinfoarray->AddMtmDllInfoL(mtmdllinfo3);