1 // Copyright (c) 2007-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 "ctestsmtpmobilityaccounts.h"

    17 #include <cemailaccounts.h>

    18 #include <smtpset.h>

    19 #include <pop3set.h>

    20 #include <imapset.h>

    21 #include <iapprefs.h>

    22 #include <cimsmtpmobilitysettings.h>

    23 

    24 _LIT(KSmtpAcc1Name, "SMTP Acc 1");

    25 _LIT(KSmtpAcc2Name, "SMTP Acc 2");

    26 _LIT(KSmtpAcc3Name, "SMTP Acc 3");

    27 _LIT(KMobAcc1Name, "Mob Acc 1");

    28 _LIT(KMobAcc2Name, "Mob Acc 2");

    29 _LIT(KMobAcc3Name, "Mob Acc 3");

    30 _LIT(KPopAcc1Name, "POP Acc 1");

    31 _LIT(KPopAcc2Name, "POP Acc 2");

    32 _LIT(KImapAcc1Name, "IMAP Acc 1");

    33 _LIT(KImapAcc2Name, "IMAP Acc 1");

    34 _LIT8(KSmtpLoginName, "SMTP Login");

    35 _LIT8(KMobLoginName, "Mob Login");

    36 _LIT8(KTestLoginName, "TestLoginName");

    37 

    38 /**

    39 Constructor

    40 */

    41 CTestSmtpMobilityAccounts::CTestSmtpMobilityAccounts()

    42 	{

    43 	}

    44 

    45 /**

    46 Destructor

    47 */

    48 CTestSmtpMobilityAccounts::~CTestSmtpMobilityAccounts()

    49 	{

    50 	delete iEmailAccounts;

    51 	delete iSmtpAccSettings;

    52 	delete iIapPrefs;

    53 	delete iMobAccSettings;

    54 	iIapList.Close();

    55 	}

    56 

    57 /**

    58 Test setup

    59 */

    60 void CTestSmtpMobilityAccounts::SetupL()

    61 	{

    62 	iEmailAccounts = CEmailAccounts::NewL();

    63 

    64 	iSmtpAccSettings = new (ELeave) CImSmtpSettings();

    65 	iIapPrefs = CImIAPPreferences::NewLC();

    66 	CleanupStack::Pop(iIapPrefs);

    67 	iEmailAccounts->PopulateDefaultSmtpSettingsL(*iSmtpAccSettings, *iIapPrefs);

    68 	iSmtpAccSettings->SetLoginNameL(KSmtpLoginName);

    69 

    70 	iMobAccSettings = CImSmtpMobilitySettings::NewL();

    71 	iEmailAccounts->PopulateDefaultSmtpMobilitySettingsL(*iMobAccSettings);

    72 	iMobAccSettings->SetLoginNameL(KMobLoginName);

    73 

    74 	TImIAPChoice iapChoice;

    75 	iapChoice.iIAP = 1;

    76 	iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

    77 	iIapPrefs->AddIAPL(iapChoice, 0);

    78 

    79 	iIapList.AppendL(1);

    80 

    81 	ResetAccountsL();

    82 	}

    83 

    84 /**

    85 Test cleanup

    86 */

    87 void CTestSmtpMobilityAccounts::TearDownL()

    88 	{

    89 	ResetAccountsL();

    90 

    91 	delete iEmailAccounts;

    92 	iEmailAccounts = NULL;

    93 

    94 	delete iSmtpAccSettings;

    95 	iSmtpAccSettings = NULL;

    96 

    97 	delete iMobAccSettings;

    98 	iMobAccSettings = NULL;

    99 

   100 	delete iIapPrefs;

   101 	iIapPrefs = NULL;

   102 

   103 	iIapList.Reset();

   104 	}

   105 

   106 /**

   107 Delete all email accounts

   108 */

   109 void CTestSmtpMobilityAccounts::ResetAccountsL()

   110 	{

   111 	RArray<TPopAccount> popAccounts;

   112 	CleanupClosePushL(popAccounts);

   113 	iEmailAccounts->GetPopAccountsL(popAccounts);

   114 	for (TInt count = 0; count < popAccounts.Count(); ++count)

   115 		{

   116 		iEmailAccounts->DeletePopAccountL(popAccounts[count]);

   117 		}

   118 	CleanupStack::PopAndDestroy(&popAccounts);

   119 

   120 	RArray<TImapAccount> imapAccounts;

   121 	CleanupClosePushL(imapAccounts);

   122 	iEmailAccounts->GetImapAccountsL(imapAccounts);

   123 	for (TInt count = 0; count < imapAccounts.Count(); ++count)

   124 		{

   125 		iEmailAccounts->DeleteImapAccountL(imapAccounts[count]);

   126 		}

   127 	CleanupStack::PopAndDestroy(&imapAccounts);

   128 

   129 	RArray<TSmtpAccount> smtpAccounts;

   130 	CleanupClosePushL(smtpAccounts);

   131 	iEmailAccounts->GetSmtpAccountsL(smtpAccounts);

   132 	for (TInt count = 0; count < smtpAccounts.Count(); ++count)

   133 		{

   134 		iEmailAccounts->DeleteSmtpAccountL(smtpAccounts[count]);

   135 		}

   136 	CleanupStack::PopAndDestroy(&smtpAccounts);

   137 	}

   138 

   139 /**

   140 Check number of SMTP accounts matches expected value

   141 

   142 @param aNum Number expected

   143 */

   144 void CTestSmtpMobilityAccounts::CheckNumberSMTPAccountsL(TInt aNum)

   145 	{

   146 	RArray<TSmtpAccount> accounts;

   147 	CleanupClosePushL(accounts);

   148 	iEmailAccounts->GetSmtpAccountsL(accounts);

   149 	ASSERT_EQUALS(aNum, accounts.Count());

   150 	CleanupStack::PopAndDestroy(&accounts);

   151 	}

   152 

   153 /**

   154 Check SMTP account settings match expected values

   155 

   156 @param aAcount Account to check

   157 @param aSettings Settings to compare against

   158 */

   159 void CTestSmtpMobilityAccounts::CheckSmtpAccountSettingsL(TSmtpAccount aAccount, const CImSmtpSettings& aSettings)

   160 	{

   161 	CImSmtpSettings* settings = new (ELeave) CImSmtpSettings();

   162 	CleanupStack::PushL(settings);

   163 

   164 	iEmailAccounts->LoadSmtpSettingsL(aAccount, *settings);

   165 

   166 	ASSERT_EQUALS(*settings, aSettings);

   167 

   168 	CleanupStack::PopAndDestroy(settings);

   169 	}

   170 

   171 /**

   172 Check number of SMTP mobility accounts matches expected value

   173 

   174 @param aNum Number expected

   175 */

   176 void CTestSmtpMobilityAccounts::CheckNumberMobilityAccountsL(TInt aNum)

   177 	{

   178 	RArray<TSmtpMobilityAccount> accounts;

   179 	CleanupClosePushL(accounts);

   180 	iEmailAccounts->GetSmtpMobilityAccountsL(accounts);

   181 	ASSERT_EQUALS(aNum, accounts.Count());

   182 	CleanupStack::PopAndDestroy(&accounts);

   183 	}

   184 

   185 /**

   186 Check number of SMTP mobility accounts matches expected value for a

   187 given parent SMTP account

   188 

   189 @param aNum Number expected

   190 @param aSmtpAcc SMTP account

   191 */

   192 void CTestSmtpMobilityAccounts::CheckNumberMobilityAccountsL(TInt aNum, TSmtpAccount aSmtpAcc)

   193 	{

   194 	RArray<TSmtpMobilityAccount> accounts;

   195 	CleanupClosePushL(accounts);

   196 	iEmailAccounts->GetSmtpMobilityAccountsL(aSmtpAcc, accounts);

   197 	ASSERT_EQUALS(aNum, accounts.Count());

   198 	CleanupStack::PopAndDestroy(&accounts);

   199 	}

   200 

   201 /**

   202 Check mobility account details match expected values.

   203 Looks up the account given the account name, and checks the settings,

   204 IAP list, and read only flag.

   205 

   206 @param aAccName Account name

   207 @param aSmtpSettings Expected settings

   208 @param aIapList Expected IAP list

   209 @param aReadOnly Expected read only flag value

   210 @param aSmtpAcc Parent SMTP account

   211 */

   212 void CTestSmtpMobilityAccounts::CheckMobilityAccountDetailsL(const TDesC& aAccName, const CImSmtpSettings& aSmtpSettings, const RArrayIAP& aIapList, TBool aReadOnly, TSmtpAccount aSmtpAcc)

   213 	{

   214 	RArray<TSmtpMobilityAccount> accounts;

   215 	CleanupClosePushL(accounts);

   216 	iEmailAccounts->GetSmtpMobilityAccountsL(aSmtpAcc, accounts);

   217 	for (TInt count = 0; count < accounts.Count(); ++count)

   218 		{

   219 		if (accounts[count].iName.Compare(aAccName) == 0)

   220 			{

   221 			CImSmtpMobilitySettings* mobAccSettings = CImSmtpMobilitySettings::NewLC();

   222 			iEmailAccounts->LoadSmtpMobilitySettingsL(accounts[count], *mobAccSettings);

   223 			ASSERT_EQUALS(mobAccSettings->SmtpSettings(), aSmtpSettings);

   224 			CleanupStack::PopAndDestroy(mobAccSettings);

   225 

   226 			RArrayIAP iapList;

   227 			CleanupClosePushL(iapList);

   228 			iEmailAccounts->LoadSmtpMobilityAccountIapListL(accounts[count], iapList);

   229 			ASSERT_EQUALS(iapList.Count(), aIapList.Count());

   230 			for (TInt iap = 0; iap < iapList.Count(); ++iap)

   231 				{

   232 				ASSERT_EQUALS(iapList[iap], aIapList[iap]);

   233 				}

   234 			CleanupStack::PopAndDestroy(&iapList);

   235 

   236 			TBool isReadOnly = iEmailAccounts->IsAccountReadOnlyL(accounts[count]);

   237 			ASSERT_EQUALS(isReadOnly, aReadOnly);

   238 			CleanupStack::PopAndDestroy(&accounts);

   239 			return;

   240 			}

   241 		}

   242 

   243 	// Account not found, so signal a failure

   244 	ASSERT_TRUE(EFalse);

   245 

   246 	CleanupStack::PopAndDestroy(&accounts);	

   247 	}

   248 

   249 /**

   250 Checks that mobility account does not exist

   251 

   252 @param aAccName Mobility account name

   253 */

   254 void CTestSmtpMobilityAccounts::CheckMobilityAccountMissingL(const TDesC& aAccName)

   255 	{

   256 	TBool found = EFalse;

   257 

   258 	RArray<TSmtpMobilityAccount> accounts;

   259 	CleanupClosePushL(accounts);

   260 	iEmailAccounts->GetSmtpMobilityAccountsL(accounts);

   261 	for (TInt count = 0; count < accounts.Count(); ++count)

   262 		{

   263 		if (accounts[count].iName.Compare(aAccName) == 0)

   264 			{

   265 			found = ETrue;

   266 			break;

   267 			}

   268 		}

   269 

   270 	CleanupStack::PopAndDestroy(&accounts);

   271 

   272 	ASSERT_FALSE(found);

   273 	}

   274 

   275 /**

   276 @SYMTestCaseID SMTP-MOB-BASE-0001

   277 @SYMTestType CIT

   278 @SYMPREQ PREQ1307

   279 @SYMREQ REQ6981

   280 @SYMTestCaseDesc Tests SMTP account operations

   281 */

   282 void CTestSmtpMobilityAccounts::TestSmtpAccountL()

   283 	{

   284 	INFO_PRINTF1(_L("TestSmtpAccountL - Start"));

   285 

   286 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   287 

   288 	CheckNumberSMTPAccountsL(1);

   289 

   290 	// Load SMTP settings

   291 	CImSmtpSettings* smtpAccSettings = new (ELeave) CImSmtpSettings();

   292 	CleanupStack::PushL(smtpAccSettings);

   293 	iEmailAccounts->LoadSmtpSettingsL(smtpAcc, *smtpAccSettings);

   294 

   295 	// Check SMTP settings

   296 	ASSERT_EQUALS(*iSmtpAccSettings, *smtpAccSettings);

   297 

   298 	// Load IAP settings

   299 	CImIAPPreferences* iapPrefs = CImIAPPreferences::NewLC();

   300 	iEmailAccounts->LoadSmtpIapSettingsL(smtpAcc, *iapPrefs);

   301 

   302 	// Check IAP settings

   303 	ASSERT_EQUALS(iapPrefs->NumberOfIAPs(), iIapPrefs->NumberOfIAPs());

   304 	TImIAPChoice iapChoice1;

   305 	TImIAPChoice iapChoice2;

   306 	for (TInt count = 0; count < iapPrefs->NumberOfIAPs(); ++count)

   307 		{

   308 		iapChoice1 = iapPrefs->IAPPreference(count);

   309 		iapChoice2 = iIapPrefs->IAPPreference(count);

   310 		ASSERT_EQUALS(iapChoice1.iIAP, iapChoice2.iIAP);

   311 		ASSERT_EQUALS(iapChoice1.iDialogPref, iapChoice2.iDialogPref);

   312 		}

   313 

   314 	// Save new IAP settings

   315 	iIapPrefs->RemoveIAPL(0);

   316 	TImIAPChoice iapChoice;

   317 	iapChoice.iIAP = 2;

   318 	iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

   319 	iIapPrefs->AddIAPL(iapChoice, 0);

   320 	iEmailAccounts->SaveSmtpIapSettingsL(smtpAcc, *iIapPrefs);

   321 

   322 	// Save new SMTP settings

   323 	iSmtpAccSettings->SetLoginNameL(KTestLoginName);

   324 	iEmailAccounts->SaveSmtpSettingsL(smtpAcc, *iSmtpAccSettings);

   325 

   326 	iEmailAccounts->LoadSmtpIapSettingsL(smtpAcc, *iapPrefs);

   327 

   328 	// Check IAP settings

   329 	ASSERT_EQUALS(iapPrefs->NumberOfIAPs(), iIapPrefs->NumberOfIAPs());

   330 	for (TInt count = 0; count < iapPrefs->NumberOfIAPs(); ++count)

   331 		{

   332 		iapChoice1 = iapPrefs->IAPPreference(count);

   333 		iapChoice2 = iIapPrefs->IAPPreference(count);

   334 		ASSERT_EQUALS(iapChoice1.iIAP, iapChoice2.iIAP);

   335 		ASSERT_EQUALS(iapChoice1.iDialogPref, iapChoice2.iDialogPref);

   336 		}

   337 

   338 	CheckSmtpAccountSettingsL(smtpAcc, *iSmtpAccSettings);

   339 

   340 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   341 

   342 	CheckNumberSMTPAccountsL(0);

   343 

   344 	CleanupStack::PopAndDestroy(2, smtpAccSettings);

   345 

   346 	INFO_PRINTF1(_L("TestSmtpAccountL - End"));

   347 	}

   348 

   349 /**

   350 @SYMTestCaseID SMTP-MOB-PAR-ACC-0001

   351 @SYMTestType CIT

   352 @SYMPREQ PREQ1307

   353 @SYMREQ REQ6981

   354 @SYMTestCaseDesc Tests adding single SMTP mobility account

   355 */

   356 void CTestSmtpMobilityAccounts::Test1MobilityAccountL()

   357 	{

   358 	INFO_PRINTF1(_L("Test1MobilityAccountL - Start"));

   359 

   360 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   361 

   362 	TSmtpMobilityAccount mobAcc = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, *iMobAccSettings, EFalse);

   363 

   364 	CheckNumberMobilityAccountsL(1);

   365 	CheckNumberMobilityAccountsL(1, smtpAcc);

   366 

   367 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   368 	

   369 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc);

   370 

   371 	CheckNumberMobilityAccountsL(0);

   372 	CheckNumberMobilityAccountsL(0, smtpAcc);

   373 

   374 	CheckMobilityAccountMissingL(KMobAcc1Name);

   375 

   376 	CheckNumberSMTPAccountsL(1);

   377 

   378 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   379 

   380 	INFO_PRINTF1(_L("Test1MobilityAccountL - End"));

   381 	}

   382 

   383 /**

   384 @SYMTestCaseID SMTP-MOB-PAR-ACC-0002

   385 @SYMTestType CIT

   386 @SYMPREQ PREQ1307

   387 @SYMREQ REQ6981

   388 @SYMTestCaseDesc Tests adding single SMTP mobility account and deleting parent

   389 */

   390 void CTestSmtpMobilityAccounts::Test1MobilityAccountWithParentDeletionL()

   391 	{

   392 	INFO_PRINTF1(_L("Test1MobilityAccountWithParentDeletionL - Start"));

   393 

   394 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   395 

   396 	TSmtpMobilityAccount mobAcc = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, *iMobAccSettings, EFalse);

   397 

   398 	CheckNumberMobilityAccountsL(1);

   399 	CheckNumberMobilityAccountsL(1, smtpAcc);

   400 

   401 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   402 

   403 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   404 

   405 	CheckNumberMobilityAccountsL(0);

   406 

   407 	CheckMobilityAccountMissingL(KMobAcc1Name);

   408 

   409 	CheckNumberSMTPAccountsL(0);

   410 

   411 	INFO_PRINTF1(_L("Test1MobilityAccountWithParentDeletionL - End"));

   412 	}

   413 

   414 /**

   415 @SYMTestCaseID SMTP-MOB-PAR-ACC-0003

   416 @SYMTestType CIT

   417 @SYMPREQ PREQ1307

   418 @SYMREQ REQ6981

   419 @SYMTestCaseDesc Tests adding 2 SMTP mobility accounts

   420 */

   421 void CTestSmtpMobilityAccounts::Test2MobilityAccountsL()

   422 	{

   423 	INFO_PRINTF1(_L("Test2MobilityAccountsL - Start"));

   424 

   425 	TSmtpAccount smtpAcc1 = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   426 	TSmtpAccount smtpAcc2 = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc2Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   427 

   428 	TSmtpMobilityAccount mobAcc1 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc1, *iMobAccSettings, EFalse);

   429 

   430 	RArrayIAP iapList;

   431 	CleanupClosePushL(iapList);

   432 	iapList.AppendL(2);

   433 

   434 	TSmtpMobilityAccount mobAcc2 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc2Name, iapList, smtpAcc2, *iMobAccSettings, ETrue);

   435 

   436 	CheckNumberMobilityAccountsL(2);

   437 	CheckNumberMobilityAccountsL(1, smtpAcc1);

   438 	CheckNumberMobilityAccountsL(1, smtpAcc2);

   439 

   440 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc1);

   441 	CheckMobilityAccountDetailsL(KMobAcc2Name, iMobAccSettings->SmtpSettings(), iapList, ETrue, smtpAcc2);

   442 

   443 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc2);

   444 

   445 	CheckNumberMobilityAccountsL(1);

   446 	CheckNumberMobilityAccountsL(1, smtpAcc1);

   447 	CheckNumberMobilityAccountsL(0, smtpAcc2);

   448 

   449 	CheckMobilityAccountMissingL(KMobAcc2Name);

   450 

   451 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc1);

   452 

   453 	CheckNumberSMTPAccountsL(2);

   454 

   455 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc1);

   456 

   457 	CheckNumberMobilityAccountsL(0);

   458 	CheckNumberMobilityAccountsL(0, smtpAcc1);

   459 	CheckNumberMobilityAccountsL(0, smtpAcc2);

   460 

   461 	CheckMobilityAccountMissingL(KMobAcc1Name);

   462 

   463 	CheckNumberSMTPAccountsL(2);

   464 

   465 	CheckSmtpAccountSettingsL(smtpAcc1, *iSmtpAccSettings);

   466 	CheckSmtpAccountSettingsL(smtpAcc2, *iSmtpAccSettings);

   467 

   468 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc1);

   469 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc2);

   470 

   471 	CleanupStack::PopAndDestroy(&iapList);

   472 

   473 	INFO_PRINTF1(_L("Test2MobilityAccountsL - End"));

   474 	}

   475 

   476 /**

   477 @SYMTestCaseID SMTP-MOB-PAR-ACC-0004

   478 @SYMTestType CIT

   479 @SYMPREQ PREQ1307

   480 @SYMREQ REQ6981

   481 @SYMTestCaseDesc Tests adding 2 SMTP mobility accounts and deleting parents

   482 */

   483 void CTestSmtpMobilityAccounts::Test2MobilityAccountsWithParentDeletionL()

   484 	{

   485 	INFO_PRINTF1(_L("Test2MobilityAccountsWithParentDeletionL - Start"));

   486 

   487 	TSmtpAccount smtpAcc1 = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   488 	TSmtpAccount smtpAcc2 = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc2Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   489 

   490 	TSmtpMobilityAccount mobAcc1 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc1, *iMobAccSettings, EFalse);

   491 

   492 	RArrayIAP iapList;

   493 	CleanupClosePushL(iapList);

   494 	iapList.AppendL(2);

   495 

   496 	TSmtpMobilityAccount mobAcc2 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc2Name, iapList, smtpAcc2, *iMobAccSettings, ETrue);

   497 

   498 	CheckNumberMobilityAccountsL(2);

   499 	CheckNumberMobilityAccountsL(1, smtpAcc1);

   500 	CheckNumberMobilityAccountsL(1, smtpAcc2);

   501 

   502 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc1);

   503 	CheckMobilityAccountDetailsL(KMobAcc2Name, iMobAccSettings->SmtpSettings(), iapList, ETrue, smtpAcc2);

   504 

   505 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc2);

   506 

   507 	CheckNumberMobilityAccountsL(1);

   508 	CheckNumberMobilityAccountsL(1, smtpAcc1);

   509 

   510 	CheckMobilityAccountMissingL(KMobAcc2Name);

   511 

   512 	CheckNumberSMTPAccountsL(1);

   513 

   514 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc1);

   515 

   516 	CheckNumberMobilityAccountsL(0);

   517 

   518 	CheckMobilityAccountMissingL(KMobAcc1Name);

   519 

   520 	CheckNumberSMTPAccountsL(0);

   521 

   522 	CleanupStack::PopAndDestroy(&iapList);

   523 

   524 	INFO_PRINTF1(_L("Test2MobilityAccountsWithParentDeletionL - End"));

   525 	}

   526 

   527 /**

   528 @SYMTestCaseID SMTP-MOB-PAR-ACC-0005

   529 @SYMTestType CIT

   530 @SYMPREQ PREQ1307

   531 @SYMREQ REQ6981

   532 @SYMTestCaseDesc Tests adding 2 SMTP mobility accounts with the same parent and deleting parent

   533 */

   534 void CTestSmtpMobilityAccounts::Test2MobilityAccountsWithSameParentDeletionL()

   535 	{

   536 	INFO_PRINTF1(_L("Test2MobilityAccountsWithSameParentDeletionL - Start"));

   537 

   538 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   539 

   540 	TSmtpMobilityAccount mobAcc1 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, *iMobAccSettings, EFalse);

   541 

   542 	RArrayIAP iapList;

   543 	CleanupClosePushL(iapList);

   544 	iapList.AppendL(2);

   545 

   546 	TSmtpMobilityAccount mobAcc2 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc2Name, iapList, smtpAcc, *iMobAccSettings, ETrue);

   547 

   548 	CheckNumberMobilityAccountsL(2);

   549 	CheckNumberMobilityAccountsL(2, smtpAcc);

   550 

   551 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   552 	CheckMobilityAccountDetailsL(KMobAcc2Name, iMobAccSettings->SmtpSettings(), iapList, ETrue, smtpAcc);

   553 

   554 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   555 

   556 	CheckNumberMobilityAccountsL(0);

   557 

   558 	CheckMobilityAccountMissingL(KMobAcc1Name);

   559 	CheckMobilityAccountMissingL(KMobAcc2Name);

   560 

   561 	CheckNumberSMTPAccountsL(0);

   562 

   563 	CleanupStack::PopAndDestroy(&iapList);

   564 

   565 	INFO_PRINTF1(_L("Test2MobilityAccountsWithSameParentDeletionL - End"));

   566 	}

   567 

   568 /**

   569 @SYMTestCaseID SMTP-MOB-PAR-ACC-0006

   570 @SYMTestType CIT

   571 @SYMPREQ PREQ1307

   572 @SYMREQ REQ6981

   573 @SYMTestCaseDesc Tests adding 2 mobility account with same parent

   574 */

   575 void CTestSmtpMobilityAccounts::Test2MobilityAccountsWithSameParentL()

   576 	{

   577 	INFO_PRINTF1(_L("Test2MobilityAccountsWithSameParentL - Start"));

   578 

   579 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   580 

   581 	TSmtpMobilityAccount mobAcc1 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, *iMobAccSettings, EFalse);

   582 

   583 	RArrayIAP iapList;

   584 	CleanupClosePushL(iapList);

   585 	iapList.AppendL(2);

   586 

   587 	TSmtpMobilityAccount mobAcc2 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc2Name, iapList, smtpAcc, *iMobAccSettings, ETrue);

   588 

   589 	CheckNumberMobilityAccountsL(2);

   590 	CheckNumberMobilityAccountsL(2, smtpAcc);

   591 

   592 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   593 	CheckMobilityAccountDetailsL(KMobAcc2Name, iMobAccSettings->SmtpSettings(), iapList, ETrue, smtpAcc);

   594 

   595 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc1);

   596 

   597 	CheckNumberSMTPAccountsL(1);

   598 

   599 	CheckNumberMobilityAccountsL(1);

   600 	CheckNumberMobilityAccountsL(1, smtpAcc);

   601 

   602 	CheckMobilityAccountMissingL(KMobAcc1Name);

   603 

   604 	CheckMobilityAccountDetailsL(KMobAcc2Name, iMobAccSettings->SmtpSettings(), iapList, ETrue, smtpAcc);

   605 

   606 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc2);

   607 

   608 	CheckNumberSMTPAccountsL(1);

   609 

   610 	CheckNumberMobilityAccountsL(0);

   611 	CheckNumberMobilityAccountsL(0, smtpAcc);

   612 

   613 	CheckMobilityAccountMissingL(KMobAcc1Name);

   614 	CheckMobilityAccountMissingL(KMobAcc2Name);

   615 

   616 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   617 

   618 	CleanupStack::PopAndDestroy(&iapList);

   619 

   620 	INFO_PRINTF1(_L("Test2MobilityAccountsWithSameParentL - End"));

   621 	}

   622 

   623 /**

   624 @SYMTestCaseID SMTP-MOB-PAR-ACC-0007

   625 @SYMTestType CIT

   626 @SYMPREQ PREQ1307

   627 @SYMREQ REQ6981

   628 @SYMTestCaseDesc Tests adding single SMTP mobility account to POP associated SMTP account

   629 */

   630 void CTestSmtpMobilityAccounts::TestMobilityAccountWithPopL()

   631 	{

   632 	INFO_PRINTF1(_L("TestMobilityAccountWithPopL - Start"));

   633 

   634 	CImPop3Settings* settings = new (ELeave) CImPop3Settings();

   635 

   636 	TPopAccount popAcc = iEmailAccounts->CreatePopAccountL(KPopAcc1Name, *settings, *iIapPrefs, EFalse);

   637 

   638 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(popAcc, *iSmtpAccSettings, *iIapPrefs, EFalse);

   639 

   640 	TSmtpMobilityAccount mobAcc = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, *iMobAccSettings, EFalse);

   641 

   642 	CheckNumberMobilityAccountsL(1);

   643 	CheckNumberMobilityAccountsL(1, smtpAcc);

   644 

   645 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   646 	

   647 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   648 

   649 	CheckNumberMobilityAccountsL(0);

   650 

   651 	CheckMobilityAccountMissingL(KMobAcc1Name);

   652 

   653 	CheckNumberSMTPAccountsL(0);

   654 

   655 	iEmailAccounts->DeletePopAccountL(popAcc);

   656 

   657 	INFO_PRINTF1(_L("TestMobilityAccountWithPopL - End"));

   658 	}

   659 

   660 /**

   661 @SYMTestCaseID SMTP-MOB-PAR-ACC-0008

   662 @SYMTestType CIT

   663 @SYMPREQ PREQ1307

   664 @SYMREQ REQ6981

   665 @SYMTestCaseDesc Tests adding single SMTP mobility account to IMAP associated SMTP account

   666 */

   667 void CTestSmtpMobilityAccounts::TestMobilityAccountWithImapL()

   668 	{

   669 	INFO_PRINTF1(_L("TestMobilityAccountWithImapL - Start"));

   670 

   671 	CImImap4Settings* settings = new (ELeave) CImImap4Settings();

   672 

   673 	TImapAccount imapAcc = iEmailAccounts->CreateImapAccountL(KImapAcc1Name, *settings, *iIapPrefs, EFalse);

   674 

   675 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(imapAcc, *iSmtpAccSettings, *iIapPrefs, EFalse);

   676 

   677 	TSmtpMobilityAccount mobAcc = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, *iMobAccSettings, EFalse);

   678 

   679 	CheckNumberMobilityAccountsL(1);

   680 	CheckNumberMobilityAccountsL(1, smtpAcc);

   681 

   682 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   683 

   684 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   685 

   686 	CheckNumberMobilityAccountsL(0);

   687 

   688 	CheckMobilityAccountMissingL(KMobAcc1Name);

   689 

   690 	CheckNumberSMTPAccountsL(0);

   691 

   692 	iEmailAccounts->DeleteImapAccountL(imapAcc);

   693 

   694 	INFO_PRINTF1(_L("TestMobilityAccountWithImapL - End"));	

   695 	}

   696 

   697 /**

   698 @SYMTestCaseID SMTP-MOB-PAR-ACC-0009

   699 @SYMTestType CIT

   700 @SYMPREQ PREQ1307

   701 @SYMREQ REQ6981

   702 @SYMTestCaseDesc Tests adding 3 SMTP mobility accounts to same parent and deleting them in the order first, second, third

   703 */

   704 void CTestSmtpMobilityAccounts::Test3MobilityAccountsDelete123L()

   705 	{

   706 	INFO_PRINTF1(_L("Test3MobilityAccountsDelete123L - Start"));

   707 

   708 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   709 

   710 	TSmtpMobilityAccount mobAcc1 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, *iMobAccSettings, EFalse);

   711 

   712 	RArrayIAP iapList;

   713 	CleanupClosePushL(iapList);

   714 	iapList.AppendL(2);

   715 

   716 	TSmtpMobilityAccount mobAcc2 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc2Name, iapList, smtpAcc, *iMobAccSettings, ETrue);

   717 

   718 	RArrayIAP iapList2;

   719 	CleanupClosePushL(iapList2);

   720 	iapList2.AppendL(3);

   721 

   722 	TSmtpMobilityAccount mobAcc3 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc3Name, iapList2, smtpAcc, *iMobAccSettings, ETrue);

   723 

   724 	CheckNumberMobilityAccountsL(3, smtpAcc);

   725 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   726 	CheckMobilityAccountDetailsL(KMobAcc2Name, iMobAccSettings->SmtpSettings(), iapList, ETrue, smtpAcc);

   727 	CheckMobilityAccountDetailsL(KMobAcc3Name, iMobAccSettings->SmtpSettings(), iapList2, ETrue, smtpAcc);

   728 

   729 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc1);

   730 

   731 	CheckNumberMobilityAccountsL(2, smtpAcc);

   732 	CheckMobilityAccountMissingL(KMobAcc1Name);

   733 	CheckMobilityAccountDetailsL(KMobAcc2Name, iMobAccSettings->SmtpSettings(), iapList, ETrue, smtpAcc);

   734 	CheckMobilityAccountDetailsL(KMobAcc3Name, iMobAccSettings->SmtpSettings(), iapList2, ETrue, smtpAcc);

   735 

   736 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc2);

   737 

   738 	CheckNumberMobilityAccountsL(1, smtpAcc);

   739 	CheckMobilityAccountMissingL(KMobAcc1Name);

   740 	CheckMobilityAccountMissingL(KMobAcc2Name);

   741 	CheckMobilityAccountDetailsL(KMobAcc3Name, iMobAccSettings->SmtpSettings(), iapList2, ETrue, smtpAcc);

   742 

   743 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc3);

   744 

   745 	CheckNumberMobilityAccountsL(0, smtpAcc);

   746 	CheckMobilityAccountMissingL(KMobAcc1Name);

   747 	CheckMobilityAccountMissingL(KMobAcc2Name);

   748 	CheckMobilityAccountMissingL(KMobAcc3Name);

   749 

   750 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   751 

   752 	CleanupStack::PopAndDestroy(2, &iapList);

   753 

   754 	INFO_PRINTF1(_L("Test3MobilityAccountsDelete123L - End"));	

   755 	}

   756 

   757 /**

   758 @SYMTestCaseID SMTP-MOB-PAR-ACC-0010

   759 @SYMTestType CIT

   760 @SYMPREQ PREQ1307

   761 @SYMREQ REQ6981

   762 @SYMTestCaseDesc Tests adding 3 SMTP mobility accounts to same parent and deleting them in the order third, second, first

   763 */

   764 void CTestSmtpMobilityAccounts::Test3MobilityAccountsDelete321L()

   765 	{

   766 	INFO_PRINTF1(_L("Test3MobilityAccountsDelete321L - Start"));

   767 

   768 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   769 

   770 	TSmtpMobilityAccount mobAcc1 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, *iMobAccSettings, EFalse);

   771 

   772 	RArrayIAP iapList;

   773 	CleanupClosePushL(iapList);

   774 	iapList.AppendL(2);

   775 

   776 	TSmtpMobilityAccount mobAcc2 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc2Name, iapList, smtpAcc, *iMobAccSettings, ETrue);

   777 

   778 	RArrayIAP iapList2;

   779 	CleanupClosePushL(iapList2);

   780 	iapList2.AppendL(3);

   781 

   782 	TSmtpMobilityAccount mobAcc3 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc3Name, iapList2, smtpAcc, *iMobAccSettings, ETrue);

   783 

   784 	CheckNumberMobilityAccountsL(3, smtpAcc);

   785 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   786 	CheckMobilityAccountDetailsL(KMobAcc2Name, iMobAccSettings->SmtpSettings(), iapList, ETrue, smtpAcc);

   787 	CheckMobilityAccountDetailsL(KMobAcc3Name, iMobAccSettings->SmtpSettings(), iapList2, ETrue, smtpAcc);

   788 

   789 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc3);

   790 

   791 	CheckNumberMobilityAccountsL(2, smtpAcc);

   792 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   793 	CheckMobilityAccountDetailsL(KMobAcc2Name, iMobAccSettings->SmtpSettings(), iapList, ETrue, smtpAcc);

   794 	CheckMobilityAccountMissingL(KMobAcc3Name);

   795 

   796 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc2);

   797 

   798 	CheckNumberMobilityAccountsL(1, smtpAcc);

   799 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   800 	CheckMobilityAccountMissingL(KMobAcc2Name);

   801 	CheckMobilityAccountMissingL(KMobAcc3Name);

   802 

   803 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc1);

   804 

   805 	CheckNumberMobilityAccountsL(0, smtpAcc);

   806 	CheckMobilityAccountMissingL(KMobAcc1Name);

   807 	CheckMobilityAccountMissingL(KMobAcc2Name);

   808 	CheckMobilityAccountMissingL(KMobAcc3Name);

   809 

   810 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   811 

   812 	CleanupStack::PopAndDestroy(2, &iapList);

   813 

   814 	INFO_PRINTF1(_L("Test3MobilityAccountsDelete321L - End"));	

   815 	}

   816 

   817 /**

   818 @SYMTestCaseID SMTP-MOB-PAR-ACC-0011

   819 @SYMTestType CIT

   820 @SYMPREQ PREQ1307

   821 @SYMREQ REQ6981

   822 @SYMTestCaseDesc Tests adding 3 SMTP mobility accounts to same parent and deleting them in the order second, first, third

   823 */

   824 void CTestSmtpMobilityAccounts::Test3MobilityAccountsDelete213L()

   825 	{

   826 	INFO_PRINTF1(_L("Test3MobilityAccountsDelete213L - Start"));

   827 

   828 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   829 

   830 	TSmtpMobilityAccount mobAcc1 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, *iMobAccSettings, EFalse);

   831 

   832 	RArrayIAP iapList;

   833 	CleanupClosePushL(iapList);

   834 	iapList.AppendL(2);

   835 

   836 	TSmtpMobilityAccount mobAcc2 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc2Name, iapList, smtpAcc, *iMobAccSettings, ETrue);

   837 

   838 	RArrayIAP iapList2;

   839 	CleanupClosePushL(iapList2);

   840 	iapList2.AppendL(3);

   841 

   842 	TSmtpMobilityAccount mobAcc3 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc3Name, iapList2, smtpAcc, *iMobAccSettings, ETrue);

   843 

   844 	CheckNumberMobilityAccountsL(3, smtpAcc);

   845 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   846 	CheckMobilityAccountDetailsL(KMobAcc2Name, iMobAccSettings->SmtpSettings(), iapList, ETrue, smtpAcc);

   847 	CheckMobilityAccountDetailsL(KMobAcc3Name, iMobAccSettings->SmtpSettings(), iapList2, ETrue, smtpAcc);

   848 

   849 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc2);

   850 

   851 	CheckNumberMobilityAccountsL(2, smtpAcc);

   852 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   853 	CheckMobilityAccountMissingL(KMobAcc2Name);

   854 	CheckMobilityAccountDetailsL(KMobAcc3Name, iMobAccSettings->SmtpSettings(), iapList2, ETrue, smtpAcc);

   855 

   856 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc1);

   857 

   858 	CheckNumberMobilityAccountsL(1, smtpAcc);

   859 	CheckMobilityAccountMissingL(KMobAcc1Name);

   860 	CheckMobilityAccountMissingL(KMobAcc2Name);

   861 	CheckMobilityAccountDetailsL(KMobAcc3Name, iMobAccSettings->SmtpSettings(), iapList2, ETrue, smtpAcc);

   862 

   863 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc3);

   864 

   865 	CheckNumberMobilityAccountsL(0, smtpAcc);

   866 	CheckMobilityAccountMissingL(KMobAcc1Name);

   867 	CheckMobilityAccountMissingL(KMobAcc2Name);

   868 	CheckMobilityAccountMissingL(KMobAcc3Name);

   869 

   870 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   871 

   872 	CleanupStack::PopAndDestroy(2, &iapList);

   873 

   874 	INFO_PRINTF1(_L("Test3MobilityAccountsDelete213L - End"));	

   875 	}

   876 

   877 /**

   878 @SYMTestCaseID SMTP-MOB-PAR-ACC-0012

   879 @SYMTestType CIT

   880 @SYMPREQ PREQ1307

   881 @SYMREQ REQ6981

   882 @SYMTestCaseDesc Tests changing mobility account settings

   883 */

   884 void CTestSmtpMobilityAccounts::TestChangeMobilityAccountSettingsL()

   885 	{

   886 	INFO_PRINTF1(_L("TestChangeMobilityAccountSettingsL - Start"));

   887 

   888 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   889 

   890 	TSmtpMobilityAccount mobAcc = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, *iMobAccSettings, EFalse);

   891 

   892 	CheckNumberMobilityAccountsL(1);

   893 	CheckNumberMobilityAccountsL(1, smtpAcc);

   894 

   895 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   896 

   897 	iMobAccSettings->SetLoginNameL(KTestLoginName);

   898 

   899 	iEmailAccounts->SaveSmtpMobilitySettingsL(mobAcc, *iMobAccSettings);

   900 

   901 	iMobAccSettings->SetLoginNameL(KMobLoginName);

   902 

   903 	iEmailAccounts->LoadSmtpMobilitySettingsL(mobAcc, *iMobAccSettings);

   904 

   905 	ASSERT_EQUALS(iMobAccSettings->LoginName().Compare(KTestLoginName), 0);

   906 

   907 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   908 

   909 	INFO_PRINTF1(_L("TestChangeMobilityAccountSettingsL - End"));

   910 	}

   911 

   912 /**

   913 @SYMTestCaseID SMTP-MOB-PAR-ACC-0013

   914 @SYMTestType CIT

   915 @SYMPREQ PREQ1307

   916 @SYMREQ REQ6981

   917 @SYMTestCaseDesc Tests changing mobility account IAP list

   918 */

   919 void CTestSmtpMobilityAccounts::TestChangeMobilityAccountIapListL()

   920 	{

   921 	INFO_PRINTF1(_L("TestChangeMobilityAccountIapListL - Start"));

   922 

   923 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   924 

   925 	TSmtpMobilityAccount mobAcc = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, *iMobAccSettings, EFalse);

   926 

   927 	CheckNumberMobilityAccountsL(1);

   928 	CheckNumberMobilityAccountsL(1, smtpAcc);

   929 

   930 	CheckMobilityAccountDetailsL(KMobAcc1Name, iMobAccSettings->SmtpSettings(), iIapList, EFalse, smtpAcc);

   931 

   932 	iIapList.AppendL(2);

   933 

   934 	iEmailAccounts->SaveSmtpMobilityAccountIapListL(mobAcc, iIapList);

   935 

   936 	iIapList.Reset();

   937 

   938 	iEmailAccounts->LoadSmtpMobilityAccountIapListL(mobAcc, iIapList);

   939 

   940 	ASSERT_EQUALS(iIapList.Count(), 2);

   941 	ASSERT_TRUE(iIapList[0] == 1);

   942 	ASSERT_TRUE(iIapList[1] == 2);

   943 

   944 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   945 

   946 	INFO_PRINTF1(_L("TestChangeMobilityAccountIapListL - End"));

   947 	}

   948 

   949 /**

   950 @SYMTestCaseID SMTP-MOB-LNK-ACC-0001

   951 @SYMTestType CIT

   952 @SYMPREQ PREQ1307

   953 @SYMREQ REQ6981

   954 @SYMTestCaseDesc Tests adding single linked SMTP mobility account

   955 */

   956 void CTestSmtpMobilityAccounts::Test1LinkedMobilityAccountL()

   957 	{

   958 	INFO_PRINTF1(_L("Test1LinkedMobilityAccountL - Start"));

   959 

   960 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   961 	TSmtpAccount linkedAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc2Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   962 

   963 	TSmtpMobilityAccount mobAcc = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, linkedAcc, EFalse);

   964 

   965 	CheckNumberMobilityAccountsL(1);

   966 	CheckNumberMobilityAccountsL(1, smtpAcc);

   967 

   968 	CheckMobilityAccountDetailsL(KMobAcc1Name, *iSmtpAccSettings, iIapList, EFalse, smtpAcc);

   969 

   970 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc);

   971 

   972 	CheckNumberMobilityAccountsL(0);

   973 	CheckNumberMobilityAccountsL(0, smtpAcc);

   974 

   975 	CheckMobilityAccountMissingL(KMobAcc1Name);

   976 

   977 	CheckNumberSMTPAccountsL(2);

   978 

   979 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

   980 	iEmailAccounts->DeleteSmtpAccountL(linkedAcc);

   981 

   982 	INFO_PRINTF1(_L("Test1LinkedMobilityAccountL - End"));

   983 	}

   984 

   985 /**

   986 @SYMTestCaseID SMTP-MOB-LNK-ACC-0002

   987 @SYMTestType CIT

   988 @SYMPREQ PREQ1307

   989 @SYMREQ REQ6981

   990 @SYMTestCaseDesc Tests adding single linked SMTP mobility account and deleting parent

   991 */

   992 void CTestSmtpMobilityAccounts::Test1LinkedMobilityAccountWithLinkedDeletionL()

   993 	{

   994 	INFO_PRINTF1(_L("Test1LinkedMobilityAccountWithLinkedDeletionL - Start"));

   995 

   996 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   997 	TSmtpAccount linkedAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc2Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

   998 

   999 	TSmtpMobilityAccount mobAcc = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, linkedAcc, EFalse);

  1000 

  1001 	CheckNumberMobilityAccountsL(1);

  1002 	CheckNumberMobilityAccountsL(1, smtpAcc);

  1003 

  1004 	CheckMobilityAccountDetailsL(KMobAcc1Name, *iSmtpAccSettings, iIapList, EFalse, smtpAcc);

  1005 

  1006 	iEmailAccounts->DeleteSmtpAccountL(linkedAcc);

  1007 

  1008 	CheckNumberMobilityAccountsL(0);

  1009 

  1010 	CheckMobilityAccountMissingL(KMobAcc1Name);

  1011 

  1012 	CheckNumberSMTPAccountsL(1);

  1013 

  1014 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

  1015 

  1016 	INFO_PRINTF1(_L("Test1LinkedMobilityAccountWithLinkedDeletionL - End"));

  1017 	}

  1018 

  1019 /**

  1020 @SYMTestCaseID SMTP-MOB-LNK-ACC-0003

  1021 @SYMTestType CIT

  1022 @SYMPREQ PREQ1307

  1023 @SYMREQ REQ6981

  1024 @SYMTestCaseDesc Tests adding 2 linked SMTP mobility accounts

  1025 */

  1026 void CTestSmtpMobilityAccounts::Test2LinkedMobilityAccountsL()

  1027 	{

  1028 	INFO_PRINTF1(_L("Test2LinkedMobilityAccountsL - Start"));

  1029 

  1030 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

  1031 	TSmtpAccount linkedAcc1 = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc2Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

  1032 	TSmtpAccount linkedAcc2 = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc3Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

  1033 

  1034 	TSmtpMobilityAccount mobAcc1 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, linkedAcc1, EFalse);

  1035 

  1036 	RArrayIAP iapList;

  1037 	CleanupClosePushL(iapList);

  1038 	iapList.AppendL(2);

  1039 

  1040 	TSmtpMobilityAccount mobAcc2 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc2Name, iapList, smtpAcc, linkedAcc2, ETrue);

  1041 

  1042 	CheckNumberMobilityAccountsL(2);

  1043 	CheckNumberMobilityAccountsL(2, smtpAcc);

  1044 

  1045 	CheckMobilityAccountDetailsL(KMobAcc1Name, *iSmtpAccSettings, iIapList, EFalse, smtpAcc);

  1046 	CheckMobilityAccountDetailsL(KMobAcc2Name, *iSmtpAccSettings, iapList, ETrue, smtpAcc);

  1047 

  1048 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc2);

  1049 

  1050 	CheckNumberMobilityAccountsL(1);

  1051 	CheckNumberMobilityAccountsL(1, smtpAcc);

  1052 

  1053 	CheckMobilityAccountMissingL(KMobAcc2Name);

  1054 

  1055 	CheckMobilityAccountDetailsL(KMobAcc1Name, *iSmtpAccSettings, iIapList, EFalse, smtpAcc);

  1056 

  1057 	CheckNumberSMTPAccountsL(3);

  1058 

  1059 	iEmailAccounts->DeleteSmtpMobilityAccountL(mobAcc1);

  1060 

  1061 	CheckNumberMobilityAccountsL(0);

  1062 	CheckNumberMobilityAccountsL(0, smtpAcc);

  1063 

  1064 	CheckMobilityAccountMissingL(KMobAcc1Name);

  1065 

  1066 	CheckNumberSMTPAccountsL(3);

  1067 

  1068 	CheckSmtpAccountSettingsL(smtpAcc, *iSmtpAccSettings);

  1069 	CheckSmtpAccountSettingsL(linkedAcc1, *iSmtpAccSettings);

  1070 	CheckSmtpAccountSettingsL(linkedAcc2, *iSmtpAccSettings);

  1071 

  1072 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

  1073 	iEmailAccounts->DeleteSmtpAccountL(linkedAcc1);

  1074 	iEmailAccounts->DeleteSmtpAccountL(linkedAcc2);

  1075 

  1076 	CleanupStack::PopAndDestroy(&iapList);

  1077 

  1078 	INFO_PRINTF1(_L("Test2LinkedMobilityAccountsL - End"));

  1079 	}

  1080 

  1081 /**

  1082 @SYMTestCaseID SMTP-MOB-LNK-ACC-0004

  1083 @SYMTestType CIT

  1084 @SYMPREQ PREQ1307

  1085 @SYMREQ REQ6981

  1086 @SYMTestCaseDesc Tests adding 2 linked SMTP mobility accounts and deleting parents

  1087 */

  1088 void CTestSmtpMobilityAccounts::Test2LinkedMobilityAccountsWithLinkedDeletionL()

  1089 	{

  1090 	INFO_PRINTF1(_L("Test2LinkedMobilityAccountsWithLinkedDeletionL - Start"));

  1091 

  1092 	TSmtpAccount smtpAcc = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc1Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

  1093 	TSmtpAccount linkedAcc1 = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc2Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

  1094 	TSmtpAccount linkedAcc2 = iEmailAccounts->CreateSmtpAccountL(KSmtpAcc3Name, *iSmtpAccSettings, *iIapPrefs, EFalse);

  1095 

  1096 	TSmtpMobilityAccount mobAcc1 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc1Name, iIapList, smtpAcc, linkedAcc1, EFalse);

  1097 

  1098 	RArrayIAP iapList;

  1099 	CleanupClosePushL(iapList);

  1100 	iapList.AppendL(2);

  1101 

  1102 	TSmtpMobilityAccount mobAcc2 = iEmailAccounts->CreateSmtpMobilityAccountL(KMobAcc2Name, iapList, smtpAcc, linkedAcc2, ETrue);

  1103 

  1104 	CheckNumberMobilityAccountsL(2);

  1105 	CheckNumberMobilityAccountsL(2, smtpAcc);

  1106 

  1107 	CheckMobilityAccountDetailsL(KMobAcc1Name, *iSmtpAccSettings, iIapList, EFalse, smtpAcc);

  1108 	CheckMobilityAccountDetailsL(KMobAcc2Name, *iSmtpAccSettings, iapList, ETrue, smtpAcc);

  1109 

  1110 	iEmailAccounts->DeleteSmtpAccountL(linkedAcc2);

  1111 

  1112 	CheckNumberMobilityAccountsL(1);

  1113 	CheckNumberMobilityAccountsL(1, smtpAcc);

  1114 

  1115 	CheckMobilityAccountMissingL(KMobAcc2Name);

  1116 

  1117 	CheckNumberSMTPAccountsL(2);

  1118 

  1119 	iEmailAccounts->DeleteSmtpAccountL(linkedAcc1);

  1120 

  1121 	CheckNumberMobilityAccountsL(0);

  1122 

  1123 	CheckMobilityAccountMissingL(KMobAcc1Name);

  1124 

  1125 	CheckNumberSMTPAccountsL(1);

  1126 

  1127 	iEmailAccounts->DeleteSmtpAccountL(smtpAcc);

  1128 

  1129 	CleanupStack::PopAndDestroy(&iapList);

  1130 

  1131 	INFO_PRINTF1(_L("Test2LinkedMobilityAccountsWithLinkedDeletionL - End"));

  1132 	}

  1133 

  1134 /**

  1135 @SYMTestCaseID SMTP-MOB-LNK-ACC-0005