// Copyright (c) 2004-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_PARTIALFETCH

// Component: IMCM

// Owner: KP

// Brief description of test harness:

// Tests CImImap4GetMail - tests combination of Partial populate 

// new/all/selection when the user is already connected; connects, does 

// operation, disconnects; connects, does operation and stays online.

// Detailed description of test harness:

// As above.

// Input files required to run test harness:

// None

// Output files produced by running test harness:

// <DRIVE>:\msglogs\T_PARTIALFETCH.<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_PARTIALFETCH.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_PARTIALFETCH.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_PARTIALFETCH.exe on the other platform

// 

//

#include "emailtestutils.h"

#include <txtrich.h>

#include <commdb.h>

#include "TESTENV.h"

#include <imapconnectionobserver.h>

#include <bacline.h>

#include <cemailaccounts.h>

// For loading the serial comms device drivers 

#if defined (__WINS__)

	#define PDD_NAME		_L("ECDRV")

	#define LDD_NAME		_L("ECOMM")

#else

	#define PDD_NAME		_L("EUART1")

	#define LDD_NAME		_L("ECOMM")

#endif

// local variables etc //

class CDummyConnectionObserver : public MMsvImapConnectionObserver

	{

		void HandleImapConnectionEvent(TImapConnectionEvent aConnectionEvent);

	};

void CDummyConnectionObserver::HandleImapConnectionEvent(TImapConnectionEvent)

	{

	}

_LIT(KImcmTest, "T_PARTIALFETCH - Testing CImImap4GetMail");

RTest test(KImcmTest);

_LIT(KTestParams,"-testparams");

enum TCmdLineArgs

	{

	EArgProgramName,

	EArgTestParams,

	EArgServerAddress,

	EArgLogin,

	EArgPassword,

	EArgFolderPath,

	EArgEnd

	};

LOCAL_D TMsvId imap4Service;

LOCAL_D TMsvId smtpService;

LOCAL_D TInt globalError;

LOCAL_D CTrapCleanup* theCleanup;

LOCAL_D CEmailTestUtils* testUtils;

LOCAL_D CMsvOperation* msvOperation;

LOCAL_D CMsvEntrySelection* msvSelection;

LOCAL_D CConsoleBase* console;

class COperationActive;

LOCAL_D COperationActive* opActive;

#if 1

_LIT(KImapServer, "lon-msgtest06.intra");

_LIT8(KFolderPath, "");

#else

_LIT(KImapServer, "utter.chaos.org.uk");

_LIT8(KLoginName, "test");

_LIT8(KPassword, "testtest");

_LIT8(KFolderPath, "~/mail");

#endif

//

class TestUiTimer : public CTimer

	{

public:

	static TestUiTimer* NewLC(CConsoleBase* aConsole);

	~TestUiTimer();

	void RunL();

	void DoCancel();

	void ConstructL();

	void IssueRequest();

	void SetOperation(CMsvOperation* aOperation);

	TTimeIntervalMicroSeconds32 period;

	TPtrC Progress(TInt progressNumber);

	void SetCancelState(TInt aState);

protected:

	TestUiTimer(CConsoleBase* aConsole);

	CConsoleBase*		iConsole;

public:

	CMsvOperation*		iOperation;

private:

	TInt	iCancelState;

	};

//

