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

    15 

    16 #include <logcli.h>

    17 #include <logview.h>

    18 

    19 #include "EmailTestUtils.h"

    20 #include <commdb.h>

    21 #include <bacline.h>

    22 #include <cemailaccounts.h>

    23 

    24 

    25 

    26 #include "t_log.h"

    27 

    28 // For loading the serial comms device drivers 

    29 #if defined (__WINS__)

    30 	#define PDD_NAME		_L("ECDRV")

    31 	#define LDD_NAME		_L("ECOMM")

    32 #else

    33 	#define PDD_NAME		_L("EUART1")

    34 	#define LDD_NAME		_L("ECOMM")

    35 #endif

    36 

    37 // --------------------------------------------------------------------------

    38 

    39 //#define _DEBUG_MTMCOMMAND_

    40 

    41 // Static variables

    42 

    43 LOCAL_D RTest test(_L("IMPS.dll Testrig"));

    44 LOCAL_D RFs theFs;

    45 

    46 // LOCAL_C CMsvServer* theServer;

    47 

    48 _LIT(KFolderNameToEncode, "αινσϊ");

    49 

    50 _LIT(KMessageNameTest, "Test: 12");

    51 _LIT(KMessageNameAttachment, "Test: 9");

    52 

    53 _LIT(KMessageNamePriority,"Test: 23");

    54 _LIT(KMessageNameXPriority,"Test: 15");

    55 _LIT(KMessageNamePrecedence,"Test: 24");

    56 _LIT(KMessageNameImportance,"Test: 14");

    57 

    58 _LIT(KMessageNameMimeHTML, "Test: 2");

    59 

    60 

    61 LOCAL_D const TUid KUidImQueuedOperationList = {0x10001794};	// 2648441492 dec.

    62 

    63 _LIT(KTestParams,"-testparams");

    64 enum TCmdLineArgs

    65 	{

    66 	EArgProgramName,

    67 	EArgTestParams,

    68 	EArgRemoveMsgStore,

    69 	EArgMainMenu

    70 	};

    71 

    72 // --------------------------------------------------------------------------

    73 

    74 class TestScheduler : public CActiveScheduler

    75 	{

    76 public:

    77 	void Error (TInt aError) const;

    78 	};

    79 

    80 void TestScheduler::Error(TInt anError) const

    81 	{

    82 	test.Printf(_L("Scheduler Error %d"), anError );

    83 	CActiveScheduler::Stop();

    84 	}

    85 

    86 // -------------------------------------------------------------------------

    87 

    88 class TestUiTimer : public CTimer

    89 	{

    90 public:

    91 	static TestUiTimer* NewL( CConsoleBase*, CBaseServerMtm* &aImppServerMtm );

    92 	~TestUiTimer();

    93 

    94 	void RunL();

    95 	void DoCancel();

    96 	void ConstructL();

    97 	void IssueRequest();

    98 	void Dump();

    99 	TPtrC StateName(TImap4GenericProgress::TImap4GenericProgressState aState);

   100 	TPtrC OpName(TImap4GenericProgress::TImap4GenericProgressOp aOp);

   101 	TPtrC SyncStateName(TImap4SyncProgress::TImap4SyncProgressState aState);

   102 

   103 	CConsoleBase*				iConsole;

   104 	CBaseServerMtm*				&iImppServerMtm;

   105 	TTimeIntervalMicroSeconds32 period;

   106 protected:

   107 	TestUiTimer( CConsoleBase* , CBaseServerMtm* &aImppServerMtm );

   108 

   109 	TInt iCount;

   110 	TBool iClosing;

   111 	TBool iDoneConnecting;

   112 	};

   113 

   114 // --------------------------------------------------------------------------

   115 

   116 enum TImap4OpType

   117 	{

   118 	EImap4OpCopyToLocal,

   119 	EImap4OpMoveToLocal,

   120 	EImap4OpCopyFromLocal,

   121 	EImap4OpMoveFromLocal,

   122 	EImap4OpCopyWithinService,

   123 	EImap4OpMoveWithinService,

   124 	EImap4OpMoveWithinServiceToInbox,

   125 	EImap4OpPopulate,

   126 	EImap4OpDelete,

   127 	EImap4OpUndelete,

   128 	EImap4OpCopyWithinFolder,

   129 	EImap4OpCopyToLocalAndDelete,

   130 	EImap4OpMoveToLocalAndDelete,

   131 	EImap4OpCopyFromLocalAndDelete,

   132 	EImap4OpMoveFromLocalAndDelete,

   133 	EImap4OpCopyWithinServiceAndDelete,

   134 	EImap4OpMoveWithinServiceAndDelete

   135 	};

   136 

   137 enum TDebugLevel

   138 	{

   139 	EDebugLevel0=0,

   140 	EDebugLevel1,

   141 	EDebugLevel2,

   142 	EDebugLevel3,

   143 	EDebugLevel4,

   144 	EDebugLevel5,

   145 	EDebugLevel6,

   146 	EDebugLevel7,

   147 	EDebugLevel8,

   148 	EDebugLevel9

   149 	};

   150 class CActiveConsole;

   151 class CTestRefreshMBox : public CActive

   152 	{

   153 public:

   154 	static CTestRefreshMBox* NewLC(CCommandLineArguments* aCmdLineArgs);

   155 	static CTestRefreshMBox* NewL(CCommandLineArguments* aCmdLineArgs);

   156 

   157 	// Destruction

   158 	~CTestRefreshMBox();

   159 	

   160 	// Issue request

   161 	void StartL();

   162 	void EnterStateL(TInt aState);

   163 

   164 	// Cancel request.

   165 	// Defined as pure virtual by CActive;

   166 	// implementation provided by this class.

   167 	void DoCancel();

   168 

   169 	// Service  request.

   170 	// Defined as pure virtual by CActive;

   171 	// implementation provided by this class,

   172 	void RunL();

   173 	TInt NumBadMessages();

   174 

   175 	void ModifyImap4SynchronisationLimitsL(TInt aInboxSyncLimit,TInt aMailboxSyncLimit);

   176 	void FindImap4SettingsL();

   177 	void CreateDefaultServiceL(CImImap4Settings* aSettings);

   178 	void CreateServiceL( const CImImap4Settings* aSettings,

   179 						 const TDesC& aDetails, const TDesC& aDescription,

   180 						 const TBool aLocalOnly =EFalse);

   181 	void QueueOpL(TImap4OpType aOp);

   182 	void UnQueueOpL(TImap4OpType aOp);

   183 	void QueueLocalToLocalOpL(TImap4OpType aOp);

   184 

   185  	CMsvServerEntry* ServerEntry();

   186 	void SelectServiceIdL();

   187 	TMsvId iServiceId;

   188 	void DoCancelOffLineOpsL();

   189 	

   190 	void SetConsole(CActiveConsole* aConsole) {iConsole=aConsole;} 

   191 

   192 	CEmailTestUtils*		iTestUtils;

   193 	TInt iDebugLevel;

   194 

   195 private:

   196     void EndOfTest();  

   197 	void SetSubscriptionsL( TFolderSyncType aSync, TFolderSubscribeType aSubscribe );

   198 	void FindAttachmentL();

   199 	void FindMessagesInSelectionL();

   200 

   201 	void DoConnectL();

   202 	void DoConnectAndSyncL();

   203 	void DoFullSyncL();

   204 	void DoInboxNewSyncL();

   205 	void DoSyncTreeL();

   206 	void DoFetchInboxL();

   207 	void DoDisconnectL();

   208 	void DoWaitForBackgroundL();

   209 	void DoFetchAttachmentL();

   210     void DoFetchAttachedMessageL();

   211 	void DoRenameFolderL();

   212 	void DoAutomatedOffLineOpsL();

   213 	void DoAutomatedSyncOpsL();

   214 	void DoFetchTestL();

   215 	void DoFolderRemoveL();

   216 	void DoFolderRemoveL(TMsvId aParent, const TDesC& aName);

   217 	void DoFolderCreateL();

   218 	void DoFolderCreateL(TMsvId aParent, const TDesC& aName);

   219 	void DoAutomatedSecondaryConnectOpsL();

   220 	void DoCopyMessagesL();

   221 

   222 	TBool StateMachineCheckServerContentsL();

   223 	void DoCheckServerContentsL();

   224 

   225 	TBool StateMachineNSynchronisationL();

   226 	void DoNSynchronisationRegressionL();

   227 	void DoNSynchronisationTestsL();

   228 	void DoNSynchronisationSpecialTestsL();

   229 	void DoNSynchronisationPerformanceTestsL();

   230 	void DoNSynchronisationOneOffTestsL();

   231 

   232 	void StartTimerL();

   233 	void ClearTimer();

   234 	void ConstructL();

   235 	TPtrC TestMsgName(TImap4OpType aOpType, TImap4GetMailOptions aOptions);

   236 	void TestFolders(TImap4OpType aOpType,

   237 					 TMsvId& srcFolder, TMsvId& destination);

   238 	

   239 	TMsvId FindMessageByNameL(TMsvId aSrcFolder, const TDesC& aName);

   240 	TMsvId FindMessageByOpL(TMsvId aSrcFolder, TImap4OpType aOp);

   241 	TMsvId FindMessageByOpL(TMsvId aSrcFolder, TImap4OpType aOp, TImap4GetMailOptions aOptions);

   242 	TMsvId FindFolderByNameL(TMsvId aSrcFolder, const TDesC& aName);

   243 	TMsvId FindByNameL(TMsvId aSrcFolder, const TDesC& aName, TBool aSearchOnDetails);

   244 	

   245 	TMsvId CountMessagesByNameL(TMsvId aSrcFolder, const TDesC& aName);

   246 	TInt CountMessagesByOpL(TMsvId aSrcFolder, TImap4OpType aOp);

   247 

   248 

   249 protected:

   250 	// Data members defined by this class

   251 	CBaseServerMtm*			iImppServerMtm;

   252 	CMsvServerEntry*		iEntry;

   253 	CMsvEntrySelection*		iSelection;

   254 	TInt					iState;

   255 

   256 private:

   257 	CMsvServerEntry* SetEntryL(TMsvId aFolder, const TDesC& aName);

   258 	CImHeader* GetHeaderLC();

   259 	CImImap4Settings* GetImap4SettingsLC();

   260 

   261 	TBool HandleSyncStateL();

   262 	TBool HandleOffLineStateL();

   263 	TBool TestSecondaryConnectStateMachineL();

   264 

   265 	void NextState(TInt aInc);

   266 	void NextState();

   267 	void PerformOpL( TImap4OpType aOpType, const TDesC8& aParams);

   268 	void PerformSpecialOpL(TMsvId aId, TImap4Cmds aCommand);

   269 	

   270 	void DoOpByIdL( TImap4OpType aOpType, TMsvId aId );

   271 	void DoOpByIdL( TImap4OpType aOpType, TMsvId aId, const TDesC8& aParams );

   272 	void DoOpL( TImap4OpType aOpType, const TDesC& aName, TMsvId aSourceFolder, TMsvId aDestFolder, const TDesC8& aParams);

   273 	void DoOpL( TImap4OpType aOpType, TMsvId aSourceFolder, TMsvId aDestFolder, const TDesC8& aParams);

   274 	void DoOpL( TImap4OpType aOpType, TMsvId aSourceFolder, TMsvId aDestFolder);

   275 	void DoOpL( TImap4OpType aOpType, TMsvId aSourceFolder, TMsvId aDestFolder, TImap4GetMailOptions aOptions);

   276 	void DoOpNamedL( TImap4OpType aOpType, TMsvId aSrcFolder, TMsvId aDestFolder, const TDesC8& params);

   277 	void DoOpNamedL( TImap4OpType aOpType, TMsvId aSrcFolder, TMsvId aDestFolder);

   278 	void DoOpNamedL( TImap4OpType aOpType, TMsvId aSrcFolder, TMsvId aDestFolder, TImap4GetMailOptions aOptions);

   279 

   280 	TBool TestQueueL( TMsvId aFolder, CImOffLineOperation::TOffLineOpType aOpType, TMsvId aMessage, TMsvId aTarget, TInt aFnId,	const TDesC8& aParams );

   281 	TBool TestQueueL( TMsvId aFolder, CImOffLineOperation::TOffLineOpType aOpType, TMsvId aMessage, TMsvId aTarget, TImap4GetMailOptions aOptions );

   282 	TBool TestQueueL( TMsvId aFolder, CImOffLineOperation::TOffLineOpType aOpType, TMsvId aMessage, TMsvId aTarget );

   283 	TBool TestQueueEmptyL( TMsvId aFolder );

   284 	TMsvId FindShadowL( TMsvId aFolder, TMsvId aSourceId );

   285 	TBool TestShadowL( TMsvId aFolder, TMsvId aSourceId );

   286 	TBool TestVisible( TMsvId aSourceId );

   287 	TBool TestInvisible( TMsvId aSourceId );

   288 	TBool TestComplete( TMsvId aSourceId );

   289 	TBool TestExists( TMsvId aSourceId );

   290 	TImDisconnectedOperationType TestDisconnectedFlags( TMsvId aSourceId );

   291 	TBool TestSubscribed( TMsvId aSourceId );

   292 	TBool TestNotSubscribed( TMsvId aSourceId );

   293 	TBool TestLocalSubscription( TMsvId aSourceId );

   294 	TBool TestNotLocalSubscription( TMsvId aSourceId );

   295 

   296 	void TestPriorityAndReceiptAddressL();

   297 

   298 	void DebugFormatL(TInt aDebugLevel,TRefByValue<const TDesC> aFmt,...);

   299 	void DebugUidListL(TInt aDebugLevel);

   300 

   301 	TMsvId iRemoteInbox;

   302 

   303 	TMsvId iRemoteFolder1;

   304 	TMsvId iRemoteFolder2;

   305 	TMsvId iLocalFolder1;

   306 	TMsvId iLocalFolder2;

   307 

   308 	TInt iOpState;

   309 	TInt iTestNum;

   310 	TMsvId iSourceId;

   311 	TMsvId iSourceFolder;

   312 	TMsvId iDestFolder;

   313 	TMsvId iOrigSourceId;

   314 

   315 	CLogClient *iLogClient;

   316 	CLogViewEvent *iLogView;

   317 	CLogFilter *iLogFilter;

   318 

   319 	TUint32 iMessageUid;

   320 	TInt iSyncLimit;

   321 	TTime iTimeStamp;

   322 	

   323 private:

   324 	CTestRefreshMBox();

   325 	TestUiTimer*			iTimer;

   326 

   327 	TBool					iRenamedFolder;

   328 	

   329 	CActiveConsole*			iConsole;

   330 	CCommandLineArguments*	iCmdLineArgs;	

   331 

   332 public:

   333 	enum

   334 		{

   335 		EImapTestConnect,

   336 		EImapTestConnectAndSync,

   337 		EImapTestFullSync,

   338 		EImapTestInboxNewSync,

   339 		EImapTestSyncTree,

   340 		EImapTestDisconnect,

   341 		EImapTestFetchInbox,

   342 		EImapTestOffLineOp,

   343 		EImapTestWaitForBackground,

   344 		EImapTestFetchAttachment,

   345 		EImapTestCancelOffLineOps,

   346 		EImapTestRenameFolder,

   347 		EImapTestAutoOffLineOp,

   348 		EImapTestAutoSyncOp,

   349 		EImapTestFetchTest,

   350 		EImapTestFolderDelete,

   351 		EImapTestFolderCreate,

   352 		EImapTestCheckServerContents,

   353 		EImapTestAutoSecondaryConnect,

   354 		EImapTestLocalSubscribe,

   355 		EImapTestLocalUnsubscribe,

   356         EImapTestFetchAttachedMessage,

   357         EImapTestCopyMessages,

   358 		EImapTestNSynchronisation,	 

   359 		EImapTestNSynchronisationTests,			 

   360 		EImapTestNSynchronisationSpecialTests,

   361 		EImapTestNSynchronisationPerformanceTests,

   362 		EImapTestNSynchronisationOneOffTests

   363 		};

   364 	};

   365 

   366 // --------------------------------------------------------------------------

   367 

   368 // My derived Console, as per the example code and the stuff in T_POPC 

   369 

   370 class CActiveConsole : public CActive

   371 	{

   372 public:

   373 	// Construction

   374 	static CActiveConsole* NewLC( CTestRefreshMBox *aRefresher,CCommandLineArguments* aCmdLineArgs );

   375 

   376 	// Destruction

   377 	~CActiveConsole();

   378 

   379 	// Issue request

   380 	void RequestCharacter();

   381 	

   382 	// Cancel request.

   383 	// Defined as pure virtual by CActive;

   384 	void DoCancel();

   385 

   386 	// Service completed request.

   387 	// Defined as pure virtual by CActive;

   388 	void RunL();

   389 

   390 	// Called from RunL() to handle the completed request

   391 	void ProcessKeyPressL(TChar aChar); 

   392 

   393 	void DumpMessageStructureL( TMsvId aId,

   394 							   TInt aSummary,

   395 							   TInt aParts,

   396 							   TBool aRecurse,

   397 							   TBool aShowIds,

   398 							   MsgMatchFn aMatch =0);

   399 private:

   400 	void ConstructL();

   401 	CActiveConsole();

   402 

   403 	void DisplayMainMenu();

   404 	void DisplayImap4ServerMenu();

   405 	void DisplayImap4SettingsMenu();

   406 	void DisplayImap4DumpMenu();

   407 	void DisplayHousekeepingMenu();

   408 	void DisplayOffLineOpMenu();

   409 	void DisplayOffLineOpQueueMenu();

   410 	void DisplayOffLineOpUnQueueMenu();

   411 	void DisplayOffLineOpQueueLocalToLocalMenu();

   412 	void DisplayConnectMenu();

   413 	void DisplayConnect2Menu();

   414 	void DisplayAutomationMenu();

   415 	void DisplaySynchroniseMenu();

   416 	void DisplayDebugMenu();

   417 

   418 	void SelectImap4ServerEntryL(TChar aChar);

   419 	void SelectImap4SettingsEntryL(TChar aChar);

   420 	

   421 

   422 public:

   423 	TBool	iIssueCancel;

   424 

   425 private:	

   426 	TUint iMenuState;

   427 	TUint iPrevState;

   428 

   429 	CTestRefreshMBox *iRefresher;

   430 	

   431 	CCommandLineArguments*	iCmdLineArgs;

   432 	TInt					iLevel;

   433 

   434 	enum

   435 		{

   436 		EExit = 0,

   437 		EMainMenu,

   438 		EImap4ServerMenu,

   439 		EImap4SettingsMenu,

   440 		EImap4DumpMenu,

   441 		EHousekeepingMenu,

   442 		EOffLineOpMenu,

   443 		EOffLineOpQueueMenu,

   444 		EOffLineOpUnQueueMenu,

   445 		EOffLineOpQueueLocalToLocalMenu,

   446 		EConnectMenu,

   447 		EConnect2Menu,

   448 		EAutomationMenu,

   449 		ESynchroniseMenu,

   450 		EDebugMenu

   451 		};

   452 	};

   453 

   454 // -------------------------------------------------------------------------

   455 

   456 // Constants

   457 

   458 _LIT(KFilePathMailTest, "c:\\mailtest\\");

   459 

   460 #define KPeriod 10000	// period of timer

   461 

   462 // -------------------------------------------------------------------------

   463 

   464 TestUiTimer* TestUiTimer::NewL( CConsoleBase* aConsole, CBaseServerMtm* &aImppServerMtm)

   465 	{

   466 	TestUiTimer* self = new(ELeave) TestUiTimer( aConsole , aImppServerMtm);

   467 	CleanupStack::PushL(self);

   468 	self->iImppServerMtm = aImppServerMtm;

   469 	self->ConstructL();

   470 	CleanupStack::Pop();

   471 	return self;

   472 	}

   473 

   474 

   475 TestUiTimer::TestUiTimer( CConsoleBase* aConsole , CBaseServerMtm* &aImppServerMtm)

   476 	: CTimer(10 /*KMsgPop3RefreshMailboxPriority+1*/) , iImppServerMtm(aImppServerMtm)

   477 	{

   478 	iConsole = aConsole;

   479 	period = 	KPeriod;

   480 	iClosing = EFalse;

   481 	iCount = 0;

   482 	iDoneConnecting = EFalse;

   483 	}

   484 

   485 TestUiTimer::~TestUiTimer()

   486 	{

   487 	}

   488 

   489 void TestUiTimer::ConstructL()

   490 	{

   491 	CTimer::ConstructL();

   492 

   493 	CActiveScheduler::Add( this );

   494 	}

   495 

   496 

   497 void TestUiTimer::IssueRequest()

   498 	{

   499 	After( period );

   500 	}

   501 

   502 

   503 void TestUiTimer::DoCancel()

   504 	{

   505 	CTimer::DoCancel();

   506 	}

   507 

   508 TPtrC TestUiTimer::OpName(TImap4GenericProgress::TImap4GenericProgressOp aOp)

   509 	{

   510 	switch (aOp)

   511 		{

   512 	case TImap4GenericProgress::EConnect:

   513 		return _L("EConnect");

   514 	case TImap4GenericProgress::EDisconnect:

   515 		return _L("EDisconnect");

   516 	case TImap4GenericProgress::ESync:

   517 		return _L("ESync");

   518 	case TImap4GenericProgress::ESelect:

   519 		return _L("ESelect");

   520 		

   521 	case TImap4GenericProgress::ECopyToLocal:

   522 		return _L("ECopyToLocal");

   523 	case TImap4GenericProgress::ECopyWithinService:

   524 		return _L("ECopyWithinService");

   525 	case TImap4GenericProgress::ECopyFromLocal:

   526 		return _L("ECopyFromLocal");

   527 	case TImap4GenericProgress::EMoveToLocal:

   528 		return _L("EMoveToLocal");

   529 	case TImap4GenericProgress::EMoveWithinService:

   530 		return _L("EMoveWithinService");

   531 	case TImap4GenericProgress::EMoveFromLocal:

   532 		return _L("EMoveFromLocal");

   533 	case TImap4GenericProgress::EPopulate:

   534 		return _L("EPopulate");

   535 	case TImap4GenericProgress::EDelete:

   536 		return _L("EDelete");

   537 		

   538 	case TImap4GenericProgress::EOffLineDelete:

   539 	case TImap4GenericProgress::EOffLineUndelete:

   540 	case TImap4GenericProgress::EOffLineCopyToLocal:

   541 	case TImap4GenericProgress::EOffLineMoveToLocal:

   542 	case TImap4GenericProgress::EOffLineCopyFromLocal:

   543 	case TImap4GenericProgress::EOffLineMoveFromLocal:

   544 	case TImap4GenericProgress::EOffLineCopyWithinService:

   545 	case TImap4GenericProgress::EOffLineMoveWithinService:

   546 	case TImap4GenericProgress::EOffLinePopulate:

   547 		return _L("EOffLineOp");

   548 		

   549 	default:

   550 		test.Panic(_L("Unknown Op %d"),aOp);

   551 		break;

   552 		}

   553 	return _L("EUnknown");

   554 	}

   555 

   556 TPtrC TestUiTimer::StateName(TImap4GenericProgress::TImap4GenericProgressState aState)

   557 	{

   558 	switch (aState)

   559 		{

   560 	case TImap4GenericProgress::EDisconnected:

   561 		return _L("EDisconnected");

   562 	case TImap4GenericProgress::EConnecting:

   563 		return _L("EConnecting");

   564 	case TImap4GenericProgress::EIdle:

   565 		return _L("EIdle");

   566 	case TImap4GenericProgress::ESelecting:

   567 		return _L("ESelecting");

   568 	case TImap4GenericProgress::EFetching:

   569 		return _L("EFetching");

   570 	case TImap4GenericProgress::EAppending:

   571 		return _L("EAppending");

   572 	case TImap4GenericProgress::ECopying:

   573 		return _L("ECopying");

   574 	case TImap4GenericProgress::EDeleting:

   575 		return _L("EDeleting");

   576 	case TImap4GenericProgress::ESyncing:

   577 		return _L("ESyncing");

   578 	case TImap4GenericProgress::EDisconnecting:

   579 		return _L("EDisconnecting");

   580 	case TImap4GenericProgress::EBusy:		

   581 		return _L("EBusy");

   582 	default:

   583 		test.Panic(_L("Unknown State %d"),aState);

   584 		break;

   585 		}

   586 	return _L("EUnknown");

   587 	}

   588 

   589 

   590 TPtrC TestUiTimer::SyncStateName(TImap4SyncProgress::TImap4SyncProgressState aState)

   591 	{

   592 	switch (aState)

   593 		{

   594 	case TImap4SyncProgress::EIdle:

   595 		return _L("Idle");

   596 	case TImap4SyncProgress::EBusy:

   597 		return _L("Busy");

   598 	case TImap4SyncProgress::EConnecting:

   599 		return _L("Connecting");

   600 	case TImap4SyncProgress::EDisconnecting:

   601 		return _L("Disconnecting");

   602 	case TImap4SyncProgress::ESyncInbox:

   603 		return _L("SyncInbox");

   604 	case TImap4SyncProgress::ESyncFolderTree:

   605 		return _L("SyncFolderTree");

   606 	case TImap4SyncProgress::ECheckRemoteSubscription:

   607 		return _L("CheckRemoteSubscription");

   608 	case TImap4SyncProgress::EUpdateRemoteSubscription:

   609 		return _L("UpdateRemoteSubscription");

   610 	case TImap4SyncProgress::ESyncOther:

   611 		return _L("SyncOther");

   612 	case TImap4SyncProgress::EDeleting:

   613 		return _L("Deleting");

   614 	case TImap4SyncProgress::EProcessingPendingOps:

   615 		return _L("ProcPending");

   616 	default:

   617 		test.Panic(_L("Unknown SyncState %d"),aState);

   618 		break;

   619 		}

   620 	return _L("EUnknown");

   621 	}

   622 

   623 void TestUiTimer::Dump()

   624 	{

   625 	// display the current progress

   626 	TImap4CompoundProgress temp;	

   627 	TPckgC<TImap4CompoundProgress> paramPack(temp);

   628 

   629 	const TDesC8& progBuf = iImppServerMtm->Progress();	

   630 	paramPack.Set(progBuf);

   631 	TImap4CompoundProgress progress=paramPack();	

   632 

   633 	test.Console()->SetPos(0, 15);

   634 

   635 	if ( progress.iGenericProgress.iState == TImap4GenericProgress::EConnecting &&

   636 		 progress.iGenericProgress.iErrorCode == KErrNone )

   637 		{

   638 		if ( iDoneConnecting )

   639 			return;

   640 		iDoneConnecting = ETrue;

   641 		}

   642 	

   643 	TPtrC opName = OpName(progress.iGenericProgress.iOperation);

   644 	TPtrC stateName = StateName(progress.iGenericProgress.iState);

   645 

   646 	test.Printf(_L("%-11S: %-14S M %3d/%3d P %2d/%2d B %6d/%6d T %6d Err %d\n"),

   647 				&opName, &stateName,

   648 				progress.iGenericProgress.iMsgsDone, progress.iGenericProgress.iMsgsToDo,

   649 				progress.iGenericProgress.iPartsDone, progress.iGenericProgress.iPartsToDo,

   650 				progress.iGenericProgress.iBytesDone, progress.iGenericProgress.iBytesToDo,

   651 				progress.iGenericProgress.iTotalSize,

   652 				progress.iGenericProgress.iErrorCode);

   653 	

   654 	TPtrC syncName = SyncStateName(progress.iSyncProgress.iState);

   655 	test.Printf(_L("           : %-14S M %3d/%3d F %2d/%2d   \n"),

   656 				&syncName,

   657 				progress.iSyncProgress.iMsgsDone, progress.iSyncProgress.iMsgsToDo,

   658 				progress.iSyncProgress.iFoldersDone, progress.iSyncProgress.iFoldersToDo);

   659 	}

   660 

   661 void TestUiTimer::RunL()

   662 	{

   663 	Dump();

   664 	IssueRequest();

   665 	};

   666 

   667 // -------------------------------------------------------------------------

   668 

   669 // CTestRefresh CActive object

   670 CTestRefreshMBox::CTestRefreshMBox() // construct low-priority active object

   671 	: CActive(-3)

   672 	{

   673 	}

   674 

   675 CTestRefreshMBox  *CTestRefreshMBox::NewLC(CCommandLineArguments* aCmdLineArgs)

   676 	{

   677 	CTestRefreshMBox* self=new (ELeave) CTestRefreshMBox();

   678 	

   679 	CleanupStack::PushL(self);

   680 	self->iCmdLineArgs = aCmdLineArgs;

   681 	self->ConstructL();

   682 	return self;

   683 	}

   684 

   685 CTestRefreshMBox  *CTestRefreshMBox::NewL(CCommandLineArguments* aCmdLineArgs)

   686 	{

   687 	CTestRefreshMBox* self=NewLC(aCmdLineArgs);

   688 	CleanupStack::Pop();

   689 	return self;

   690 	}

   691 

   692 void CTestRefreshMBox::ConstructL()

   693 	{

   694 	iTestUtils = CEmailTestUtils::NewL(test);

   695 

   696 	iTestUtils->CreateAllTestDirectories();

   697 	iTestUtils->FileSession().SetSessionPath(_L("C:\\"));

   698 

   699 #if 1

   700 	test.Printf(_L("Remove message store? (y/N)\n"));

   701 	TChar choice;

   702 	if (iCmdLineArgs)

   703 		{

   704 		TLex lex(iCmdLineArgs->Arg(EArgRemoveMsgStore));

   705 		choice=lex.Get();

   706 		}

   707 	else

   708 		choice = test.Getch();

   709 	if (choice=='y' || choice=='Y')

   710 #endif

   711 		iTestUtils->Reset();

   712 		iTestUtils->CleanMessageFolderL();	

   713 		iTestUtils->ClearEmailAccountsL();

   714 		iTestUtils->GoClientSideL();

   715 	

   716 	iTestUtils->GoServerSideL();

   717 	iEntry = iTestUtils->iServerEntry;

   718 

   719 	CActiveScheduler::Add(this); // add to active scheduler

   720 

   721 	// Get server MTM.

   722 	iTestUtils->InstantiateImapServerMtmL();

   723 	iImppServerMtm = iTestUtils->iImapServerMtm;

   724 

   725 	iTestUtils->FileSession().SetSessionPath(_L("c:\\"));

   726 

   727 	test.Printf(_L("Created server mtm \n"));

   728 	// create an entry selection

   729 	iSelection = new (ELeave) CMsvEntrySelection;

   730 

   731 	test.Console()->ClearScreen(); // get rid of menu

   732 	User::LeaveIfError(iEntry->SetEntry(KMsvRootIndexEntryId));

   733 

   734 	// test num written to log

   735 	iTestNum = 1;

   736 

   737 	// default debug level

   738 	iDebugLevel = EDebugLevel3;

   739 	}

   740  

   741 CTestRefreshMBox::~CTestRefreshMBox()

   742 	{ 

   743 	Cancel(); // make sure we're cancelled

   744 

   745 	ClearTimer();

   746 

   747 	delete iSelection;

   748 	delete iTestUtils;

   749 	delete iLogView;

   750 	delete iLogClient;

   751 	delete iLogFilter;

   752 	}

   753 

   754 void  CTestRefreshMBox::DoCancel()

   755 	{

   756 	if (iTimer)

   757 		iTimer->Cancel();	// stop the timer

   758 	}

   759 

   760 void CTestRefreshMBox::StartL()

   761 	{

   762 	if (iCmdLineArgs)

   763 		iConsole->iIssueCancel=FALSE;

   764 	switch(iState)

   765 		{

   766 	case EImapTestConnect:

   767 		DoConnectL();

   768 		break;

   769 

   770 	case EImapTestConnectAndSync:

   771 		DoConnectAndSyncL();

   772 		break;

   773 

   774 	case EImapTestFullSync:

   775 		DoFullSyncL();

   776 		break;

   777 

   778 	case EImapTestInboxNewSync:

   779 		DoInboxNewSyncL();

   780 		break;

   781 

   782 	case EImapTestSyncTree:

   783 		DoSyncTreeL();

   784 		break;

   785 

   786 	case EImapTestFetchInbox:

   787 		DoFetchInboxL();

   788 		break;

   789 

   790 	case EImapTestDisconnect:

   791 		DoDisconnectL();

   792 		break;

   793 

   794 	case EImapTestAutoOffLineOp:

   795 		DoAutomatedOffLineOpsL();

   796 		break;

   797 

   798 	case EImapTestAutoSyncOp:

   799 		DoAutomatedSyncOpsL();

   800 		break;

   801 

   802 	case EImapTestAutoSecondaryConnect:

   803 		DoAutomatedSecondaryConnectOpsL();

   804 		break;

   805 

   806 	case EImapTestOffLineOp:

   807 		break;

   808 

   809 	case EImapTestCancelOffLineOps:

   810 		DoCancelOffLineOpsL();

   811 		break;

   812 

   813 	case EImapTestWaitForBackground:

   814 		DoWaitForBackgroundL();

   815 		break;

   816 

   817 	case EImapTestFetchAttachment:

   818 		DoFetchAttachmentL();

   819 		break;

   820 

   821 	case EImapTestRenameFolder:

   822 		DoRenameFolderL();

   823 		break;

   824 

   825 	case EImapTestFetchTest:

   826 		DoFetchTestL();

   827 		break;

   828 

   829 	case EImapTestFolderDelete:

   830 		DoFolderRemoveL();

   831 		break;

   832 

   833 	case EImapTestFolderCreate:

   834 		DoFolderCreateL(iServiceId, _L("Test1"));

   835 		break;

   836 

   837 	case EImapTestCheckServerContents:

   838 		DoCheckServerContentsL();

   839 		break;

   840 

   841 	case EImapTestNSynchronisation:	   

   842 		DoNSynchronisationRegressionL();

   843 		break;

   844 

   845 	case EImapTestNSynchronisationTests:

   846 		DoNSynchronisationTestsL();

   847 		break;

   848 

   849 	case EImapTestNSynchronisationSpecialTests:

   850 		DoNSynchronisationSpecialTestsL();

   851 		break;

   852 

   853 	case EImapTestNSynchronisationPerformanceTests:

   854 		DoNSynchronisationPerformanceTestsL();

   855 		break;

   856 

   857 	case EImapTestNSynchronisationOneOffTests:

   858 		DoNSynchronisationOneOffTestsL();

   859 		break;

   860 

   861     case EImapTestLocalSubscribe:

   862         PerformSpecialOpL(FindFolderByNameL(iServiceId, _L("Test1")), KIMAP4MTMLocalSubscribe);

   863         break;

   864 

   865     case EImapTestLocalUnsubscribe:

   866         PerformSpecialOpL(FindFolderByNameL(iServiceId, _L("Test1")), KIMAP4MTMLocalUnsubscribe);

   867         break;

   868 

   869 	case EImapTestFetchAttachedMessage:

   870 		DoFetchAttachedMessageL();

   871 		break;

   872 		

   873 	case EImapTestCopyMessages:

   874 		DoCopyMessagesL();

   875 		break;

   876 		}

   877 	}

   878 

   879 void CTestRefreshMBox::EndOfTest()

   880 	{

   881 	if (iCmdLineArgs)

   882 		{

   883 		iConsole->iIssueCancel=TRUE;

   884 		iConsole->DoCancel();

   885 		}

   886 	}

   887 

   888 const TInt KDebugLogMaxLineSize=256;

   889 

   890 void CTestRefreshMBox::DebugFormatL(TInt aDebugLevel,TRefByValue<const TDesC> aFmt,...)

   891 	{

   892 	// Log this debug text?

   893 	if (aDebugLevel>iDebugLevel)

   894 		return;

   895 

   896 	// Build parameter list.

   897 	VA_LIST list;

   898 	VA_START(list, aFmt);

   899 

   900 	// Print to log file.

   901 	TBuf<KDebugLogMaxLineSize> buf;

   902 	TRAPD(ret,buf.FormatList(aFmt, list));		

   903 

   904 	// Log the debug buffer.

   905 	if (ret==KErrNone)

   906 		iTestUtils->WriteComment(buf);

   907 	else

   908 		iTestUtils->WriteComment(_L("ERROR: Formatting debug output"));

   909 	}

   910 

   911 void CTestRefreshMBox::DebugUidListL(TInt /*aDebugLevel*/)

   912 	{

   913 #if 0	// crashes on big test

   914 	

   915 	// Log this debug text?

   916 	if (aDebugLevel>iDebugLevel)

   917 		return;

   918 

   919 	// Build list of UIDs.

   920 	TBuf<KDebugLogMaxLineSize> buf;

   921  	TMsvEntry* entryPtr;

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

   923 		{

   924 		TRAPD(ret,buf.AppendFormat(i?_L(", "):_L("UID list: ")));

   925 		if (!ret)

   926 			{

   927 			User::LeaveIfError(iEntry->GetEntryFromId((*iSelection)[i],entryPtr));

   928 			TRAPD(ret,buf.AppendFormat(_L("%d"),((TMsvEmailEntry)(*entryPtr)).UID()));		

   929 			if (ret!=KErrNone)

   930 				{

   931 				iTestUtils->WriteComment(_L("ERROR: Formatting debug output"));

   932 				return;

   933 				}

   934 			}

   935 		}

   936 

   937 	// Log the debug buffer.

   938 	iTestUtils->WriteComment(buf);

   939 #endif

   940 	}

   941 

   942 void CTestRefreshMBox::EnterStateL(TInt aState)

   943 	{

   944 	iState = aState;

   945 	StartL();

   946 	}

   947 

   948 void CTestRefreshMBox::StartTimerL()

   949 	{

   950 	if (!iTimer)

   951 		{

   952 		iTimer = TestUiTimer::NewL( test.Console(), iImppServerMtm );

   953 		iTimer->IssueRequest( );	// START THE OBSERVATION TIMER

   954 		}

   955 	}

   956 

   957 void CTestRefreshMBox::ClearTimer()

   958 	{

   959 	if (iTimer)

   960 		{

   961 		// output last known state before clearing

   962 		iTimer->Dump();

   963 		

   964 		delete iTimer;

   965 		iTimer = NULL;

   966 		}

   967 	}

   968 

   969 CMsvServerEntry* CTestRefreshMBox::ServerEntry()

   970 	{

   971 	return iEntry;

   972 	}

   973 

   974 void CTestRefreshMBox::SelectServiceIdL()

   975 	{

   976 	User::LeaveIfError(iEntry->SetEntry(iServiceId));

   977 	}

   978 

   979 CMsvServerEntry* CTestRefreshMBox::SetEntryL(TMsvId aFolder, const TDesC& aName)

   980 	{

   981 	TMsvId id = FindMessageByNameL(aFolder, aName);

   982 	User::LeaveIfError(iEntry->SetEntry(id));

   983 	return iEntry;

   984 	}

   985 

   986 void CTestRefreshMBox::DoConnectAndSyncL()

   987 	{

   988 	// Kick off connection to specified service

   989 	test.Console()->SetPos(0, 13);

   990 	test.Printf(_L("DoConnectAndSync\n"));

   991 

   992 	iSelection->Reset();

   993 	iSelection->AppendL(iServiceId);

   994 	TBuf8<128> paramBuf(_L8(""));

   995 

   996 	SetActive();

   997 	iImppServerMtm->StartCommandL(*iSelection,KIMAP4MTMConnectAndSynchronise,paramBuf,iStatus);

   998 

   999 	// create the progress Timer object

  1000 	StartTimerL();

  1001 	}

  1002 

  1003 void CTestRefreshMBox::DoConnectL()

  1004 	{

  1005 	// Kick off connection to specified service

  1006 	test.Console()->SetPos(0, 13);

  1007 	test.Printf(_L("DoConnect\n"));

  1008 

  1009 	iSelection->Reset();

  1010 	iSelection->AppendL(iServiceId);

  1011 	TBuf8<128> paramBuf(_L8(""));

  1012 

  1013 	SetActive();

  1014 	iImppServerMtm->StartCommandL(*iSelection,KIMAP4MTMConnect,paramBuf,iStatus);

  1015 

  1016 	// create the progress Timer object

  1017 	StartTimerL();

  1018 	}

  1019 

  1020 void CTestRefreshMBox::DoFullSyncL()

  1021 	{

  1022 	// Kick off connection to specified service

  1023 	test.Console()->SetPos(0, 13);

  1024 	test.Printf(_L("DoFullSync\n"));

  1025 

  1026 	iSelection->Reset();

  1027 	TBuf8<128> paramBuf(_L8(""));

  1028 

  1029 	SetActive();

  1030 	iImppServerMtm->StartCommandL(*iSelection,KIMAP4MTMFullSync,paramBuf,iStatus);

  1031 

  1032 	// create the progress Timer object

  1033 	StartTimerL();

  1034 	}

  1035 

  1036 void CTestRefreshMBox::DoInboxNewSyncL()

  1037 	{

  1038 	// Kick off connection to specified service

  1039 	test.Console()->SetPos(0, 13);

  1040 	test.Printf(_L("DoInboxNewSync\n"));

  1041 

  1042 	iSelection->Reset();

  1043 	TBuf8<128> paramBuf(_L8(""));

  1044 

  1045 	SetActive();

  1046 	iImppServerMtm->StartCommandL(*iSelection,KIMAP4MTMInboxNewSync,paramBuf,iStatus);

  1047 

  1048 	// create the progress Timer object

  1049 	StartTimerL();

  1050 	}

  1051 

  1052 void CTestRefreshMBox::DoSyncTreeL()

  1053 	{

  1054 	// Kick off connection to specified service

  1055 	test.Console()->SetPos(0, 13);

  1056 	test.Printf(_L("DoSyncTree\n"));

  1057 

  1058 	iSelection->Reset();

  1059 	TBuf8<128> paramBuf(_L8(""));

  1060 

  1061 	SetActive();

  1062 	iImppServerMtm->StartCommandL(*iSelection,KIMAP4MTMSyncTree,paramBuf,iStatus);

  1063 

  1064 	// create the progress Timer object

  1065 	StartTimerL();

  1066 	}

  1067 

  1068 void CTestRefreshMBox::DoFetchTestL()

  1069 	{

  1070 	test.Console()->SetPos(0, 13);

  1071 	test.Printf(_L("DoFetchTest\n"));

  1072 

  1073 	TMsvId id = FindMessageByNameL(iRemoteInbox, KMessageNameTest);

  1074 

  1075 	// check message is there

  1076 	test(id != KErrNone);

  1077 	test(id != KErrNotFound);

  1078 

  1079 	iSelection->Reset();

  1080 	iSelection->AppendL(id);

  1081 	

  1082 	SetActive();

  1083 	iImppServerMtm->CopyToLocalL(*iSelection, KMsvGlobalInBoxIndexEntryId, iStatus);

  1084 

  1085 	StartTimerL();

  1086 	}

  1087 

  1088 void CTestRefreshMBox::DoFetchInboxL()

  1089 	{

  1090 	test.Console()->SetPos(0, 13);

  1091 	test.Printf(_L("DoFetchInbox\n"));

  1092 

  1093 	User::LeaveIfError(iEntry->SetEntry( iRemoteInbox ));

  1094 

  1095 	User::LeaveIfError(iEntry->GetChildren(*iSelection));

  1096 

  1097 	// strip out any nested folders

  1098 	TInt a=0;

  1099 	while (a<iSelection->Count())

  1100 		{

  1101 		iEntry->SetEntry((*iSelection)[a]);

  1102 		if (iEntry->Entry().iType == KUidMsvFolderEntry)

  1103 			iSelection->Delete(a);

  1104 		else

  1105 			a++;

  1106 		}

  1107 	

  1108 	SetActive();

  1109 	iImppServerMtm->CopyToLocalL(*iSelection, KMsvGlobalInBoxIndexEntryId, iStatus);

  1110 

  1111 	StartTimerL();

  1112 	}

  1113 

  1114 void CTestRefreshMBox::DoDisconnectL()

  1115 	{

  1116 	test.Console()->SetPos(0, 13);

  1117 	test.Printf(_L("DoDisconnect\n"));

  1118 

  1119 	TBuf8<128> paramBuf(_L8(""));

  1120 

  1121 	SetActive();

  1122 	iImppServerMtm->StartCommandL(*iSelection,KIMAP4MTMDisconnect,paramBuf,iStatus);

  1123 

  1124 	StartTimerL();

  1125 	}

  1126 

  1127 void CTestRefreshMBox::DoWaitForBackgroundL()

  1128 	{

  1129 	test.Console()->SetPos(0, 13);

  1130 	test.Printf(_L("DoWaitForBackground\n"));

  1131 

  1132 	TBuf8<128> paramBuf(_L8(""));

  1133 

  1134 	SetActive();

  1135 	iImppServerMtm->StartCommandL(*iSelection,KIMAP4MTMWaitForBackground,paramBuf,iStatus);