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 CallBarring functional unit.

    15 // 

    16 //

    17 

    18 /**

    19  @internalTechnology

    20 */

    21 

    22 #include "cctsyintegrationtestcallbarring.h"

    23 #include "cctsyinidata.h"

    24 

    25 _LIT(KAltPassword, "0000");

    26 _LIT(KAltPassword2, "1234");

    27 _LIT(KAltPassword4, "1235");

    28 _LIT(KAltPassword5, "123");

    29 _LIT(KAltPasswordVoda, "1919");

    30 _LIT(KIncorrectPassword , "9999");

    31 

    32 static const TInt KSsCallBarringAllServices=330;

    33 

    34 

    35 CCTSYIntegrationTestCallBarringBase::CCTSYIntegrationTestCallBarringBase(CEtelSessionMgr& aEtelSessionMgr)

    36 	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), 

    37 		iSupplementalTsyTestHelper(*this),

    38 		iCallControlTsyTestHelper(*this),

    39 		iNetworkTsyTestHelper(*this)

    40 		

    41 /**

    42  * Constructor

    43  */

    44 	{

    45 	}

    46 

    47 CCTSYIntegrationTestCallBarringBase::~CCTSYIntegrationTestCallBarringBase()

    48 /*

    49  * Destructor

    50  */

    51 	{

    52 	}

    53 	

    54 /**

    55 * Checks that the call barring password for this SIM is known and leaves if not

    56 @param aPhone RMobilePhone session

    57 @param aPassword On completion, the call barring password. The function leaves if this is not found.

    58 */

    59 void CCTSYIntegrationTestCallBarringBase::CheckCBPasswordL( RMobilePhone &aPhone, RMobilePhone::TMobilePassword &aPassword )

    60 	{

    61 

    62 	DEBUG_PRINTF1(_L("Attempting to check call barring password is known"));

    63 	

    64 	// wait until we are on the network

    65 	

    66 	CHECK_EQUALS_L( iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL( aPhone ), KErrNone, 

    67 						_L("Network is unavailable") );

    68 			

    69 	const TDesC* networkSection = NULL;

    70 	iNetworkTsyTestHelper.GetNetworkPasswordsSectionL(aPhone,networkSection);

    71 	

    72 	// Get the password from the ini file

    73 	TPtrC password; 

    74 	TBool gotPass = GetStringFromConfig( *networkSection, KIniCallBarring1, password );

    75 	

    76 	CHECK_TRUE_L( gotPass, _L("Failed to read password from INI file"));

    77 	

    78 	// Check the call barring password by attempting to reset call barring for all services

    79 	DEBUG_PRINTF2(_L("Checking call barring password from INI file %S"), &password);

    80 	

    81 	aPassword = password;

    82 	TInt err = DeactivateCallBarringL( aPhone, aPassword );

    83 	CHECK_EQUALS_L( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

    84 	

    85 	}

    86 	

    87 	

    88 /**

    89 * Resest call barring for all services

    90 */

    91 TInt CCTSYIntegrationTestCallBarringBase::DeactivateCallBarringL( RMobilePhone &aPhone, 

    92 																	const RMobilePhone::TMobilePassword& aPassword )

    93 	{

    94 	RMobilePhone::TMobilePhoneCBChangeV1 cbInfo;

    95 	cbInfo.iAction = RMobilePhone::EServiceActionDeactivate;

    96 	cbInfo.iPassword = aPassword;

    97 	cbInfo.iServiceGroup = RMobilePhone::EAllServices;

    98 	

    99 	TExtEtelRequestStatus reqStatus(aPhone, EMobilePhoneSetCallBarringStatus);

   100 	CleanupStack::PushL(reqStatus);

   101 	

   102 	aPhone.SetCallBarringStatus( reqStatus, RMobilePhone::EBarAllCases, cbInfo );

   103 	TInt err = WaitForRequestWithTimeOut( reqStatus, ETimeMedium);

   104 	

   105 	if( KErrNone == err )

   106 		{

   107 		err = reqStatus.Int();

   108 		}

   109 		

   110 	CleanupStack::PopAndDestroy(1,&reqStatus);

   111 	

   112 	return err;

   113 	}

   114 		

   115 

   116 /** 

   117 * Set the call barring status

   118 */

   119 TInt CCTSYIntegrationTestCallBarringBase::SetCBStatusL( RMobilePhone& aPhone, 

   120 						RMobilePhone::TMobilePhoneCBChangeV1& aInfo,

   121 						RMobilePhone::TMobilePhoneCBCondition aCondition )

   122 	{

   123 	TExtEtelRequestStatus reqStatus(aPhone, EMobilePhoneSetCallBarringStatus);

   124 	CleanupStack::PushL(reqStatus);

   125 	

   126 	aPhone.SetCallBarringStatus( reqStatus, aCondition, aInfo );

   127 	

   128 	TInt err = WaitForRequestWithTimeOut( reqStatus, ETimeMedium);

   129 	

   130 	if( KErrNone == err )

   131 		{

   132 		err = reqStatus.Int();

   133 		}

   134 		

   135 	CleanupStack::PopAndDestroy(1);	

   136 

   137 	return err;		

   138 	}

   139 

   140 

   141 /** 

   142 * Search a status list for particular call barring entry

   143 */

   144 TBool CCTSYIntegrationTestCallBarringBase::SearchCBStatusListL( CMobilePhoneCBList* aList, 

   145 								RMobilePhone::TMobilePhoneCBCondition aCondition, 

   146 								RMobilePhone::TMobileService aService,

   147 								RMobilePhone::TMobilePhoneCBStatus aStatus )

   148 	{	

   149 	TInt count = aList->Enumerate();

   150 	

   151 	for( TInt i=0; i < count; i++ )

   152 		{

   153 		const RMobilePhone::TMobilePhoneCBInfoEntryV1 ele = aList->GetEntryL(i);

   154 		

   155 		if( ele.iCondition == aCondition && 

   156 			ele.iServiceGroup == aService && 

   157 			ele.iStatus == aStatus )

   158 			{

   159 			return ETrue;

   160 			}		

   161 		}

   162 		

   163 	DEBUG_PRINTF4( _L("Failed to find CMobilePhoneCBList entry condition=%d service=%d status=%d"), aCondition, aService, aStatus );

   164 	return EFalse;

   165 	}

   166 

   167 /******************************************************************************/

   168 	

   169 

   170 CCTSYIntegrationTestCallBarring0001::CCTSYIntegrationTestCallBarring0001(CEtelSessionMgr& aEtelSessionMgr)

   171 	: CCTSYIntegrationTestCallBarringBase(aEtelSessionMgr)

   172 /**

   173  * Constructor.

   174  */

   175 	{

   176 	SetTestStepName(CCTSYIntegrationTestCallBarring0001::GetTestStepName());

   177 	}

   178 

   179 CCTSYIntegrationTestCallBarring0001::~CCTSYIntegrationTestCallBarring0001()

   180 /**

   181  * Destructor.

   182  */

   183 	{

   184 	}

   185 

   186 TVerdict CCTSYIntegrationTestCallBarring0001::doTestStepL()

   187 /**

   188  * @SYMTestCaseID BA-CTSY-INT-CBAR-0001

   189  * @SYMFssID BA/CTSY/CBAR-0001

   190  * @SYMTestCaseDesc Activate and deactivate call barring for outgoing voice calls.

   191  * @SYMTestPriority High

   192  * @SYMTestActions RMobilePhone::NotifyCallBarringStatusChange, RMobilePhone::SetCallBarringStatus, RCall::Dial, RCall::HangUp

   193  * @SYMTestExpectedResults Pass - Call barring activated and barred numbers cannot be dialled.

   194  * @SYMTestType CIT

   195  * @SYMTestCaseDependencies live/automatic

   196  *

   197  * Reason for test: Verify call barring status and barred number cannot be dialled.

   198  *

   199  * @return - TVerdict code

   200  */

   201 	{

   202 

   203 	//

   204 	// SET UP

   205 	//

   206 	

   207 	RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   208 	RMobilePhone::TMobilePassword password;

   209 	CheckCBPasswordL( phone, password );

   210 

   211 	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of: KCapsNotifyCBStatus | KCapsSetCBStatus | KCapsBarAllOutgoing | KCapsBarOutgoingInternational | KCapsBarOutgoingInternationalExHC

   212 	TUint32 callBarCaps;

   213 	TInt err = phone.GetCallServiceCaps( callBarCaps );

   214 	CHECK_EQUALS_L(err, KErrNone, _L("RMobilePhone::GetCallServiceCaps returned error"));

   215 	CHECK_BITS_SET_L( callBarCaps, 	(RMobilePhone::KCapsNotifyCBStatus | 

   216 									 RMobilePhone::KCapsSetCBStatus | 

   217 									 RMobilePhone::KCapsBarAllOutgoing | 

   218 									 RMobilePhone::KCapsBarOutgoingInternational | 

   219 									 RMobilePhone::KCapsBarOutgoingInternationalExHC) ,

   220 								     KNoUnwantedBits,

   221 								     _L("GetCallServiceCaps returned unexpected bitmap"));	

   222 

   223 	// Set the call barring password to a known password using RMobilePhone::SetSSPassword 

   224 	RMobilePhone::TMobilePhonePasswordChangeV2 passwordV2;

   225 	RMobilePhone::TMobilePhonePasswordChangeV2Pckg passwordPkg(passwordV2);

   226 

   227 	// NOTE - we don't actually change the password for safety

   228 	passwordV2.iOldPassword = password;

   229 	passwordV2.iNewPassword = password;

   230 	passwordV2.iVerifiedPassword = password;

   231 

   232 	TExtEtelRequestStatus reqSetSSPasswordStatus(phone, EMobilePhoneSetSSPassword);

   233 	CleanupStack::PushL(reqSetSSPasswordStatus);

   234 	phone.SetSSPassword(reqSetSSPasswordStatus, passwordPkg, KSsCallBarringAllServices );

   235 	CHECK_EQUALS_L( WaitForRequestWithTimeOut( reqSetSSPasswordStatus, ETimeMedium), KErrNone, 

   236 						_L("RMobilePhone::SetSSPassword timed out") );	

   237 	CHECK_EQUALS_L( reqSetSSPasswordStatus.Int(), KErrNone, _L("RMobilePhone::SetSSPassword returned error"));

   238 

   239 	// Get voice line 1. 

   240 	RMobileLine& voiceLine = iEtelSessionMgr.GetLineL(KMainServer,KMainPhone, KVoiceLine);

   241 

   242 	// Get call 1. 

   243 	RMobileCall& call1 = iEtelSessionMgr.GetCallL(KMainServer,KMainPhone, KVoiceLine,KCall1 );	

   244 	

   245 	// Obtain our test call numbers

   246 	TPtrC intNumber; 

   247 	TBool numOK = GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumberInternational, intNumber);

   248 	CHECK_TRUE_L( numOK, _L("Failed to obtain international number for test") );

   249 	

   250 	TPtrC natNumberWithPrefix; 

   251 	numOK = GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumberIntExHC, natNumberWithPrefix);

   252 	CHECK_TRUE_L( numOK, _L("Failed to obtain prefixed national number for test") );

   253 	

   254 	

   255 	TPtrC natNumber; 

   256 	numOK = GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, natNumber);

   257 	CHECK_TRUE_L( numOK, _L("Failed to obtain national number for test") );

   258 	

   259 

   260 	//

   261 	// SET UP END

   262 	//

   263 	

   264 	StartTest();

   265 	

   266 	//

   267 	// TEST START

   268 	//

   269 		

   270 	

   271 	// ===  Activate call barring on voice calls to outgoing international numbers and check 

   272 	// international number cannot be dialled ===

   273 		

   274 	// Set up the notification request

   275 	TExtEtelRequestStatus cbStatusNotify( phone, EMobilePhoneNotifyCallBarringStatusChange );

   276 	CleanupStack::PushL(cbStatusNotify);

   277 	RMobilePhone::TMobilePhoneCBCondition notifiedCBCondition;

   278 	phone.NotifyCallBarringStatusChange( cbStatusNotify, notifiedCBCondition);

   279 		

   280 	// Activate call barring using RMobilePhone::SetCallBarringStatus with 

   281 	// aInfo.iAction=EServiceActionActivate, 

   282 	// aInfo.iPassword=correct call barring password, 

   283 	// aInfo.iServiceGroup=EVoiceService and 

   284 	// aCondition=EBarOutgoingInternational

   285 	RMobilePhone::TMobilePhoneCBChangeV1 cbInfo;

   286 	cbInfo.iAction = RMobilePhone::EServiceActionActivate;

   287 	cbInfo.iPassword = password;

   288 	cbInfo.iServiceGroup = RMobilePhone::EVoiceService;

   289 

   290 	RMobilePhone::TMobilePhoneCBCondition wantedCBCondition = RMobilePhone::EBarOutgoingInternational;

   291 	err = SetCBStatusL( phone, cbInfo, wantedCBCondition);

   292 	ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

   293 		

   294 	// Check RMobilePhone::NotifyCallBarringStatusChange completes with aCondition=EBarOutgoingInternational

   295 	iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallBarringStatusChange(phone, 

   296 												cbStatusNotify,

   297 												notifiedCBCondition,

   298 												wantedCBCondition,

   299 												KErrNone );													

   300 

   301 	ASSERT_EQUALS( notifiedCBCondition, wantedCBCondition,

   302 					_L("RMobilePhone::NotifyCallBarringStatusChange did not return matching condition") );

   303 

   304 	// Dial an international number. 

   305 	// Check this fails.

   306 	DEBUG_PRINTF2(_L("Barred international - Calling international %S should not be allowed"), &intNumber );

   307 

   308 	TExtEtelRequestStatus notifyMobileCallStatusChangeStatus(call1, EMobileCallNotifyMobileCallStatusChange);

   309 	CleanupStack::PushL(notifyMobileCallStatusChangeStatus);

   310 	RMobileCall::TMobileCallStatus mobileCallStatus;

   311 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   312 	

   313 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

   314 	TCoreEtelRequestStatus<RCall> dialStatus(call1, &RCall::DialCancel);

   315 	CleanupStack::PushL(dialStatus);

   316 	call1.Dial(dialStatus, intNumber);

   317 

   318 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDialling ->

   319 	DEBUG_PRINTF1(_L("Checking EStatusDialling") );

   320 	RMobileCall::TMobileCallStatus expectedMobileCallStatus = RMobileCall::EStatusDialling;

   321 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   322 																		notifyMobileCallStatusChangeStatus,

   323 																		mobileCallStatus,

   324 																		expectedMobileCallStatus,

   325 																		KErrNone);

   326 																		

   327 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDisconnecting.																		

   328 	DEBUG_PRINTF1(_L("Checking EStatusDisconnecting") );	

   329 	expectedMobileCallStatus = RMobileCall::EStatusDisconnecting;

   330 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   331 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   332 																		notifyMobileCallStatusChangeStatus,

   333 																		mobileCallStatus,

   334 																		expectedMobileCallStatus,

   335 																		KErrNone);

   336 	

   337 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusIdle.																		

   338 	DEBUG_PRINTF1(_L("Checking EStatusIdle") );	

   339 	expectedMobileCallStatus = RMobileCall::EStatusIdle;

   340 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   341 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   342 																		notifyMobileCallStatusChangeStatus,

   343 																		mobileCallStatus,

   344 																		expectedMobileCallStatus,

   345 																		KErrNone);

   346 	DEBUG_PRINTF1(_L("Dial status request") );	

   347 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

   348 		_L("RMobileCall::Dial timed-out"));

   349 	ASSERT_EQUALS(dialStatus.Int(), KErrGsmCCNormalUnspecified, 

   350 		_L("RMobileCall::Dial returned error") );

   351 	

   352 	// Precaution when expected no connection

   353 	DEBUG_PRINTF1(_L("Hanging up...") );	

   354 	call1.HangUp();		

   355 	

   356 	// ===  Deactivate call barring on voice calls to outgoing international numbers and check 

   357 	// international number can be dialled 

   358 	// ===

   359 	

   360 	// Deactivate call barring using RMobilePhone::SetCallBarringStatus with 

   361 	// aInfo.iAction=EServiceActionDeactivate, 

   362 	// aInfo.iPassword=correct call barring password, 

   363 	// aInfo.iServiceGroup=EVoiceService 

   364 	// and aCondition=EBarOutgoingInternational 

   365 

   366 	cbInfo.iAction = RMobilePhone::EServiceActionDeactivate;

   367 	wantedCBCondition = RMobilePhone::EBarOutgoingInternational;

   368 	

   369 	phone.NotifyCallBarringStatusChange( cbStatusNotify, notifiedCBCondition);

   370 		

   371 	err = SetCBStatusL( phone, cbInfo, wantedCBCondition);

   372 	ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

   373 	

   374 	// Check RMobilePhone::NotifyCallBarringStatusChange completes with aCondition=EBarOutgoingInternational

   375 	iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallBarringStatusChange(phone, 

   376 												cbStatusNotify,

   377 												notifiedCBCondition,

   378 												wantedCBCondition,

   379 												KErrNone );												

   380 												

   381 	ASSERT_EQUALS( notifiedCBCondition, wantedCBCondition,

   382 					_L("RMobilePhone::NotifyCallBarringStatusChange did not return matching condition") );

   383 		

   384 	

   385 	// Dial an international number that answers. 

   386 	DEBUG_PRINTF2(_L("Calling international %S should be allowed"), &intNumber );

   387 	

   388 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   389 	call1.Dial(dialStatus, intNumber ); 

   390 	

   391 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected.

   392 	expectedMobileCallStatus = RMobileCall::EStatusConnected;

   393 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

   394 														notifyMobileCallStatusChangeStatus, 

   395 														mobileCallStatus, 

   396 														RMobileCall::EStatusConnected, 

   397 														KErrNone );

   398 

   399 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

   400 			_L("RMobileCall::Dial timed-out"));

   401 	ASSERT_EQUALS(dialStatus.Int(), KErrNone, 

   402 			_L("RMobileCall::Dial returned an error") );

   403 

   404 	// Hang up

   405 	call1.NotifyMobileCallStatusChange( notifyMobileCallStatusChangeStatus, mobileCallStatus );

   406 	call1.HangUp();

   407 

   408 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

   409 	expectedMobileCallStatus = RMobileCall::EStatusIdle;

   410 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

   411 														notifyMobileCallStatusChangeStatus, 

   412 														mobileCallStatus, 

   413 														RMobileCall::EStatusIdle, 

   414 														KErrNone );

   415 														

   416 	ASSERT_EQUALS( mobileCallStatus, RMobileCall::EStatusIdle, _L("Call status is not EStatusIdle") );

   417 	

   418 	// ===  Activate call barring on voice calls to outgoing international numbers

   419 	// excluding home country and check national number with + prefix can be dialled 

   420 	// but international number in another country cannot be dialled 

   421 	// ===

   422 	

   423 	// Activate call barring using RMobilePhone::SetCallBarringStatus with 

   424 	// aInfo.iAction=EServiceActionActivate, 

   425 	// aInfo.iPassword=correct call barring password, 

   426 	// aInfo.iServiceGroup=EVoiceService and 

   427 	// aCondition=EBarOutgoingInternationalExHC 

   428 	

   429 	cbInfo.iAction = RMobilePhone::EServiceActionActivate;

   430 	wantedCBCondition = RMobilePhone::EBarOutgoingInternationalExHC;

   431 	

   432 	phone.NotifyCallBarringStatusChange( cbStatusNotify, notifiedCBCondition);

   433 	err = SetCBStatusL( phone, cbInfo, wantedCBCondition);

   434 	ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

   435 		

   436 	// Check RMobilePhone::NotifyCallBarringStatusChange completes with aCondition=EBarOutgoingInternationalExHC

   437 	iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallBarringStatusChange(phone, 

   438 													cbStatusNotify,

   439 													notifiedCBCondition,

   440 													RMobilePhone::EBarOutgoingInternationalExHC,

   441 													KErrNone );

   442 

   443 	// Dial a national number that answers specifying the number using + prefix. 

   444 	DEBUG_PRINTF1(_L("Barred international ExHC - Calling national with + prefix"));

   445 	

   446 	call1.NotifyMobileCallStatusChange( notifyMobileCallStatusChangeStatus, mobileCallStatus );

   447 	call1.Dial(dialStatus, natNumberWithPrefix ); 

   448 	

   449 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected.

   450 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

   451 														notifyMobileCallStatusChangeStatus, 

   452 														mobileCallStatus, 

   453 														RMobileCall::EStatusConnected, KErrNone );

   454 		

   455 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

   456 			_L("RMobileCall::Dial timed-out"));

   457 	ASSERT_EQUALS(dialStatus.Int(), KErrNone, 

   458 			_L("RMobileCall::Dial returned an error") );

   459 	

   460 	// Hang up. 

   461 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

   462 	call1.NotifyMobileCallStatusChange( notifyMobileCallStatusChangeStatus, mobileCallStatus );

   463 	call1.HangUp();

   464 

   465 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

   466 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

   467 														notifyMobileCallStatusChangeStatus, 

   468 														mobileCallStatus, 

   469 														RMobileCall::EStatusIdle, 

   470 														KErrNone );

   471 														

   472 	ASSERT_EQUALS( mobileCallStatus, RMobileCall::EStatusIdle, _L("RMobileCall::NotifyMobileCallStatusChange did not complete with EStatusIdle") );

   473 		

   474 	// Dial an international number in another country. 

   475 	// Check this fails.

   476 	DEBUG_PRINTF1(_L("Barred international ExHC- Calling international"));

   477 	

   478 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   479 	call1.Dial(dialStatus, intNumber); 

   480 	

   481 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDialling ->

   482 	DEBUG_PRINTF1(_L("Checking EStatusDialling") );

   483 	expectedMobileCallStatus = RMobileCall::EStatusDialling;

   484 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   485 																		notifyMobileCallStatusChangeStatus,

   486 																		mobileCallStatus,

   487 																		expectedMobileCallStatus,

   488 																		KErrNone);

   489 																		

   490 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusConnecting ->

   491 	DEBUG_PRINTF1(_L("Checking EStatusConnecting") );	

   492 	expectedMobileCallStatus = RMobileCall::EStatusConnecting;

   493 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   494 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   495 																		notifyMobileCallStatusChangeStatus,

   496 																		mobileCallStatus,

   497 																		expectedMobileCallStatus,

   498 																		KErrNone);

   499 

   500 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDisconnecting.																		

   501 	DEBUG_PRINTF1(_L("Checking EStatusDisconnecting") );	

   502 	expectedMobileCallStatus = RMobileCall::EStatusDisconnecting;

   503 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   504 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   505 																		notifyMobileCallStatusChangeStatus,

   506 																		mobileCallStatus,

   507 																		expectedMobileCallStatus,

   508 																		KErrNone);

   509 	

   510 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusIdle.																		

   511 	DEBUG_PRINTF1(_L("Checking EStatusIdle") );	

   512 	expectedMobileCallStatus = RMobileCall::EStatusIdle;

   513 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   514 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   515 																		notifyMobileCallStatusChangeStatus,

   516 																		mobileCallStatus,

   517 																		expectedMobileCallStatus,

   518 																		KErrNone);

   519 	

   520 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

   521 		_L("RMobileCall::Dial timed-out"));

   522 	ASSERT_EQUALS(dialStatus.Int(), KErrGsmCCNormalUnspecified, 

   523 		_L("RMobileCall::Dial returned error") );

   524 	

   525 	// Precaution when expected no connection

   526 	call1.HangUp();		

   527 	

   528 	// ===  Deactivate call barring on voice calls to outgoing international numbers excluding home country 

   529 	// and check national and international numbers in international format can be dialled 

   530 	// ===

   531 	

   532 	// Deactivate call barring using RMobilePhone::SetCallBarringStatus with 

   533 	// aInfo.iAction=EServiceActionDeactivate, 

   534 	// aInfo.iPassword=correct call barring password, 

   535 	// aInfo.iServiceGroup=EVoiceService and 

   536 	// aCondition=EBarOutgoingInternationalExHC 

   537 	cbInfo.iAction = RMobilePhone::EServiceActionDeactivate;

   538 	wantedCBCondition = RMobilePhone::EBarOutgoingInternationalExHC;

   539 	phone.NotifyCallBarringStatusChange( cbStatusNotify, notifiedCBCondition);

   540 		

   541 	err = SetCBStatusL( phone, cbInfo, wantedCBCondition);

   542 	ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

   543 	

   544 	// Check RMobilePhone::NotifyCallBarringStatusChange completes with aCondition=EBarOutgoingInternationalExHC

   545 	iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallBarringStatusChange(phone, 

   546 												cbStatusNotify,

   547 												notifiedCBCondition,

   548 												wantedCBCondition,

   549 												KErrNone );												

   550 												

   551 	ASSERT_EQUALS( notifiedCBCondition, wantedCBCondition,

   552 					_L("RMobilePhone::NotifyCallBarringStatusChange did not return matching condition") );

   553 		

   554 	// Dial a national number using + prefix. 

   555 	DEBUG_PRINTF1(_L("No barring - Calling national with + prefix"));

   556 

   557 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   558 	call1.Dial(dialStatus, natNumberWithPrefix ); 

   559 

   560 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected.

   561 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

   562 														notifyMobileCallStatusChangeStatus, 

   563 														mobileCallStatus, 

   564 														RMobileCall::EStatusConnected, 

   565 														KErrNone );

   566 	

   567 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

   568 			_L("RCall::Dial timed-out"));

   569 	ASSERT_EQUALS(dialStatus.Int(), KErrNone, 

   570 			_L("RCall::Dial returned error") );

   571 		

   572 	// Hang up. 

   573 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   574 	call1.HangUp();

   575 

   576 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

   577 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

   578 														notifyMobileCallStatusChangeStatus, 

   579 														mobileCallStatus, 

   580 														RMobileCall::EStatusIdle, 

   581 														KErrNone );

   582 														

   583 	ASSERT_EQUALS( mobileCallStatus, RMobileCall::EStatusIdle, _L("Call status is not EStatusIdle") );

   584 

   585 	// Dial an international number in another country. 

   586 	DEBUG_PRINTF1(_L("No barring - Calling international"));

   587 

   588 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   589 	call1.Dial(dialStatus, intNumber ); 

   590 	

   591 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected.

   592 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

   593 														notifyMobileCallStatusChangeStatus, 

   594 														mobileCallStatus, 

   595 														RMobileCall::EStatusConnected, 

   596 														KErrNone );

   597 	

   598 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

   599 			_L("RMobileCall::Dial timed-out"));

   600 	ASSERT_EQUALS(dialStatus.Int(), KErrNone, 

   601 			_L("RMobileCall::Dial returned an error") );

   602 	

   603 	// Hang up. 

   604 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

   605 	call1.NotifyMobileCallStatusChange( notifyMobileCallStatusChangeStatus, mobileCallStatus );

   606 	call1.HangUp();

   607 

   608 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

   609 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

   610 														notifyMobileCallStatusChangeStatus, 

   611 														mobileCallStatus,

   612 														RMobileCall::EStatusIdle, 

   613 														KErrNone );

   614 														

   615 	ASSERT_EQUALS( mobileCallStatus, RMobileCall::EStatusIdle, _L("Call status is not EStatusIdle") );

   616 

   617 	// ===  Activate call barring on voice calls to all outgoing numbers and check they cannot be dialled ===

   618 	// Activate call barring using RMobilePhone::SetCallBarringStatus with 

   619 	// aInfo.iAction=EServiceActionActivate, 

   620 	// aInfo.iPassword=correct call barring password, 

   621 	// aInfo.iServiceGroup=EVoiceService and 

   622 	// aCondition=EBarAllOutgoing 

   623 	cbInfo.iAction = RMobilePhone::EServiceActionActivate;	

   624 	wantedCBCondition = RMobilePhone::EBarAllOutgoing;

   625 	phone.NotifyCallBarringStatusChange( cbStatusNotify, notifiedCBCondition);

   626 	

   627 	err = SetCBStatusL( phone, cbInfo, wantedCBCondition);

   628 	ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

   629 	

   630 	// Check RMobilePhone::NotifyCallBarringStatusChange completes with aCondition=EBarAllOutgoing

   631 	iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallBarringStatusChange(phone, 

   632 												cbStatusNotify,

   633 												notifiedCBCondition,

   634 												wantedCBCondition,

   635 												KErrNone );												

   636 												

   637 	ASSERT_EQUALS( notifiedCBCondition, wantedCBCondition,

   638 					_L("RMobilePhone::NotifyCallBarringStatusChange did not return matching condition") );

   639 	

   640 	// Dial a national number. 

   641 	// Check this fails.

   642 	DEBUG_PRINTF1(_L("All calls barred - Calling national"));

   643 	

   644 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   645 	call1.Dial(dialStatus, natNumber); 

   646 

   647 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDialling ->

   648 	DEBUG_PRINTF1(_L("Checking EStatusDialling") );

   649 	expectedMobileCallStatus = RMobileCall::EStatusDialling;

   650 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   651 																		notifyMobileCallStatusChangeStatus,

   652 																		mobileCallStatus,

   653 																		expectedMobileCallStatus,

   654 																		KErrNone);

   655 																		

   656 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusConnecting ->

   657 	DEBUG_PRINTF1(_L("Checking EStatusConnecting") );	

   658 	expectedMobileCallStatus = RMobileCall::EStatusConnecting;

   659 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   660 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   661 																		notifyMobileCallStatusChangeStatus,

   662 																		mobileCallStatus,

   663 																		expectedMobileCallStatus,

   664 																		KErrNone);

   665 

   666 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDisconnecting.																		

   667 	DEBUG_PRINTF1(_L("Checking EStatusDisconnecting") );	

   668 	expectedMobileCallStatus = RMobileCall::EStatusDisconnecting;

   669 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   670 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   671 																		notifyMobileCallStatusChangeStatus,

   672 																		mobileCallStatus,

   673 																		expectedMobileCallStatus,

   674 																		KErrNone);

   675 	

   676 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusIdle.																		

   677 	DEBUG_PRINTF1(_L("Checking EStatusIdle") );	

   678 	expectedMobileCallStatus = RMobileCall::EStatusIdle;

   679 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   680 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   681 																		notifyMobileCallStatusChangeStatus,

   682 																		mobileCallStatus,

   683 																		expectedMobileCallStatus,

   684 																		KErrNone);

   685 	

   686 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

   687 		_L("RMobileCall::Dial timed-out"));

   688 	ASSERT_EQUALS(dialStatus.Int(), KErrGsmCCNormalUnspecified, 

   689 		_L("RMobileCall::Dial returned error") );

   690 

   691 	// Precaution when expected no connection

   692 	call1.HangUp();		

   693 		

   694 	// Dial an international number. 

   695 	// Check this fails.

   696 	DEBUG_PRINTF1(_L("All calls barred - Calling international"));

   697 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   698 	call1.Dial(dialStatus, intNumber); 

   699 	

   700 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDialling ->

   701 	DEBUG_PRINTF1(_L("Checking EStatusDialling") );

   702 	expectedMobileCallStatus = RMobileCall::EStatusDialling;

   703 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   704 																		notifyMobileCallStatusChangeStatus,

   705 																		mobileCallStatus,

   706 																		expectedMobileCallStatus,

   707 																		KErrNone);

   708 																		

   709 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusConnecting ->

   710 	DEBUG_PRINTF1(_L("Checking EStatusConnecting") );	

   711 	expectedMobileCallStatus = RMobileCall::EStatusConnecting;

   712 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   713 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   714 																		notifyMobileCallStatusChangeStatus,

   715 																		mobileCallStatus,

   716 																		expectedMobileCallStatus,

   717 																		KErrNone);

   718 

   719 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusDisconnecting.																		

   720 	DEBUG_PRINTF1(_L("Checking EStatusDisconnecting") );	

   721 	expectedMobileCallStatus = RMobileCall::EStatusDisconnecting;

   722 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   723 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   724 																		notifyMobileCallStatusChangeStatus,

   725 																		mobileCallStatus,

   726 																		expectedMobileCallStatus,

   727 																		KErrNone);

   728 	

   729 	// Check RMobileLine::NotifyMobileLineStatusChange completes with with EStatusIdle.																		

   730 	DEBUG_PRINTF1(_L("Checking EStatusIdle") );	

   731 	expectedMobileCallStatus = RMobileCall::EStatusIdle;

   732 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   733 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(call1,

   734 																		notifyMobileCallStatusChangeStatus,

   735 																		mobileCallStatus,

   736 																		expectedMobileCallStatus,

   737 																		KErrNone);

   738 	

   739 	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, 

   740 		_L("RMobileCall::Dial timed-out"));

   741 	ASSERT_EQUALS(dialStatus.Int(), KErrGsmCCNormalUnspecified, 

   742 		_L("RMobileCall::Dial returned error") );

   743 	

   744 	// Precaution when expected no connection

   745 	call1.HangUp();		

   746 	

   747 	// ===  Deactivate call barring on voice calls to all outgoing numbers and check national and 

   748 	// international numbers can be dialled ===

   749 

   750 	// Deactivate call barring using RMobilePhone::SetCallBarringStatus with 

   751 	// aInfo.iAction=EServiceActionDeactivate, 

   752 	// aInfo.iPassword=correct call barring password, 

   753 	// aInfo.iServiceGroup=EVoiceService and 

   754 	// aCondition=EBarAllOutgoing 

   755 	cbInfo.iAction = RMobilePhone::EServiceActionDeactivate;	

   756 	wantedCBCondition = RMobilePhone::EBarAllOutgoing;

   757 	

   758 	phone.NotifyCallBarringStatusChange( cbStatusNotify, notifiedCBCondition);

   759 		

   760 	err = SetCBStatusL( phone, cbInfo, wantedCBCondition);

   761 	ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

   762 	

   763 	// Check RMobilePhone::NotifyCallBarringStatusChange completes with aCondition=EBarAllOutgoing

   764 	iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallBarringStatusChange(phone, 

   765 												cbStatusNotify,

   766 												notifiedCBCondition,

   767 												wantedCBCondition,

   768 												KErrNone );												

   769 												

   770 	ASSERT_EQUALS( notifiedCBCondition, wantedCBCondition,

   771 					_L("RMobilePhone::NotifyCallBarringStatusChange did not return matching condition") );

   772 

   773 	// Dial a national number that answers. 

   774 	DEBUG_PRINTF1(_L("No call barring - Calling national"));

   775 

   776 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   777 	call1.Dial(dialStatus, natNumber ); 

   778 

   779 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected.

   780 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

   781 													notifyMobileCallStatusChangeStatus, 

   782 													mobileCallStatus, 

   783 													RMobileCall::EStatusConnected, 

   784 													KErrNone );

   785 	// Hang up. 

   786 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

   787 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   788 	call1.HangUp();

   789 

   790 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

   791 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

   792 													notifyMobileCallStatusChangeStatus, 

   793 													mobileCallStatus, 

   794 													RMobileCall::EStatusIdle, 

   795 													KErrNone );

   796 														

   797 	ASSERT_EQUALS( mobileCallStatus, RMobileCall::EStatusIdle, _L("RMobileCall::NotifyMobileCallStatusChange did not complete with EStatusIdle") );

   798 

   799 	// Dial an international number that answers. 

   800 	DEBUG_PRINTF1(_L("No call barring - Calling international"));		

   801 	

   802 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   803 	call1.Dial(dialStatus, intNumber ); 

   804 	

   805 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusConnected.

   806 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

   807 													notifyMobileCallStatusChangeStatus, 

   808 													mobileCallStatus, 

   809 													RMobileCall::EStatusConnected, 

   810 													KErrNone );

   811 

   812 	// Hang up. 

   813 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

   814 	DEBUG_PRINTF1(_L("Hanging up"));		

   815 	call1.NotifyMobileCallStatusChange(notifyMobileCallStatusChangeStatus, mobileCallStatus);

   816 	call1.HangUp();

   817 

   818 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

   819 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( call1, 

   820 													notifyMobileCallStatusChangeStatus, 

   821 													mobileCallStatus, 

   822 													RMobileCall::EStatusIdle, 

   823 													KErrNone );

   824 														

   825 	ASSERT_EQUALS( mobileCallStatus, RMobileCall::EStatusIdle, _L("Call status is not EStatusIdle") );

   826 	

   827 	//

   828 	// TEST END

   829 	//

   830 

   831     StartCleanup();

   832 	// reqSetCBStatus

   833 	// dialStatus

   834 	// cbStatusNotify

   835 	// reqSetSSPasswordStatus

   836 	CleanupStack::PopAndDestroy(4, &reqSetSSPasswordStatus);

   837 	

   838 	return TestStepResult();

   839 	}

   840 

   841 TPtrC CCTSYIntegrationTestCallBarring0001::GetTestStepName()

   842 /**

   843  * @return The test step name.

   844  */

   845 	{

   846 	return _L("CCTSYIntegrationTestCallBarring0001");

   847 	}

   848 

   849 

   850 

   851 CCTSYIntegrationTestCallBarring0002::CCTSYIntegrationTestCallBarring0002(CEtelSessionMgr& aEtelSessionMgr)

   852 	: CCTSYIntegrationTestCallBarringBase(aEtelSessionMgr)

   853 /**

   854  * Constructor.

   855  */

   856 	{

   857 	SetTestStepName(CCTSYIntegrationTestCallBarring0002::GetTestStepName());

   858 	}

   859 

   860 CCTSYIntegrationTestCallBarring0002::~CCTSYIntegrationTestCallBarring0002()

   861 /**

   862  * Destructor.

   863  */

   864 	{

   865 	}

   866 

   867 TVerdict CCTSYIntegrationTestCallBarring0002::doTestStepL()

   868 /**

   869  * @SYMTestCaseID BA-CTSY-INT-CBAR-0002

   870  * @SYMFssID BA/CTSY/CBAR-0002

   871  * @SYMTestCaseDesc Activate and deactivate call barring for incoming voice calls.

   872  * @SYMTestPriority High

   873  * @SYMTestActions RCall::AnswerIncomingCall, RMobilePhone::NotifyCallBarringStatusChange, RMobilePhone::SetCallBarringStatus, RLine::NotifyIncomingCall, RCall::HangUp

   874  * @SYMTestExpectedResults Pass - Incoming call barring is activated.

   875  * @SYMTestType CIT

   876  * @SYMTestCaseDependencies live/manual

   877  *

   878  * Reason for test: Verify call barring status and barred incoming call are not received.

   879  *

   880  * @return - TVerdict code

   881  */

   882 	{

   883 

   884 	//

   885 	// SET UP

   886 	//

   887 	RMobilePhone &phone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

   888 

   889 	//Check just to ensure the passwords are OK from the INI file

   890 	RMobilePhone::TMobilePassword password;

   891 	CheckCBPasswordL( phone, password );

   892 

   893 	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of: 

   894 	// KCapsNotifyCBStatus | KCapsSetCBStatus | KCapsBarAllIncoming  

   895 	TUint32 callServiceCaps;

   896 	TInt err=phone.GetCallServiceCaps(callServiceCaps);

   897 	CHECK_EQUALS_L(err, KErrNone, _L("RMobilePhone::GetCallServiceCaps returned error"));

   898 	CHECK_BITS_SET_L(callServiceCaps, (RMobilePhone::KCapsNotifyCBStatus | 

   899 									  RMobilePhone::KCapsSetCBStatus | 

   900 									  RMobilePhone::KCapsBarAllIncoming),

   901 									  KNoUnwantedBits, 

   902 									  _L("RMobilePhone::GetCallServiceCaps returned with incorrect bitmask"));

   903 	

   904 	// Set the call barring password to a known password using RMobilePhone::SetSSPassword 

   905 	RMobilePhone::TMobilePhonePasswordChangeV2 passwordV2;

   906 	RMobilePhone::TMobilePhonePasswordChangeV2Pckg passwordPkg(passwordV2);

   907 	passwordV2.iOldPassword = password;

   908 	passwordV2.iNewPassword = password;

   909 	passwordV2.iVerifiedPassword = password;

   910 	

   911 	TExtEtelRequestStatus setPasswordStatus(phone, EMobilePhoneSetSSPassword);

   912 	CleanupStack::PushL(setPasswordStatus);

   913 	phone.SetSSPassword(setPasswordStatus, passwordPkg, KSsCallBarringAllServices);

   914 	CHECK_EQUALS_L( WaitForRequestWithTimeOut( setPasswordStatus, ETimeMedium), KErrNone, 

   915 			_L("RMobilePhone::SetSSPassword timed out") );	

   916 	CHECK_EQUALS_L( setPasswordStatus.Int(), KErrNone, _L("RMobilePhone::SetSSPassword returned error"));

   917 		

   918 	// Get voice line 1. 

   919 	RMobileLine &mobileLine = iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine );	

   920 	

   921 	// Get call 1. 

   922 	RMobileCall &mobileCall1 = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);

   923 

   924 	//

   925 	// SET UP END

   926 	//

   927 	

   928 	StartTest();

   929 	

   930 	//

   931 	// TEST START

   932 	//

   933 	

   934 	

   935 	// ===  Activate call barring on incoming voice calls and check incoming call is not received ===

   936 	TExtEtelRequestStatus cbStatusNotify( phone, EMobilePhoneNotifyCallBarringStatusChange );

   937 	CleanupStack::PushL(cbStatusNotify);

   938 	RMobilePhone::TMobilePhoneCBCondition notifiedCBCondition;

   939 	phone.NotifyCallBarringStatusChange( cbStatusNotify, notifiedCBCondition);

   940 		

   941 	/* Activate call barring using RMobilePhone::SetCallBarringStatus with 

   942 		aInfo.iAction=EServiceActionActivate, 

   943 		aInfo.iPassword=correct call barring password, 

   944 		aInfo.iServiceGroup=EVoiceService and 

   945 		aCondition=EBarAllIncoming 	*/

   946 	RMobilePhone::TMobilePhoneCBChangeV1 cbInfo;

   947 	cbInfo.iAction = RMobilePhone::EServiceActionActivate;

   948 	cbInfo.iPassword = password;

   949 	cbInfo.iServiceGroup = RMobilePhone::EVoiceService;

   950 	RMobilePhone::TMobilePhoneCBCondition wantedCBCondition = RMobilePhone::EBarAllIncoming;

   951 	err = SetCBStatusL( phone, cbInfo, wantedCBCondition);

   952 	ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

   953 		

   954 	// Check RMobilePhone::NotifyCallBarringStatusChange completes with aCondition=EBarAllIncoming

   955 	iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallBarringStatusChange(phone, 

   956 			cbStatusNotify,

   957 			notifiedCBCondition,

   958 			wantedCBCondition,

   959 			KErrNone );													

   960 

   961 	ASSERT_EQUALS( notifiedCBCondition, wantedCBCondition,

   962 			_L("RMobilePhone::NotifyCallBarringStatusChange did not return matching condition") );

   963 

   964 	// Request incoming call from RPS. 

   965 	TCoreEtelRequestStatus<RLine> notifyIncomingCallStatus( mobileLine, &RLine::NotifyIncomingCallCancel );

   966 	CleanupStack::PushL( notifyIncomingCallStatus );

   967 	TName mobileCallName;

   968 	mobileLine.NotifyIncomingCall( notifyIncomingCallStatus, mobileCallName);

   969 	ASSERT_EQUALS(RPSRequestIncomingCallL(EVoiceLine), KErrNone, _L("RPSRequestIncomingCallL return code is not KErrNone"));

   970 	

   971 	// Check RPS dialling fails.

   972 	ASSERT_EQUALS(WaitForRequestWithTimeOut(notifyIncomingCallStatus,ETimeMedium),KErrTimedOut,

   973 		_L("RLine::NotifyIncomingCall did not time out"));

   974 			

   975 	// ===  Deactivate call barring on incoming voice calls and check incoming call is received ===

   976 	DEBUG_PRINTF1(_L("Deactivating call barring on incoming voice calls"));		

   977 	phone.NotifyCallBarringStatusChange( cbStatusNotify, notifiedCBCondition);

   978 	

   979 	cbInfo.iAction = RMobilePhone::EServiceActionDeactivate;

   980 	wantedCBCondition = RMobilePhone::EBarAllIncoming;

   981 	err = SetCBStatusL( phone, cbInfo, wantedCBCondition);

   982 	ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::SetCallBarringStatus returned error"));

   983 	

   984 	// Check RMobilePhone::NotifyCallBarringStatusChange completes with aCondition=EBarAllIncoming

   985 	iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallBarringStatusChange(phone, 

   986 											cbStatusNotify,

   987 											notifiedCBCondition,

   988 											wantedCBCondition,

   989 											KErrNone );													

   990 

   991 	ASSERT_EQUALS( notifiedCBCondition, wantedCBCondition,

   992 				_L("RMobilePhone::NotifyCallBarringStatusChange did not return matching condition") );

   993 

   994 	// Request an incoming call from RPS. 

   995 	mobileLine.NotifyIncomingCall( notifyIncomingCallStatus, mobileCallName );

   996 

   997 	TExtEtelRequestStatus notifyMobileCallStatusChangeStatus(mobileCall1, EMobileCallNotifyMobileCallStatusChange);

   998 	CleanupStack::PushL(notifyMobileCallStatusChangeStatus);

   999 	RMobileCall::TMobileCallStatus mobileCallStatus;

  1000 	

  1001 	ASSERT_EQUALS(RPSRequestIncomingCallL(EVoiceLine), KErrNone, _L("RPSRequestIncomingCallL return code is not KErrNone"));

  1002 	

  1003 	// Check RLine::NotifyIncomingCall completes.

  1004 	DEBUG_PRINTF1(_L("Waiting for incoming call notification."));	

  1005 	TName expectedMobileName = _L("Voice11");

  1006 	iCallControlTsyTestHelper.WaitForLineNotifyIncomingCall(mobileLine,

  1007 												notifyIncomingCallStatus,

  1008 												mobileCallName,

  1009 												expectedMobileName,	

  1010 												KErrNone);

  1011 	

  1012 	// Answer the incoming call

  1013 	DEBUG_PRINTF1(_L("About to answer the incoming call."));

  1014 	TCallId incomingCallId;

  1015 	RMobileCall& incomingMobileCall = iEtelSessionMgr.GetIncomingCallL(KMainServer, KMainPhone, KVoiceLine, mobileCallName, incomingCallId);

  1016 		

  1017 	TCoreEtelRequestStatus<RCall> incomingCallStatus( incomingMobileCall, &RCall::AnswerIncomingCallCancel );

  1018 	CleanupStack::PushL( incomingCallStatus );

  1019 	incomingMobileCall.AnswerIncomingCall( incomingCallStatus );

  1020 	ASSERT_EQUALS(WaitForRequestWithTimeOut(incomingCallStatus, ETimeMedium), KErrNone, 

  1021 		_L("RMobileCall::AnswerIncomingCall timed-out"));

  1022 	ASSERT_EQUALS(incomingCallStatus.Int(), KErrNone, 

  1023 		_L("RMobileCall::AnswerIncomingCall returned an error") );

  1024 	

  1025 	// Hang up. 

  1026 	DEBUG_PRINTF1(_L("Hanging up call."));		

  1027 	incomingMobileCall.NotifyMobileCallStatusChange( notifyMobileCallStatusChangeStatus, mobileCallStatus );

  1028 	incomingMobileCall.HangUp();

  1029 

  1030 	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusIdle.

  1031 	iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange( incomingMobileCall, 

  1032 														notifyMobileCallStatusChangeStatus, 

  1033 														mobileCallStatus, 

  1034 														RMobileCall::EStatusIdle, 

  1035 														KErrNone );

  1036 														

  1037 	ASSERT_EQUALS( mobileCallStatus, RMobileCall::EStatusIdle, _L("Call status is not EStatusIdle") );

  1038 

  1039 	//

  1040 	// TEST END

  1041 	//

  1042 

  1043     StartCleanup();

  1044 	

  1045 	/* setPasswordStatus

  1046 	 * cbStatusNotify 

  1047 	 * notifyIncomingCallStatus

  1048 	 * notifyMobileCallStatusChangeStatus

  1049 	 * incomingCallStatus*/

  1050     CleanupStack::PopAndDestroy(5, &setPasswordStatus);

  1051 

  1052     return TestStepResult();

  1053 	}

  1054 

  1055 TPtrC CCTSYIntegrationTestCallBarring0002::GetTestStepName()

  1056 /**

  1057  * @return The test step name.

  1058  */

  1059 	{

  1060 	return _L("CCTSYIntegrationTestCallBarring0002");

  1061 	}

  1062 

  1063 

  1064 

  1065 CCTSYIntegrationTestCallBarring0003::CCTSYIntegrationTestCallBarring0003(CEtelSessionMgr& aEtelSessionMgr)

  1066 	: CCTSYIntegrationTestCallBarringBase(aEtelSessionMgr)

  1067 /**

  1068  * Constructor.

  1069  */

  1070 	{

  1071 	SetTestStepName(CCTSYIntegrationTestCallBarring0003::GetTestStepName());

  1072 	}

  1073 

  1074 CCTSYIntegrationTestCallBarring0003::~CCTSYIntegrationTestCallBarring0003()

  1075 /**

  1076  * Destructor.

  1077  */

  1078 	{

  1079 	}

  1080 

  1081 TVerdict CCTSYIntegrationTestCallBarring0003::doTestStepL()

  1082 /**

  1083  * @SYMTestCaseID BA-CTSY-INT-CBAR-0003

  1084  * @SYMFssID BA/CTSY/CBAR-0003

  1085  * @SYMTestCaseDesc Activate and deactivate, and register and erase call barring for incoming voice calls when roaming.

  1086  * @SYMTestPriority High

  1087  * @SYMTestActions RCall::AnswerIncomingCall, RMobilePhone::NotifyCallBarringStatusChange, RMobilePhone::SetCallBarringStatus, RLine::NotifyIncomingCall, RCall::HangUp

  1088  * @SYMTestExpectedResults Pass - Incoming call barring whilst roaming is activated.

  1089  * @SYMTestType CIT

  1090  * @SYMTestCaseDependencies live/manual

  1091  *

  1092  * Reason for test: Verify call barring status and barred numbers cannot be dialled.

  1093  *

  1094  * @return - TVerdict code

  1095  */

  1096 	{

  1097 

  1098 	//

  1099 	// SET UP

  1100 	//

  1101 

  1102 	RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

  1103 	RMobilePhone::TMobilePassword password;

  1104 	CheckCBPasswordL(phone, password);

  1105 

  1106 	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of: 

  1107 	// KCapsNotifyCBStatus | KCapsSetCBStatus | KCapsBarIncomingRoaming 

  1108 	TUint32 callServiceCaps;

  1109 	TUint32 expectedCallServiceCaps = RMobilePhone::KCapsNotifyCBStatus | RMobilePhone::KCapsSetCBStatus | RMobilePhone::KCapsBarIncomingRoaming;

  1110 	CHECK_EQUALS_L(phone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps returned error"));

  1111 	CHECK_BITS_SET_L(callServiceCaps, expectedCallServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));

  1112 

  1113 	// Set the call barring password to a known password using RMobilePhone::SetSSPassword 

  1114 	RMobilePhone::TMobilePhonePasswordChangeV2 passwordV2;

  1115 	RMobilePhone::TMobilePhonePasswordChangeV2Pckg passwordPkg(passwordV2);

  1116 

  1117 	// For safety we are going to change the password and then immediately change it back

  1118 	passwordV2.iOldPassword = password;

  1119 	passwordV2.iNewPassword = KAltPassword;

  1120 	passwordV2.iVerifiedPassword = KAltPassword;

  1121 

  1122 	TExtEtelRequestStatus reqSetSSPasswordStatus(phone, EMobilePhoneSetSSPassword);

  1123 	CleanupStack::PushL(reqSetSSPasswordStatus);

  1124 	

  1125 	phone.SetSSPassword(reqSetSSPasswordStatus, passwordPkg, KSsCallBarringAllServices);

  1126 	CHECK_EQUALS_L( WaitForRequestWithTimeOut(reqSetSSPasswordStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SetSSPassword timed out"));

  1127 	CHECK_EQUALS_L( reqSetSSPasswordStatus.Int(), KErrNone, _L("RMobilePhone::SetSSPassword returned error"));

  1128 	

  1129 	// Succeeded in changing the password, reset

  1130 	passwordV2.iOldPassword = KAltPassword;

  1131 	passwordV2.iNewPassword = password;

  1132 	passwordV2.iVerifiedPassword = password;

  1133 

  1134 	phone.SetSSPassword(reqSetSSPasswordStatus, passwordPkg, KSsCallBarringAllServices);