TestUiTimer* TestUiTimer::NewLC(CConsoleBase* aConsole)

	{

	TestUiTimer* self = new(ELeave) TestUiTimer(aConsole);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

TestUiTimer::TestUiTimer(CConsoleBase* aConsole)

	: CTimer(1), iCancelState(200)

	{

	iConsole = aConsole;

	period = 10000;

	}

TestUiTimer::~TestUiTimer()

	{

	delete iOperation;

	}

void TestUiTimer::ConstructL()

	{

	CTimer::ConstructL();

	CActiveScheduler::Add(this);

	}

void TestUiTimer::IssueRequest()

	{

	After(period);

	}

void TestUiTimer::SetOperation(CMsvOperation* aOperation)

	{

	if(iOperation)

		{

		delete iOperation;

		iOperation=NULL;

		}

	iOperation = aOperation;

	}

void TestUiTimer::DoCancel()

	{

	CTimer::DoCancel();

	}

TPtrC TestUiTimer::Progress(TInt progressNumber)

	{

	switch (progressNumber)

		{

		case 0:

			return _L("Disconnected              ");

		case 1:

			return _L("Connecting                ");

		case 2:

			return _L("Idle                      ");

		case 3:

			return _L("Selecting                 ");

		case 4:

			return _L("Fetching                  ");

		case 5:

			return _L("Appending                 ");

		case 6:

			return _L("Copying                   ");

		case 7:

			return _L("Deleting                  ");

		case 8:

			return _L("Syncing                   ");

		case 9:

			return _L("Disconnecting             ");

		case 10:

			return _L("Busy                      ");

		case 11:

			return _L("Moving                    ");

		case 12:

			return _L("Copying New Mail          ");

		case 13:

			return _L("Moving New Mail           ");

		case 14:

			return _L("Copying Mail Selection    ");

		case 15:

			return _L("Moving Mail Selection     ");

		case 16:

			return _L("Copying All Mail          ");

		case 17:

			return _L("Moving All Mail           ");

		case 18:

			return _L("Populating New Mail       ");

		case 19:

			return _L("Populating All Mail       ");

		case 20:

			return _L("Populating Mail Selection ");

		default:

			return _L("Unknown Progress          ");

		}

	}

void TestUiTimer::SetCancelState(TInt aState)

	{

	iCancelState = aState;

	}

void TestUiTimer::RunL()

	{

	// display the current progress

	if(iOperation!=NULL)

		{

		TImap4GenericProgress temp;	

		TPckgC<TImap4GenericProgress> paramPack(temp);

		paramPack.Set(iOperation->ProgressL());

		TImap4GenericProgress progress=paramPack();	

		if (iCancelState == progress.iImap4SubStateProgress)

			{

			iConsole->Printf(_L("	Calling Cancel\n"));

			iOperation->Cancel();

			}

		iConsole->SetPos(0, 12);

		TBuf<80> progressBuf = Progress(progress.iState);

		iConsole->Printf(TRefByValue<const TDesC>_L("   Super Operation Progress: %S           "), &progressBuf);

		iConsole->SetPos(0, 13);

		progressBuf = Progress(progress.iImap4SubStateProgress);

		iConsole->Printf(TRefByValue<const TDesC>_L("   Sub Operation Progress  : %S           "), &progressBuf);

		iConsole->SetPos(0, 14);

		iConsole->Printf(TRefByValue<const TDesC>_L("   Progress:  %d/%d %d/%d Total:%d             \n"),

					progress.iMsgsDone,

					progress.iMsgsToDo,

					progress.iBytesDone,

					progress.iBytesToDo,

					progress.iTotalSize);

		iConsole->SetPos(0, 15);

		iConsole->Printf(TRefByValue<const TDesC>_L("   Error: %d                             \n"), progress.iErrorCode);

		if (!globalError && progress.iErrorCode)

			globalError=progress.iErrorCode;

		}

	IssueRequest();

	};

//

class COperationActive : public CActive

	{

public:

	COperationActive();

	~COperationActive();

	static COperationActive* NewL();

	void StartL();

	void SetOperation(CMsvOperation*);

	void SetCancelState(TInt aCancelState);

protected:

	void DoCancel();

	void RunL();

public:	

	TestUiTimer* iTimer;

private:

	TBool iSetActive;

	};

//

COperationActive::COperationActive()

: CActive(0)

	{

	}

COperationActive::~COperationActive()

	{

	Cancel();

	delete iTimer;

	}

COperationActive* COperationActive::NewL()

	{

	COperationActive* self = new (ELeave) COperationActive;

	CActiveScheduler::Add(self);

	self->iSetActive = ETrue;

	self->iTimer = TestUiTimer::NewLC(test.Console());

	CleanupStack::Pop();

	return self;

	}

void COperationActive::DoCancel()

	{

	iTimer->DoCancel();

	}

void COperationActive::StartL()

	{

	globalError=0;

	iTimer->IssueRequest();	// Start the connect observation timer

	SetActive();

	test.Console()->SetPos(0, 17);

	test.Printf(TRefByValue<const TDesC>_L("Operation TRequestStatus %d"), iStatus);

	}

void COperationActive::SetOperation(CMsvOperation *aOperation)

	{

	iTimer->SetOperation(aOperation);

	}

void COperationActive::SetCancelState(TInt aCancelState)

	{

	iTimer->SetCancelState(aCancelState);

	}

void COperationActive::RunL() 

 	{

	iTimer->Cancel();

	test.Console()->SetPos(25, 17);

	test.Printf(_L("                "));

	test.Console()->SetPos(0, 17);

	test.Printf(TRefByValue<const TDesC>_L("Operation TRequestStatus %d"), iStatus);

	CActiveScheduler::Stop();

	}

//

LOCAL_C void CreateMailSelection(CMsvEntrySelection& aSelection)

	{

//	Create a selection of all IMAP4 messages in the parent folder. 

	testUtils->iMsvEntry->SetEntryL(imap4Service+1);

//	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service+1);

	CMsvEntrySelection* selection = testUtils->iMsvEntry->ChildrenWithTypeL(KUidMsvMessageEntry);

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

		 aSelection.AppendL(selection->At(i));

	testUtils->iMsvEntry->SetEntryL(imap4Service);

	}

LOCAL_C void ConnectAndSyncCompleteL()

	{

	testUtils->WriteComment(_L("Inside ConnectAndSyncCompleteL "));

	testUtils->WriteComment(_L("Connecting to the IMAP4 server"));

	CDummyConnectionObserver *dummyObserver = new(ELeave)CDummyConnectionObserver;

	//CleanupStack::PushL(dummyObserver);

	TPckg<MMsvImapConnectionObserver*> aParameter(dummyObserver);

	msvSelection->ResizeL(0);

	msvSelection->AppendL(imap4Service);

	opActive->iStatus = KRequestPending;

	msvOperation = testUtils->iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMConnectAndSyncCompleteAfterDisconnect, *msvSelection, aParameter, opActive->iStatus);

	opActive->SetOperation(msvOperation);

	opActive->StartL();	// Start the connect active object

	testUtils->WriteComment(_L("End of  ConnectAndSyncCompleteL "));

	}

