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 // The TEFUnit test suite for APNControlList in the Common TSY.

    15 // 

    16 //

    17 

    18 /**

    19  @file 

    20 */

    21 

    22 #include "cctsyapncontrollistfu.h"

    23 #include <etel.h>

    24 #include <etelmm.h>

    25 #include <et_clsvr.h>

    26 #include <ctsy/mmtsy_names.h>

    27 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>

    28 #include "tmockltsydata.h"

    29 #include <ctsy/serviceapi/gsmerror.h>

    30 

    31 CTestSuite* CCTsyAPNControlListFU::CreateSuiteL(const TDesC& aName)

    32 	{

    33 	SUB_SUITE;

    34 

    35 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestGetAPNname0001L);

    36 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestGetAPNname0002L);

    37 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestGetAPNname0003L);

    38 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestGetAPNname0004L);

    39 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestGetAPNname0005L);

    40 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestEnumerateAPNEntries0001L);

    41 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestEnumerateAPNEntries0002L);

    42 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestEnumerateAPNEntries0004L);

    43 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestEnumerateAPNEntries0005L);

    44 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestAppendAPNName0001L);

    45 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestAppendAPNName0002L);

    46 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestAppendAPNName0004L);

    47 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestAppendAPNName0005L);

    48 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestDeleteAPNName0001L);

    49 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestDeleteAPNName0002L);

    50 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestDeleteAPNName0004L);

    51 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestDeleteAPNName0005L);

    52 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestNotifyAPNListChanged0001L);

    53 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestNotifyAPNListChanged0002L);

    54 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestNotifyAPNListChanged0004L);

    55 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestGetAPNControlListServiceStatus0001L);

    56 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestGetAPNControlListServiceStatus0002L);

    57 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestGetAPNControlListServiceStatus0004L);

    58 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestGetAPNControlListServiceStatus0005L);

    59 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestSetAPNControlListServiceStatus0001L);

    60 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestSetAPNControlListServiceStatus0002L);

    61 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestSetAPNControlListServiceStatus0003L);

    62 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestSetAPNControlListServiceStatus0004L);

    63 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestSetAPNControlListServiceStatus0005L);

    64 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestNotifyAPNControlListServiceStatusChange0001L);

    65 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestNotifyAPNControlListServiceStatusChange0002L);

    66 	ADD_TEST_STEP_ISO_CPP(CCTsyAPNControlListFU, TestNotifyAPNControlListServiceStatusChange0004L);

    67 

    68 	END_SUITE;

    69 	}

    70 

    71 

    72 //

    73 // Actual test cases

    74 //

    75 

    76 

    77 /**

    78 @SYMTestCaseID BA-CTSY-ACL-MGAN-0001

    79 @SYMComponent  telephony_ctsy

    80 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetAPNname

    81 @SYMTestPriority High

    82 @SYMTestActions Invokes RMobilePhone::GetAPNname

    83 @SYMTestExpectedResults Pass

    84 @SYMTestType CT

    85 */

    86 void CCTsyAPNControlListFU::TestGetAPNname0001L()

    87 	{

    88 	OpenEtelServerL(EUseExtendedError);

    89 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

    90 	OpenPhoneL();

    91 

    92 	RBuf8 dataExpect;

    93 	CleanupClosePushL(dataExpect);

    94 	

    95 	RBuf8 dataComplete;

    96 	CleanupClosePushL(dataComplete);

    97 	

    98 	// data for RMobilePhone::GetAPNname itself

    99 	TRequestStatus reqStatus;

   100 	TUint32 index = 0;

   101 	RMobilePhone::TAPNEntryV3 apnEntry;

   102 	RMobilePhone::TAPNEntryV3Pckg pckgEntry(apnEntry);	

   103 	

   104 	// data for ExpectL

   105 	TMockLtsyData1<TUint32> ltsyData(index);

   106 	ltsyData.SerialiseL(dataExpect);

   107 	

   108 	// data for CompleteL

   109 	RMobilePhone::TAPNEntryV3 apnEntryComplete;

   110 	_LIT8(KSameName, "SameName");

   111 	apnEntryComplete.iApn.Copy(KSameName);

   112 	TMockLtsyData1<RMobilePhone::TAPNEntryV3> ltsyData2(apnEntryComplete);

   113 	ltsyData2.SerialiseL(dataComplete);

   114 	

   115  	//-------------------------------------------------------------------------

   116 	// TEST A: failure to dispatch request to LTSY

   117  	//-------------------------------------------------------------------------

   118 	iMockLTSY.ExpectL(EMobilePhoneGetAPNname, dataExpect, KErrNotSupported);

   119 	

   120 	iPhone.GetAPNname(reqStatus, index, pckgEntry);

   121 	User::WaitForRequest(reqStatus);

   122    	AssertMockLtsyStatusL();

   123 	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

   124 	

   125 

   126 	//-------------------------------------------------------------------------

   127 	// TEST B: failure on completion of pending request from LTSY->CTSY

   128  	//-------------------------------------------------------------------------

   129 	iMockLTSY.ExpectL(EMobilePhoneGetAPNname, dataExpect);

   130 	iMockLTSY.CompleteL(EMobilePhoneGetAPNname, KErrGeneral, dataComplete);

   131 	

   132 	iPhone.GetAPNname(reqStatus, index, pckgEntry);

   133 	User::WaitForRequest(reqStatus);

   134    	AssertMockLtsyStatusL();

   135 	ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

   136 	

   137 	//-------------------------------------------------------------------------

   138 	// TEST C: Successful completion request of

   139 	// RMobilePhone::GetAPNname when result is not cached.

   140  	//-------------------------------------------------------------------------

   141 	iMockLTSY.ExpectL(EMobilePhoneGetAPNname, dataExpect);

   142 	iMockLTSY.CompleteL(EMobilePhoneGetAPNname, KErrNone, dataComplete);

   143 	

   144 	iPhone.GetAPNname(reqStatus, index, pckgEntry);

   145 	User::WaitForRequest(reqStatus);

   146    	AssertMockLtsyStatusL();

   147 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   148 	ASSERT_EQUALS(apnEntryComplete.iApn, apnEntry.iApn);	

   149 	

   150  	//-------------------------------------------------------------------------

   151 	// TEST E: Unsolicited completion of RMobilePhone::GetAPNname

   152 	// from LTSY.

   153  	//-------------------------------------------------------------------------	

   154 	TRequestStatus mockLtsyStatus;

   155 	iMockLTSY.NotifyTerminated(mockLtsyStatus); 

   156  	// Issue the Complete...	

   157 	iMockLTSY.CompleteL(EMobilePhoneGetAPNname, KErrNone, dataComplete);

   158 	// wait for completion 

   159 	User::WaitForRequest(mockLtsyStatus);

   160 	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   161 	

   162 	AssertMockLtsyStatusL();

   163 	CleanupStack::PopAndDestroy(3, this); // dataComplete, expectData, this

   164 	

   165 	}

   166 

   167 

   168 /**

   169 @SYMTestCaseID BA-CTSY-ACL-MGAN-0002

   170 @SYMComponent  telephony_ctsy

   171 @SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::GetAPNname

   172 @SYMTestPriority High

   173 @SYMTestActions Invokes cancelling of RMobilePhone::GetAPNname

   174 @SYMTestExpectedResults Pass

   175 @SYMTestType CT

   176 */

   177 void CCTsyAPNControlListFU::TestGetAPNname0002L()

   178 	{

   179 

   180 // This test should test cancellation of GetAPNname

   181 // If this API does not have a cancel, the test step should be completely removed.

   182 

   183 	OpenEtelServerL(EUseExtendedError);

   184 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   185 	OpenPhoneL();

   186 

   187 	TRequestStatus mockLtsyStatus;

   188 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   189 

   190 	RBuf8 dataExpect;

   191 	CleanupClosePushL(dataExpect);

   192 	

   193 	RBuf8 dataComplete;

   194 	CleanupClosePushL(dataComplete);

   195 	

   196 	// data for RMobilePhone::GetAPNname itself

   197 	TRequestStatus reqStatus;

   198 	TUint32 index = 0;

   199 	RMobilePhone::TAPNEntryV3 apnEntry;

   200 	RMobilePhone::TAPNEntryV3Pckg pckgEntry(apnEntry);	

   201 	

   202 	// data for ExpectL

   203 	TMockLtsyData1<TUint32> ltsyData(index);

   204 	ltsyData.SerialiseL(dataExpect);

   205 	

   206 	// data for CompleteL

   207 	RMobilePhone::TAPNEntryV3 apnEntryComplete;

   208 	_LIT8(KSameName, "SameName");

   209 	apnEntryComplete.iApn.Copy(KSameName);

   210 	TMockLtsyData1<RMobilePhone::TAPNEntryV3> ltsyData2(apnEntryComplete);

   211 	ltsyData2.SerialiseL(dataComplete);

   212 

   213  	//-------------------------------------------------------------------------

   214 	// Test cancelling of RMobilePhone::GetAPNname

   215  	//-------------------------------------------------------------------------

   216  	

   217 	iMockLTSY.ExpectL(EMobilePhoneGetAPNname, dataExpect);

   218 	iMockLTSY.CompleteL(EMobilePhoneGetAPNname, KErrNone, dataComplete, 20);

   219 	

   220 	iPhone.GetAPNname(reqStatus, index, pckgEntry);

   221 	//cancel reguest

   222 	iPhone.CancelAsyncRequest(EMobilePhoneGetAPNname);

   223 	

   224 	User::WaitForRequest(reqStatus);

   225 	

   226 	// This defect was fixed. For more information see defect description    

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

   228   	ASSERT_EQUALS(KErrCancel, reqStatus.Int());

   229 	

   230 	// Wait for completion of iMockLTSY.NotifyTerminated

   231 	User::WaitForRequest(mockLtsyStatus);	

   232 	AssertMockLtsyStatusL();

   233 	CleanupStack::PopAndDestroy(3); // dataComplete, dataExpect, this	

   234 	}

   235 

   236 

   237 /**

   238 @SYMTestCaseID BA-CTSY-ACL-MGAN-0003

   239 @SYMComponent  telephony_ctsy

   240 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetAPNname with bad parameter data

   241 @SYMTestPriority High

   242 @SYMTestActions Invokes RMobilePhone::GetAPNname with bad parameter data

   243 @SYMTestExpectedResults Pass

   244 @SYMTestType CT

   245 */

   246 void CCTsyAPNControlListFU::TestGetAPNname0003L()

   247     {

   248 

   249     OpenEtelServerL(EUseExtendedError);

   250     CleanupStack::PushL(TCleanupItem(Cleanup,this));

   251     OpenPhoneL();

   252 

   253     TRequestStatus reqStatus;

   254     TUint32 index = 0;

   255 

   256     //-------------------------------------------------------------------------

   257     // Test A: Test passing wrong version of parameters to

   258     // RMobilePhone::GetAPNname

   259     //-------------------------------------------------------------------------

   260 

   261     // Bad argument

   262     TInt apnEntry;

   263     TPckg<TInt> pckgEntry(apnEntry);

   264 

   265     // Call GetAPNname with bad argument

   266     iPhone.GetAPNname(reqStatus, index, pckgEntry);

   267     User::WaitForRequest(reqStatus);

   268     AssertMockLtsyStatusL();

   269     ASSERT_EQUALS(KErrArgument, reqStatus.Int());

   270 

   271     CleanupStack::PopAndDestroy(this);

   272 	

   273 	}

   274 

   275 

   276 /**

   277 @SYMTestCaseID BA-CTSY-ACL-MGAN-0004

   278 @SYMComponent  telephony_ctsy

   279 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::GetAPNname

   280 @SYMTestPriority High

   281 @SYMTestActions Invokes multiple client requests to RMobilePhone::GetAPNname

   282 @SYMTestExpectedResults Pass

   283 @SYMTestType CT

   284 */

   285 void CCTsyAPNControlListFU::TestGetAPNname0004L()

   286 	{

   287 					

   288 	OpenEtelServerL(EUseExtendedError);

   289 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   290 	OpenPhoneL();

   291 

   292 	// Open second client

   293 	RTelServer telServer2;

   294 	TInt ret = telServer2.Connect();

   295 	ASSERT_EQUALS(KErrNone, ret);

   296 	CleanupClosePushL(telServer2);

   297 

   298 	RMobilePhone phone2;

   299 	ret = phone2.Open(telServer2, KMmTsyPhoneName);

   300 	ASSERT_EQUALS(KErrNone, ret);

   301 	CleanupClosePushL(phone2);

   302 	

   303 	RBuf8 dataExpect;

   304 	CleanupClosePushL(dataExpect);

   305 	

   306 	RBuf8 dataComplete;

   307 	CleanupClosePushL(dataComplete);

   308 	

   309 	// data for RMobilePhone::GetAPNname itself	

   310 	TRequestStatus reqStatus;	

   311 	TRequestStatus reqStatus2;

   312 	TUint32 index = 0;

   313 	RMobilePhone::TAPNEntryV3 apnEntry;

   314 	RMobilePhone::TAPNEntryV3Pckg pckgEntry(apnEntry);	

   315 	

   316 	// data for ExpectL

   317 	TMockLtsyData1<TUint32> ltsyData(index);

   318 	ltsyData.SerialiseL(dataExpect);

   319 	

   320 	// data for CompleteL

   321 	RMobilePhone::TAPNEntryV3 apnEntryComplete;

   322 	_LIT8(KSameName, "SameName");

   323 	apnEntryComplete.iApn.Copy(KSameName);

   324 	TMockLtsyData1<RMobilePhone::TAPNEntryV3> ltsyData2(apnEntryComplete);

   325 	ltsyData2.SerialiseL(dataComplete);

   326 	

   327 

   328 	//-------------------------------------------------------------------------

   329 	// Test A: Test multiple clients requesting RMobilePhone::GetAPNname

   330  	//------------------------------------------------------------------------- 	

   331  	// first client 	

   332  	iMockLTSY.ExpectL(EMobilePhoneGetAPNname, dataExpect);

   333 	iMockLTSY.CompleteL(EMobilePhoneGetAPNname, KErrNone, dataComplete);	

   334 	iPhone.GetAPNname(reqStatus, index, pckgEntry);

   335 	

   336 	// second client	

   337 	phone2.GetAPNname(reqStatus2, index, pckgEntry);

   338 	

   339 	// wait for the first client	

   340 	User::WaitForRequest(reqStatus);

   341 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   342 	ASSERT_EQUALS(apnEntryComplete.iApn, apnEntry.iApn);

   343 	

   344 	// wait for the second client	

   345 	User::WaitForRequest(reqStatus2);   

   346 	ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());

   347 	

   348 	AssertMockLtsyStatusL();

   349 	// Done !

   350 	CleanupStack::PopAndDestroy(5, this); // phone2, telServer2, dataComplete, dataExpect, this

   351 	}

   352 

   353 

   354 /**

   355 @SYMTestCaseID BA-CTSY-ACL-MGAN-0005

   356 @SYMComponent  telephony_ctsy

   357 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetAPNname with timeout

   358 @SYMTestPriority High

   359 @SYMTestActions Invokes RMobilePhone::GetAPNname and tests for timeout

   360 @SYMTestExpectedResults Pass

   361 @SYMTestType CT

   362 */

   363 void CCTsyAPNControlListFU::TestGetAPNname0005L()

   364 	{

   365 

   366 	OpenEtelServerL(EUseExtendedError);

   367 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   368 	OpenPhoneL();

   369 

   370 	RBuf8 data;

   371 	CleanupClosePushL(data);

   372 	

   373 		

   374 	// data for RMobilePhone::GetAPNname itself

   375 	TRequestStatus reqStatus;

   376 	TUint32 index = 0;

   377 	RMobilePhone::TAPNEntryV3 apnEntry;

   378 	RMobilePhone::TAPNEntryV3Pckg pckgEntry(apnEntry);	

   379 	

   380 	// data for ExpectL

   381 	TMockLtsyData1<TUint32> ltsyData(index);

   382 	ltsyData.SerialiseL(data);

   383 

   384 	//-------------------------------------------------------------------------

   385 	// Test A: Test timeout of RMobilePhone::GetAPNname

   386  	//-------------------------------------------------------------------------

   387 

   388 	iMockLTSY.ExpectL(EMobilePhoneGetAPNname, data);

   389 	

   390 	iPhone.GetAPNname(reqStatus, index, pckgEntry);

   391 	User::WaitForRequest(reqStatus);

   392    	AssertMockLtsyStatusL();

   393 	ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());

   394 

   395 	// Done !

   396 	CleanupStack::PopAndDestroy(2, this); // data, this

   397 

   398 	}

   399 

   400 

   401 /**

   402 @SYMTestCaseID BA-CTSY-ACL-MEAE-0001

   403 @SYMComponent  telephony_ctsy

   404 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::EnumerateAPNEntries

   405 @SYMTestPriority High

   406 @SYMTestActions Invokes RMobilePhone::EnumerateAPNEntries

   407 @SYMTestExpectedResults Pass

   408 @SYMTestType CT

   409 */

   410 void CCTsyAPNControlListFU::TestEnumerateAPNEntries0001L()

   411 	{

   412 

   413 	OpenEtelServerL(EUseExtendedError);

   414 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   415 	OpenPhoneL();

   416 

   417 	RBuf8 dataComplete;

   418 	CleanupClosePushL(dataComplete);	

   419 	

   420 	// data for EnumerateAPNEntries itself

   421 	TRequestStatus reqStatus;

   422 	TUint32 index = 0;

   423 	

   424 	// data for CompleteL

   425 	TUint32 indexComplete = 5;

   426 	TMockLtsyData1<TUint32> ltsyData(indexComplete);

   427 	ltsyData.SerialiseL(dataComplete);

   428 		

   429  	//-------------------------------------------------------------------------

   430 	// TEST A: failure to dispatch request to LTSY

   431  	//-------------------------------------------------------------------------

   432 	iMockLTSY.ExpectL(EMobilePhoneEnumerateAPNEntries, KErrNotSupported);

   433 		

   434 	iPhone.EnumerateAPNEntries( reqStatus, index );

   435 	User::WaitForRequest(reqStatus);

   436    	AssertMockLtsyStatusL();

   437 	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

   438 

   439 	//-------------------------------------------------------------------------

   440 	// TEST B: failure on completion of pending request from LTSY->CTSY

   441  	//-------------------------------------------------------------------------

   442 

   443 	iMockLTSY.ExpectL(EMobilePhoneEnumerateAPNEntries);

   444 	iMockLTSY.CompleteL(EMobilePhoneEnumerateAPNEntries, KErrGeneral, dataComplete);

   445 		

   446 	iPhone.EnumerateAPNEntries( reqStatus, index );

   447 	User::WaitForRequest(reqStatus);

   448    	AssertMockLtsyStatusL();

   449 	ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

   450 

   451  	//-------------------------------------------------------------------------

   452 	// TEST C: Successful completion request of

   453 	// RMobilePhone::EnumerateAPNEntries when result is not cached.

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

   455 

   456 	iMockLTSY.ExpectL(EMobilePhoneEnumerateAPNEntries);

   457 	iMockLTSY.CompleteL(EMobilePhoneEnumerateAPNEntries, KErrNone, dataComplete);

   458 		

   459 	iPhone.EnumerateAPNEntries( reqStatus, index );

   460 	User::WaitForRequest(reqStatus);

   461    	AssertMockLtsyStatusL();

   462 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   463 	ASSERT_EQUALS(indexComplete, index);

   464 

   465  	//-------------------------------------------------------------------------

   466 	// TEST E: Unsolicited completion of RMobilePhone::EnumerateAPNEntries

   467 	// from LTSY.

   468  	//-------------------------------------------------------------------------

   469 	TRequestStatus mockLtsyStatus;

   470 	iMockLTSY.NotifyTerminated(mockLtsyStatus); 

   471  	// Issue the Complete...	

   472 	iMockLTSY.CompleteL(EMobilePhoneEnumerateAPNEntries, KErrNone, dataComplete);

   473 	// wait for completion 

   474 	User::WaitForRequest(mockLtsyStatus);

   475 	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   476 

   477 	AssertMockLtsyStatusL();

   478 	CleanupStack::PopAndDestroy(2, this); // dataComplete, this

   479 	

   480 	}

   481 

   482 

   483 /**

   484 @SYMTestCaseID BA-CTSY-ACL-MEAE-0002

   485 @SYMComponent  telephony_ctsy

   486 @SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::EnumerateAPNEntries

   487 @SYMTestPriority High

   488 @SYMTestActions Invokes cancelling of RMobilePhone::EnumerateAPNEntries

   489 @SYMTestExpectedResults Pass

   490 @SYMTestType CT

   491 */

   492 void CCTsyAPNControlListFU::TestEnumerateAPNEntries0002L()

   493 	{

   494 

   495 // This test should test cancellation of EnumerateAPNEntries

   496 // If this API does not have a cancel, the test step should be completely removed.

   497 

   498 	OpenEtelServerL(EUseExtendedError);

   499 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   500 	OpenPhoneL();

   501 

   502 	TRequestStatus mockLtsyStatus;

   503 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   504 

   505 	RBuf8 data;

   506 	CleanupClosePushL(data);

   507 	

   508 	// data for EnumerateAPNEntries itself

   509 	TRequestStatus reqStatus;

   510 	TUint32 index = 0;

   511 	

   512 	// data for CompleteL

   513 	TUint32 indexComplete = 5;

   514 	TMockLtsyData1<TUint32> ltsyData(indexComplete);

   515 	ltsyData.SerialiseL(data);

   516 

   517  	//-------------------------------------------------------------------------

   518 	// Test cancelling of RMobilePhone::EnumerateAPNEntries

   519  	//-------------------------------------------------------------------------

   520  	iMockLTSY.ExpectL(EMobilePhoneEnumerateAPNEntries);

   521 	iMockLTSY.CompleteL(EMobilePhoneEnumerateAPNEntries, KErrNone, data, 10);

   522 		

   523 	iPhone.EnumerateAPNEntries( reqStatus, index );	

   524 	//cancel reguest

   525 	iPhone.CancelAsyncRequest(EMobilePhoneEnumerateAPNEntries);

   526 	

   527 	User::WaitForRequest(reqStatus);

   528 	// This defect was fixed. For more information see defect description  

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

   530   	ASSERT_EQUALS(KErrCancel, reqStatus.Int());

   531 

   532 	// Wait for completion of iMockLTSY.NotifyTerminated

   533 	User::WaitForRequest(mockLtsyStatus);

   534 		

   535 	AssertMockLtsyStatusL();

   536 	CleanupStack::PopAndDestroy(2); // data, this	

   537 	}

   538 

   539 

   540 /**

   541 @SYMTestCaseID BA-CTSY-ACL-MEAE-0004

   542 @SYMComponent  telephony_ctsy

   543 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::EnumerateAPNEntries

   544 @SYMTestPriority High

   545 @SYMTestActions Invokes multiple client requests to RMobilePhone::EnumerateAPNEntries

   546 @SYMTestExpectedResults Pass

   547 @SYMTestType CT

   548 */

   549 void CCTsyAPNControlListFU::TestEnumerateAPNEntries0004L()

   550 	{

   551 				

   552 	OpenEtelServerL(EUseExtendedError);

   553 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   554 	OpenPhoneL();

   555 

   556 	RBuf8 data;

   557 	CleanupClosePushL(data);

   558 

   559 	// Open second client

   560 	RTelServer telServer2;

   561 	TInt ret = telServer2.Connect();

   562 	ASSERT_EQUALS(KErrNone, ret);

   563 	CleanupClosePushL(telServer2);

   564 

   565 	RMobilePhone phone2;

   566 	ret = phone2.Open(telServer2, KMmTsyPhoneName);

   567 	ASSERT_EQUALS(KErrNone, ret);

   568 	CleanupClosePushL(phone2);

   569 	

   570 	// data for EnumerateAPNEntrieses itself

   571 	TRequestStatus reqStatus;

   572 	TUint32 index = 0;	

   573 	TRequestStatus reqStatus2;

   574 	TUint32 index2 = 0;

   575 	

   576 	// data for CompleteL

   577 	TUint32 indexComplete = 5;

   578 	TMockLtsyData1<TUint32> ltsyData(indexComplete);

   579 	ltsyData.SerialiseL(data);

   580 	

   581 

   582 	//-------------------------------------------------------------------------

   583 	// Test A: Test multiple clients requesting RMobilePhone::EnumerateAPNEntries

   584  	//-------------------------------------------------------------------------

   585 	iMockLTSY.ExpectL(EMobilePhoneEnumerateAPNEntries);

   586 	iMockLTSY.CompleteL(EMobilePhoneEnumerateAPNEntries, KErrNone, data, 5);

   587 	

   588 	//send first request

   589 	iPhone.EnumerateAPNEntries( reqStatus, index );

   590 	

   591 	//send second request

   592 	phone2.EnumerateAPNEntries( reqStatus2, index2 );	

   593 	

   594 	// wait for the first client	

   595 	User::WaitForRequest(reqStatus);

   596 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   597 	ASSERT_EQUALS(indexComplete, index);

   598 	

   599 	// wait for the second client	

   600 	User::WaitForRequest(reqStatus2);

   601    	AssertMockLtsyStatusL();

   602 	ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());

   603 

   604 	// Done !

   605 	CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, data, this

   606 	}

   607 

   608 

   609 /**

   610 @SYMTestCaseID BA-CTSY-ACL-MEAE-0005

   611 @SYMComponent  telephony_ctsy

   612 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::EnumerateAPNEntries with timeout

   613 @SYMTestPriority High

   614 @SYMTestActions Invokes RMobilePhone::EnumerateAPNEntries and tests for timeout

   615 @SYMTestExpectedResults Pass

   616 @SYMTestType CT

   617 */

   618 void CCTsyAPNControlListFU::TestEnumerateAPNEntries0005L()

   619 	{

   620 	OpenEtelServerL(EUseExtendedError);

   621 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   622 	OpenPhoneL();

   623 	// data for EnumerateAPNEntries itself

   624 	TRequestStatus reqStatus;

   625 	TUint32 index = 0;

   626 	

   627 	//-------------------------------------------------------------------------

   628 	// Test A: Test timeout of RMobilePhone::EnumerateAPNEntries

   629  	//-------------------------------------------------------------------------	

   630 	iMockLTSY.ExpectL(EMobilePhoneEnumerateAPNEntries);

   631 	iPhone.EnumerateAPNEntries( reqStatus, index );

   632 	

   633 	User::WaitForRequest(reqStatus);

   634 	ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());

   635 	

   636 	AssertMockLtsyStatusL();

   637 	// Done !

   638 	CleanupStack::PopAndDestroy(1, this); // this

   639 	}

   640 

   641 

   642 /**

   643 @SYMTestCaseID BA-CTSY-ACL-MAAN-0001

   644 @SYMComponent  telephony_ctsy

   645 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::AppendAPNName

   646 @SYMTestPriority High

   647 @SYMTestActions Invokes RMobilePhone::AppendAPNName

   648 @SYMTestExpectedResults Pass

   649 @SYMTestType CT

   650 */

   651 void CCTsyAPNControlListFU::TestAppendAPNName0001L()

   652 	{

   653 

   654 	OpenEtelServerL(EUseExtendedError);

   655 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   656 	OpenPhoneL();

   657 

   658 	RBuf8 dataExpect;

   659 	CleanupClosePushL(dataExpect);

   660 

   661 	// data for AppendAPNName itself

   662 	TRequestStatus reqStatus;

   663 	RMobilePhone::TAPNEntryV3 apnEntry;

   664 	_LIT8(KSomeName, "SomeName");

   665 	apnEntry.iApn.Copy(KSomeName);

   666 	RMobilePhone::TAPNEntryV3Pckg pckgEntry(apnEntry);

   667 	// data for ExpectL

   668 	TMockLtsyData1<RMobilePhone::TAPNEntryV3> ltsyData( apnEntry );

   669 	ltsyData.SerialiseL(dataExpect);

   670 	

   671  	//-------------------------------------------------------------------------

   672 	// TEST A: failure to dispatch request to LTSY

   673  	//-------------------------------------------------------------------------

   674 	iMockLTSY.ExpectL(EMobilePhoneAppendAPNName, dataExpect, KErrNotSupported);

   675 			

   676 	iPhone.AppendAPNName(reqStatus, pckgEntry);

   677 	User::WaitForRequest(reqStatus);

   678 	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

   679 	AssertMockLtsyStatusL();

   680 

   681 	//-------------------------------------------------------------------------

   682 	// TEST B: failure on completion of pending request from LTSY->CTSY

   683  	//-------------------------------------------------------------------------

   684 	iMockLTSY.ExpectL(EMobilePhoneAppendAPNName, dataExpect);

   685 	iMockLTSY.CompleteL(EMobilePhoneAppendAPNName, KErrGeneral);

   686 		

   687 	iPhone.AppendAPNName(reqStatus, pckgEntry);

   688 	User::WaitForRequest(reqStatus);

   689 	ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

   690 	AssertMockLtsyStatusL();

   691 	

   692  	//-------------------------------------------------------------------------

   693 	// TEST C: Successful completion request of

   694 	// RMobilePhone::AppendAPNName when result is not cached.

   695  	//-------------------------------------------------------------------------

   696 	iMockLTSY.ExpectL(EMobilePhoneAppendAPNName, dataExpect);

   697 	iMockLTSY.CompleteL(EMobilePhoneAppendAPNName, KErrNone);

   698 		

   699 	iPhone.AppendAPNName(reqStatus, pckgEntry);

   700 	User::WaitForRequest(reqStatus);

   701 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   702 	AssertMockLtsyStatusL();

   703 

   704  	//-------------------------------------------------------------------------

   705 	// TEST E: Unsolicited completion of RMobilePhone::AppendAPNName

   706 	// from LTSY.

   707  	//-------------------------------------------------------------------------	

   708 	TRequestStatus mockLtsyStatus;

   709 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   710 	

   711 	iMockLTSY.CompleteL(EMobilePhoneAppendAPNName, KErrNone);

   712 	

   713 	User::WaitForRequest(mockLtsyStatus);

   714 	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   715 

   716 	AssertMockLtsyStatusL();

   717 	CleanupStack::PopAndDestroy(2, this); // dataExpect, this	 

   718 	}

   719 

   720 

   721 /**

   722 @SYMTestCaseID BA-CTSY-ACL-MAAN-0002

   723 @SYMComponent  telephony_ctsy

   724 @SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::AppendAPNName

   725 @SYMTestPriority High

   726 @SYMTestActions Invokes cancelling of RMobilePhone::AppendAPNName

   727 @SYMTestExpectedResults Pass

   728 @SYMTestType CT

   729 */

   730 void CCTsyAPNControlListFU::TestAppendAPNName0002L()

   731 	{

   732 

   733 	// This test should test cancellation of AppendAPNName

   734 	// If this API does not have a cancel, the test step should be completely removed.

   735 

   736 	OpenEtelServerL(EUseExtendedError);

   737 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   738 	OpenPhoneL();

   739 

   740 	TRequestStatus mockLtsyStatus;

   741 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   742 

   743 	RBuf8 data;

   744 	CleanupClosePushL(data);

   745 	

   746 	// data for AppendAPNName itself

   747 	TRequestStatus reqStatus;

   748 	RMobilePhone::TAPNEntryV3 apnEntry;

   749 	_LIT8(KSomeName, "SomeName");

   750 	apnEntry.iApn.Copy(KSomeName);

   751 	RMobilePhone::TAPNEntryV3Pckg pckgEntry(apnEntry);

   752 	// data for ExpectL

   753 	TMockLtsyData1<RMobilePhone::TAPNEntryV3> ltsyData( apnEntry );

   754 	ltsyData.SerialiseL(data);

   755 

   756 	//-------------------------------------------------------------------------

   757 	// For coverage increasing call Cancel without calling RMobilePhone::AppendAPNName

   758  	//------------------------------------------------------------------------- 	 	

   759  	iPhone.CancelAsyncRequest(EMobilePhoneAppendAPNName);

   760 

   761  	//-------------------------------------------------------------------------

   762 	// Test cancelling of RMobilePhone::AppendAPNName

   763  	//------------------------------------------------------------------------- 	

   764 	iMockLTSY.ExpectL(EMobilePhoneAppendAPNName, data);

   765 	iMockLTSY.CompleteL(EMobilePhoneAppendAPNName, KErrNone, 10);

   766 		

   767 	iPhone.AppendAPNName(reqStatus, pckgEntry);

   768 	//cancel reguest

   769 	iPhone.CancelAsyncRequest(EMobilePhoneAppendAPNName);

   770 	

   771 	User::WaitForRequest(reqStatus);

   772 	ASSERT_EQUALS(KErrCancel, reqStatus.Int());

   773 	

   774 	// Wait for completion of iMockLTSY.NotifyTerminated

   775 	User::WaitForRequest(mockLtsyStatus);

   776 	AssertMockLtsyStatusL();

   777 	CleanupStack::PopAndDestroy(2); // data, this

   778 	

   779 	}

   780 

   781 

   782 /**

   783 @SYMTestCaseID BA-CTSY-ACL-MAAN-0004

   784 @SYMComponent  telephony_ctsy

   785 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::AppendAPNName

   786 @SYMTestPriority High

   787 @SYMTestActions Invokes multiple client requests to RMobilePhone::AppendAPNName

   788 @SYMTestExpectedResults Pass

   789 @SYMTestType CT

   790 */

   791 void CCTsyAPNControlListFU::TestAppendAPNName0004L()

   792 	{

   793 					

   794 	OpenEtelServerL(EUseExtendedError);

   795 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   796 	OpenPhoneL();

   797 

   798 	RBuf8 data;

   799 	CleanupClosePushL(data);

   800 

   801 	// Open second client

   802 	RTelServer telServer2;

   803 	TInt ret = telServer2.Connect();

   804 	ASSERT_EQUALS(KErrNone, ret);

   805 	CleanupClosePushL(telServer2);

   806 

   807 	RMobilePhone phone2;

   808 	ret = phone2.Open(telServer2, KMmTsyPhoneName);

   809 	ASSERT_EQUALS(KErrNone, ret);

   810 	CleanupClosePushL(phone2);	

   811 	

   812 	// data for first AppendAPNName()

   813 	TRequestStatus reqStatus;

   814 	RMobilePhone::TAPNEntryV3 apnEntry;

   815 	_LIT8(KSomeName, "SomeName");

   816 	apnEntry.iApn.Copy(KSomeName);

   817 	RMobilePhone::TAPNEntryV3Pckg pckgEntry(apnEntry);

   818 	

   819 	// data for second AppendAPNName()

   820 	TRequestStatus reqStatus2;

   821 	RMobilePhone::TAPNEntryV3 apnEntry2;

   822 	_LIT8(KSomeName2, "SomeName2");

   823 	apnEntry2.iApn.Copy(KSomeName2);

   824 	RMobilePhone::TAPNEntryV3Pckg pckgEntry2(apnEntry2);

   825 	

   826 	// data for first ExpectL

   827 	TMockLtsyData1<RMobilePhone::TAPNEntryV3> ltsyData( apnEntry );

   828 	ltsyData.SerialiseL(data);

   829 

   830 	//-------------------------------------------------------------------------

   831 	// Test A: Test multiple clients requesting RMobilePhone::AppendAPNName

   832  	//-------------------------------------------------------------------------

   833  	 	

   834  	// first request

   835  	iMockLTSY.ExpectL(EMobilePhoneAppendAPNName, data);

   836 	iMockLTSY.CompleteL(EMobilePhoneAppendAPNName, KErrNone, 10);		

   837 	iPhone.AppendAPNName(reqStatus, pckgEntry);

   838 	

   839 	// second request	

   840 	phone2.AppendAPNName(reqStatus2, pckgEntry2);

   841 	

   842 	// wait for the first answer

   843 	User::WaitForRequest(reqStatus);

   844 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   845 	

   846 	// wait for the second answer

   847 	User::WaitForRequest(reqStatus2);

   848 	ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());	

   849 	

   850 	AssertMockLtsyStatusL();

   851 	// Done !

   852 	CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, data, this

   853 	}

   854 

   855 

   856 /**

   857 @SYMTestCaseID BA-CTSY-ACL-MAAN-0005

   858 @SYMComponent  telephony_ctsy

   859 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::AppendAPNName with timeout

   860 @SYMTestPriority High

   861 @SYMTestActions Invokes RMobilePhone::AppendAPNName and tests for timeout

   862 @SYMTestExpectedResults Pass

   863 @SYMTestType CT

   864 */

   865 void CCTsyAPNControlListFU::TestAppendAPNName0005L()

   866 	{

   867 	OpenEtelServerL(EUseExtendedError);

   868 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   869 	OpenPhoneL();

   870 

   871 	RBuf8 data;

   872 	CleanupClosePushL(data);

   873 	

   874 	// data for AppendAPNName itself

   875 	TRequestStatus reqStatus;

   876 	RMobilePhone::TAPNEntryV3 apnEntry;

   877 	_LIT8(KSomeName, "SomeName");

   878 	apnEntry.iApn.Copy(KSomeName);

   879 	RMobilePhone::TAPNEntryV3Pckg pckgEntry(apnEntry);

   880 	// data for ExpectL

   881 	TMockLtsyData1<RMobilePhone::TAPNEntryV3> ltsyData( apnEntry );

   882 	ltsyData.SerialiseL(data);

   883 

   884 	//-------------------------------------------------------------------------

   885 	// Test A: Test timeout of RMobilePhone::AppendAPNName

   886  	//------------------------------------------------------------------------- 	

   887  	iMockLTSY.ExpectL(EMobilePhoneAppendAPNName, data);		

   888 	iPhone.AppendAPNName(reqStatus, pckgEntry);

   889 	

   890 	User::WaitForRequest(reqStatus);

   891 	

   892 	ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());

   893 	

   894 	AssertMockLtsyStatusL();

   895 	// Done !

   896 	CleanupStack::PopAndDestroy(2, this); // data, this

   897 

   898 	}

   899 

   900 

   901 /**

   902 @SYMTestCaseID BA-CTSY-ACL-MDAN-0001

   903 @SYMComponent  telephony_ctsy

   904 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::DeleteAPNName

   905 @SYMTestPriority High

   906 @SYMTestActions Invokes RMobilePhone::DeleteAPNName

   907 @SYMTestExpectedResults Pass

   908 @SYMTestType CT

   909 */

   910 void CCTsyAPNControlListFU::TestDeleteAPNName0001L()

   911 	{

   912 

   913 	OpenEtelServerL(EUseExtendedError);

   914 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   915 	OpenPhoneL();

   916 

   917 	RBuf8 dataExpect;

   918 	CleanupClosePushL(dataExpect);

   919 	

   920 	// data for DeleteAPNName itself

   921 	TRequestStatus reqStatus;

   922 	TUint32 index = 0;

   923 	

   924 	// data for ExpectL

   925 	TMockLtsyData1<TUint32> ltsyData( index );

   926 	ltsyData.SerialiseL(dataExpect);

   927 	

   928  	//-------------------------------------------------------------------------

   929 	// TEST A: failure to dispatch request to LTSY

   930  	//-------------------------------------------------------------------------

   931 	iMockLTSY.ExpectL(EMobilePhoneDeleteAPNName, dataExpect, KErrNotSupported);	

   932 	

   933 	iPhone.DeleteAPNName(reqStatus, index);

   934 	User::WaitForRequest(reqStatus);

   935 	ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());

   936 	AssertMockLtsyStatusL();

   937 

   938 	//-------------------------------------------------------------------------

   939 	// TEST B: failure on completion of pending request from LTSY->CTSY

   940  	//-------------------------------------------------------------------------

   941 	iMockLTSY.ExpectL(EMobilePhoneDeleteAPNName, dataExpect);	

   942 	iMockLTSY.CompleteL(EMobilePhoneDeleteAPNName, KErrGeneral);	

   943 	

   944 	iPhone.DeleteAPNName(reqStatus, index);

   945 	User::WaitForRequest(reqStatus);

   946 	ASSERT_EQUALS(KErrGeneral, reqStatus.Int());

   947 	AssertMockLtsyStatusL();

   948 

   949  	//-------------------------------------------------------------------------

   950 	// TEST C: Successful completion request of

   951 	// RMobilePhone::DeleteAPNName when result is not cached.

   952  	//-------------------------------------------------------------------------

   953 	iMockLTSY.ExpectL(EMobilePhoneDeleteAPNName, dataExpect);	

   954 	iMockLTSY.CompleteL(EMobilePhoneDeleteAPNName, KErrNone);	

   955 	

   956 	iPhone.DeleteAPNName(reqStatus, index);

   957 	User::WaitForRequest(reqStatus);

   958 	ASSERT_EQUALS(KErrNone, reqStatus.Int());

   959 	AssertMockLtsyStatusL();

   960 

   961  	//-------------------------------------------------------------------------

   962 	// TEST E: Unsolicited completion of RMobilePhone::DeleteAPNName

   963 	// from LTSY.

   964  	//-------------------------------------------------------------------------

   965 	TRequestStatus mockLtsyStatus;

   966 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

   967 

   968 	iMockLTSY.CompleteL(EMobilePhoneDeleteAPNName, KErrNone);	

   969 

   970 	User::WaitForRequest(mockLtsyStatus);

   971 	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   972 

   973 	AssertMockLtsyStatusL();

   974 	CleanupStack::PopAndDestroy(2, this); // dataExpect, this

   975 	

   976 	}

   977 

   978 

   979 /**

   980 @SYMTestCaseID BA-CTSY-ACL-MDAN-0002

   981 @SYMComponent  telephony_ctsy

   982 @SYMTestCaseDesc Test support in CTSY for cancelling of RMobilePhone::DeleteAPNName

   983 @SYMTestPriority High

   984 @SYMTestActions Invokes cancelling of RMobilePhone::DeleteAPNName

   985 @SYMTestExpectedResults Pass

   986 @SYMTestType CT

   987 */

   988 void CCTsyAPNControlListFU::TestDeleteAPNName0002L()

   989 	{

   990 

   991 // This test should test cancellation of DeleteAPNName

   992 // If this API does not have a cancel, the test step should be completely removed.

   993 

   994 	OpenEtelServerL(EUseExtendedError);

   995 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

   996 	OpenPhoneL();

   997 

   998 	TRequestStatus mockLtsyStatus;

   999 	iMockLTSY.NotifyTerminated(mockLtsyStatus);

  1000 

  1001 	RBuf8 dataExpect;

  1002 	CleanupClosePushL(dataExpect);

  1003 	

  1004 	// data for DeleteAPNName itself

  1005 	TRequestStatus reqStatus;

  1006 	TUint32 index = 0;

  1007 	

  1008 	// data for ExpectL

  1009 	TMockLtsyData1<TUint32> ltsyData( index );

  1010 	ltsyData.SerialiseL(dataExpect);

  1011 	

  1012 	//-------------------------------------------------------------------------

  1013 	// For coverage increasing call Cancel without calling RMobilePhone::DeleteAPNName

  1014  	//------------------------------------------------------------------------- 	 	

  1015  	iPhone.CancelAsyncRequest(EMobilePhoneDeleteAPNName);

  1016 

  1017  	//-------------------------------------------------------------------------

  1018 	// Test cancelling of RMobilePhone::DeleteAPNName

  1019  	//------------------------------------------------------------------------- 	

  1020 	iMockLTSY.ExpectL(EMobilePhoneDeleteAPNName, dataExpect);	

  1021 	iMockLTSY.CompleteL(EMobilePhoneDeleteAPNName, KErrNone, 10);	

  1022 	

  1023 	iPhone.DeleteAPNName(reqStatus, index);

  1024 	

  1025 	//cancel reguest

  1026 	iPhone.CancelAsyncRequest(EMobilePhoneDeleteAPNName);

  1027 	

  1028 	User::WaitForRequest(reqStatus);

  1029 	ASSERT_EQUALS(KErrCancel, reqStatus.Int());

  1030 	

  1031 

  1032 	// Wait for completion of iMockLTSY.NotifyTerminated

  1033 	User::WaitForRequest(mockLtsyStatus);

  1034 	AssertMockLtsyStatusL();

  1035 	CleanupStack::PopAndDestroy(2); // dataExpect, this

  1036 	

  1037 	}

  1038 

  1039 /**

  1040 @SYMTestCaseID BA-CTSY-ACL-MDAN-0004

  1041 @SYMComponent  telephony_ctsy

  1042 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobilePhone::DeleteAPNName

  1043 @SYMTestPriority High

  1044 @SYMTestActions Invokes multiple client requests to RMobilePhone::DeleteAPNName

  1045 @SYMTestExpectedResults Pass

  1046 @SYMTestType CT

  1047 */

  1048 void CCTsyAPNControlListFU::TestDeleteAPNName0004L()

  1049 	{				

  1050 	OpenEtelServerL(EUseExtendedError);

  1051 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

  1052 	OpenPhoneL();

  1053 

  1054 	RBuf8 data;

  1055 	CleanupClosePushL(data);

  1056 

  1057 	// Open second client

  1058 	RTelServer telServer2;

  1059 	TInt ret = telServer2.Connect();

  1060 	ASSERT_EQUALS(KErrNone, ret);

  1061 	CleanupClosePushL(telServer2);

  1062 

  1063 	RMobilePhone phone2;

  1064 	ret = phone2.Open(telServer2,KMmTsyPhoneName);

  1065 	ASSERT_EQUALS(KErrNone, ret);

  1066 	CleanupClosePushL(phone2);

  1067 	

  1068 	// data for the first DeleteAPNName itself

  1069 	TRequestStatus reqStatus;

  1070 	TUint32 index = 0;

  1071 	

  1072 	// data for the second DeleteAPNName itself

  1073 	TRequestStatus reqStatus2;

  1074 	TUint32 index2 = 1;

  1075 	

  1076 	// data for ExpectL

  1077 	TMockLtsyData1<TUint32> ltsyData( index );

  1078 	ltsyData.SerialiseL(data);		

  1079 

  1080 	//-------------------------------------------------------------------------

  1081 	// Test A: Test multiple clients requesting RMobilePhone::DeleteAPNName

  1082  	//-------------------------------------------------------------------------

  1083 	iMockLTSY.ExpectL(EMobilePhoneDeleteAPNName, data);	

  1084 	iMockLTSY.CompleteL(EMobilePhoneDeleteAPNName, KErrNone);	

  1085 	

  1086 	// first request

  1087 	iPhone.DeleteAPNName(reqStatus, index);	

  1088 	// second request

  1089 	phone2.DeleteAPNName(reqStatus2, index2);

  1090 		

  1091 	// wait for the first answer

  1092 	User::WaitForRequest(reqStatus);

  1093 	ASSERT_EQUALS(KErrNone, reqStatus.Int());	

  1094 	

  1095 	// wait for the second answer

  1096 	User::WaitForRequest(reqStatus2);

  1097 	ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());	

  1098 	

  1099 	AssertMockLtsyStatusL();

  1100 	// Done !

  1101 	CleanupStack::PopAndDestroy(4, this); // phone2, telServer2, data, this

  1102 	}

  1103 

  1104 

  1105 /**

  1106 @SYMTestCaseID BA-CTSY-ACL-MDAN-0005

  1107 @SYMComponent  telephony_ctsy

  1108 @SYMTestCaseDesc Test support in CTSY for RMobilePhone::DeleteAPNName with timeout

  1109 @SYMTestPriority High

  1110 @SYMTestActions Invokes RMobilePhone::DeleteAPNName and tests for timeout

  1111 @SYMTestExpectedResults Pass

  1112 @SYMTestType CT

  1113 */

  1114 void CCTsyAPNControlListFU::TestDeleteAPNName0005L()

  1115 	{

  1116 	OpenEtelServerL(EUseExtendedError);

  1117 	CleanupStack::PushL(TCleanupItem(Cleanup,this));

  1118 	OpenPhoneL();

  1119 

  1120 	RBuf8 dataExpect;

  1121 	CleanupClosePushL(dataExpect);

  1122 	

  1123 	// data for DeleteAPNName itself

  1124 	TRequestStatus reqStatus;

  1125 	TUint32 index = 0;

  1126 	

  1127 	// data for ExpectL

  1128 	TMockLtsyData1<TUint32> ltsyData( index );

  1129 	ltsyData.SerialiseL(dataExpect);

  1130 

  1131 	//-------------------------------------------------------------------------

  1132 	// Test A: Test timeout of RMobilePhone::DeleteAPNName

  1133  	//-------------------------------------------------------------------------

  1134 	iMockLTSY.ExpectL(EMobilePhoneDeleteAPNName, dataExpect);