1 // Copyright (c) 1999-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 #ifndef __IMAPTESTS_H

    17 #define __IMAPTESTS_H

    18 

    19 #include "emailsmoke.h"

    20 #include "emailsmokecommands.h"

    21 #include <imapconnectionobserver.h>

    22 

    23 

    24 //

    25 //

    26 // CImapClientTest

    27 //

    28 

    29 class CImapClientTest : public CEmailClientTest

    30 	{

    31 public:

    32 	static CImapClientTest* NewL(CEmailTestUtils& aTestUtils, RTest& aTest);

    33 	virtual ~CImapClientTest();

    34 

    35 protected:

    36 	virtual void ConstructL();

    37 	CImapClientTest(CEmailTestUtils& aTestUtils, RTest& aTest);

    38 	};

    39 

    40 

    41 //

    42 //

    43 // CCreateImapClientMtm

    44 //

    45 

    46 class CCreateImapClientMtm : public CBase, public MBaseTestState

    47 	{

    48 public:

    49 	void StartL(TRequestStatus& aStatus);

    50 	CCreateImapClientMtm(CEmailClientTest& aTest);

    51 

    52 private:

    53 	CEmailClientTest& iTest;

    54 	};

    55 

    56 

    57 //

    58 //

    59 // CCreateImapService

    60 //

    61 

    62 

    63 class CCreateImapService : public CCreateEmailService

    64 	{

    65 public:

    66 	static CCreateImapService* NewL(CEmailClientTest& aTestHarness);

    67 	void StartL(TRequestStatus& aStatus);

    68 	~CCreateImapService();

    69 	CImImap4Settings& Settings();

    70 

    71 private:

    72 	void ConstructL();

    73 	CCreateImapService(CEmailClientTest& aTestHarness);

    74 

    75 private:

    76 	CEmailClientTest& iTestHarness;

    77 	CImImap4Settings* iSettings;

    78 	};

    79 

    80 

    81 

    82 //

    83 //

    84 // CImapUseService

    85 //

    86 

    87 class CImapUseService : public CBase, public MBaseTestState

    88 	{

    89 public:

    90 	CImapUseService(CImapClientTest& aTestHarness);

    91 	void StartL(TRequestStatus& aStatus);

    92 

    93 private:

    94 	CImapClientTest& iTestHarness;

    95 	};

    96 

    97 

    98 

    99 //

   100 //

   101 // CImapConnect

   102 //

   103 

   104 class CImapConnect;

   105 class ImapConnectionObserver : public MMsvImapConnectionObserver

   106 	{

   107 public:

   108 	ImapConnectionObserver(CImapConnect* aImapConnect);

   109 	void HandleImapConnectionEvent(TImapConnectionEvent aConnectionState);

   110 private:

   111 	CImapConnect* iImapConnect;

   112 	TInt iCount;

   113 	};

   114 

   115 class CImapConnect : public CActive, public MBaseTestState

   116 	{

   117 public:

   118 	enum TSyncStatus

   119 		{

   120 		ENoSync,

   121 		EConnectAndSync,

   122 		EConnectAndPeriodicSync

   123 		};

   124 

   125 	CImapConnect(CEmailClientTest& aParentTestHarness, TSyncStatus aSynchronise = ENoSync);

   126 	void StartL(TRequestStatus& aStatus);

   127 	void RunL();

   128 	void DummyRun();

   129 	void DoCancel();

   130 	~CImapConnect();

   131 

   132 private:

   133 	CEmailClientTest& iParentTestHarness;

   134 	TRequestStatus* iReportStatus;

   135 	TSyncStatus iSynchronise;

   136 	ImapConnectionObserver* iObserver;

   137 	TBool iDummyComplete;

   138 	};

   139 

   140 

   141 //

   142 //

   143 // CImapConnectAndMonitor

   144 //

   145 

   146 class CImapConnectAndMonitor : public CActive, public MBaseTestState, public MMsvImapConnectionObserver

   147 	{

   148 public:

   149 	CImapConnectAndMonitor(CEmailClientTest& aParentTestHarness, TBool aSynchronise = EFalse);

   150 	void StartL(TRequestStatus& aStatus);

   151 	void RunL();

   152 	void DoCancel();

   153 	~CImapConnectAndMonitor();

   154 

   155 private:

   156 	void LogCommentFormat(TRefByValue<const TDesC> format,...);

   157 	void HandleImapConnectionEvent(TImapConnectionEvent aConnectionEvent);

   158 	void MonitorConnectionL();

   159 private:

   160 	CEmailClientTest& iParentTestHarness;

   161 	TRequestStatus* iReportStatus;

   162 	TBool iSynchronise;

   163 	TBool iConnectionError;

   164 	};

   165 

   166 

   167 //

   168 //

   169 // CImapConnectAndCancel

   170 //

   171 

   172 class CImapConnectAndCancel : public CActive, public MBaseTestState

   173 	{

   174 

   175 public:

   176 	CImapConnectAndCancel(CEmailClientTest& aParentTestHarness, TUint aCancelDelay = 500);

   177 	void StartL(TRequestStatus& aStatus);

   178 	void RunL();

   179 	void DoCancel();

   180 	~CImapConnectAndCancel();

   181 

   182 	// What operation is currently in progress

   183 	enum TCommandState

   184 		{

   185 		EFirstConnect,

   186 		EDisconnect,

   187 		ESecondSync,

   188 		ESecondSyncCancelled,

   189 		EThirdSync,

   190 		EComplete

   191 		};

   192 

   193 private:

   194 	void LogCommentFormat(TRefByValue<const TDesC> format,...);

   195 	void CancelOperation();

   196 private:

   197 	CEmailClientTest& iParentTestHarness;

   198 	TRequestStatus* iReportStatus;

   199 	CMsvEntrySelection* iSelection;

   200 	TUint iCancelDelay;

   201 	TInt iCommandState;

   202 	};

   203 

   204 

   205 //

   206 //

   207 // CImapDisconnect

   208 //

   209 

   210 class CImapDisconnect : public CActive, public MBaseTestState

   211 	{

   212 public:

   213 	CImapDisconnect(CEmailClientTest& aParentTestHarness);

   214 	void StartL(TRequestStatus& aStatus);

   215 	void RunL();

   216 	void DoCancel();

   217 	~CImapDisconnect();

   218 

   219 private:

   220 	CEmailClientTest& iParentTestHarness;

   221 	TRequestStatus* iReportStatus;

   222 	};

   223 

   224 

   225 

   226 //

   227 //

   228 // CCheckImapOperation

   229 //

   230 

   231 class CCheckImapOperation : public CBase, public MBaseTestState

   232 	{

   233 public:

   234 	CCheckImapOperation(TInt aExpectedStatus, CImapClientTest& aTestHarness);

   235 	void StartL(TRequestStatus& aStatus);

   236 

   237 private:

   238 	CImapClientTest& iTestHarness;

   239 	TInt iExpectedStatus;

   240 	};

   241 

   242 //

   243 //

   244 // CImapSyncTree

   245 //

   246 

   247 class CImapSyncTree : public CActive, public MBaseTestState

   248 	{

   249 public:

   250 	CImapSyncTree(CEmailClientTest& aParentTestHarness);

   251 	void StartL(TRequestStatus& aStatus);

   252 	void RunL();

   253 	void DoCancel();

   254 	~CImapSyncTree();

   255 

   256 private:

   257 	CEmailClientTest& iParentTestHarness;

   258 	TRequestStatus* iReportStatus;

   259 	};

   260 

   261 

   262 //

   263 //

   264 // CImapInboxNewSync

   265 //

   266 

   267 class CImapInboxNewSync : public CActive, public MBaseTestState

   268 	{

   269 public:

   270 	CImapInboxNewSync(CEmailClientTest& aParentTestHarness);

   271 	void StartL(TRequestStatus& aStatus);

   272 	void RunL();

   273 	void DoCancel();

   274 	~CImapInboxNewSync();

   275 

   276 private:

   277 	CEmailClientTest& iParentTestHarness;

   278 	TRequestStatus* iReportStatus;

   279 	};

   280 

   281 //

   282 //

   283 // CImapFolderSync

   284 //

   285 

   286 class CImapFolderSync : public CActive, public MBaseTestState

   287 	{

   288 public:

   289 	CImapFolderSync(CEmailClientTest& aParentTestHarness);

   290 	void StartL(TRequestStatus& aStatus);

   291 	void RunL();

   292 	void DoCancel();

   293 	~CImapFolderSync();

   294 

   295 private:

   296 	CEmailClientTest& iParentTestHarness;

   297 	TRequestStatus* iReportStatus;

   298 	};

   299 

   300 //

   301 //

   302 // CImapPerformFullSync

   303 //

   304 

   305 class CImapPerformFullSync : public CActive, public MBaseTestState

   306 	{

   307 public:

   308 	CImapPerformFullSync(CEmailClientTest& aParentTestHarness);

   309 	void StartL(TRequestStatus& aStatus);

   310 	void RunL();

   311 	void DoCancel();

   312 	~CImapPerformFullSync();

   313 

   314 private:

   315 	CEmailClientTest& iParentTestHarness;

   316 	TRequestStatus* iReportStatus;

   317 	};

   318 

   319 //

   320 //

   321 // CImapSetSyncLimits

   322 //

   323 

   324 class CImapSetSyncLimits : public CBase, public MBaseTestState

   325 	{

   326 public:

   327 	CImapSetSyncLimits(TInt aInboxSyncLimit, TInt aFolderSyncLimit, CImapClientTest& aTestHarness);

   328 	void StartL(TRequestStatus& aStatus);

   329 

   330 private:

   331 	void LogCommentFormat(TRefByValue<const TDesC> format,...);

   332 

   333 private:

   334 	CImapClientTest& iTestHarness;

   335 	TInt iInboxSyncLimit;

   336 	TInt iFolderSyncLimit;

   337 	};

   338 

   339 //

   340 //

   341 // CImapSubscribeFolder

   342 //

   343 

   344 class CImapSubscribeFolder : public CActive, public MBaseTestState

   345 	{

   346 public:

   347 	CImapSubscribeFolder(TBool aSubscribe, CEmailClientTest& aParentTestHarness);

   348 	void StartL(TRequestStatus& aStatus);

   349 	void RunL();

   350 	void DoCancel();

   351 	~CImapSubscribeFolder();

   352 

   353 private:

   354 	CEmailClientTest& iParentTestHarness;

   355 	TRequestStatus* iReportStatus;

   356 	TBool iSubscribe;

   357 	};

   358 

   359 

   360 

   361 //

   362 //

   363 // CImapPopulateFolder

   364 //

   365 

   366 class CImapPopulateFolder : public CActive, public MBaseTestState

   367 	{

   368 public:

   369 	CImapPopulateFolder(CEmailClientTest& aParentTestHarness);

   370 	void StartL(TRequestStatus& aStatus);

   371 	void RunL();

   372 	void DoCancel();

   373 	~CImapPopulateFolder();

   374 

   375 private:

   376 	CEmailClientTest& iParentTestHarness;

   377 	TRequestStatus* iReportStatus;

   378 	};

   379 

   380 

   381 //

   382 //

   383 // CImapMarkSelectionUnread

   384 //

   385 

   386 class CImapMarkSelection : public CBase, public MBaseTestState

   387 	{

   388 public:

   389 	CImapMarkSelection(TBool Unreadflag, CMsvEntrySelection& aSelection, CMsvTestUtils& aTestUtils);

   390 	void StartL(TRequestStatus& aStatus);

   391 	~CImapMarkSelection();

   392 

   393 protected:

   394 	void LogCommentFormat(TRefByValue<const TDesC> format,...);

   395 

   396 private:

   397 	CMsvTestUtils& iTestUtils;

   398 	CMsvEntrySelection& iSelection;

   399 	

   400 	TBool iUnreadflag;

   401 	

   402 	};

   403 

   404 //

   405 

   406 

   407 //

   408 //

   409 // CImapCheckSelectionUnread

   410 //

   411 

   412 class CImapCheckSelectionUnread : public CBase, public MBaseTestState

   413 	{

   414 public:

   415 	CImapCheckSelectionUnread(TInt aTestType, CMsvEntrySelection& aSelection, CMsvTestUtils& aTestUtils);

   416 	void StartL(TRequestStatus& aStatus);

   417 	~CImapCheckSelectionUnread();

   418 

   419 protected:

   420 	void LogCommentFormat(TRefByValue<const TDesC> format,...);

   421 

   422 private:

   423 	CMsvTestUtils& iTestUtils;

   424 	CMsvEntrySelection& iSelection;

   425 	

   426 	TInt iTestType;

   427 	};

   428 

   429 

   430 //

   431 //

   432 // CImapCheckSelectionSeen

   433 //

   434 

   435 class CImapCheckSelectionSeen : public CBase, public MBaseTestState

   436 	{

   437 public:

   438 	CImapCheckSelectionSeen(TInt aTestType, CMsvEntrySelection& aSelection, CMsvTestUtils& aTestUtils);

   439 	void StartL(TRequestStatus& aStatus);

   440 	~CImapCheckSelectionSeen();

   441 

   442 protected:

   443 	void LogCommentFormat(TRefByValue<const TDesC> format,...);

   444 

   445 private:

   446 	CMsvTestUtils& iTestUtils;

   447 	CMsvEntrySelection& iSelection;

   448 	

   449 	TInt iSeenflag;

   450 	};

   451 

   452 //

   453 //

   454 // CImapMarkSelectedMail

   455 //

   456 

   457 class CImapMarkSelectedMail : public CBase, public MBaseTestState

   458 	{

   459 public:

   460 	CImapMarkSelectedMail(CMsvEntrySelection& aSelection, CMsvTestUtils& aTestUtils);

   461 	void StartL(TRequestStatus& aStatus);

   462 	~CImapMarkSelectedMail();

   463 

   464 protected:

   465 	void LogCommentFormat(TRefByValue<const TDesC> format,...);

   466 

   467 private:

   468 	CMsvTestUtils& iTestUtils;

   469 	CMsvEntrySelection& iSelection;

   470 	

   471 	

   472 	};

   473 

   474 //

   475 //

   476 // CImapCheckSelectedMail

   477 //

   478 

   479 class CImapCheckSelectedMail : public CBase, public MBaseTestState

   480 	{

   481 public:

   482 	CImapCheckSelectedMail(CMsvEntrySelection& aSelection, CMsvTestUtils& aTestUtils);

   483 	void StartL(TRequestStatus& aStatus);

   484 	~CImapCheckSelectedMail();

   485 

   486 protected:

   487 void LogCommentFormat(TRefByValue<const TDesC> format,...);

   488 

   489 private:

   490 	CMsvTestUtils& iTestUtils;

   491 	

   492 	CMsvEntrySelection& iSelection;	

   493 	};

   494 

   495 //

   496 //

   497 // CImapSetSyncRate 

   498 //

   499 

   500 class CImapSetSyncRate : public CBase, public MBaseTestState

   501 	{

   502 public:

   503 	CImapSetSyncRate(TInt aSyncRate, CImapClientTest& aTestHarness);

   504 	void StartL(TRequestStatus& aStatus);

   505 

   506 private:

   507 	CImapClientTest& iTestHarness;

   508 	TInt iSyncRate;

   509 	};

   510 

   511 //

   512 //

   513 // CImapSetSyncRate 

   514 //

   515 

   516 class CImapGetSyncRate : public CBase, public MBaseTestState

   517 	{

   518 public:

   519 	CImapGetSyncRate(TInt aSyncRate, CImapClientTest& aTestHarness);

   520 	void StartL(TRequestStatus& aStatus);

   521 

   522 private:

   523 	CImapClientTest& iTestHarness;

   524 	TInt iSyncRate;

   525 	};

   526 

   527 

   528 

   529 

   530 #endif