LOCAL_C void ConnectToServerL()

	{

	testUtils->WriteComment(_L("Connecting to the IMAP4 server"));

	TBuf8<1> aParameter;

	msvSelection->ResizeL(0);

	msvSelection->AppendL(imap4Service);

	opActive->iStatus = KRequestPending;

	msvOperation = testUtils->iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMConnect, *msvSelection, aParameter, opActive->iStatus);

	opActive->SetOperation(msvOperation);

	opActive->StartL();	// Start the connect active object

	}

LOCAL_C void SynchronizeRemoteInbox()

	{

	testUtils->WriteComment(_L("Synchronizing Remote Inbox")); 

	msvSelection->ResizeL(0);

	msvSelection->AppendL(imap4Service);

	TImImap4GetMailInfo imap4GetMailInfo;

	imap4GetMailInfo.iMaxEmailSize = KMaxTInt;

	imap4GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

	imap4GetMailInfo.iGetMailBodyParts = EGetImap4EmailBodyText;//EGetImap4EmailBodyTextAndAttachments;

	TPckgBuf<TImImap4GetMailInfo> package(imap4GetMailInfo);

	opActive->iStatus = KRequestPending;

	msvOperation = testUtils->iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMFullSync, *msvSelection, package, opActive->iStatus);

	opActive->SetOperation(msvOperation);

	opActive->StartL();	// Start the active object

	}

LOCAL_C void DisconnectFromServerL()

	{

	testUtils->WriteComment(_L("Disconnecting from the IMAP4 server"));

	TBuf8<1> aParameter;

	msvSelection->ResizeL(0);

	msvSelection->AppendL(imap4Service); 

	opActive->iStatus = KRequestPending;

	msvOperation = testUtils->iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMDisconnect, *msvSelection, aParameter, opActive->iStatus);

	opActive->SetOperation(msvOperation);

	opActive->StartL();	// Start the disconnect active object

	}

//

// Get Mail when already Connected tests

//

