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 // Test step definitions for the APNControlList functional unit.

    15 // 

    16 //

    17 

    18 /**

    19  @internalTechnology

    20 */

    21 

    22 #include "cctsyintegrationtestapncontrollist.h"

    23 

    24 #include <etelmmerr.h>

    25 #include "cctsyinidata.h"

    26 #include <pcktcs.h>

    27 

    28 _LIT(KPrompt, "This test requires USIM service table, Insert a 3G enabled SIM which has the APN control list service enabled");

    29 CCTSYIntegrationTestAPNControlListBase::CCTSYIntegrationTestAPNControlListBase(CEtelSessionMgr& aEtelSessionMgr)

    30 	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), iPhoneTestHelper(*this), iNetworkTestHelper(*this),iSimTestHelper(*this), iPacketServiceHelper(*this)

    31 /**

    32  * Constructor

    33  */

    34 	{

    35 	}

    36 

    37 CCTSYIntegrationTestAPNControlListBase::~CCTSYIntegrationTestAPNControlListBase()

    38 /*

    39  * Destructor

    40  */

    41 	{

    42 	}

    43 

    44 void CCTSYIntegrationTestAPNControlListBase::EnsureApnListIsEmptyL(RMobilePhone &aMobilePhone)

    45 /*

    46  * This function ensures that Apn List is empty.

    47  *

    48  * @param aMobilePhone Reference to opened RMobilePhone subsession.

    49  * 

    50  */

    51 	{

    52 	TUint32 index= 0;

    53 	TExtEtelRequestStatus deleteAPNNameStatus(aMobilePhone, EMobilePhoneDeleteAPNName);

    54 	CleanupStack::PushL(deleteAPNNameStatus);

    55 	TExtEtelRequestStatus enumerateAPNEntriesStatus(aMobilePhone, EMobilePhoneEnumerateAPNEntries);

    56 	CleanupStack::PushL(enumerateAPNEntriesStatus);

    57 	aMobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, index);

    58 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

    59 	CHECK_EQUALS_L(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

    60 	while(index!=0)

    61 		{

    62 		aMobilePhone.DeleteAPNName(deleteAPNNameStatus, index-1);

    63 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(deleteAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::DeleteAPNName timed out"));

    64 		CHECK_EQUALS_L(deleteAPNNameStatus.Int(), KErrNone, _L("RMobilePhone::DeleteAPNName returned with an error"));		

    65 		index=index-1;

    66 		if(index==0)

    67 			{

    68 			aMobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, index);

    69 			CHECK_EQUALS_L(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

    70 			CHECK_EQUALS_L(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

    71 			}

    72 		}

    73 	

    74 	CHECK_TRUE_L(index==0 , _L("RMobilePhone::EnumerateAPNEntries did not return empty list"));		

    75 	CleanupStack::PopAndDestroy(2, &deleteAPNNameStatus);

    76 	

    77 	}

    78 

    79 TBool CCTSYIntegrationTestAPNControlListBase::CheckEntryIsInListL(RMobilePhone &aMobilePhone,RMobilePhone::TAPNEntryV3 &aExpectedAPnEntry, TUint32 &aIndex)

    80 /*

    81  * This function undo checks a specific entry in list by comparing them

    82  *

    83  * @param aMobilePhone Reference to opened RMobilePhone subsession.

    84  * @param expectedAPnEntry Reference to the entry for which check is being carried out.

    85  * @param index stores the specific index of found entry in the APN list, which can be used by some other operation. 

    86  * @return true if entry is found.

    87  */

    88 	{

    89 	// Check RMobilePhone::EnumerateAPNEntries returns aIndex 

    90 	TUint32 listIndex= 0;

    91 	TBool ret(EFalse);

    92 	TExtEtelRequestStatus enumerateAPNEntriesStatus(aMobilePhone, EMobilePhoneEnumerateAPNEntries);

    93 	CleanupStack::PushL(enumerateAPNEntriesStatus);

    94 	aMobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, listIndex);

    95 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

    96 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

    97 	

    98 	// Check no entry exists in the list

    99 	if(listIndex==0)

   100 		{

   101 		ret=EFalse;

   102 		}

   103 	

   104 	// Check RMobilePhone::GetAPNname returns same APN name as that written

   105 	RMobilePhone::TAPNEntryV3Pckg expectedAPnEntryPckg(aExpectedAPnEntry);

   106 	RMobilePhone::TAPNEntryV3 myAPnEntry;

   107 	RMobilePhone::TAPNEntryV3Pckg myAPnEntryPckg(myAPnEntry);

   108 	TExtEtelRequestStatus getAPNnameStatus(aMobilePhone, EMobilePhoneGetAPNname);

   109 	CleanupStack::PushL(getAPNnameStatus);

   110 	for(TInt i=0; i<listIndex;i++)

   111 		{

   112 		aMobilePhone.GetAPNname(getAPNnameStatus,i, myAPnEntryPckg);

   113 		ASSERT_EQUALS(WaitForRequestWithTimeOut(getAPNnameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNname timed out"));

   114 		ASSERT_EQUALS(getAPNnameStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNname returned with an error"));		

   115 		if(myAPnEntry.iApn== aExpectedAPnEntry.iApn)

   116 			{

   117 			aIndex=i;

   118 			ret= ETrue;

   119 			break;

   120 			}

   121 		else

   122 			{

   123 			ret=EFalse;	

   124 			}

   125 		}

   126 			

   127 	// Pop:

   128 	// enumerateAPNEntriesStatus

   129 	// getAPNnameStatus

   130 		

   131 	CleanupStack::PopAndDestroy(2, &enumerateAPNEntriesStatus);

   132 		

   133 	return ret;

   134 	}

   135 

   136 

   137 CCTSYIntegrationTestAPNControlList0001::CCTSYIntegrationTestAPNControlList0001(CEtelSessionMgr& aEtelSessionMgr)

   138 	: CCTSYIntegrationTestAPNControlListBase(aEtelSessionMgr)

   139 /**

   140  * Constructor.

   141  */

   142 	{

   143 	SetTestStepName(CCTSYIntegrationTestAPNControlList0001::GetTestStepName());

   144 	}

   145 

   146 CCTSYIntegrationTestAPNControlList0001::~CCTSYIntegrationTestAPNControlList0001()

   147 /**

   148  * Destructor.

   149  */

   150 	{

   151 	}

   152 

   153 TVerdict CCTSYIntegrationTestAPNControlList0001::doTestStepL()

   154 /**

   155  * @SYMTestCaseID BA-CTSY-INT-ACL-0001

   156  * @SYMFssID BA/CTSY/ACL-0001

   157  * @SYMTestCaseDesc Append and get entries from the APN control list.

   158  * @SYMTestPriority High

   159  * @SYMTestActions RMobilePhone::VerifySecurityCode, RMobilePhone::NotifySecurityEvent, RMobilePhone::NotifyAPNListChanged, RMobilePhone::GetAPNname, RMobilePhone::AppendAPNName

   160  * @SYMTestExpectedResults Pass - Number of APNs in list is correct. Written entries can be read.

   161  * @SYMTestType CIT

   162  * @SYMTestCaseDependencies live/manual

   163  *

   164  * Reason for test: Verify number of APNs is correct, APN notification completes and that written entries can be read.

   165  *

   166  * @return - TVerdict code

   167  */

   168 	{

   169 

   170 	//

   171 	// SET UP

   172 	//

   173 

   174 	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   175 	

   176 	DisplayUserInteractionPromptL(KPrompt); // 30 seconds

   177 	

   178 	// Verify Pin2

   179 	iSimTestHelper.VerifyPin2L(mobilePhone, iNetworkTestHelper); 

   180 	

   181 	// Take the backup of APN Control list. 

   182 	TInt listCountAtStart;

   183 	TBackupAPNList backup(*this,mobilePhone);

   184 	CHECK_TRUE_L(backup.BackupL(listCountAtStart), _L("TBackupAPNList::Backup could not backup"));

   185 	CleanupStack::PushL (backup);

   186 	

   187 	// Ensure RMobilePhone::GetSecurityCaps returns caps in set of KCapsAccessPin2 

   188 	TUint32 securityCaps;

   189 	CHECK_EQUALS_L(mobilePhone.GetSecurityCaps(securityCaps), KErrNone,_L("RMobilePhone::GetSecurityCaps returned with an error"));

   190 	CHECK_BITS_SET_L(securityCaps,RMobilePhone::KCapsAccessPin2 ,KNoUnwantedBits, _L("RMobilePhone::GetSecurityCaps returned did not return KCapsAccessPin2 bits"));

   191 	

   192 	// Ensure the APN Control List Service Status is EAPNControlListServiceEnabled. 

   193 	RMobilePhone::TAPNControlListServiceStatus serviceApnControlListStatus;

   194 	TExtEtelRequestStatus setAPNControlListServiceStatus(mobilePhone, EMobilePhoneSetAPNControlListServiceStatus);

   195 	CleanupStack::PushL(setAPNControlListServiceStatus);

   196 	TExtEtelRequestStatus getAPNControlListServiceStatus(mobilePhone, EMobilePhoneGetAPNControlListServiceStatus);

   197 	CleanupStack::PushL(getAPNControlListServiceStatus);

   198 	mobilePhone.GetAPNControlListServiceStatus(getAPNControlListServiceStatus, serviceApnControlListStatus);

   199 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus timed out"));

   200 	CHECK_EQUALS_L(getAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus returned with an error"));		

   201 	

   202 	if(serviceApnControlListStatus== RMobilePhone::EAPNControlListServiceDisabled)

   203 		{

   204 		// Enable the APN control List Service

   205 		serviceApnControlListStatus=RMobilePhone::EAPNControlListServiceEnabled;

   206 		mobilePhone.SetAPNControlListServiceStatus(setAPNControlListServiceStatus, serviceApnControlListStatus);

   207 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(setAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::SetAPNControlListServiceStatus timed out"));

   208 		CHECK_EQUALS_L(setAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::SetAPNControlListServiceStatus returned with an error"));		

   209 			

   210 		// Get the APN Contol List Service Status again

   211 		mobilePhone.GetAPNControlListServiceStatus(getAPNControlListServiceStatus, serviceApnControlListStatus);

   212 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus timed out"));

   213 		CHECK_EQUALS_L(getAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus returned with an error"));		

   214 		}

   215 		

   216 	CHECK_EQUALS_L(serviceApnControlListStatus, RMobilePhone::EAPNControlListServiceEnabled, _L("RMobilePhone::GetAPNControlListServiceStatus did not return EAPNControlListServiceEnabled status"));		

   217 	

   218 	// Ensure the APN list is empty.

   219 	EnsureApnListIsEmptyL(mobilePhone);

   220 

   221 	//

   222 	// SET UP END

   223 	//

   224 	

   225 	StartTest();

   226 	

   227 	//

   228 	// TEST START

   229 	//

   230 	

   231 	// ===  Append a name to the list ===

   232 	

   233 	// Post a notification RMobilePhone::NotifyAPNListChanged

   234 	TExtEtelRequestStatus notifyAPNListChangedStatus(mobilePhone, EMobilePhoneNotifyAPNListChanged);

   235 	CleanupStack::PushL(notifyAPNListChangedStatus);

   236 	mobilePhone.NotifyAPNListChanged(notifyAPNListChangedStatus); 

   237 	

   238 	// Append an APN name to the APN Control List using RMobilePhone::AppendAPNName 

   239 	RMobilePhone::TAPNEntryV3 myAPnEntry;

   240 	TBuf16<20> name = _L("WiFi");

   241 	myAPnEntry.iApn.Copy(name);

   242 	RMobilePhone::TAPNEntryV3Pckg myAPnEntryPckg(myAPnEntry);

   243 	TExtEtelRequestStatus appendAPNNameStatus(mobilePhone, EMobilePhoneAppendAPNName);

   244 	CleanupStack::PushL(appendAPNNameStatus);

   245 	mobilePhone.AppendAPNName(appendAPNNameStatus, myAPnEntryPckg);

   246 	ASSERT_EQUALS(WaitForRequestWithTimeOut(appendAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::AppendAPNName timed out"));

   247 	ASSERT_EQUALS(appendAPNNameStatus.Int(), KErrNone, _L("RMobilePhone::AppendAPNName returned with an error"));		

   248 	

   249 	// Check RMobilePhone::NotifyAPNListChanged completes with KErrNone

   250 	ASSERT_EQUALS(WaitForRequestWithTimeOut(notifyAPNListChangedStatus, ETimeMedium),KErrNone, _L("RMobilePhone::NotifyAPNListChanged timed out"));

   251 	ASSERT_EQUALS(notifyAPNListChangedStatus.Int(), KErrNone, _L("RMobilePhone::NotifyAPNListChanged returned with an error"));		

   252 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10014);

   253 			

   254 	// Check RMobilePhone::EnumerateAPNEntries returns aIndex = 1

   255 	TUint32 index= 0;

   256 	TExtEtelRequestStatus enumerateAPNEntriesStatus(mobilePhone, EMobilePhoneEnumerateAPNEntries);

   257 	CleanupStack::PushL(enumerateAPNEntriesStatus);

   258 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, index);

   259 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   260 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   261 	ASSERT_TRUE(index==1 , _L("RMobilePhone::EnumerateAPNEntries did not return the correct index number"));		

   262 		

   263 	// Check the first name written exists in the list

   264 	ASSERT_TRUE(CheckEntryIsInListL(mobilePhone,myAPnEntry, index), _L("CheckEntryIsInList was executed and expectedAPnEntry was not found"));

   265 

   266 	// ===  Append another name ===

   267 	

   268 	// Post a notification RMobilePhone::NotifyAPNListChanged

   269 	mobilePhone.NotifyAPNListChanged(notifyAPNListChangedStatus); 

   270 	

   271 	// Append an APN name to the APN Control List using RMobilePhone::AppendAPNName 

   272 	RMobilePhone::TAPNEntryV3 myAPnEntry2;

   273 	TBuf16<20> name2 = _L("GPRS");

   274 	myAPnEntry2.iApn.Copy(name2);

   275 	RMobilePhone::TAPNEntryV3Pckg myAPnEntryPckg2(myAPnEntry2);

   276 	mobilePhone.AppendAPNName(appendAPNNameStatus, myAPnEntryPckg2);

   277 	ASSERT_EQUALS(WaitForRequestWithTimeOut(appendAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::AppendAPNName timed out"));

   278 	ASSERT_EQUALS(appendAPNNameStatus.Int(), KErrNone, _L("RMobilePhone::AppendAPNName returned with an error"));		

   279 	

   280 	// Check RMobilePhone::NotifyAPNListChanged completes with KErrNone

   281 	ASSERT_EQUALS(WaitForRequestWithTimeOut(notifyAPNListChangedStatus, ETimeMedium),KErrNone, _L("RMobilePhone::NotifyAPNListChanged timed out"));

   282 	ASSERT_EQUALS(notifyAPNListChangedStatus.Int(), KErrNone, _L("RMobilePhone::NotifyAPNListChanged returned with an error"));		

   283 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10014);

   284 	

   285 	// Check RMobilePhone::EnumerateAPNEntries returns aIndex = 2

   286 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, index);

   287 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   288 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   289 	ASSERT_EQUALS((TInt)index, 2 , _L("RMobilePhone::EnumerateAPNEntries did not return the correct index number"));		

   290 	

   291 	// Check the first name that was written exists in the list

   292 	ASSERT_TRUE(CheckEntryIsInListL(mobilePhone,myAPnEntry, index), _L("CheckEntryIsInList was executed and expectedAPnEntry was not found"));

   293 

   294 	// Check the second name that was written exists in the list

   295 	ASSERT_TRUE(CheckEntryIsInListL(mobilePhone,myAPnEntry2, index), _L("CheckEntryIsInList was executed and expectedAPnEntry2 was not found"));

   296 	

   297 	//

   298 	// TEST END

   299 	//

   300 

   301     StartCleanup();

   302     

   303     EnsureApnListIsEmptyL(mobilePhone);

   304     // Pop:

   305     // backup

   306     // setAPNControlListServiceStatus

   307 	// getAPNControlListServiceStatus

   308 	// notifyAPNListChangedStatus

   309 	// appendAPNNameStatus

   310 	// enumerateAPNEntriesStatus

   311     CleanupStack::PopAndDestroy(6, &backup);

   312  

   313 	return TestStepResult();

   314 	}

   315 

   316 TPtrC CCTSYIntegrationTestAPNControlList0001::GetTestStepName()

   317 /**

   318  * @return The test step name.

   319  */

   320 	{

   321 	return _L("CCTSYIntegrationTestAPNControlList0001");

   322 	}

   323 

   324 

   325 

   326 CCTSYIntegrationTestAPNControlList0002::CCTSYIntegrationTestAPNControlList0002(CEtelSessionMgr& aEtelSessionMgr)

   327 	: CCTSYIntegrationTestAPNControlListBase(aEtelSessionMgr)

   328 /**

   329  * Constructor.

   330  */

   331 	{

   332 	SetTestStepName(CCTSYIntegrationTestAPNControlList0002::GetTestStepName());

   333 	}

   334 

   335 CCTSYIntegrationTestAPNControlList0002::~CCTSYIntegrationTestAPNControlList0002()

   336 /**

   337  * Destructor.

   338  */

   339 	{

   340 	}

   341 

   342 TVerdict CCTSYIntegrationTestAPNControlList0002::doTestStepL()

   343 /**

   344  * @SYMTestCaseID BA-CTSY-INT-ACL-0002

   345  * @SYMFssID BA/CTSY/ACL-0002

   346  * @SYMTestCaseDesc Get APN name from the APN control list with an invalid index.

   347  * @SYMTestPriority High

   348  * @SYMTestActions RMobilePhone::EnumerateAPNEntries

   349  * @SYMTestExpectedResults Pass - Error returned when invalid index is specified.

   350  * @SYMTestType CIT

   351  * @SYMTestCaseDependencies live/manual

   352  *

   353  * Reason for test: Verify error is returned if an invalid index is specified.

   354  *

   355  * @return - TVerdict code

   356  */

   357 	{

   358 

   359 	//

   360 	// SET UP

   361 	//

   362 

   363 	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   364 	

   365 	DisplayUserInteractionPromptL(KPrompt); // 30 seconds

   366 	

   367 	// Ensure the APN Control List Service Status is EAPNControlListServiceEnabled. 

   368 	RMobilePhone::TAPNControlListServiceStatus serviceApnControlListStatus;

   369 	TExtEtelRequestStatus setAPNControlListServiceStatus(mobilePhone, EMobilePhoneSetAPNControlListServiceStatus);

   370 	CleanupStack::PushL(setAPNControlListServiceStatus);

   371 	TExtEtelRequestStatus getAPNControlListServiceStatus(mobilePhone, EMobilePhoneGetAPNControlListServiceStatus);

   372 	CleanupStack::PushL(getAPNControlListServiceStatus);

   373 	mobilePhone.GetAPNControlListServiceStatus(getAPNControlListServiceStatus, serviceApnControlListStatus);

   374 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus timed out"));

   375 	CHECK_EQUALS_L(getAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus returned with an error"));		

   376 	

   377 	iSimTestHelper.VerifyPin2L(mobilePhone,iNetworkTestHelper);	

   378 		

   379 	if(serviceApnControlListStatus== RMobilePhone::EAPNControlListServiceDisabled)

   380 		{

   381 		

   382 		serviceApnControlListStatus=RMobilePhone::EAPNControlListServiceEnabled;

   383 		mobilePhone.SetAPNControlListServiceStatus(setAPNControlListServiceStatus, serviceApnControlListStatus);

   384 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(setAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::SetAPNControlListServiceStatus timed out"));

   385 		CHECK_EQUALS_L(setAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::SetAPNControlListServiceStatus returned with an error"));		

   386 			

   387 		// Get the APN Contol List Service Status again

   388 		mobilePhone.GetAPNControlListServiceStatus(getAPNControlListServiceStatus, serviceApnControlListStatus);

   389 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus timed out"));

   390 		CHECK_EQUALS_L(getAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus returned with an error"));		

   391 		}

   392 	CHECK_EQUALS_L(serviceApnControlListStatus, RMobilePhone::EAPNControlListServiceEnabled, _L("RMobilePhone::GetAPNControlListServiceStatus did not return EAPNControlListServiceEnabled status"));		

   393 	

   394 	//

   395 	// SET UP END

   396 	//

   397 	

   398 	StartTest();

   399 	

   400 	//

   401 	// TEST START

   402 	//

   403 	

   404 	// Check Check RMobilePhone::EnumerateAPNEntries returns aIndex > 0

   405 	TUint32 index= 0;

   406 	TExtEtelRequestStatus enumerateAPNEntriesStatus(mobilePhone, EMobilePhoneEnumerateAPNEntries);

   407 	CleanupStack::PushL(enumerateAPNEntriesStatus);

   408 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, index);

   409 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   410 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   411 	ASSERT_TRUE(index>0 , _L("RMobilePhone::EnumerateAPNEntries did not return the correct index number"))		

   412 	

   413 	// Check RMobilePhone::GetAPNname with aIndex = -1 returns an error.

   414 	TUint invalidIndex= (TUint)-1;

   415 	RMobilePhone::TAPNEntryV3 myAPnEntry;

   416 	RMobilePhone::TAPNEntryV3Pckg myAPnEntryPckg(myAPnEntry);

   417 	TExtEtelRequestStatus getAPNnameStatus(mobilePhone, EMobilePhoneGetAPNname);

   418 	CleanupStack::PushL(getAPNnameStatus);

   419 	mobilePhone.GetAPNname(getAPNnameStatus,invalidIndex, myAPnEntryPckg);

   420 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getAPNnameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNname timed out"));

   421 	ASSERT_TRUE(getAPNnameStatus.Int()!=KErrNone, _L("RMobilePhone::GetAPNname did not return an error"))		

   422 		

   423 	// Check RMobilePhone::GetAPNname with aIndex = -10 returns an error.

   424 	invalidIndex= (TUint)-10;

   425 	mobilePhone.GetAPNname(getAPNnameStatus,invalidIndex, myAPnEntryPckg);

   426 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getAPNnameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNname timed out"));

   427 	ASSERT_TRUE(getAPNnameStatus.Int()!=KErrNone, _L("RMobilePhone::GetAPNname did not return an error"))		

   428 	

   429 	// Check RMobilePhone::GetAPNname with aIndex = 1000000 returns an error.

   430 	invalidIndex= 1000000;

   431 	mobilePhone.GetAPNname(getAPNnameStatus,invalidIndex, myAPnEntryPckg);

   432 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getAPNnameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNname timed out"));

   433 	ASSERT_TRUE(getAPNnameStatus.Int()!=KErrNone, _L("RMobilePhone::GetAPNname did not return an error"))		

   434 		

   435 	//

   436 	// TEST END

   437 	//

   438 

   439     StartCleanup();

   440 			

   441 	// Pop

   442 	// setAPNControlListServiceStatus

   443 	// getAPNControlListServiceStatus

   444 	// enumerateAPNEntriesStatus

   445 	// getAPNnameStatus

   446 	CleanupStack::PopAndDestroy(4,&setAPNControlListServiceStatus);

   447 

   448 	return TestStepResult();

   449 	}

   450 

   451 TPtrC CCTSYIntegrationTestAPNControlList0002::GetTestStepName()

   452 /**

   453  * @return The test step name.

   454  */

   455 	{

   456 	return _L("CCTSYIntegrationTestAPNControlList0002");

   457 	}

   458 

   459 

   460 

   461 CCTSYIntegrationTestAPNControlList0003::CCTSYIntegrationTestAPNControlList0003(CEtelSessionMgr& aEtelSessionMgr)

   462 	: CCTSYIntegrationTestAPNControlListBase(aEtelSessionMgr)

   463 /**

   464  * Constructor.

   465  */

   466 	{

   467 	SetTestStepName(CCTSYIntegrationTestAPNControlList0003::GetTestStepName());

   468 	}

   469 

   470 CCTSYIntegrationTestAPNControlList0003::~CCTSYIntegrationTestAPNControlList0003()

   471 /**

   472  * Destructor.

   473  */

   474 	{

   475 	}

   476 

   477 TVerdict CCTSYIntegrationTestAPNControlList0003::doTestStepL()

   478 /**

   479  * @SYMTestCaseID BA-CTSY-INT-ACL-0003

   480  * @SYMFssID BA/CTSY/ACL-0003

   481  * @SYMTestCaseDesc Delete an entry from the APN control list.

   482  * @SYMTestPriority High

   483  * @SYMTestActions RMobilePhone::VerifySecurityCode, RMobilePhone::NotifySecurityEvent, RMobilePhone::NotifyAPNListChanged, RMobilePhone::GetAPNname, RMobilePhone::DeleteAPNName, RMobilePhone::AppendAPNName

   484  * @SYMTestExpectedResults Pass - An APN can be deleted from the APN control list.

   485  * @SYMTestType CIT

   486  * @SYMTestCaseDependencies live/manual

   487  *

   488  * Reason for test: Verify entry deleted, number of APN entries correct and APN notification completes.

   489  *

   490  * @return - TVerdict code

   491  */

   492 	{

   493 

   494 	//

   495 	// SET UP

   496 	//

   497 	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   498 	

   499 	DisplayUserInteractionPromptL(KPrompt); // 30 seconds

   500 	

   501 	// Take the backup of APN Control list. 

   502 	TInt listCountAtStart;

   503 	TBackupAPNList backup(*this,mobilePhone);

   504 	CHECK_TRUE_L(backup.BackupL(listCountAtStart), _L("TBackupAPNList::Backup could not backup"));

   505 	CleanupStack::PushL (backup);

   506 	

   507 	// Ensure RMobilePhone::GetSecurityCaps returns caps in set of KCapsAccessPin2 

   508 	TUint32 securityCaps;

   509 	CHECK_EQUALS_L(mobilePhone.GetSecurityCaps(securityCaps), KErrNone,_L("RMobilePhone::GetSecurityCaps returned with an error"));

   510 	CHECK_BITS_SET_L(securityCaps,RMobilePhone::KCapsAccessPin2 ,KNoUnwantedBits, _L("RMobilePhone::GetSecurityCaps returned did not return KCapsAccessPin2 bits"));

   511 	

   512 	// 	Verify Pin2

   513 	iSimTestHelper.VerifyPin2L(mobilePhone, iNetworkTestHelper);

   514 	

   515 	// Ensure the APN Control List Service Status is EAPNControlListServiceEnabled. 

   516 	RMobilePhone::TAPNControlListServiceStatus serviceApnControlListStatus;

   517 	TExtEtelRequestStatus setAPNControlListServiceStatus(mobilePhone, EMobilePhoneSetAPNControlListServiceStatus);

   518 	CleanupStack::PushL(setAPNControlListServiceStatus);

   519 	TExtEtelRequestStatus getAPNControlListServiceStatus(mobilePhone, EMobilePhoneGetAPNControlListServiceStatus);

   520 	CleanupStack::PushL(getAPNControlListServiceStatus);

   521 	mobilePhone.GetAPNControlListServiceStatus(getAPNControlListServiceStatus, serviceApnControlListStatus);

   522 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus timed out"));

   523 	CHECK_EQUALS_L(getAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus returned with an error"));		

   524 	if(serviceApnControlListStatus== RMobilePhone::EAPNControlListServiceDisabled)

   525 		{	

   526 		serviceApnControlListStatus=RMobilePhone::EAPNControlListServiceEnabled;

   527 		mobilePhone.SetAPNControlListServiceStatus(setAPNControlListServiceStatus, serviceApnControlListStatus);

   528 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(setAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::SetAPNControlListServiceStatus timed out"));

   529 		CHECK_EQUALS_L(setAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::SetAPNControlListServiceStatus returned with an error"));		

   530 			

   531 		// Get the APN Contol List Service Status again

   532 		mobilePhone.GetAPNControlListServiceStatus(getAPNControlListServiceStatus, serviceApnControlListStatus);

   533 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus timed out"));

   534 		CHECK_EQUALS_L(getAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus returned with an error"));		

   535 		}

   536 	CHECK_EQUALS_L(serviceApnControlListStatus, RMobilePhone::EAPNControlListServiceEnabled, _L("RMobilePhone::GetAPNControlListServiceStatus did not return EAPNControlListServiceEnabled status"));		

   537 	

   538 	// Ensure the APN list is empty. 

   539 	EnsureApnListIsEmptyL(mobilePhone);

   540 	//

   541 	// SET UP END

   542 	//

   543 	

   544 	StartTest();

   545 	

   546 	//

   547 	// TEST START

   548 	//

   549 	

   550 	// ===  Verify PIN2 and append a name to the list ===

   551 	

   552 	// Post a notification RMobilePhone::NotifyAPNListChanged

   553 	TExtEtelRequestStatus notifyAPNListChangedStatus(mobilePhone, EMobilePhoneNotifyAPNListChanged);

   554 	CleanupStack::PushL(notifyAPNListChangedStatus);

   555 	mobilePhone.NotifyAPNListChanged(notifyAPNListChangedStatus); 

   556 	

   557 	// Append an APN name to the APN Control List using RMobilePhone::AppendAPNName 

   558 	RMobilePhone::TAPNEntryV3 myAPnEntry;

   559 	TBuf16<20> name = _L("WiFi");

   560 	myAPnEntry.iApn.Copy(name);

   561 	RMobilePhone::TAPNEntryV3Pckg myAPnEntryPckg(myAPnEntry);

   562 	TExtEtelRequestStatus appendAPNNameStatus(mobilePhone, EMobilePhoneAppendAPNName);

   563 	CleanupStack::PushL(appendAPNNameStatus);

   564 	mobilePhone.AppendAPNName(appendAPNNameStatus, myAPnEntryPckg);

   565 	ASSERT_EQUALS(WaitForRequestWithTimeOut(appendAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::AppendAPNName timed out"));

   566 	ASSERT_EQUALS(appendAPNNameStatus.Int(), KErrNone, _L("RMobilePhone::AppendAPNName returned with an error"));		

   567 	

   568 	// Check RMobilePhone::NotifyAPNListChanged completes with KErrNone

   569 	ASSERT_EQUALS(WaitForRequestWithTimeOut(notifyAPNListChangedStatus, ETimeMedium),KErrNone, _L("RMobilePhone::NotifyAPNListChanged timed out"));

   570 	ASSERT_EQUALS(notifyAPNListChangedStatus.Int(), KErrNone, _L("RMobilePhone::NotifyAPNListChanged returned with an error"));

   571 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10014);		

   572 	

   573 	// Check RMobilePhone::EnumerateAPNEntries returns aIndex = 1

   574 	TUint32 index= 0;

   575 	TUint32 indexValue=0;

   576 	TExtEtelRequestStatus enumerateAPNEntriesStatus(mobilePhone, EMobilePhoneEnumerateAPNEntries);

   577 	CleanupStack::PushL(enumerateAPNEntriesStatus);

   578 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, index);

   579 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   580 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   581 	ASSERT_EQUALS((TInt)index, 1 , _L("RMobilePhone::EnumerateAPNEntries did not return the correct index number"));		

   582 	

   583 	// ===  Append another name ===

   584 	

   585 	// Post a notification RMobilePhone::NotifyAPNListChanged

   586 	mobilePhone.NotifyAPNListChanged(notifyAPNListChangedStatus); 

   587 	

   588 	// Append an APN name to the APN Control List using RMobilePhone::AppendAPNName 

   589 	RMobilePhone::TAPNEntryV3 myAPnEntry2;

   590 	TBuf16<20> name2 = _L("GPRS");

   591 	myAPnEntry2.iApn.Copy(name2);

   592 	RMobilePhone::TAPNEntryV3Pckg myAPnEntryPckg2(myAPnEntry2);

   593 	mobilePhone.AppendAPNName(appendAPNNameStatus, myAPnEntryPckg2);

   594 	ASSERT_EQUALS(WaitForRequestWithTimeOut(appendAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::AppendAPNName timed out"));

   595 	ASSERT_EQUALS(appendAPNNameStatus.Int(), KErrNone, _L("RMobilePhone::AppendAPNName returned with an error"));		

   596 	

   597 	// Check RMobilePhone::NotifyAPNListChanged completes with KErrNone

   598 	ASSERT_EQUALS(WaitForRequestWithTimeOut(notifyAPNListChangedStatus, ETimeMedium),KErrNone, _L("RMobilePhone::NotifyAPNListChanged timed out"));

   599 	ASSERT_EQUALS(notifyAPNListChangedStatus.Int(), KErrNone, _L("RMobilePhone::NotifyAPNListChanged returned with an error"));		

   600 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10014);		

   601 	

   602 	// Check RMobilePhone::EnumerateAPNEntries returns aIndex = 2

   603 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, index);

   604 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeShort),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   605 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   606 	ASSERT_EQUALS((int)index, 2 , _L("RMobilePhone::EnumerateAPNEntries did not return the correct index number"));		

   607 	

   608 	// ===  Delete first name written ===

   609 	

   610 	// Post a notification RMobilePhone::NotifyAPNListChanged

   611 	mobilePhone.NotifyAPNListChanged(notifyAPNListChangedStatus); 

   612 	

   613 	// Check the first written entry exists is in the APN list.

   614 	ASSERT_TRUE(CheckEntryIsInListL(mobilePhone,myAPnEntry, indexValue), _L("CheckEntryIsInList was executed and expectedAPnEntry was not found"));

   615 		

   616 	// Delete a first written APN name with RMobilePhone::DeleteAPNName

   617 	TExtEtelRequestStatus deleteAPNNameStatus(mobilePhone, EMobilePhoneDeleteAPNName);

   618 	CleanupStack::PushL(deleteAPNNameStatus);

   619 	mobilePhone.DeleteAPNName(deleteAPNNameStatus, indexValue);

   620 	ASSERT_EQUALS(WaitForRequestWithTimeOut(deleteAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::DeleteAPNName timed out"));

   621 	ASSERT_EQUALS(deleteAPNNameStatus.Int(), KErrNone, _L("RMobilePhone::DeleteAPNName returned with an error"));		

   622 	

   623 	// Check RMobilePhone::NotifyAPNListChanged completes with KErrNone

   624 	ASSERT_EQUALS(WaitForRequestWithTimeOut(notifyAPNListChangedStatus, ETimeShort),KErrNone, _L("RMobilePhone::NotifyAPNListChanged timed out"));

   625 	ASSERT_EQUALS(notifyAPNListChangedStatus.Int(), KErrNone, _L("RMobilePhone::NotifyAPNListChanged returned with an error"));		

   626 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10014);		

   627 	

   628 	// Check RMobilePhone::EnumerateAPNEntries returns aIndex = 1

   629 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, index);

   630 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   631 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   632 	ASSERT_EQUALS((int)index, 1 , _L("RMobilePhone::EnumerateAPNEntries did not return the correct index number"));		

   633 	

   634 	// Check first written entry does not exist and returns an error

   635 	ASSERT_TRUE(!(CheckEntryIsInListL(mobilePhone,myAPnEntry, indexValue)), _L("CheckEntryIsInList was executed and it did not return an error"));

   636 

   637 	// Check the second written entry exists is in the APN list.

   638 	ASSERT_TRUE(CheckEntryIsInListL(mobilePhone,myAPnEntry2, indexValue), _L("CheckEntryIsInList was executed and expectedAPnEntry was not found"));

   639 

   640 	// ===  Delete second name written ===

   641 

   642 	// Post a notification RMobilePhone::NotifyAPNListChanged

   643 	mobilePhone.NotifyAPNListChanged(notifyAPNListChangedStatus); 

   644 	

   645 	// Delete the second APN name entry with RMobilePhone::DeleteAPNName 

   646 	mobilePhone.DeleteAPNName(deleteAPNNameStatus, indexValue);

   647 	ASSERT_EQUALS(WaitForRequestWithTimeOut(deleteAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::DeleteAPNName timed out"));

   648 	ASSERT_EQUALS(deleteAPNNameStatus.Int(), KErrNone, _L("RMobilePhone::DeleteAPNName returned with an error"));		

   649 	

   650 	// Check RMobilePhone::NotifyAPNListChanged completes with KErrNone

   651 	ASSERT_EQUALS(WaitForRequestWithTimeOut(notifyAPNListChangedStatus, ETimeMedium),KErrNone, _L("RMobilePhone::NotifyAPNListChanged timed out"));

   652 	ASSERT_EQUALS(notifyAPNListChangedStatus.Int(), KErrNone, _L("RMobilePhone::NotifyAPNListChanged returned with an error"));		

   653 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10014);		

   654 		

   655 	// Check RMobilePhone::EnumerateAPNEntries returns aIndex = 0

   656 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, index);

   657 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   658 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   659 	ASSERT_TRUE(index==0 , _L("RMobilePhone::EnumerateAPNEntries did not return the correct index number"));		

   660 	

   661 	// Check first written entry does not exist and returns an error

   662 	ASSERT_TRUE(!(CheckEntryIsInListL(mobilePhone,myAPnEntry, indexValue)), _L("CheckEntryIsInList was executed and it did not return an error"));

   663 	

   664 	// Check second written entry does not exist and returns an error

   665 	ASSERT_TRUE(!(CheckEntryIsInListL(mobilePhone,myAPnEntry2, indexValue)), _L("CheckEntryIsInList was executed and it did not return an error"));

   666 	

   667 	//

   668 	// TEST END

   669 	//

   670 

   671     StartCleanup();

   672     

   673     EnsureApnListIsEmptyL(mobilePhone);

   674     

   675     // Pop

   676     // backup

   677     // setAPNControlListServiceStatus

   678     // getAPNControlListServiceStatus

   679     // notifyAPNListChangedStatus

   680     // appendAPNNameStatus

   681    	// enumerateAPNEntriesStatus

   682     // deleteAPNNameStatus

   683     CleanupStack::PopAndDestroy(7, &backup);

   684    

   685   	return TestStepResult();

   686 	}

   687 

   688 TPtrC CCTSYIntegrationTestAPNControlList0003::GetTestStepName()

   689 /**

   690  * @return The test step name.

   691  */

   692 	{

   693 	return _L("CCTSYIntegrationTestAPNControlList0003");

   694 	}

   695 

   696 

   697 

   698 CCTSYIntegrationTestAPNControlList0004::CCTSYIntegrationTestAPNControlList0004(CEtelSessionMgr& aEtelSessionMgr)

   699 	: CCTSYIntegrationTestAPNControlListBase(aEtelSessionMgr)

   700 /**

   701  * Constructor.

   702  */

   703 	{

   704 	SetTestStepName(CCTSYIntegrationTestAPNControlList0004::GetTestStepName());

   705 	}

   706 

   707 CCTSYIntegrationTestAPNControlList0004::~CCTSYIntegrationTestAPNControlList0004()

   708 /**

   709  * Destructor.

   710  */

   711 	{

   712 	}

   713 

   714 TVerdict CCTSYIntegrationTestAPNControlList0004::doTestStepL()

   715 /**

   716  * @SYMTestCaseID BA-CTSY-INT-ACL-0004

   717  * @SYMFssID BA/CTSY/ACL-0004

   718  * @SYMTestCaseDesc Attempt to delete an entry from the APN control list with invalid index.

   719  * @SYMTestPriority High

   720  * @SYMTestActions RMobilePhone::VerifySecurityCode, RMobilePhone::NotifySecurityEvent, RMobilePhone::DeleteAPNName

   721  * @SYMTestExpectedResults Pass - Cannot delete entry from APN control list when index is invalid.

   722  * @SYMTestType CIT

   723  * @SYMTestCaseDependencies live/manual

   724  *

   725  * Reason for test: Verify error is returned and number of entries in APN control list does not change.

   726  *

   727  * @return - TVerdict code

   728  */

   729 	{

   730 

   731 	//

   732 	// SET UP

   733 	//

   734 	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   735 	

   736 	DisplayUserInteractionPromptL(KPrompt); // 30 seconds

   737 	

   738 	// Ensure RMobilePhone::GetSecurityCaps returns caps in set of KCapsAccessPin2 

   739 	TUint32 securityCaps;

   740 	CHECK_EQUALS_L(mobilePhone.GetSecurityCaps(securityCaps), KErrNone,_L("RMobilePhone::GetSecurityCaps returned with an error"));

   741 	CHECK_BITS_SET_L(securityCaps,RMobilePhone::KCapsAccessPin2 ,KNoUnwantedBits, _L("RMobilePhone::GetSecurityCaps returned did not return KCapsAccessPin2 bits"));

   742 	

   743 	// Ensure the APN Control List Service Status is EAPNControlListServiceEnabled. 

   744 	RMobilePhone::TAPNControlListServiceStatus serviceApnControlListStatus;

   745 	TExtEtelRequestStatus setAPNControlListServiceStatus(mobilePhone, EMobilePhoneSetAPNControlListServiceStatus);

   746 	CleanupStack::PushL(setAPNControlListServiceStatus);

   747 	TExtEtelRequestStatus getAPNControlListServiceStatus(mobilePhone, EMobilePhoneGetAPNControlListServiceStatus);

   748 	CleanupStack::PushL(getAPNControlListServiceStatus);

   749 	mobilePhone.GetAPNControlListServiceStatus(getAPNControlListServiceStatus, serviceApnControlListStatus);

   750 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus timed out"));

   751 	CHECK_EQUALS_L(getAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus returned with an error"));		

   752 	

   753 	iSimTestHelper.VerifyPin2L(mobilePhone, iNetworkTestHelper);

   754 	

   755 	if(serviceApnControlListStatus== RMobilePhone::EAPNControlListServiceDisabled)

   756 		{

   757 		serviceApnControlListStatus=RMobilePhone::EAPNControlListServiceEnabled;

   758 		mobilePhone.SetAPNControlListServiceStatus(setAPNControlListServiceStatus, serviceApnControlListStatus);

   759 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(setAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::SetAPNControlListServiceStatus timed out"));

   760 		CHECK_EQUALS_L(setAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::SetAPNControlListServiceStatus returned with an error"));		

   761 			

   762 		// Get the APN Contol List Service Status again

   763 		mobilePhone.GetAPNControlListServiceStatus(getAPNControlListServiceStatus, serviceApnControlListStatus);

   764 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus timed out"));

   765 		CHECK_EQUALS_L(getAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus returned with an error"));		

   766 		}

   767 	CHECK_EQUALS_L(serviceApnControlListStatus, RMobilePhone::EAPNControlListServiceEnabled, _L("RMobilePhone::GetAPNControlListServiceStatus did not return EAPNControlListServiceEnabled status"));		

   768 	

   769 	// Ensure APN Control List is not empty. 

   770 	TUint32 storeIndex;

   771 	TExtEtelRequestStatus enumerateAPNEntriesStatus(mobilePhone, EMobilePhoneEnumerateAPNEntries);

   772 	CleanupStack::PushL(enumerateAPNEntriesStatus);

   773 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, storeIndex);

   774 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   775 	CHECK_EQUALS_L(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));	

   776 	if(storeIndex==0)

   777 		{

   778 		RMobilePhone::TAPNEntryV3 myAPnEntry;

   779 		TBuf16<20> name = _L("WiFi");

   780 		myAPnEntry.iApn.Copy(name);

   781 		RMobilePhone::TAPNEntryV3Pckg myAPnEntryPckg(myAPnEntry);

   782 		TExtEtelRequestStatus appendAPNNameStatus(mobilePhone, EMobilePhoneAppendAPNName);

   783 		CleanupStack::PushL(appendAPNNameStatus);

   784 		mobilePhone.AppendAPNName(appendAPNNameStatus, myAPnEntryPckg);

   785 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(appendAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::AppendAPNName timed out"));

   786 		CHECK_EQUALS_L(appendAPNNameStatus.Int(), KErrNone, _L("RMobilePhone::AppendAPNName returned with an error"));		

   787 		}

   788 	CHECK_TRUE_L(storeIndex>0 , _L("RMobilePhone::EnumerateAPNEntries returned an empty list"));		

   789 	

   790 	// Ensure index 5 in the APN Control List is empty. 

   791 	CHECK_TRUE_L(storeIndex<5, _L("The desired Index in the APN Control List is not empty"));		

   792 	

   793 	//

   794 	// SET UP END

   795 	//

   796 	

   797 	StartTest();

   798 	

   799 	//

   800 	// TEST START

   801 	//

   802 	

   803 	// ===  Delete an entry which is empty ===

   804 	

   805 	// Check RMobilePhone::DeleteAPNName with aIndex = 5 returns an error

   806 	TUint32 index=5;

   807 	TExtEtelRequestStatus deleteAPNNameStatus(mobilePhone, EMobilePhoneDeleteAPNName);

   808 	CleanupStack::PushL(deleteAPNNameStatus);

   809 	mobilePhone.DeleteAPNName(deleteAPNNameStatus, index);

   810 	ASSERT_EQUALS(WaitForRequestWithTimeOut(deleteAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::DeleteAPNName timed out"));

   811 	ASSERT_TRUE(deleteAPNNameStatus.Int()!=KErrNone, _L("RMobilePhone::DeleteAPNName did not return an error"))	;	

   812 	

   813 	// Check RMobilePhone::EnumerateAPNEntries returns same aIndex as before

   814 	TUint32 checkIndex;

   815 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, checkIndex);

   816 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   817 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   818 	ASSERT_EQUALS(checkIndex, storeIndex , _L("RMobilePhone::EnumerateAPNEntries did not return the same index"));		

   819 	

   820 	// ===  Delete an entry which is negative ===

   821 	

   822 	// Check RMobilePhone::DeleteAPNName with aIndex = -1 returns KErrMMEtelAPNNameInvalidIndex

   823 	index= (TUint)-1;

   824 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10022);		

   825 	CHECK_EQUALS_L(1, 2, _L("This test has been made to leave intentially"));		

   826 	mobilePhone.DeleteAPNName(deleteAPNNameStatus, index);

   827 	ASSERT_EQUALS(WaitForRequestWithTimeOut(deleteAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::DeleteAPNName timed out"));

   828 	ASSERT_EQUALS(deleteAPNNameStatus.Int(), KErrMMEtelAPNNameInvalidIndex, _L("RMobilePhone::DeleteAPNName returned wrong error"));		

   829 	

   830 	// Check RMobilePhone::EnumerateAPNEntries returns same aIndex as before

   831 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, checkIndex);

   832 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   833 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   834 	ASSERT_EQUALS(checkIndex,storeIndex , _L("RMobilePhone::EnumerateAPNEntries did not returne the same index"));		

   835 	

   836 	

   837 	// ===  Delete an entry which is too high ===

   838 		

   839 	// Check RMobilePhone::DeleteAPNName with aIndex = 1000000 returns KErrMMEtelAPNNameInvalidIndex

   840 	index=1000000;

   841 	mobilePhone.DeleteAPNName(deleteAPNNameStatus, index);

   842 	ASSERT_EQUALS(WaitForRequestWithTimeOut(deleteAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::DeleteAPNName timed out"));

   843 	ASSERT_EQUALS(deleteAPNNameStatus.Int(), KErrMMEtelAPNNameInvalidIndex, _L("RMobilePhone::DeleteAPNName returned wrong error"));		

   844 	

   845 	// Check RMobilePhone::EnumerateAPNEntries returns same aIndex as before

   846 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, checkIndex);

   847 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   848 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   849 	ASSERT_EQUALS(checkIndex, storeIndex , _L("RMobilePhone::EnumerateAPNEntries did not return the same index"));		

   850 	

   851 	//

   852 	// TEST END

   853 	//

   854 

   855     StartCleanup();

   856     

   857     EnsureApnListIsEmptyL(mobilePhone);

   858     

   859     // Pop

   860     // setAPNControlListServiceStatus

   861     // getAPNControlListServiceStatus

   862     // enumerateAPNEntriesStatus

   863     // getAPNnameStatus

   864     // deleteAPNNameStatus

   865     CleanupStack::PopAndDestroy(5,&setAPNControlListServiceStatus); 

   866 

   867 	return TestStepResult();

   868 	}

   869 

   870 TPtrC CCTSYIntegrationTestAPNControlList0004::GetTestStepName()

   871 /**

   872  * @return The test step name.

   873  */

   874 	{

   875 	return _L("CCTSYIntegrationTestAPNControlList0004");

   876 	}

   877 

   878 

   879 

   880 CCTSYIntegrationTestAPNControlList0005::CCTSYIntegrationTestAPNControlList0005(CEtelSessionMgr& aEtelSessionMgr)

   881 	: CCTSYIntegrationTestAPNControlListBase(aEtelSessionMgr)

   882 /**

   883  * Constructor.

   884  */

   885 	{

   886 	SetTestStepName(CCTSYIntegrationTestAPNControlList0005::GetTestStepName());

   887 	}

   888 

   889 CCTSYIntegrationTestAPNControlList0005::~CCTSYIntegrationTestAPNControlList0005()

   890 /**

   891  * Destructor.

   892  */

   893 	{

   894 	}

   895 

   896 TVerdict CCTSYIntegrationTestAPNControlList0005::doTestStepL()

   897 /**

   898  * @SYMTestCaseID BA-CTSY-INT-ACL-0005

   899  * @SYMFssID BA/CTSY/ACL-0005

   900  * @SYMTestCaseDesc Modify APN control list without verifying PIN2.

   901  * @SYMTestPriority High

   902  * @SYMTestActions RMobilePhone::DeleteAPNName, RMobilePhone::EnumerateAPNEntries

   903  * @SYMTestExpectedResults Pass - APN control list cannot be modified without PIN2.

   904  * @SYMTestType CIT

   905  * @SYMTestCaseDependencies live/manual

   906  *

   907  * Reason for test: Verify KErrGsm0707SimPin2Required is returned on attempt to append or delete a name.

   908  *

   909  * @return - TVerdict code

   910  */

   911 	{

   912 

   913 	//

   914 	// SET UP

   915 	//

   916 	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   917 	

   918 	DisplayUserInteractionPromptL(KPrompt); // 30 seconds

   919 	

   920 	// Check the APN Control List Service Status is EAPNControlListServiceEnabled. 

   921 	RMobilePhone::TAPNControlListServiceStatus serviceApnControlListStatus;

   922 	TExtEtelRequestStatus getAPNControlListServiceStatus(mobilePhone, EMobilePhoneGetAPNControlListServiceStatus);

   923 	CleanupStack::PushL(getAPNControlListServiceStatus);

   924 	mobilePhone.GetAPNControlListServiceStatus(getAPNControlListServiceStatus, serviceApnControlListStatus);

   925 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus timed out"));

   926 	CHECK_EQUALS_L(getAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus returned with an error"));		

   927 	CHECK_EQUALS_L(serviceApnControlListStatus, RMobilePhone::EAPNControlListServiceEnabled, _L("RMobilePhone::GetAPNControlListServiceStatus did not return EAPNControlListServiceEnabled status"));		

   928 	

   929 	//

   930 	// SET UP END

   931 	//

   932 	

   933 	StartTest();

   934 	

   935 	//

   936 	// TEST START

   937 	//

   938 	

   939 	

   940 	// ===  Get the number of APN entries ===

   941 

   942 	// Check RMobilePhone::EnumerateAPNEntries returns aIndex >= 0 (store aIndex for later)

   943 	TUint32 storeIndex;

   944 	TExtEtelRequestStatus enumerateAPNEntriesStatus(mobilePhone, EMobilePhoneEnumerateAPNEntries);

   945 	CleanupStack::PushL(enumerateAPNEntriesStatus);

   946 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, storeIndex);

   947 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   948 	CHECK_EQUALS_L(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   949 	CHECK_TRUE_L((int)storeIndex>=0 , _L("RMobilePhone::EnumerateAPNEntries returned an empty list"));		

   950 

   951 	// ===  Attempt to append an APN name without PIN2 ===

   952 

   953 	// Check RMobilePhone::AppendAPNName with a valid name returns KErrGsm0707SimPin2Required or KErrAccessDenied

   954 	RMobilePhone::TAPNEntryV3 myAPnEntry;

   955 	TBuf16<20> name = _L("WiFi");

   956 	myAPnEntry.iApn.Copy(name);

   957 	RMobilePhone::TAPNEntryV3Pckg myAPnEntryPckg(myAPnEntry);

   958 	TExtEtelRequestStatus appendAPNNameStatus(mobilePhone, EMobilePhoneAppendAPNName);

   959 	CleanupStack::PushL(appendAPNNameStatus);

   960 	mobilePhone.AppendAPNName(appendAPNNameStatus, myAPnEntryPckg);

   961 	ASSERT_EQUALS(WaitForRequestWithTimeOut(appendAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::AppendAPNName timed out"));

   962 	ASSERT_TRUE((appendAPNNameStatus.Int()==KErrGsm0707SimPin2Required || appendAPNNameStatus.Int()== KErrAccessDenied) , _L("RMobilePhone::AppendAPNName did not return an error"));		

   963 

   964 	

   965 	// Check RMobilePhone::EnumerateAPNEntries returns same aIndex as before

   966 	TUint32 checkIndex;

   967 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, checkIndex);

   968 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   969 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   970 	ASSERT_EQUALS(checkIndex, storeIndex , _L("RMobilePhone::EnumerateAPNEntries did not return the same index"));		

   971 	

   972 	// ===  Attempt to delete an APN name without PIN2 ===

   973 

   974 	// Check RMobilePhone::DeleteAPNName with a valid index returns KErrGsm0707SimPin2Required

   975 	TUint32 indexValue=0;

   976 	TExtEtelRequestStatus deleteAPNNameStatus(mobilePhone, EMobilePhoneDeleteAPNName);

   977 	CleanupStack::PushL(deleteAPNNameStatus);

   978 	mobilePhone.DeleteAPNName(deleteAPNNameStatus, indexValue);

   979 	ASSERT_EQUALS(WaitForRequestWithTimeOut(deleteAPNNameStatus, ETimeMedium),KErrNone, _L("RMobilePhone::DeleteAPNName timed out"));

   980 	ASSERT_TRUE((deleteAPNNameStatus.Int()==KErrGsm0707SimPin2Required || deleteAPNNameStatus.Int()== KErrAccessDenied) , _L("RMobilePhone::DeleteAPNName did not return an error"));		

   981 

   982 	

   983 	// Check RMobilePhone::EnumerateAPNEntries returns same aIndex as before

   984 	mobilePhone.EnumerateAPNEntries(enumerateAPNEntriesStatus, checkIndex);

   985 	ASSERT_EQUALS(WaitForRequestWithTimeOut(enumerateAPNEntriesStatus, ETimeMedium),KErrNone, _L("RMobilePhone::EnumerateAPNEntries timed out"));

   986 	ASSERT_EQUALS(enumerateAPNEntriesStatus.Int(), KErrNone, _L("RMobilePhone::EnumerateAPNEntries returned with an error"));		

   987 	ASSERT_EQUALS(checkIndex, storeIndex , _L("RMobilePhone::EnumerateAPNEntries did not return the same index"));		

   988 	

   989 	//

   990 	// TEST END

   991 	//

   992 

   993     StartCleanup();

   994 	

   995 	// Pop:

   996 	// getAPNControlListServiceStatus

   997 	// enumerateAPNEntriesStatus

   998 	// appendAPNNameStatus

   999 	// deleteAPNNameStatus

  1000 	

  1001 	CleanupStack::PopAndDestroy(4, &getAPNControlListServiceStatus);

  1002 

  1003 			

  1004 	return TestStepResult();

  1005 	}

  1006 

  1007 TPtrC CCTSYIntegrationTestAPNControlList0005::GetTestStepName()

  1008 /**

  1009  * @return The test step name.

  1010  */

  1011 	{

  1012 	return _L("CCTSYIntegrationTestAPNControlList0005");

  1013 	}

  1014 

  1015 

  1016 

  1017 CCTSYIntegrationTestAPNControlList0006::CCTSYIntegrationTestAPNControlList0006(CEtelSessionMgr& aEtelSessionMgr)

  1018 	: CCTSYIntegrationTestAPNControlListBase(aEtelSessionMgr)

  1019 /**

  1020  * Constructor.

  1021  */

  1022 	{

  1023 	SetTestStepName(CCTSYIntegrationTestAPNControlList0006::GetTestStepName());

  1024 	}

  1025 

  1026 CCTSYIntegrationTestAPNControlList0006::~CCTSYIntegrationTestAPNControlList0006()

  1027 /**

  1028  * Destructor.

  1029  */

  1030 	{

  1031 	}

  1032 

  1033 TVerdict CCTSYIntegrationTestAPNControlList0006::doTestStepL()

  1034 /**

  1035  * @SYMTestCaseID BA-CTSY-INT-ACL-0006

  1036  * @SYMFssID BA/CTSY/ACL-0006

  1037  * @SYMTestCaseDesc Enable and disable the APN control list service.

  1038  * @SYMTestPriority High

  1039  * @SYMTestActions RMobilePhone::NotifySecurityEvent, RMobilePhone::GetAPNControlListServiceStatus, RMobilePhone::SetAPNControlListServiceStatus, RMobilePhone::NotifyAPNControlListServiceStatusChange

  1040  * @SYMTestExpectedResults Pass - APN control list can be enabled and disabled.

  1041  * @SYMTestType CIT

  1042  * @SYMTestCaseDependencies live/manual

  1043  *

  1044  * Reason for test: Verify control list service status and notification.

  1045  *

  1046  * @return - TVerdict code

  1047  */

  1048 	{

  1049 

  1050 	//

  1051 	// SET UP

  1052 	//

  1053 	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

  1054 	

  1055 	DisplayUserInteractionPromptL(KPrompt); // 30 seconds

  1056 	

  1057 	// Verify Pin2

  1058 	iSimTestHelper.VerifyPin2L(mobilePhone,iNetworkTestHelper);

  1059 	

  1060 	// Ensure the APN Control List Service Status is EAPNControlListServiceDisabled 

  1061 	RMobilePhone::TAPNControlListServiceStatus serviceApnControlListStatus;

  1062 	TExtEtelRequestStatus setAPNControlListServiceStatus(mobilePhone, EMobilePhoneSetAPNControlListServiceStatus);

  1063 	CleanupStack::PushL(setAPNControlListServiceStatus);

  1064 	TExtEtelRequestStatus getAPNControlListServiceStatus(mobilePhone, EMobilePhoneGetAPNControlListServiceStatus);

  1065 	CleanupStack::PushL(getAPNControlListServiceStatus);

  1066 	mobilePhone.GetAPNControlListServiceStatus(getAPNControlListServiceStatus, serviceApnControlListStatus);

  1067 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus timed out"));

  1068 	CHECK_EQUALS_L(getAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus returned with an error"));		

  1069 	if(serviceApnControlListStatus== RMobilePhone::EAPNControlListServiceEnabled)

  1070 		{	

  1071 		serviceApnControlListStatus=RMobilePhone::EAPNControlListServiceDisabled;

  1072 		mobilePhone.SetAPNControlListServiceStatus(setAPNControlListServiceStatus, serviceApnControlListStatus);

  1073 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(setAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::SetAPNControlListServiceStatus timed out"));

  1074 		CHECK_EQUALS_L(setAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::SetAPNControlListServiceStatus returned with an error"));		

  1075 			

  1076 		// Get the APN Contol List Service Status again

  1077 		mobilePhone.GetAPNControlListServiceStatus(getAPNControlListServiceStatus, serviceApnControlListStatus);

  1078 		CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus timed out"));

  1079 		CHECK_EQUALS_L(getAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus returned with an error"));		

  1080 		}

  1081 	

  1082 	CHECK_EQUALS_L(serviceApnControlListStatus, RMobilePhone::EAPNControlListServiceDisabled, _L("RMobilePhone::GetAPNControlListServiceStatus did not return EAPNControlListServiceDisabled status"));		

  1083 

  1084 	//

  1085 	// SET UP END

  1086 	//

  1087 	

  1088 	StartTest();

  1089 	

  1090 	//

  1091 	// TEST START

  1092 	//

  1093 		

  1094 

  1095 	// ===  Enable the APN control list service ===

  1096 

  1097 	ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10019);

  1098 	CHECK_EQUALS_L(1, 2, _L("This test has been made to leave intentially"));		

  1099 	

  1100 	// Call RMobilePhone::NotifyAPNControlListServiceStatusChange 

  1101 	TExtEtelRequestStatus notifyAPNControlListServiceStatusChangeStatus(mobilePhone, EMobilePhoneNotifyAPNControlListServiceStatusChange);

  1102 	CleanupStack::PushL(notifyAPNControlListServiceStatusChangeStatus);

  1103 	mobilePhone.NotifyAPNControlListServiceStatusChange(notifyAPNControlListServiceStatusChangeStatus, serviceApnControlListStatus); 

  1104 	

  1105 	// Enable the APN control list service with RMobilePhone::SetAPNControlListServiceStatus with aAPNControlListServiceStatus = EAPNControlListServiceEnabled 

  1106 	RMobilePhone::TAPNControlListServiceStatus aPNControlListServiceStatus2=RMobilePhone::EAPNControlListServiceEnabled;

  1107 	mobilePhone.SetAPNControlListServiceStatus(setAPNControlListServiceStatus, aPNControlListServiceStatus2);

  1108 	ASSERT_EQUALS(WaitForRequestWithTimeOut(setAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::SetAPNControlListServiceStatus timed out"));

  1109 	ASSERT_EQUALS(setAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::SetAPNControlListServiceStatus returned with an error"));		

  1110 	

  1111     // Check RMobilePhone::NotifyAPNControlListServiceStatusChange completes with aAPNControlListServiceStatus = EAPNControlListServiceEnabled

  1112 	TInt wantedStatus= KErrNone;

  1113 	RMobilePhone::TAPNControlListServiceStatus expectedAPNControlListServiceStatus= RMobilePhone::EAPNControlListServiceEnabled;

  1114 	iNetworkTestHelper.WaitForMobilePhoneNotifyAPNControlListServiceStatusChange(mobilePhone,

  1115 																		  notifyAPNControlListServiceStatusChangeStatus,

  1116 																          serviceApnControlListStatus, 

  1117 																		  expectedAPNControlListServiceStatus,

  1118 																		  wantedStatus );

  1119 	

  1120 	// ===  Get the service status ===

  1121 	

  1122 	// Check RMobilePhone::GetAPNControlListServiceStatus returns aAPNControlListServiceStatus = EAPNControlListServiceEnabled

  1123 	mobilePhone.GetAPNControlListServiceStatus(getAPNControlListServiceStatus, serviceApnControlListStatus);

  1124 	ASSERT_EQUALS(WaitForRequestWithTimeOut(getAPNControlListServiceStatus, ETimeMedium),KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus timed out"));

  1125 	ASSERT_EQUALS(getAPNControlListServiceStatus.Int(), KErrNone, _L("RMobilePhone::GetAPNControlListServiceStatus returned with an error"));		

  1126 	ASSERT_EQUALS(serviceApnControlListStatus, RMobilePhone::EAPNControlListServiceEnabled, _L("RMobilePhone::GetAPNControlListServiceStatus did not return EAPNControlListServiceEnabled status"));		

  1127 	

  1128 	// ===  Disable the APN control list service ===

  1129 			

  1130 	// Verify Pin2

  1131 	iSimTestHelper.VerifyPin2L(mobilePhone,iNetworkTestHelper);			

  1132 	

  1133 	// Post notifier RMobilePhone::NotifyAPNControlListServiceStatusChange 

  1134 	mobilePhone.NotifyAPNControlListServiceStatusChange(notifyAPNControlListServiceStatusChangeStatus, serviceApnControlListStatus);