1 // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Name of test harness: T_POPC

    15 // Component: IMCM

    16 // Owner: KP

    17 // Brief description of test harness:

    18 // Tests the client-side API of POP3 MTM; Query capability; standard POP3 

    19 // functionality; CImPop3GetMail API.

    20 // Detailed description of test harness:

    21 // As above.

    22 // Input files required to run test harness:

    23 // None

    24 // Intermediate files produced while running test harness:

    25 // <DRIVE>:\msglogs\T_POPC\T_IMCM.log

    26 // <DRIVE>:\msglogs\T_POPC\Entry_Structure.txt

    27 // Output files produced by running test harness:

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

    29 // Description of how to build test harness:

    30 // cd \msg\imcm\

    31 // bldmake bldfiles

    32 // abld test build

    33 // Description of how to run test harness:

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

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

    36 // cd \commdb\group

    37 // bldmake bldfiles

    38 // abld test build t_db

    39 // 2. Build the test utilities:

    40 // cd \msg\testutils\group\

    41 // bldmake bldfiles

    42 // abld build

    43 // WINS running instructions:

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

    45 // or executable can be run from Windows Explorer.

    46 // All other platform running instructions:

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

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

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

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

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

    52 // 4. Run T_POPC.exe on the other platform

    53 // 

    54 //

    55 

    56 #include "emailtestutils.h"

    57 #include <txtrich.h>

    58 #include <c32comm.h>

    59 #include <commdb.h>

    60 #include <mtmuids.h>

    61 #include "TESTENV.h"

    62 #include <bacline.h>

    63 #include <cemailaccounts.h>

    64 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

    65 #include "cimmessagepart.h"

    66 #endif

    67 

    68 

    69 // For loading the serial comms device drivers 

    70 #if defined (__WINS__)

    71 	#define PDD_NAME		_L("ECDRV")

    72 	#define LDD_NAME		_L("ECOMM")

    73 #else

    74 	#define PDD_NAME		_L("EUART1")

    75 	#define LDD_NAME		_L("ECOMM")

    76 #endif

    77 

    78 // local variables etc //

    79 

    80 _LIT(KImcmTest, "T_POPC - Testing CImPop3GetMail");

    81 RTest test(KImcmTest);

    82 

    83 _LIT(KTestParams,"-testparams");

    84 enum TCmdLineArgs

    85 	{

    86 	EArgProgramName,

    87 	EArgTestParams,

    88 	EArgServerAddress,

    89 	EArgLogin,

    90 	EArgPassword,

    91 	EArgPopulationLimit,

    92 	EArgEnd

    93 	};

    94 

    95 

    96 LOCAL_D TMsvId Pop3Service;

    97 LOCAL_D TMsvId smtpService;

    98 

    99 LOCAL_D CTrapCleanup* theCleanup;

   100 LOCAL_D CEmailTestUtils* testUtils;

   101 

   102 LOCAL_D CMsvOperation* msvOperation;

   103 LOCAL_D CMsvEntrySelection* msvSelection;

   104 

   105 LOCAL_D CMsvEntrySelection* messageSelection;

   106 

   107 LOCAL_D CConsoleBase* console;

   108 

   109 class COperationActive;

   110 LOCAL_D COperationActive* opActive;

   111 LOCAL_D TInt testNo = 1;

   112 LOCAL_D TInt globalError = 0;

   113 LOCAL_D TBool iDoCancel = EFalse;

   114 

   115 _LIT(KTestSettingsServerAddress,"2.2.2.2");

   116 const TInt KTestSettingsPort = 111;

   117 _LIT8(KTestSettingsLoginName,"testuser");

   118 _LIT8(KTestSettingsPassword,"password");

   119 const TInt KTestPopulationLimit=30;

   120 

   121 _LIT(KServer, "lon-cn-exchng2k.msexchange2k.closedtest.intra");

   122 _LIT8(KLoginName, "t_popc");

   123 _LIT8(KPassword, "t_popc");

   124 

   125 

   126 //

   127 class TestUiTimer : public CTimer

   128 	{

   129 public:

   130 	static TestUiTimer* NewLC(CConsoleBase* aConsole);

   131 	~TestUiTimer();

   132 

   133 	void RunL();

   134 	void DoCancel();

   135 	void ConstructL();

   136 	void IssueRequest();

   137 	void SetOperation(CMsvOperation* aOperation);

   138 	TTimeIntervalMicroSeconds32 period;

   139 	TPtrC Progress(TInt progressNumber);

   140 	void SetCancelState(TInt aState);

   141 protected:

   142 	TestUiTimer(CConsoleBase* aConsole);

   143 	

   144 	CConsoleBase*		iConsole;

   145 public:

   146 	CMsvOperation*		iOperation;

   147 private:

   148 	TInt	iCancelState;

   149 	};

   150 

   151 //

   152 TestUiTimer* TestUiTimer::NewLC(CConsoleBase* aConsole)

   153 	{

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

   155 	CleanupStack::PushL(self);

   156 	self->ConstructL();

   157 	return self;

   158 	}

   159 

   160 TestUiTimer::TestUiTimer(CConsoleBase* aConsole)

   161 	: CTimer(1), iCancelState(KMaxTInt)

   162 	{

   163 	iConsole = aConsole;

   164 	period = 10000;

   165 	}

   166 

   167 TestUiTimer::~TestUiTimer()

   168 	{

   169 	delete iOperation;

   170 	}

   171 

   172 void TestUiTimer::ConstructL()

   173 	{

   174 	CTimer::ConstructL();

   175 	CActiveScheduler::Add(this);

   176 	}

   177 

   178 void TestUiTimer::IssueRequest()

   179 	{

   180 	After(period);

   181 	}

   182 

   183 void TestUiTimer::SetOperation(CMsvOperation* aOperation)

   184 	{

   185 	if(iOperation)

   186 		{

   187 		delete iOperation;

   188 		iOperation=NULL;

   189 		}

   190 	iOperation = aOperation;

   191 	}

   192 

   193 void TestUiTimer::DoCancel()

   194 	{

   195 	CTimer::DoCancel();

   196 	}

   197 

   198 TPtrC TestUiTimer::Progress(TInt progressNumber)

   199 	{

   200 	switch (progressNumber)

   201 		{

   202 		case 0:

   203 			return _L("Refreshing              ");

   204 		case 1:

   205 			return _L("Copying                 ");

   206 		case 2:

   207 			return _L("Deleting                ");

   208 		case 3:

   209 			return _L("Connecting              ");

   210 		case 4:

   211 			return _L("Tidying                 ");

   212 		case 5:

   213 			return _L("Connected and Idle      ");

   214 		case 6:

   215 			return _L("Disconnecting           ");

   216 		case 7:

   217 			return _L("Disconnected            ");

   218 		case 8:

   219 			return _L("Moving                  ");

   220 		case 9:

   221 			return _L("Copying New Mail        ");

   222 		case 10:

   223 			return _L("Moving New Mail         ");

   224 		case 11:

   225 			return _L("Copying Mail Selection  ");

   226 		case 12:

   227 			return _L("Moving Mail Selection   ");

   228 		case 13:

   229 			return _L("Copying All Mail        ");

   230 		case 14:

   231 			return _L("Moving All Mail         ");

   232 		default:

   233 			return _L("Unknown Progress        ");

   234 		}

   235 	}

   236 

   237 void TestUiTimer::SetCancelState(TInt aState)

   238 	{

   239 	iCancelState = aState;

   240 	}

   241 

   242 void TestUiTimer::RunL()

   243 	{

   244 	// display the current progress

   245 	if(iOperation!=NULL)

   246 		{

   247 		if(iDoCancel == TBool(ETrue))

   248 			{

   249 			iOperation->Cancel();

   250 			}

   251 		TPop3Progress temp;	

   252 		TPckgC<TPop3Progress> paramPack(temp);

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

   254 		TPop3Progress progress=paramPack();	

   255 

   256 		if (iCancelState == progress.iPop3SubStateProgress)

   257 			{

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

   259 			iOperation->Cancel();

   260 			}

   261 

   262 		iConsole->SetPos(0, 12);

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

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

   265 		iConsole->SetPos(0, 13);

   266 		progressBuf = Progress(progress.iPop3SubStateProgress);

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

   268 		iConsole->SetPos(0, 14);

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

   270 					progress.iTotalMsgs-progress.iMsgsToProcess,

   271 					progress.iTotalMsgs,

   272 					progress.iBytesDone,

   273 					progress.iTotalBytes,

   274 					progress.iTotalSize);

   275 		iConsole->SetPos(0, 15);

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

   277 		if (progress.iErrorCode && !globalError)

   278 			{

   279 			if(!iDoCancel || progress.iErrorCode!=KErrCancel)

   280 				{// we should not report KErrCancel as an error when iDoCancel is true because that is expected behviour

   281 				globalError=progress.iErrorCode;

   282 				}

   283 			}

   284 		}

   285 	IssueRequest();

   286 	};

   287 

   288 //

   289 

   290 class COperationActive : public CActive

   291 	{

   292 public:

   293 	COperationActive();

   294 	~COperationActive();

   295 	static COperationActive* NewL();

   296 	void StartL(TBool aDisableProgress = EFalse);

   297 	void SetOperation(CMsvOperation*);

   298 	void SetCancelState(TInt aCancelState);

   299 	

   300 protected:

   301 	void DoCancel();

   302 	void RunL();

   303 public:	

   304 	TestUiTimer* iTimer;

   305 private:

   306 	TBool iSetActive;

   307 	};

   308 

   309 //

   310 COperationActive::COperationActive()

   311 : CActive(0)

   312 	{

   313 	}

   314 

   315 COperationActive::~COperationActive()

   316 	{

   317 	Cancel();

   318 	delete iTimer;

   319 	}

   320 

   321 COperationActive* COperationActive::NewL()

   322 	{

   323 	COperationActive* self = new (ELeave) COperationActive;

   324 	CActiveScheduler::Add(self);

   325 

   326 	self->iSetActive = ETrue;

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

   328 	CleanupStack::Pop();

   329 	return self;

   330 	}

   331 

   332 void COperationActive::DoCancel()

   333 	{

   334 	iTimer->DoCancel();

   335 	}

   336 

   337 void COperationActive::StartL(TBool aDisableProgress)

   338 	{

   339 	if(aDisableProgress)

   340 		{

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

   342 		SetActive();

   343 		test.Printf(TRefByValue<const TDesC>_L("POP3 progress disabled"));

   344 		}

   345 	else

   346 		{	

   347 		TPop3Progress temp;	

   348 		TPckgC<TPop3Progress> paramPack(temp);

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

   350 		TPop3Progress progress=paramPack();	

   351 

   352 		switch(progress.iPop3Progress)

   353 			{

   354 			case TPop3Progress::EPopDisconnected:

   355 			case TPop3Progress::EPopDisconnecting:

   356 				// don't set active

   357 				iSetActive = EFalse;

   358 				break;

   359 			case TPop3Progress::EPopCopyNewMail:

   360 			case TPop3Progress::EPopMoveNewMail:

   361 			case TPop3Progress::EPopCopyMailSelection:

   362 			case TPop3Progress::EPopMoveMailSelection:

   363 			case TPop3Progress::EPopCopyAllMail:

   364 			case TPop3Progress::EPopMoveAllMail:

   365 			case TPop3Progress::EPopPopulating:

   366 			default:

   367 				switch(progress.iPop3SubStateProgress)

   368 					{

   369 					// don't set active if we are in the disconnecting state or if we have disconnected.

   370 					case TPop3Progress::EPopDisconnected:

   371 					case TPop3Progress::EPopDisconnecting:

   372 					default:

   373 						// don't set active

   374 						iSetActive = EFalse;	

   375 						break;

   376 					case TPop3Progress::EPopCopying:

   377 					case TPop3Progress::EPopDeleting:

   378 					case TPop3Progress::EPopConnectedAndIdle:

   379 					case TPop3Progress::EPopMoving:

   380 					case TPop3Progress::EPopRefreshing:

   381 					case TPop3Progress::EPopConnecting:

   382 					case TPop3Progress::EPopTidying:

   383 						{

   384 						if (iSetActive && iTimer->iOperation->IsActive())

   385 							{

   386 							

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

   388 							SetActive();

   389 							

   390 							}

   391 						}

   392 					}

   393 			}

   394 

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

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

   397 		

   398 		}

   399 	}

   400 

   401 void COperationActive::SetOperation(CMsvOperation *aOperation)

   402 	{

   403 	iTimer->SetOperation(aOperation);

   404 	}

   405 

   406 void COperationActive::SetCancelState(TInt aCancelState)

   407 	{

   408 	iTimer->SetCancelState(aCancelState);

   409 	}

   410 

   411 void COperationActive::RunL() 

   412 	{

   413 	iTimer->Cancel();

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

   415 	test.Printf(_L("                "));

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

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

   418 	CActiveScheduler::Stop();

   419 	}

   420 

   421 //

   422 

   423 LOCAL_C void StoreClientSettingsL()

   424 //

   425 // Dummy settings for checking that StoreSettingsL work for the client mtm

   426 //	

   427 	{

   428 	testUtils->WriteComment(_L("Storing settings in client mtm"));

   429 	CImPop3Settings* pop3Settings = new(ELeave)CImPop3Settings;

   430 	CleanupStack::PushL(pop3Settings);

   431 	pop3Settings->CopyL(testUtils->iPopClientMtm->Settings());

   432     pop3Settings->SetServerAddressL(KTestSettingsServerAddress);

   433 	pop3Settings->SetPort(KTestSettingsPort);

   434 	pop3Settings->SetLoginNameL(KTestSettingsLoginName);

   435 	pop3Settings->SetPasswordL(KTestSettingsPassword);

   436 	pop3Settings->SetPopulationLimitL(KTestPopulationLimit);

   437 	testUtils->iPopClientMtm->SetSettingsL(*pop3Settings);

   438 	CleanupStack::PopAndDestroy(pop3Settings);

   439 	testUtils->iPopClientMtm->StoreSettingsL();

   440 	}

   441 

   442 LOCAL_C TInt VerifyStoredClientSettingsL()

   443 //

   444 // Comparison of the settings stored to see that the client commits after storing

   445 //

   446 	{

   447 	// Handle command line arguments

   448 	CCommandLineArguments* cmdLineArg=CCommandLineArguments::NewLC();

   449 	TInt count = cmdLineArg->Count();

   450 	TBool isCmdLine=FALSE;

   451 	if (count>2)	// Command line arguments?

   452 		{

   453 		if ((!(cmdLineArg->Arg(EArgTestParams).Compare(KTestParams))) && count==EArgEnd)

   454 			isCmdLine=TRUE;

   455 		}	

   456 

   457 	testUtils->WriteComment(_L("Checking stored settings in client mtm"));

   458 	testUtils->iPopClientMtm->RestoreSettingsL();

   459 	CImPop3Settings* pop3Settings = new(ELeave)CImPop3Settings;

   460 	CleanupStack::PushL(pop3Settings);

   461 	pop3Settings->CopyL(testUtils->iPopClientMtm->Settings());

   462 

   463     TInt result=0;

   464 	result += pop3Settings->ServerAddress().Compare(KTestSettingsServerAddress);

   465 	result += pop3Settings->Port() - KTestSettingsPort;

   466 	result += pop3Settings->LoginName().Compare(KTestSettingsLoginName);

   467 	result += pop3Settings->Password().Compare(KTestSettingsPassword);

   468     result += (pop3Settings->PopulationLimit()!=KTestPopulationLimit);

   469 

   470 	pop3Settings->Reset();

   471 

   472 	if (isCmdLine)

   473 		{

   474 		TBuf<100> buf;

   475 		TLex lex(cmdLineArg->Arg(EArgServerAddress));

   476 		buf=lex.NextToken();

   477 		pop3Settings->SetServerAddressL(buf);

   478 		}

   479 	else

   480 		{

   481 		pop3Settings->SetServerAddressL(KServer);

   482 		}

   483 

   484 	if (isCmdLine)

   485 		{

   486 		TBuf<100> buf;

   487 		TBuf8<64> data;

   488 		TLex lex(cmdLineArg->Arg(EArgLogin));

   489 		buf=lex.NextToken();

   490 		data.Copy(buf);

   491 		pop3Settings->SetLoginNameL(data);

   492 		}

   493 	else

   494 		{

   495 		pop3Settings->SetLoginNameL(KLoginName);

   496 		}

   497 

   498 	if (isCmdLine)

   499 		{

   500 		TBuf<100> buf;

   501 		TBuf8<64> data;

   502 		TLex lex(cmdLineArg->Arg(EArgPassword));

   503 		buf=lex.NextToken();

   504 		data.Copy(buf);

   505 		pop3Settings->SetPasswordL(data);

   506 		}

   507 	else

   508 		{

   509 		pop3Settings->SetPasswordL(KPassword);

   510 		}

   511 

   512 	if (isCmdLine)

   513 		{

   514 		TBuf<100> buf;

   515 		TLex lex(cmdLineArg->Arg(EArgPopulationLimit));

   516 		buf=lex.NextToken();

   517 		TInt limit;

   518 		TLex lex2(buf);

   519 		lex2.Val(limit);

   520 		pop3Settings->SetPopulationLimitL(limit);

   521 		}

   522 	else

   523 		{

   524 		TInt populationLimit=40;

   525 		pop3Settings->SetPopulationLimitL(populationLimit);

   526 		}

   527 

   528 	

   529 	pop3Settings->SetPort(110);

   530 	testUtils->iPopClientMtm->SetSettingsL(*pop3Settings);

   531 	testUtils->iPopClientMtm->StoreSettingsL();

   532 	

   533    	TRequestStatus st;

   534    	TMsvId s=0;

   535    	TMsvPartList retPart=KMsvMessagePartBody;

   536    	TUint id=0;

   537    	TInt add=0;

   538    	

   539    	TBuf<1> des;

   540    	TBuf8<1> des8;

   541 

   542 	TRAP_IGNORE(testUtils->iPopClientMtm->SaveMessageL());

   543 	TRAP_IGNORE(testUtils->iPopClientMtm->ReplyL(s,retPart,st));

   544 	TRAP_IGNORE(testUtils->iPopClientMtm->ForwardL(s,retPart,st));

   545 	testUtils->iPopClientMtm->ValidateMessage(retPart);

   546 	TRAP_IGNORE(testUtils->iPopClientMtm->AddAddresseeL(des));

   547 	TRAP_IGNORE(testUtils->iPopClientMtm->AddAddresseeL(des,des));

   548 	testUtils->iPopClientMtm->RemoveAddressee(add);

   549 	TRAP_IGNORE(testUtils->iPopClientMtm->AddAttachmentL(des, des8,id,st));

   550 	TRAP_IGNORE(testUtils->iPopClientMtm->AddLinkedAttachmentL(des,des8,id,st));

   551 	TRAP_IGNORE(testUtils->iPopClientMtm->AddEntryAsAttachmentL(s,st));

   552 	TRAP_IGNORE(testUtils->iPopClientMtm->CreateMessageL(s));

   553 	TRAP_IGNORE(testUtils->iPopClientMtm->DefaultServiceL());

   554 	TRAP_IGNORE(testUtils->iPopClientMtm->RemoveDefaultServiceL());

   555 	TRAP_IGNORE(testUtils->iPopClientMtm->ChangeDefaultServiceL(s));

   556 	

   557 	CleanupStack::PopAndDestroy(pop3Settings);

   558 	CleanupStack::PopAndDestroy();	// cmdLineArg

   559 	return result;

   560 	}

   561 

   562 LOCAL_C void ConnectToServerL()

   563 	{

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

   565 	TBuf8<1> aParameter;

   566 	msvSelection->ResizeL(0);

   567 	msvSelection->AppendL(Pop3Service);

   568 	

   569 	opActive->iStatus = KRequestPending;

   570 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnect, *msvSelection, aParameter, opActive->iStatus);

   571 	opActive->SetOperation(msvOperation);

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

   573 	}

   574 

   575 LOCAL_C void DisconnectFromServerL()

   576 	{

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

   578 	TBuf8<1> aParameter;

   579 	msvSelection->ResizeL(0);

   580 	msvSelection->AppendL(Pop3Service);

   581 	

   582 	opActive->iStatus = KRequestPending;

   583 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMDisconnect, *msvSelection, aParameter, opActive->iStatus);

   584 	opActive->SetOperation(msvOperation);

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

   586 	}

   587 

   588 //

   589 // Get Mail when already Connected tests

   590 //

   591 

   592 LOCAL_C void CopyNewMailWhenAlreadyConnectedL()

   593 	{

   594 	testUtils->WriteComment(_L("Copying New Mail when already connected")); 

   595 

   596 	msvSelection->ResizeL(0);

   597 	msvSelection->AppendL(Pop3Service);

   598 	msvSelection->AppendL(0x00100002); // remote inbox

   599 	

   600 	TImPop3GetMailInfo Pop3GetMailInfo;

   601 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   602 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   603 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   604 	

   605 	opActive->iStatus = KRequestPending;

   606 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMCopyNewMailWhenAlreadyConnected, *msvSelection, package, opActive->iStatus);

   607 	opActive->SetOperation(msvOperation);

   608 	opActive->StartL(ETrue);	// Start the copy new mail active object

   609 	}

   610 

   611 

   612 LOCAL_C void MoveNewMailWhenAlreadyConnectedL()

   613 	{

   614 	testUtils->WriteComment(_L("Moving New Mail when already connected"));

   615 	msvSelection->ResizeL(0);

   616 	msvSelection->AppendL(Pop3Service);

   617 	msvSelection->AppendL(0x00100002);

   618 	TImPop3GetMailInfo Pop3GetMailInfo;

   619 	Pop3GetMailInfo.iMaxEmailSize=KMaxTInt;

   620 	Pop3GetMailInfo.iDestinationFolder= KMsvGlobalInBoxIndexEntryIdValue;

   621 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   622 	opActive->iStatus = KRequestPending;

   623 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMMoveNewMailWhenAlreadyConnected,*msvSelection,package,opActive->iStatus);

   624 	opActive->SetOperation(msvOperation);

   625 	opActive->StartL(ETrue);

   626 	}

   627 

   628 

   629 LOCAL_C void CopyAllMailWhenAlreadyConnectedL()

   630 	{

   631 	testUtils->WriteComment(_L("Copying All Mail when already connected")); 

   632 

   633 	msvSelection->ResizeL(0);

   634 	msvSelection->AppendL(Pop3Service);

   635 	msvSelection->AppendL(0x00100002); // remote inbox

   636 	

   637 	TImPop3GetMailInfo Pop3GetMailInfo;

   638 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   639 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   640 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   641 	

   642 	opActive->iStatus = KRequestPending;

   643 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMCopyAllMailWhenAlreadyConnected, *msvSelection, package, opActive->iStatus);

   644 	opActive->SetOperation(msvOperation);

   645 	opActive->StartL(ETrue);	// Start the copy all mail active object

   646 	}

   647 

   648 

   649 LOCAL_C void MoveAllMailWhenAlreadyConnectedL()

   650 	{

   651 	testUtils->WriteComment(_L("Moving All Mails when already connected"));

   652 	msvSelection->ResizeL(0);

   653 	msvSelection->AppendL(Pop3Service);

   654 	msvSelection->AppendL(0x00100002); // remote inbox

   655 	TImPop3GetMailInfo Pop3GetMailInfo;

   656 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   657 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   658 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   659 	opActive->iStatus = KRequestPending;

   660 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMMoveAllMailWhenAlreadyConnected, *msvSelection, package, opActive->iStatus);

   661 	opActive->SetOperation(msvOperation);

   662 	opActive->StartL(ETrue);	

   663 	}

   664 

   665 

   666 LOCAL_C void CopyMailSelectionWhenAlreadyConnectedL()

   667 	{

   668 	testUtils->WriteComment(_L("Copying Mail Selection when already connected")); 

   669 

   670 	msvSelection->ResizeL(0);

   671 	msvSelection->AppendL(Pop3Service);

   672 

   673 	testUtils->SetEntryL(Pop3Service);

   674 	CMsvEntrySelection* sel = testUtils->iMsvEntry->ChildrenL();

   675 	CleanupStack::PushL(sel);

   676 	if (sel->Count()>1)

   677 		{

   678 		msvSelection->AppendL((*sel)[0]); 

   679 		msvSelection->AppendL((*sel)[1]); 

   680 		}

   681 	else if (sel->Count())

   682 		msvSelection->AppendL((*sel)[0]);

   683 	CleanupStack::PopAndDestroy(); //sel

   684 	

   685 	TImPop3GetMailInfo Pop3GetMailInfo;

   686 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   687 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   688 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   689 	

   690 	opActive->iStatus = KRequestPending;

   691 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMCopyMailSelectionWhenAlreadyConnected, *msvSelection, package, opActive->iStatus);

   692 	opActive->SetOperation(msvOperation);

   693 	opActive->StartL(ETrue);	// Start the copy mail selection active object

   694 	}

   695 

   696 

   697 LOCAL_C void MoveMailSelectionWhenAlreadyConnectedL()

   698 	{

   699 	testUtils->WriteComment(_L("Moving Mail Selection when already connected")); 

   700 	msvSelection->ResizeL(0);

   701 	msvSelection->AppendL(Pop3Service);	//Pop3Service is already set while connecting to the server

   702 	testUtils->SetEntryL(Pop3Service);

   703 	CMsvEntrySelection* sel = testUtils->iMsvEntry->ChildrenL();

   704 	CleanupStack::PushL(sel);

   705 	if (sel->Count()>1)

   706 		{

   707 		msvSelection->AppendL((*sel)[0]); 

   708 		msvSelection->AppendL((*sel)[1]); 

   709 		}

   710 	else if (sel->Count())

   711 		msvSelection->AppendL((*sel)[0]);

   712 	CleanupStack::PopAndDestroy(); //sel

   713 		

   714 	TImPop3GetMailInfo Pop3GetMailInfo;

   715 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   716 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   717 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   718 	opActive->iStatus = KRequestPending;

   719 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMMoveMailSelectionWhenAlreadyConnected, *msvSelection, package, opActive->iStatus);

   720 	opActive->SetOperation(msvOperation);

   721 	opActive->StartL(ETrue);	// Start the move mail selection active object

   722 	}

   723 

   724 

   725 //

   726 // Connect, Get Mail and Disconnect tests

   727 //

   728 

   729 LOCAL_C void ConnectAndCopyNewMailAndDisconnectL()

   730 	{

   731 	testUtils->WriteComment(_L("Connect, Copying New Mail, Disconnect")); 

   732 

   733 	msvSelection->ResizeL(0);

   734 	msvSelection->AppendL(Pop3Service);

   735 	msvSelection->AppendL(0x00100002); // remote inbox

   736 	

   737 	TImPop3GetMailInfo Pop3GetMailInfo;

   738 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   739 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   740 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   741 	

   742 	opActive->iStatus = KRequestPending;

   743 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnectAndCopyNewMailAndDisconnect, *msvSelection, package, opActive->iStatus);

   744 	opActive->SetOperation(msvOperation);

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

   746 	}

   747 

   748 LOCAL_C void ConnectAndMoveNewMailAndDisconnectL()

   749 	{

   750 	testUtils->WriteComment(_L("Connect, Move New Mail, Disconnect")); 

   751 

   752 	msvSelection->ResizeL(0);

   753 	msvSelection->AppendL(Pop3Service);

   754 	msvSelection->AppendL(0x00100002); // remote inbox

   755 	

   756 	TImPop3GetMailInfo Pop3GetMailInfo;

   757 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   758 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   759 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   760 	

   761 	opActive->iStatus = KRequestPending;

   762 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnectAndMoveNewMailAndDisconnect, *msvSelection, package, opActive->iStatus);

   763 	opActive->SetOperation(msvOperation);

   764 	opActive->StartL();	

   765 	}

   766 

   767 LOCAL_C void ConnectAndCopyAllMailAndDisconnectL()

   768 	{

   769 	testUtils->WriteComment(_L("Connect, Copying All Mail, Disconnect")); 

   770 

   771 	msvSelection->ResizeL(0);

   772 	msvSelection->AppendL(Pop3Service);

   773 	msvSelection->AppendL(0x00100002); // remote inbox

   774 	

   775 	TImPop3GetMailInfo Pop3GetMailInfo;

   776 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   777 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   778 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   779 	

   780 	opActive->iStatus = KRequestPending;

   781 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnectAndCopyAllMailAndDisconnect, *msvSelection, package, opActive->iStatus);

   782 	opActive->SetOperation(msvOperation);

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

   784 	}

   785 

   786 

   787 LOCAL_C void ConnectAndMoveAllMailAndDisconnectL()

   788 	{

   789 	testUtils->WriteComment(_L("Connect, Moving All Mail, Disconnect")); 

   790 

   791 	msvSelection->ResizeL(0);

   792 	msvSelection->AppendL(Pop3Service);

   793 	msvSelection->AppendL(0x00100002); // remote inbox

   794 	

   795 	TImPop3GetMailInfo Pop3GetMailInfo;

   796 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   797 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   798 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   799 	

   800 	opActive->iStatus = KRequestPending;

   801 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnectAndMoveAllMailAndDisconnect, *msvSelection, package, opActive->iStatus);

   802 	opActive->SetOperation(msvOperation);

   803 	opActive->StartL();	

   804 	}

   805 

   806 

   807 

   808 

   809 

   810 LOCAL_C void ConnectAndCopyMailSelectionAndDisconnectL(TBool aEmptyMessageSelection = EFalse)

   811 	{

   812 	testUtils->WriteComment(_L("Connect, Copying Mail Selection, Disconnect")); 

   813 

   814 	msvSelection->ResizeL(0);

   815 	msvSelection->AppendL(Pop3Service);

   816 

   817 	if (!aEmptyMessageSelection)

   818 		{

   819 		testUtils->SetEntryL(Pop3Service);

   820 		CMsvEntrySelection* sel = testUtils->iMsvEntry->ChildrenL();

   821 		CleanupStack::PushL(sel);

   822 		if (sel->Count()>1)

   823 			{

   824 			msvSelection->AppendL((*sel)[0]); 

   825 			msvSelection->AppendL((*sel)[1]); 

   826 			}

   827 		else if (sel->Count())

   828 			msvSelection->AppendL((*sel)[0]);

   829 		CleanupStack::PopAndDestroy(); //sel

   830 		}

   831 	

   832 	TImPop3GetMailInfo Pop3GetMailInfo;

   833 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   834 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   835 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   836 	

   837 	opActive->iStatus = KRequestPending;

   838 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnectAndCopyMailSelectionAndDisconnect, *msvSelection, package, opActive->iStatus);

   839 	opActive->SetOperation(msvOperation);

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

   841 	}

   842 

   843 

   844 LOCAL_C void ConnectAndMoveMailSelectionAndDisconnectL(TBool aEmptyMessageSelection = EFalse)

   845 	{

   846 	testUtils->WriteComment(_L("Connect, Move Mail Selection, Disconnect")); 

   847 

   848 	msvSelection->ResizeL(0);

   849 	msvSelection->AppendL(Pop3Service);

   850 

   851 	if (!aEmptyMessageSelection)

   852 		{

   853 		testUtils->SetEntryL(Pop3Service);

   854 		CMsvEntrySelection* sel = testUtils->iMsvEntry->ChildrenL();

   855 		CleanupStack::PushL(sel);

   856 		if (sel->Count()>1)

   857 			{

   858 			msvSelection->AppendL((*sel)[0]); 

   859 			msvSelection->AppendL((*sel)[1]); 

   860 			}

   861 		else if (sel->Count())

   862 			msvSelection->AppendL((*sel)[0]);

   863 		CleanupStack::PopAndDestroy(); //sel

   864 		}

   865 	

   866 	TImPop3GetMailInfo Pop3GetMailInfo;

   867 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   868 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   869 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   870 	

   871 	opActive->iStatus = KRequestPending;

   872 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnectAndMoveMailSelectionAndDisconnect, *msvSelection, package, opActive->iStatus);

   873 	opActive->SetOperation(msvOperation);

   874 	opActive->StartL();

   875 	}

   876 

   877 //

   878 // Connect, Get Mail and Stay Online tests

   879 //

   880 

   881 LOCAL_C void ConnectAndCopyNewMailAndStayOnlineL()

   882 	{

   883 	testUtils->WriteComment(_L("Connect, Copying New Mail, Stay Online")); 

   884 

   885 	msvSelection->ResizeL(0);

   886 	msvSelection->AppendL(Pop3Service);

   887 	msvSelection->AppendL(0x00100002); // remote inbox

   888 	

   889 	TImPop3GetMailInfo Pop3GetMailInfo;

   890 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   891 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   892 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   893 	

   894 	opActive->iStatus = KRequestPending;

   895 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnectAndCopyNewMailAndStayOnline, *msvSelection, package, opActive->iStatus);

   896 	opActive->SetOperation(msvOperation);

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

   898 	}

   899 

   900 

   901 LOCAL_C void ConnectAndMoveNewMailAndStayOnlineL()

   902 	{

   903 	testUtils->WriteComment(_L("Connect, Moving New Mail, Stay Online"));

   904 	msvSelection->ResizeL(0);

   905 	msvSelection->AppendL(Pop3Service);

   906 	msvSelection->AppendL(0x00100002); // remote inbox

   907 	TImPop3GetMailInfo Pop3GetMailInfo;

   908 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   909 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   910 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   911 	opActive->iStatus = KRequestPending;

   912 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnectAndMoveNewMailAndStayOnline, *msvSelection, package, opActive->iStatus);

   913 	opActive->SetOperation(msvOperation);

   914 	opActive->StartL();

   915 	}

   916 

   917 LOCAL_C void ConnectAndCopyAllMailAndStayOnlineL()

   918 	{

   919 	testUtils->WriteComment(_L("Connect, Copying All Mail, Stay Online")); 

   920 

   921 	msvSelection->ResizeL(0);

   922 	msvSelection->AppendL(Pop3Service);

   923 	msvSelection->AppendL(0x00100002); // remote inbox

   924 	

   925 	TImPop3GetMailInfo Pop3GetMailInfo;

   926 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   927 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   928 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   929 	

   930 	opActive->iStatus = KRequestPending;

   931 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnectAndCopyAllMailAndStayOnline, *msvSelection, package, opActive->iStatus);

   932 	opActive->SetOperation(msvOperation);

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

   934 	}

   935 

   936 

   937 LOCAL_C void ConnectAndMoveAllMailAndStayOnlineL()

   938 	{

   939 	testUtils->WriteComment(_L("Connect, Move All Mail, Stay Online")); 

   940 

   941 	msvSelection->ResizeL(0);

   942 	msvSelection->AppendL(Pop3Service);

   943 	msvSelection->AppendL(0x00100002); // remote inbox

   944 	

   945 	TImPop3GetMailInfo Pop3GetMailInfo;

   946 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   947 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   948 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   949 	

   950 	opActive->iStatus = KRequestPending;

   951 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnectAndMoveAllMailAndStayOnline, *msvSelection, package, opActive->iStatus);

   952 	opActive->SetOperation(msvOperation);

   953 	opActive->StartL();	

   954 	}

   955 

   956 

   957 LOCAL_C void ConnectAndCopyMailSelectionAndStayOnlineL()

   958 	{

   959 	testUtils->WriteComment(_L("Connect, Copying Mail Selection, Stay Online")); 

   960 

   961 	msvSelection->ResizeL(0);

   962 	msvSelection->AppendL(Pop3Service);

   963 

   964 	testUtils->SetEntryL(Pop3Service);

   965 	CMsvEntrySelection* sel = testUtils->iMsvEntry->ChildrenL();

   966 	CleanupStack::PushL(sel);

   967 	if (sel->Count()>1)

   968 		{

   969 		msvSelection->AppendL((*sel)[0]); 

   970 		msvSelection->AppendL((*sel)[1]); 

   971 		}

   972 	else if (sel->Count())

   973 		msvSelection->AppendL((*sel)[0]);

   974 	CleanupStack::PopAndDestroy(); //sel

   975 	

   976 	TImPop3GetMailInfo Pop3GetMailInfo;

   977 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

   978 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

   979 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

   980 	

   981 	opActive->iStatus = KRequestPending;

   982 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnectAndCopyMailSelectionAndStayOnline, *msvSelection, package, opActive->iStatus);

   983 	opActive->SetOperation(msvOperation);

   984 	opActive->StartL();	// Start the copy message selection active object

   985 	}

   986 

   987 LOCAL_C void ConnectAndMoveMailSelectionAndStayOnlineL()

   988 	{

   989 	testUtils->WriteComment(_L("Connect, Move Mail Selection, Stay Online")); 

   990 

   991 	msvSelection->ResizeL(0);

   992 	msvSelection->AppendL(Pop3Service);

   993 

   994 	testUtils->SetEntryL(Pop3Service);

   995 	CMsvEntrySelection* sel = testUtils->iMsvEntry->ChildrenL();

   996 	CleanupStack::PushL(sel);

   997 	if (sel->Count()>1)

   998 		{

   999 		msvSelection->AppendL((*sel)[0]); 

  1000 		msvSelection->AppendL((*sel)[1]); 

  1001 		}

  1002 	else if (sel->Count())

  1003 		msvSelection->AppendL((*sel)[0]);

  1004 	CleanupStack::PopAndDestroy(); //sel

  1005 	

  1006 	TImPop3GetMailInfo Pop3GetMailInfo;

  1007 	Pop3GetMailInfo.iMaxEmailSize = KMaxTInt;

  1008 	Pop3GetMailInfo.iDestinationFolder = KMsvGlobalInBoxIndexEntryIdValue;

  1009 	TPckgBuf<TImPop3GetMailInfo> package(Pop3GetMailInfo);

  1010 	

  1011 	opActive->iStatus = KRequestPending;

  1012 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMConnectAndMoveMailSelectionAndStayOnline, *msvSelection, package, opActive->iStatus);

  1013 	opActive->SetOperation(msvOperation);

  1014 	opActive->StartL();	

  1015 	}

  1016 

  1017 

  1018 //

  1019 

  1020 LOCAL_C void ConnectAndDisconnectL()

  1021 	{

  1022 	console->SetPos(0, 6);

  1023 	test.Printf(_L("\nPerforming Tests\n"));

  1024 	console->SetPos(0, 7);

  1025 	test.Printf(_L("Connecting to Pop server                        \n"));

  1026 	ConnectToServerL();

  1027 	CActiveScheduler::Start();

  1028 

  1029 	CleanupStack::PopAndDestroy(); // opActive

  1030 	opActive = COperationActive::NewL();

  1031 	CleanupStack::PushL(opActive);

  1032 	console->SetPos(0, 7);

  1033 	test.Printf(_L("Disconnecting from the server                    \n"));

  1034 	DisconnectFromServerL();

  1035 	CActiveScheduler::Start();

  1036 	}

  1037 

  1038 //

  1039 

  1040 

  1041 LOCAL_C void CreateReplyEmailMessage()

  1042 	{

  1043 	testUtils->WriteComment(_L("Creating a Reply Email Message"));

  1044 	msvSelection->ResizeL(0);

  1045 	

  1046 	testUtils->iMsvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);

  1047 	messageSelection = testUtils->iMsvEntry->ChildrenWithTypeL(KUidMsvMessageEntry);

  1048 	//CleanupStack::PushL(messageSelection);

  1049 	msvSelection->AppendL(KMsvGlobalOutBoxIndexEntryId); //destination id

  1050 	msvSelection->AppendL(messageSelection->At(5)); // message id to which the reply is to be assigned

  1051 	//CleanupStack::PopAndDestroy(); 	 //messageSelection

  1052 	

  1053 	//create an object of type TImCreateMessageOptions

  1054 	TImCreateMessageOptions Pop3CreateMessage;

  1055 	

  1056 	//Initialize the member variables of TImCreateMessageOptions suitably 

  1057 	Pop3CreateMessage.iMsvPartList = KMsvMessagePartBody;

  1058 	Pop3CreateMessage.iMsvEmailTypeList = 0;

  1059 	Pop3CreateMessage.iMessageType = KUidMsgTypeSMTP;

  1060 	TPckgBuf<TImCreateMessageOptions> package(Pop3CreateMessage);

  1061 	

  1062 	//set the status

  1063 	opActive->iStatus = KRequestPending;

  1064 	

  1065 	//invoke the func InvokeAsyncFunctionL()

  1066 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMCreateReplyEmailMessage, *msvSelection, package, opActive->iStatus);

  1067 	

  1068 	//start the operation

  1069 	opActive->SetOperation(msvOperation);

  1070 	opActive->StartL(ETrue);	

  1071 	delete messageSelection;

  1072 	}

  1073 

  1074 

  1075 LOCAL_C void CreateForwardEmailMessage()

  1076 	{

  1077 	testUtils->WriteComment(_L("Creating a Forward Email Message"));

  1078 	msvSelection->ResizeL(0);

  1079 	

  1080 	testUtils->iMsvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);

  1081 	messageSelection = testUtils->iMsvEntry->ChildrenWithTypeL(KUidMsvMessageEntry);

  1082 	msvSelection->AppendL(KMsvGlobalOutBoxIndexEntryId); //destination id

  1083 	msvSelection->AppendL(messageSelection->At(5)); // message id to which the reply is to be assigned

  1084 		

  1085 	//create an object of type TImCreateMessageOptions

  1086 	TImCreateMessageOptions Pop3CreateMessage;

  1087 	

  1088 	//Initialize the member variables of TImCreateMessageOptions suitably 

  1089 	Pop3CreateMessage.iMsvPartList = KMsvMessagePartBody;

  1090 	Pop3CreateMessage.iMsvEmailTypeList = 0;

  1091 	Pop3CreateMessage.iMessageType = KUidMsgTypeSMTP;

  1092 	TPckgBuf<TImCreateMessageOptions> package(Pop3CreateMessage);

  1093 	

  1094 	//set the status

  1095 	opActive->iStatus = KRequestPending;

  1096 	

  1097 	//invoke the func InvokeAsyncFunctionL()

  1098 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMCreateForwardEmailMessage, *msvSelection, package, opActive->iStatus);

  1099 	

  1100 	//start the operation

  1101 	opActive->SetOperation(msvOperation);

  1102 	opActive->StartL(ETrue);	

  1103 	delete messageSelection;

  1104 	}

  1105 

  1106 

  1107 LOCAL_C void CreateForwardAsAttachmentEmailMessage()

  1108 	{

  1109 	testUtils->WriteComment(_L("Creating a Forward As Attachment Email Message"));

  1110 	msvSelection->ResizeL(0);

  1111 	

  1112 	testUtils->iMsvEntry->SetEntryL(KMsvGlobalInBoxIndexEntryId);

  1113 	messageSelection = testUtils->iMsvEntry->ChildrenWithTypeL(KUidMsvMessageEntry);

  1114 	

  1115 	msvSelection->AppendL(Pop3Service); //destination id

  1116 	msvSelection->AppendL(messageSelection->At(1)); // message id to which the reply is to be assigned

  1117 	

  1118 	

  1119 	//create an object of type TImCreateMessageOptions

  1120 	TImCreateMessageOptions Pop3CreateMessage;

  1121 	

  1122 	//Initialize the member variables of TImCreateMessageOptions suitably 

  1123 	Pop3CreateMessage.iMsvPartList =KMsvMessagePartBody | KMsvMessagePartAttachments;

  1124 	Pop3CreateMessage.iMsvEmailTypeList = KMsvEmailTypeListMHTMLMessage;

  1125 	Pop3CreateMessage.iMessageType = KUidMsgTypeSMTP;

  1126 	TPckgBuf<TImCreateMessageOptions> package(Pop3CreateMessage);

  1127 	

  1128 	//set the status

  1129 	opActive->iStatus = KRequestPending;

  1130 	

  1131 	//invoke the func InvokeAsyncFunctionL()

  1132 	msvOperation = testUtils->iPopClientMtm->InvokeAsyncFunctionL(KPOP3MTMCreateForwardAsAttachmentEmailMessage, *msvSelection, package, opActive->iStatus);

  1133 	

  1134 	//start the operation

  1135 	opActive->SetOperation(msvOperation);