LOCAL_C void PopulateNewMessagesPartiallyWhenAlreadyConnectedL()

	{

	testUtils->WriteComment(_L("Populating new messages when already connected")); 

	msvSelection->ResizeL(0);

	msvSelection->AppendL(imap4Service);

	msvSelection->AppendL(imap4Service+1); // remote inbox

	TImImap4GetPartialMailInfo imapGetPartialMailInfo;

	imapGetPartialMailInfo.iPartialMailOptions=EBodyTextAndAttachments;

	imapGetPartialMailInfo.iDestinationFolder = imap4Service+1;//KMsvGlobalInBoxIndexEntryIdValue;	

	imapGetPartialMailInfo.iBodyTextSizeLimit = 7000;	

	imapGetPartialMailInfo.iAttachmentSizeLimit = 7000;

	imapGetPartialMailInfo.iTotalSizeLimit = 9000;

	TPckgBuf<TImImap4GetPartialMailInfo> package(imapGetPartialMailInfo);

	opActive->iStatus = KRequestPending;

	msvOperation = testUtils->iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMPopulateNewMailWhenAlreadyConnected, *msvSelection, package, opActive->iStatus);

	opActive->SetOperation(msvOperation);

	opActive->StartL();	// Start the populate new mail active object

	}

LOCAL_C void PopulateAllMessagesPartiallyWhenAlreadyConnectedL()

	{

	testUtils->WriteComment(_L("Populating all messages partially when already connected")); 

	msvSelection->ResizeL(0);

	msvSelection->AppendL(imap4Service);

	msvSelection->AppendL(imap4Service+1); // remote inbox

	TImImap4GetPartialMailInfo imapGetPartialMailInfo;

	imapGetPartialMailInfo.iPartialMailOptions=EBodyTextAndAttachments;

	imapGetPartialMailInfo.iDestinationFolder = imap4Service+1;//KMsvGlobalInBoxIndexEntryIdValue;	

	imapGetPartialMailInfo.iBodyTextSizeLimit = 7000;	

	imapGetPartialMailInfo.iAttachmentSizeLimit = 5000;

	imapGetPartialMailInfo.iTotalSizeLimit = 9000;

	TPckgBuf<TImImap4GetPartialMailInfo> package(imapGetPartialMailInfo);

	opActive->iStatus = KRequestPending;

	msvOperation = testUtils->iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMPopulateAllMailWhenAlreadyConnected, *msvSelection, package, opActive->iStatus);

	opActive->SetOperation(msvOperation);

	opActive->StartL();	// Start the populate all mail active object

	}

LOCAL_C void PopulateAllMessagesWithCumulativeOption()

	{

	testUtils->WriteComment(_L("Populating all messages partially when already connected with TImImap4PartialMailOptions = ECumulative")); 

	msvSelection->ResizeL(0);

	msvSelection->AppendL(imap4Service);

	msvSelection->AppendL(imap4Service+1); // remote inbox

	TImImap4GetPartialMailInfo imapGetPartialMailInfo;

	imapGetPartialMailInfo.iPartialMailOptions=ECumulative;

	imapGetPartialMailInfo.iDestinationFolder = imap4Service+1;//KMsvGlobalInBoxIndexEntryIdValue;	

	imapGetPartialMailInfo.iTotalSizeLimit = 9000;

	TPckgBuf<TImImap4GetPartialMailInfo> package(imapGetPartialMailInfo);

	opActive->iStatus = KRequestPending;

	msvOperation = testUtils->iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMPopulateAllMailWhenAlreadyConnected, *msvSelection, package, opActive->iStatus);

	opActive->SetOperation(msvOperation);

	opActive->StartL();	// Start the populate all mail active object

	}

LOCAL_C void PopulateAllMessagesWithNoSizeLimitOption()

	{

	testUtils->WriteComment(_L("Populating all messages with no size limits")); 

	msvSelection->ResizeL(0);

	msvSelection->AppendL(imap4Service);

	msvSelection->AppendL(imap4Service+1); // remote inbox

	TImImap4GetPartialMailInfo imapGetPartialMailInfo;

	imapGetPartialMailInfo.iPartialMailOptions=ENoSizeLimits;

	imapGetPartialMailInfo.iDestinationFolder = imap4Service+1;//KMsvGlobalInBoxIndexEntryIdValue;	

	imapGetPartialMailInfo.iBodyTextSizeLimit = 7000;	

	imapGetPartialMailInfo.iAttachmentSizeLimit = 7000;

	imapGetPartialMailInfo.iTotalSizeLimit = 9000;

	TPckgBuf<TImImap4GetPartialMailInfo> package(imapGetPartialMailInfo);