diff -r 000000000000 -r 72b543305e3a email/pop3andsmtpmtm/clientmtms/test/src/T_PartialFetch.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/email/pop3andsmtpmtm/clientmtms/test/src/T_PartialFetch.cpp	Thu Dec 17 08:44:11 2009 +0200
@@ -0,0 +1,1879 @@
+// 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);
+	
+	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 PopulateMessageSelectionPartiallyWhenAlreadyConnectedL()
+	{
+	testUtils->WriteComment(_L("Populate mail selection partially when already connected")); 
+
+	msvSelection->ResizeL(0);
+	msvSelection->AppendL(imap4Service);
+	CreateMailSelection(*msvSelection); // message in the remote inbox (to populate)
+
+	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(KIMAP4MTMPopulateMailSelectionWhenAlreadyConnected, *msvSelection, package, opActive->iStatus);
+	opActive->SetOperation(msvOperation);
+	opActive->StartL();	// Start the populate message selection active object
+	}
+
+
+//
+// Connect, Get Mail and Disconnect tests
+//
+LOCAL_C void ConnectAndPopulateNewMailPartiallyAndDisconnectL()
+	{
+	testUtils->WriteComment(_L("Connect, Populate New Mail, Disconnect")); 
+
+	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(KIMAP4MTMConnectAndPopulateNewMailAndDisconnect, *msvSelection, package, opActive->iStatus);
+	opActive->SetOperation(msvOperation);
+	opActive->StartL();	// Start the Populate new mail active object
+	}
+
+LOCAL_C void ConnectAndPopulateAllMailPartiallyAndDisconnectL()
+	{
+	testUtils->WriteComment(_L("Connect, Populate All Mail Partially, Disconnect")); 
+
+	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(KIMAP4MTMConnectAndPopulateAllMailAndDisconnect, *msvSelection, package, opActive->iStatus);
+	opActive->SetOperation(msvOperation);
+	opActive->StartL();	// Start the Populate all mail active object
+	}
+
+
+LOCAL_C void ConnectAndPopulateAllMailAndDisconnectL()
+	{
+	testUtils->WriteComment(_L("Full download after partial download \n")); 
+
+	msvSelection->ResizeL(0);
+	msvSelection->AppendL(imap4Service);
+	msvSelection->AppendL(imap4Service+1); // remote inbox
+
+	TImImap4GetMailInfo imap4GetMailInfo;
+	imap4GetMailInfo.iMaxEmailSize = KMaxTInt;
+	imap4GetMailInfo.iDestinationFolder = imap4Service+2; // service
+	imap4GetMailInfo.iGetMailBodyParts = EGetImap4EmailBodyTextAndAttachments;
+	TPckgBuf<TImImap4GetMailInfo> package(imap4GetMailInfo);
+	
+	
+	opActive->iStatus = KRequestPending;
+	msvOperation = testUtils->iImapClientMtm->InvokeAsyncFunctionL(KIMAP4MTMConnectAndPopulateAllMailAndDisconnect, *msvSelection, package, opActive->iStatus);
+	opActive->SetOperation(msvOperation);
+	opActive->StartL();	// Start the Populate all mail active object
+	}
+
+LOCAL_C void ConnectAndPopulateMailSelectionPartiallyAndDisconnectL()
+	{
+	testUtils->WriteComment(_L("Connect, Populating remote msg, Disconnect")); 
+
+	msvSelection->ResizeL(0);
+	msvSelection->AppendL(imap4Service);
+	CreateMailSelection(*msvSelection); // message in the remote inbox (to populate)
+	
+	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(KIMAP4MTMConnectAndPopulateMailSelectionAndDisconnect, *msvSelection, package, opActive->iStatus);
+	opActive->SetOperation(msvOperation);
+	opActive->StartL();	// Start the populate message selection active object
+	}
+
+//
+// Connect, Get Mail and Stay Online tests
+//
+LOCAL_C void ConnectAndPopulateNewMailPartiallyAndStayOnlineL()
+	{
+	testUtils->WriteComment(_L("Connect, Populate New Mail, Stay Online")); 
+
+	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(KIMAP4MTMConnectAndPopulateNewMailAndStayOnline, *msvSelection, package, opActive->iStatus);
+	opActive->SetOperation(msvOperation);
+	opActive->StartL();	// Start the Populate new mail active object
+	}
+
+LOCAL_C void ConnectAndPopulateAllMailPartiallyAndStayOnlineL()
+	{
+	testUtils->WriteComment(_L("Connect, Populate All Mail, Stay Online")); 
+
+	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(KIMAP4MTMConnectAndPopulateAllMailAndStayOnline, *msvSelection, package, opActive->iStatus);
+	opActive->SetOperation(msvOperation);
+	opActive->StartL();	// Start the Populate all mail active object
+	}
+
+LOCAL_C void ConnectAndPopulateMailSelectionAndStayOnlineL()
+	{
+	testUtils->WriteComment(_L("Connect, Populating remote msg, Stay Online")); 
+
+	msvSelection->ResizeL(0);
+	msvSelection->AppendL(imap4Service);
+	CreateMailSelection(*msvSelection); // message in the remote inbox (to populate)
+	
+	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(KIMAP4MTMConnectAndPopulateMailSelectionAndStayOnline, *msvSelection, package, opActive->iStatus);
+	opActive->SetOperation(msvOperation);
+	opActive->StartL();	// Start the populate message selection active object
+	}
+
+//
+
+LOCAL_C void ConnectAndSyncRemoteInboxAndDisconnectL()
+	{
+	console->SetPos(0, 6);
+	test.Printf(_L("\nPerforming Tests\n"));
+	console->SetPos(0, 7);
+	test.Printf(_L("Connecting to IMAP server                        \n"));
+	ConnectToServerL();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		return;
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Synchronize Remote Inbox                         \n"));
+	SynchronizeRemoteInbox();
+
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		return;
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Disconnecting from the server                    \n"));
+	DisconnectFromServerL();
+
+	CActiveScheduler::Start();
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		return;
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("ConnectAndSyncCompletedAfterDisconnect                         \n"));
+
+	ConnectAndSyncCompleteL();
+
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		return;
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Disconnecting from the server                    \n"));
+	DisconnectFromServerL();
+
+	CActiveScheduler::Start();
+	if (globalError)
+		return;
+	}
+
+//
+
+LOCAL_C void DeleteAndCreateServicesL()
+	{
+	// Handle command line arguments
+	CCommandLineArguments* cmdLineArg=CCommandLineArguments::NewLC();
+	TInt count = cmdLineArg->Count();
+	TBool isCmdLine=FALSE;
+	if (count>2)	// Command line arguments?
+		{
+		if ((!(cmdLineArg->Arg(EArgTestParams).Compare(KTestParams))) && count==EArgEnd)
+			isCmdLine=TRUE;
+		}	
+	// delete services
+	testUtils->iMsvEntry->SetEntryL(KMsvRootIndexEntryId);
+	testUtils->iMsvEntry->DeleteL(imap4Service);
+	testUtils->iMsvEntry->DeleteL(smtpService);
+
+	// delete all messages in the Inbox
+	testUtils->iMsvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);
+	CMsvEntrySelection* children = testUtils->iMsvEntry->ChildrenL();
+	CleanupStack::PushL(children);
+	TInt total = children->Count();
+	for (TInt i=0; i<total; i++)
+		testUtils->iMsvEntry->DeleteL((*children)[i]);
+	CleanupStack::PopAndDestroy(children);
+
+	// Create Services
+	smtpService = testUtils->CreateSmtpServiceL();
+	imap4Service = testUtils->CreateImapServiceL();
+
+	testUtils->iMsvEntry->SetEntryL(imap4Service);
+
+	//overwrite the settings with test code one.  Don't want the default settings.
+	CEmailAccounts* accounts = CEmailAccounts::NewLC();
+
+	CImImap4Settings* settings = new(ELeave) CImImap4Settings();
+	CleanupStack::PushL(settings);
+	settings->Reset();
+
+	if (isCmdLine)
+		{
+		TBuf<100> buf;
+		TLex lex(cmdLineArg->Arg(EArgServerAddress));
+		buf=lex.NextToken();
+		settings->SetServerAddressL(buf);
+		}
+	else
+		settings->SetServerAddressL(KImapServer);
+
+	settings->SetDeleteEmailsWhenDisconnecting(ETrue);
+	settings->SetAcknowledgeReceipts(ETrue);
+	settings->SetAutoSendOnConnect(ETrue);
+
+	if (isCmdLine)
+		{
+		TBuf<100> buf;
+		TBuf8<64> data;
+		TLex lex(cmdLineArg->Arg(EArgLogin));
+		buf=lex.NextToken();
+		data.Copy(buf);
+		settings->SetLoginNameL(data);
+		}
+	else
+		settings->SetLoginNameL(testUtils->MachineName());
+
+	if (isCmdLine)
+		{
+		TBuf<100> buf;
+		TBuf8<64> data;
+		TLex lex(cmdLineArg->Arg(EArgPassword));
+		buf=lex.NextToken();
+		data.Copy(buf);
+		settings->SetPasswordL(data);
+		}
+	else
+		settings->SetPasswordL(testUtils->MachineName());
+
+	settings->SetPort(143);
+
+	if (isCmdLine)
+		{
+		TBuf<100> buf;
+		TBuf8<64> data;
+		TLex lex(cmdLineArg->Arg(EArgFolderPath));
+		buf=lex.NextToken();
+		data.Copy(buf);
+		settings->SetFolderPathL(data);
+		}
+	else
+		settings->SetFolderPathL(KFolderPath);
+
+	TImapAccount imapAccount;
+	accounts->GetImapAccountL(imap4Service, imapAccount);
+	accounts->SaveImapSettingsL(imapAccount, *settings);
+
+	CleanupStack::PopAndDestroy(2); //settings, store/accounts
+	CleanupStack::PopAndDestroy();	// cmdLineArg
+	}
+
+LOCAL_C void CreateServicesL()
+	{
+	// Handle command line arguments
+	CCommandLineArguments* cmdLineArg=CCommandLineArguments::NewLC();
+	TInt count = cmdLineArg->Count();
+	TBool isCmdLine=FALSE;
+	if (count>2)	// Command line arguments?
+		{
+		if ((!(cmdLineArg->Arg(EArgTestParams).Compare(KTestParams))) && count==EArgEnd)
+			isCmdLine=TRUE;
+		}	
+
+	//overwrite the settings with test code one.  Don't want the default settings.
+	CEmailAccounts* accounts = CEmailAccounts::NewLC();
+
+	CImImap4Settings* settings = new(ELeave) CImImap4Settings();
+	CleanupStack::PushL(settings);
+	settings->Reset();
+
+	if (isCmdLine)
+		{
+		TBuf<100> buf;
+		TLex lex(cmdLineArg->Arg(EArgServerAddress));
+		buf=lex.NextToken();
+		settings->SetServerAddressL(buf);
+		}
+	else
+		settings->SetServerAddressL(KImapServer);
+
+	settings->SetDeleteEmailsWhenDisconnecting(EFalse);
+	settings->SetAcknowledgeReceipts(ETrue);
+	settings->SetAutoSendOnConnect(ETrue);
+
+	if (isCmdLine)
+		{
+		TBuf<100> buf;
+		TBuf8<64> data;
+		TLex lex(cmdLineArg->Arg(EArgLogin));
+		buf=lex.NextToken();
+		data.Copy(buf);
+		settings->SetLoginNameL(data);
+		}
+	else
+		settings->SetLoginNameL(testUtils->MachineName());
+
+	if (isCmdLine)
+		{
+		TBuf<100> buf;
+		TBuf8<64> data;
+		TLex lex(cmdLineArg->Arg(EArgPassword));
+		buf=lex.NextToken();
+		data.Copy(buf);
+		settings->SetPasswordL(data);
+		}
+	else
+		settings->SetPasswordL(testUtils->MachineName());
+
+	settings->SetPort(143);
+
+	if (isCmdLine)
+		{
+		TBuf<100> buf;
+		TBuf8<64> data;
+		TLex lex(cmdLineArg->Arg(EArgFolderPath));
+		buf=lex.NextToken();
+		data.Copy(buf);
+		settings->SetFolderPathL(data);
+		}
+	else
+		settings->SetFolderPathL(KFolderPath);
+
+	TImapAccount imapAccount;
+	accounts->GetImapAccountL(testUtils->iMsvEntry->EntryId(), imapAccount);
+	accounts->SaveImapSettingsL(imapAccount, *settings);
+
+	CleanupStack::PopAndDestroy(2); //settings, store/accounts
+	CleanupStack::PopAndDestroy();	// cmdLineArg
+	}
+
+
+LOCAL_C void InitL()
+	{
+	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
+	CActiveScheduler::Install(scheduler);
+	CleanupStack::PushL(scheduler);
+
+	testUtils = CEmailTestUtils::NewLC(test);
+	console = test.Console();
+	testUtils->FileSession().SetSessionPath(_L("C:\\"));
+	testUtils->CleanMessageFolderL();
+	testUtils->GoClientSideL();
+	
+	console->SetPos(0, 3);
+	test.Printf(_L("Create Services                        "));
+	testUtils->WriteComment(_L("Create Services                        "));
+	// Create Services
+	smtpService = testUtils->CreateSmtpServiceL();
+	imap4Service = testUtils->CreateImapServiceL();
+
+	testUtils->WriteComment(_L("********** T_PARTIALFETCH Test  **********"));
+	}
+	
+LOCAL_C void Closedown()
+	{
+	CleanupStack::PopAndDestroy(2);  //testUtils, scheduler
+	}
+
+//
+
+LOCAL_C TPtrC 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          ");
+		}
+	}
+
+
+LOCAL_C void doMainL()
+	{
+	InitL();
+
+	// Load the serial comms device drivers.  If this is not done,
+	// connecting via NT-RAS returns KErrNotFound (-1).
+	TInt driverErr;
+	driverErr=User::LoadPhysicalDevice(PDD_NAME);
+	if (driverErr!=KErrNone && driverErr!=KErrAlreadyExists)
+		User::Leave(driverErr);
+	driverErr=User::LoadLogicalDevice(LDD_NAME);
+	if (driverErr!=KErrNone && driverErr!=KErrAlreadyExists)
+		User::Leave(driverErr);
+
+	testUtils->FileSession().SetSessionPath(_L("c:\\"));
+	// Delete any *.scr files in c:\logs\email directory.
+	testUtils->DeleteScriptFilesFromLogsDirL();
+
+	testUtils->iMsvEntry->SetEntryL(imap4Service);
+
+	// Handle command line arguments
+	CCommandLineArguments* cmdLineArg=CCommandLineArguments::NewLC();
+	TInt count = cmdLineArg->Count();
+	TBool isCmdLine=FALSE;
+	if (count>2)	// Command line arguments?
+		{
+		if ((!(cmdLineArg->Arg(EArgTestParams).Compare(KTestParams))) && count==EArgEnd)
+			isCmdLine=TRUE;
+		}	
+
+	//overwrite the settings with test code one.  Don't want the default settings.
+	CEmailAccounts* accounts = CEmailAccounts::NewLC();
+
+	CImImap4Settings* settings = new(ELeave) CImImap4Settings();
+	CleanupStack::PushL(settings);
+	settings->Reset();
+	
+	if (isCmdLine)
+		{
+		TBuf<100> buf;
+		TLex lex(cmdLineArg->Arg(EArgServerAddress));
+		buf=lex.NextToken();
+		test.Printf(_L("Server address: %S\n"),&buf);
+		settings->SetServerAddressL(buf);
+		}
+	else
+		settings->SetServerAddressL(KImapServer);
+
+	settings->SetDeleteEmailsWhenDisconnecting(EFalse);
+	settings->SetAcknowledgeReceipts(ETrue);
+//	settings->SetAutoSendOnConnect(ETrue);
+
+	if (isCmdLine)
+		{
+		TBuf<100> buf;
+		TBuf8<64> data;
+		TLex lex(cmdLineArg->Arg(EArgLogin));
+		buf=lex.NextToken();
+		test.Printf(_L("Login: %S\n"),&buf);
+		data.Copy(buf);
+		settings->SetLoginNameL(data);
+		}
+	else
+		settings->SetLoginNameL(testUtils->MachineName());
+
+	if (isCmdLine)
+		{
+		TBuf<100> buf;
+		TBuf8<64> data;
+		TLex lex(cmdLineArg->Arg(EArgPassword));
+		buf=lex.NextToken();
+		test.Printf(_L("Password: %S\n"),&buf);
+		data.Copy(buf);
+		settings->SetPasswordL(data);
+		}
+	else
+		settings->SetPasswordL(testUtils->MachineName());
+
+	settings->SetPort(143);
+
+	if (isCmdLine)
+		{
+		TBuf<100> buf;
+		TBuf8<64> data;
+		TLex lex(cmdLineArg->Arg(EArgFolderPath));
+		buf=lex.NextToken();
+		test.Printf(_L("Folder Path: %S\n"),&buf);
+		data.Copy(buf);
+		settings->SetFolderPathL(data);
+		}
+	else
+		settings->SetFolderPathL(KFolderPath);
+
+	TImapAccount imapAccount;
+	accounts->GetImapAccountL(imap4Service, imapAccount);
+	accounts->SaveImapSettingsL(imapAccount, *settings);
+	
+	CleanupStack::PopAndDestroy(2); //settings, store/accounts
+	CleanupStack::PopAndDestroy();	// cmdLineArg
+
+	console->SetPos(0, 3);
+	test.Printf(_L("Instantiating IMAP4 Client MTM"));
+	testUtils->WriteComment(_L("Instantiating IMAP4 Client MTM"));
+	testUtils->InstantiateImapClientMtmL();
+// Tests start here
+
+//
+//
+// Test 1
+// Populating all mail partially when already connected       	
+//
+//
+
+	DeleteAndCreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+
+	msvSelection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(msvSelection);
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+
+	testUtils->TestStart(1);
+	// connect, do full sync and then disconnect so that the inbox can be synced
+	ConnectAndSyncRemoteInboxAndDisconnectL();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Connecting to IMAP server                        \n"));
+	ConnectToServerL();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Populating all mails partially when already connected \n"));
+	PopulateAllMessagesPartiallyWhenAlreadyConnectedL();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Disconnecting from the server                    \n"));
+	DisconnectFromServerL();
+	CActiveScheduler::Start();
+
+	testUtils->TestFinish(1,globalError);
+	CleanupStack::PopAndDestroy(2); // opActive, msvSelection
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	
+//
+//
+// Test 2
+// Populate new mails partially when already connected to server
+//
+//
+	
+	DeleteAndCreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+
+	msvSelection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(msvSelection);
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+
+	testUtils->TestStart(2);
+	// connect, do full sync and then disconnect so that the inbox can be synced
+	ConnectAndSyncRemoteInboxAndDisconnectL();
+
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+
+	CleanupStack::PopAndDestroy(); // opActive
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Connecting to IMAP server                        \n"));
+	ConnectToServerL();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Populate new mails partially when already connected to server \n"));
+	PopulateNewMessagesPartiallyWhenAlreadyConnectedL();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Disconnecting from the server                    \n"));
+	DisconnectFromServerL();
+	CActiveScheduler::Start();
+
+	testUtils->TestFinish(2,globalError);
+	// cleanup for next test
+	CleanupStack::PopAndDestroy(2); //msvSelection, opActive, 
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+		
+//
+//
+//  Test 3
+//	Populate mail selection partially when already connected to server
+//
+//
+
+	DeleteAndCreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+
+	msvSelection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(msvSelection);
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+
+	testUtils->TestStart(3);
+	// connect, do full sync and then disconnect so that the inbox can be synced
+	ConnectAndSyncRemoteInboxAndDisconnectL();
+
+	// Populate mail selection when already connected to server
+	CleanupStack::PopAndDestroy(); // opActive
+  	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Connecting to IMAP server                        \n"));
+	ConnectToServerL();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Populate mail selection partially when already connected to server\n"));
+	PopulateMessageSelectionPartiallyWhenAlreadyConnectedL();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Disconnecting from the server                    \n"));
+	DisconnectFromServerL();
+	CActiveScheduler::Start();
+
+	testUtils->TestFinish(3,globalError);
+	// cleanup for next test
+	CleanupStack::PopAndDestroy(2); //msvSelection, opActive, 
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+
+//
+//
+// Test 4
+// Connect and populate new mails partially and disconnect
+//
+//
+	
+	DeleteAndCreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+
+	msvSelection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(msvSelection);
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+
+	ConnectAndSyncRemoteInboxAndDisconnectL();
+
+	testUtils->TestStart(4);
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Connect, Populate New Mails Partially, Disconnect           \n"));
+	ConnectAndPopulateNewMailPartiallyAndDisconnectL();
+	CActiveScheduler::Start();
+
+	testUtils->TestFinish(4,globalError);
+	// cleanup for next test
+	CleanupStack::PopAndDestroy(2); //msvSelection, opActive, 
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+
+//
+//
+// Test 5
+// Connect and populate all mails partially and disconnect
+//
+//
+	DeleteAndCreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+
+	msvSelection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(msvSelection);
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+
+	ConnectAndSyncRemoteInboxAndDisconnectL();
+
+	testUtils->TestStart(5);
+	// Connect, Populate All Mail and then disconnect
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Connect, Populate All Mails Partially, Disconnect           \n"));
+	ConnectAndPopulateAllMailPartiallyAndDisconnectL();
+	CActiveScheduler::Start();
+
+	testUtils->TestFinish(5,globalError);
+
+  	// cleanup for next test
+	CleanupStack::PopAndDestroy(2); //msvSelection, opActive, 
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	
+//
+//
+//	Test 6
+//	Connect, Populate Mail Selection Partially, Stay Online
+//
+//
+	DeleteAndCreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+
+	msvSelection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(msvSelection);
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+
+	// connect, do full sync and then disconnect so that the inbox can be synced
+	ConnectAndSyncRemoteInboxAndDisconnectL();
+
+	testUtils->TestStart(6);
+	// Connect, Populate Mail Selection and Stay Online
+	CleanupStack::PopAndDestroy(); // opActive
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Connect, Populate Mail Selection Partially, Stay Online    \n"));
+	ConnectAndPopulateMailSelectionAndStayOnlineL();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Disconnecting from the server                    \n"));
+	DisconnectFromServerL();
+	CActiveScheduler::Start();
+	testUtils->TestFinish(6,globalError);
+
+	// cleanup for next test
+	CleanupStack::PopAndDestroy(2); //msvSelection, opActive, 
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	
+//
+//
+//	Test 7
+//	Connect, Populate New Mails Partially, Stay Online
+//
+//
+	DeleteAndCreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+
+	msvSelection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(msvSelection);
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+
+	// connect, do full sync and then disconnect so that the inbox can be synced
+	ConnectAndSyncRemoteInboxAndDisconnectL();
+
+	testUtils->TestStart(7);
+	// Connect, Populate New Mail and Stay Online
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Connect, Populate New Mails Partially, Stay Online          \n"));
+	ConnectAndPopulateNewMailPartiallyAndStayOnlineL();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Disconnecting from the server                    \n"));
+	DisconnectFromServerL();
+	CActiveScheduler::Start();
+	testUtils->TestFinish(7,globalError);
+
+	// cleanup for next test
+	CleanupStack::PopAndDestroy(2); //msvSelection, opActive, 
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+//
+//
+//	Test 8
+//	Connect, Populate All Mails partially, Stay Online
+//
+//
+	
+	DeleteAndCreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+
+	msvSelection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(msvSelection);
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+
+	// connect, do full sync and then disconnect so that the inbox can be synced
+	ConnectAndSyncRemoteInboxAndDisconnectL();
+
+	testUtils->TestStart(8);
+	// Connect, Populate All Mail and Stay Online
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Connect, Populate All Mails Partially, Stay Online          \n"));
+	ConnectAndPopulateAllMailPartiallyAndStayOnlineL();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Disconnecting from the server                    \n"));
+	DisconnectFromServerL();
+	CActiveScheduler::Start();
+	testUtils->TestFinish(8,globalError);
+
+	// cleanup for next test
+	CleanupStack::PopAndDestroy(2); //msvSelection, opActive, 
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+
+//
+//
+// Test 9
+// Populating all mails partially when already connected with TImImap4PartialMailOptions = ENoSizeLimits        	
+//
+//
+	
+	DeleteAndCreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+
+	msvSelection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(msvSelection);
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	
+	testUtils->TestStart(9);
+	// connect, do full sync and then disconnect so that the inbox can be synced
+	ConnectAndSyncRemoteInboxAndDisconnectL();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Connecting to IMAP server                        \n"));
+	ConnectToServerL();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Populating all mails with No Size Limits \n"));
+	PopulateAllMessagesWithNoSizeLimitOption();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Disconnecting from the server                    \n"));
+	DisconnectFromServerL();
+	CActiveScheduler::Start();
+
+	testUtils->TestFinish(9,globalError);
+	CleanupStack::PopAndDestroy(2); // opActive,msvSelection
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+
+//
+//
+// Test 10
+// Populating all mails partially when already connected with TImImap4PartialMailOptions = ECumulative      	
+//
+//
+
+	DeleteAndCreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+
+	msvSelection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(msvSelection);
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+
+	testUtils->TestStart(10);
+	// connect, do full sync and then disconnect so that the inbox can be synced
+	ConnectAndSyncRemoteInboxAndDisconnectL();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Connecting to IMAP server                        \n"));
+	ConnectToServerL();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Populating all mails partially when already connected with TImImap4PartialMailOptions = ECumulative \n"));
+	PopulateAllMessagesWithCumulativeOption();
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Disconnecting from the server                    \n"));
+	DisconnectFromServerL();
+	CActiveScheduler::Start();
+
+	testUtils->TestFinish(10,globalError);
+	CleanupStack::PopAndDestroy(2); // opActive,msvSelection
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+
+//
+//
+//	Test 11
+//	Test for full download of emails after partial download
+//
+//
+
+	DeleteAndCreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+
+	msvSelection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(msvSelection);
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+
+	// Populating all mails partially when already connected       	
+	testUtils->TestStart(11);
+	// connect, do full sync and then disconnect so that the inbox can be synced
+ 	ConnectAndSyncRemoteInboxAndDisconnectL();
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Populating all mails partially when already connected       \n"));
+
+	ConnectAndPopulateAllMailPartiallyAndDisconnectL();
+
+	CActiveScheduler::Start();
+
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+
+	testUtils->WriteComment(_L("Doing full download of emails after partial download")); 
+	// Now do a full download of emails after partial download
+	CreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Full download all mail when already connected       \n"));
+
+	ConnectAndPopulateAllMailAndDisconnectL();
+	
+	CActiveScheduler::Start();
+
+	testUtils->TestFinish(11,globalError);
+	CleanupStack::PopAndDestroy(2); // opActive,msvSelection
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+
+//
+//
+//	Test 12
+//	Connect and populate mail selection Partially and disconnect
+//
+//
+	
+	DeleteAndCreateServicesL();
+	testUtils->iImapClientMtm->SwitchCurrentEntryL(imap4Service);
+
+	msvSelection = new (ELeave) CMsvEntrySelection;
+	CleanupStack::PushL(msvSelection);
+
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+
+	// connect, do full sync and then disconnect so that the inbox can be synced
+	ConnectAndSyncRemoteInboxAndDisconnectL();
+
+	testUtils->TestStart(12);
+	// Connect, Populate Mail Selection and then disconnect
+	CleanupStack::PopAndDestroy(); // opActive
+	if (globalError)
+		{
+		Closedown();
+		return;
+		}
+	opActive = COperationActive::NewL();
+	CleanupStack::PushL(opActive);
+	console->SetPos(0, 7);
+	test.Printf(_L("Connect, Populate Mail Selection Partially, Disconnect     \n"));
+	ConnectAndPopulateMailSelectionPartiallyAndDisconnectL();
+	CActiveScheduler::Start();
+
+// check that final progress showing the correct information
+	TPckgBuf<TImap4GenericProgress> progress;
+	progress.Copy(opActive->iTimer->iOperation->FinalProgress());
+
+	console->SetPos(0, 11);
+	console->Printf(_L("Final Progress:                    "));
+	console->SetPos(0, 12);
+	TBuf<80> progressBuf = Progress(progress().iState);
+	console->Printf(TRefByValue<const TDesC>_L("   Super Operation Progress: %S           "), &progressBuf);
+	console->SetPos(0, 13);
+	progressBuf = Progress(progress().iImap4SubStateProgress);
+	console->Printf(TRefByValue<const TDesC>_L("   Sub Operation Progress  : %S           "), &progressBuf);
+	console->SetPos(0, 14);
+	console->Printf(TRefByValue<const TDesC>_L("   Progress:  %d/%d %d/%d  Total:%d              \n"),
+				progress().iMsgsDone,
+				progress().iMsgsToDo,
+				progress().iBytesDone,
+				progress().iBytesToDo,
+				progress().iTotalSize);
+	console->SetPos(0, 15);
+	console->Printf(TRefByValue<const TDesC>_L("   Error: %d                             \n"), progress().iErrorCode);
+
+	// wait 5 seconds so that user can see the final progess!
+	CTestTimer* timer = CTestTimer::NewL();
+	timer->After(5000000);
+	CActiveScheduler::Start();
+	delete timer;
+
+//	testUtils->FindChildrenL(KMsvRootIndexEntryId, EFalse, EFalse);
+	testUtils->TestFinish(12,globalError);
+	if (globalError)
+		testUtils->TestHarnessFailed(globalError);
+	else
+		testUtils->TestHarnessCompleted();
+
+	CleanupStack::PopAndDestroy(2); //msvSelection, opActive, 
+
+	testUtils->Reset();
+	Closedown();
+	}
+
+GLDEF_C TInt E32Main()
+	{	
+	__UHEAP_MARK;
+	test.Start(_L("T_PARTIALFETCH Test for partial fetch of emails"));
+	theCleanup=CTrapCleanup::New();
+	TRAPD(ret,doMainL());		
+	test(ret==KErrNone);
+	delete theCleanup;	
+	test.End();
+	test.Close();
+	__UHEAP_MARKEND;
+	User::Heap().Check();
+	return(KErrNone);
+	}