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

    15 // 

    16 //

    17 

    18 /**

    19  @internalTechnology

    20 */

    21 

    22 #include "cctsyintegrationtestcallforwarding.h"

    23 

    24 #include "cctsyinidata.h"

    25 

    26 #include "listretrievalhelpers.h"

    27 

    28 

    29 CCTSYIntegrationTestCallForwardingBase::CCTSYIntegrationTestCallForwardingBase(CEtelSessionMgr& aEtelSessionMgr)

    30 	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), iCallForwardingSupplementalHelper(*this), iCallForwardingControlHelper(*this), iNetworkTestHelper(*this)

    31 /**

    32  * Constructor

    33  */

    34 	{

    35 	}

    36 

    37 CCTSYIntegrationTestCallForwardingBase::~CCTSYIntegrationTestCallForwardingBase()

    38 /*

    39  * Destructor

    40  */

    41 	{

    42 	}

    43 

    44 TBool CCTSYIntegrationTestCallForwardingBase::SetCallForwardingStatusUtilL(RMobilePhone& aMobilePhone, RMobilePhone::TMobilePhoneCFChangeV1 aNewSetting, RMobilePhone::TMobilePhoneCFCondition aCFConditionSet, TInt aExpected=KErrNone)

    45 /**

    46  * Util function which performs a SetCallForwardingStatus operation and relevant

    47  * checks using the arguments passed.

    48  *

    49  * @param aMobilePhone Mobile phone

    50  * @param aNewSetting The new setting to be set

    51  * @param aCFConditionSet The call forwarding condition.

    52  * @param aExpected A expect value for the status

    53  * @return TBool which represents whether cfCondition==aCFConditionSet

    54  */

    55 	{

    56 	// Post notification for RMobilePhone::NotifyCallForwardingStatusChange

    57 

    58 	TExtEtelRequestStatus notifyCallForwardStatus(aMobilePhone, EMobilePhoneNotifyCallForwardingStatusChange);

    59 	RMobilePhone::TMobilePhoneCFCondition cfCondition;

    60 	CleanupStack::PushL(notifyCallForwardStatus);

    61 	

    62 	if(aExpected==KErrNone)

    63 		{

    64 		aMobilePhone.NotifyCallForwardingStatusChange(notifyCallForwardStatus, cfCondition);	

    65 		}

    66 	

    67 	TExtEtelRequestStatus setCallForwardStatus(aMobilePhone, EMobilePhoneSetCallForwardingStatus);

    68 	CleanupStack::PushL(setCallForwardStatus);

    69 	aMobilePhone.SetCallForwardingStatus(setCallForwardStatus, aCFConditionSet, aNewSetting);

    70 	

    71 	ASSERT_EQUALS(WaitForRequestWithTimeOut(setCallForwardStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SetCallForwardingStatus timed-out"));

    72 	ASSERT_EQUALS(setCallForwardStatus.Int(), aExpected, _L("RMobilePhone::SetCallForwardingStatus setCallForwardStatus completed with incorrect error"));

    73 	

    74 	// Check RMobilePhone::NotifyCallForwardingStatusChange completes with cfcondition==aCFConditionSet

    75 	if(aExpected==KErrNone)

    76 		{

    77 		iCallForwardingSupplementalHelper.WaitForMobilePhoneNotifyCallForwardingStatusChange(aMobilePhone,

    78 																						 notifyCallForwardStatus,

    79 																						 cfCondition,

    80 																						 aCFConditionSet,

    81 																					 	 KErrNone);	

    82 		}

    83 		CleanupStack::PopAndDestroy(&setCallForwardStatus);

    84 		CleanupStack::PopAndDestroy(&notifyCallForwardStatus);

    85 	

    86 	if(aExpected==KErrNone)

    87 		{	

    88 		return cfCondition==aCFConditionSet;

    89 		}

    90 	else

    91 		{

    92 		return ETrue;

    93 		}	

    94 	}

    95 

    96 CCTSYIntegrationTestCallForwarding0001::CCTSYIntegrationTestCallForwarding0001(CEtelSessionMgr& aEtelSessionMgr)

    97 	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)

    98 /**

    99  * Constructor.

   100  */

   101 	{

   102 	SetTestStepName(CCTSYIntegrationTestCallForwarding0001::GetTestStepName());

   103 	}

   104 

   105 CCTSYIntegrationTestCallForwarding0001::~CCTSYIntegrationTestCallForwarding0001()

   106 /**

   107  * Destructor.

   108  */

   109 	{

   110 	}

   111 

   112 TVerdict CCTSYIntegrationTestCallForwarding0001::doTestStepL()

   113 /**

   114  * @SYMTestCaseID BA-CTSY-INT-CFOR-0001

   115  * @SYMFssID BA/CTSY/CFOR-0001

   116  * @SYMTestCaseDesc Register call forwarding for all services.

   117  * @SYMTestPriority High

   118  * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange

   119  * @SYMTestExpectedResults Pass - Call forwarding is registered for all services with each condition.

   120  * @SYMTestType CIT

   121  * @SYMTestCaseDependencies live/automatic

   122  *

   123  * Reason for test: Verify call forwarding is registered and call forwarding notification completes.

   124  *

   125  * @return - TVerdict code

   126  */

   127 	{

   128 

   129 	//

   130 	// SET UP

   131 	//

   132 

   133 	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 

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

   135 	TUint32 callServiceCaps = 0;

   136 	

   137 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

   138 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   139 	

   140 	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));

   141 	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;

   142 	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));

   143 

   144 	TPtrC number; 

   145 	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));

   146 	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);

   147 	

   148 	// Ensure all call forwarding is erased by calling 

   149 

   150 	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 

   151 

   152 	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices 

   153 	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;

   154 	newSetting.iServiceGroup=RMobilePhone::EAllServices;

   155 	newSetting.iAction=RMobilePhone::EServiceActionErase;

   156 	newSetting.iTimeout=-1;

   157 	

   158 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));

   159 	CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));

   160 

   161 	//

   162 	// SET UP END

   163 	//

   164 	

   165 	StartTest();

   166 	

   167 	//

   168 	// TEST START

   169 	//

   170 	

   171 	RMobilePhone::TMobilePhoneNetworkInfoV1 info;

   172 	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);

   173 	RMobilePhone::TMobilePhoneLocationAreaV1 area;

   174 	TOperatorName operatorName = EOperatorUnknown;

   175 	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	

   176 	ASSERT_EQUALS(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));

   177 	

   178 	// ===  Register call forwarding and check notification completes ===

   179 

   180 	// RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionRegister,  aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 

   181 	

   182 	// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingUnconditional

   183 	newSetting.iServiceGroup=RMobilePhone::EVoiceService;

   184 	newSetting.iAction=RMobilePhone::EServiceActionRegister;

   185 	newSetting.iNumber.iTelNumber=number;

   186 	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;

   187 	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;

   188 	newSetting.iTimeout=-1;

   189 

   190 	// $CTSYProblem The status returned from SetCallForwardingStatus does not return KErrNone.

   191 	// Instead the status varies depending on what iAction is requested. It is presumed that this is CTSY problem.

   192 	// Have had to change the test to expect the current retrieved value. 

   193 	// The error codes are being returned by the LTSY and the CTSY is propagating them back to the client correctly

   194 	// therefore these error codes do not indicate an error in the CTSY but rather that the LTSY / network is not supporting the requested operation. 

   195 	if(operatorName==EOperatorVodafone)

   196 		{

   197 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAllServices"));

   198 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAllServices failed"));

   199 	

   200 		// Repeat whole test with aCondition in RMobilePhone::SetCallForwardingStatus and RMobilePhone::NotifyCallForwardingStatusChange =ECallForwardingBusy, ECallForwardingNoReply, ECallForwardingNotReachable, ECallForwardingAllConditionalCases 

   201 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingBusy for EAllServices"));

   202 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingBusy for EAllServices failed"));

   203 	

   204 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingNoReply for EAllServices"));

   205 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNoReply, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingNoReply for EAllServices failed"));

   206 	

   207 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingNotReachable for EAllServices"));

   208 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNotReachable, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingNotReachable for EAllServices failed"));

   209 	

   210 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingAllConditionalCases for EAllServices"));

   211 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllConditionalCases, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingAllConditionalCases for EAllServices failed"));

   212 		}

   213 	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)

   214 		{

   215 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAllServices"));

   216 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAllServices failed"));

   217 	

   218 		// Repeat whole test with aCondition in RMobilePhone::SetCallForwardingStatus and RMobilePhone::NotifyCallForwardingStatusChange =ECallForwardingBusy, ECallForwardingNoReply, ECallForwardingNotReachable, ECallForwardingAllConditionalCases 

   219 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingBusy for EAllServices"));

   220 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy, KErrGsmSSIncompatibility), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingBusy for EAllServices failed"));

   221 	

   222 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingNoReply for EAllServices"));

   223 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNoReply, KErrGsmSSIncompatibility), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingNoReply for EAllServices failed"));

   224 	

   225 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingNotReachable for EAllServices"));

   226 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNotReachable, KErrGsmSSIncompatibility), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingNotReachable for EAllServices failed"));

   227 	

   228 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingAllConditionalCases for EAllServices"));

   229 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllConditionalCases, KErrGsmSSIncompatibility), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingAllConditionalCases for EAllServices failed"));	

   230 		}

   231 	else

   232 		{	

   233 		ASSERT_EQUALS(1,0,_L("Failed to identify current network"));

   234 		TEST_CHECK_POINT_L(_L("Failed to identify current network."));

   235 		}

   236 	

   237 	//

   238 	// TEST END

   239 	//

   240 

   241     StartCleanup();

   242 	

   243 	// Ensure all call forwarding setting are erased

   244 	newSetting.iServiceGroup=RMobilePhone::EAllServices;

   245 	newSetting.iAction=RMobilePhone::EServiceActionErase;

   246 	

   247 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));

   248 	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));

   249 	

   250 	return TestStepResult();

   251 	}

   252 

   253 TPtrC CCTSYIntegrationTestCallForwarding0001::GetTestStepName()

   254 /**

   255  * @return The test step name.

   256  */

   257 	{

   258 	return _L("CCTSYIntegrationTestCallForwarding0001");

   259 	}

   260 

   261 

   262 

   263 CCTSYIntegrationTestCallForwarding0002::CCTSYIntegrationTestCallForwarding0002(CEtelSessionMgr& aEtelSessionMgr)

   264 	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)

   265 /**

   266  * Constructor.

   267  */

   268 	{

   269 	SetTestStepName(CCTSYIntegrationTestCallForwarding0002::GetTestStepName());

   270 	}

   271 

   272 CCTSYIntegrationTestCallForwarding0002::~CCTSYIntegrationTestCallForwarding0002()

   273 /**

   274  * Destructor.

   275  */

   276 	{

   277 	}

   278 

   279 TVerdict CCTSYIntegrationTestCallForwarding0002::doTestStepL()

   280 /**

   281  * @SYMTestCaseID BA-CTSY-INT-CFOR-0002

   282  * @SYMFssID BA/CTSY/CFOR-0002

   283  * @SYMTestCaseDesc Register call forwarding for each provisioned basic service.

   284  * @SYMTestPriority High

   285  * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange

   286  * @SYMTestExpectedResults Pass - Call forwarding is registered for each provisioned basic service.

   287  * @SYMTestType CIT

   288  * @SYMTestCaseDependencies live/automatic

   289  *

   290  * Reason for test: Verify call forwarding is registered and call forwarding notification completes.

   291  *

   292  * @return - TVerdict code

   293  */

   294 	{

   295 	

   296 	//

   297 	// SET UP

   298 	//

   299 

   300 	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 

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

   302 

   303 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

   304 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   305 

   306 	TUint32 callServiceCaps = 0;	

   307 	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));

   308 	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsGetCFStatusNetwork;

   309 	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));

   310 

   311 	TPtrC number; 

   312 	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));

   313 	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);

   314 

   315 	// Ensure all call forwarding is erased by calling 

   316 

   317 	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 

   318 	

   319 	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 

   320 	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;

   321 	newSetting.iServiceGroup=RMobilePhone::EAllServices;

   322 	newSetting.iAction=RMobilePhone::EServiceActionErase;

   323 	newSetting.iTimeout=-1;

   324 	

   325 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));

   326 	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));

   327 	  

   328 	//

   329 	// SET UP END

   330 	//

   331 	

   332 	StartTest();

   333 	

   334 	//

   335 	// TEST START

   336 	//

   337 

   338 	RMobilePhone::TMobilePhoneNetworkInfoV1 info;

   339 	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);

   340 	RMobilePhone::TMobilePhoneLocationAreaV1 area;

   341 	TOperatorName operatorName = EOperatorUnknown;

   342 	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	

   343 	ASSERT_EQUALS(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));

   344 	

   345 	// ===  Register call forwarding and check notification completes ===

   346 	

   347 	// RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionRegister and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 

   348 	newSetting.iServiceGroup=RMobilePhone::EVoiceService;

   349 	newSetting.iAction=RMobilePhone::EServiceActionRegister;

   350 	newSetting.iNumber.iTelNumber=number;

   351 	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;

   352 	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;

   353 	newSetting.iTimeout=-1;

   354 	

   355 	// $CTSYProblem The status returned from SetCallForwardingStatus does not return KErrNone.

   356 	// Instead the status varies depending on what iAction is requested. It is presumed that this is CTSY problem.

   357 	// Have had to change the test to expect the current retrieved value. 

   358 	// The error codes are being returned by the LTSY and the CTSY is propagating them back to the client correctly

   359 	// therefore these error codes do not indicate an error in the CTSY but rather that the LTSY / network is not supporting the requested operation. 

   360 	if(operatorName==EOperatorVodafone)

   361 		{

   362 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EVoiceService"));

   363 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EVoiceService failed"));

   364 	

   365 		// Repeat test with aInfo.iServiceGroup= EAuxVoiceService...	

   366 		newSetting.iServiceGroup=RMobilePhone::EAuxVoiceService;

   367 		

   368 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAuxVoiceService"));

   369 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAuxVoiceService failed"));

   370 		

   371 		// Repeat test with aInfo.iServiceGroup= ECircuitDataService...	

   372 		newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;

   373 	

   374 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService"));

   375 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService failed"));

   376 		

   377 		// Repeat test with aInfo.iServiceGroup= EPacketDataService...

   378 		newSetting.iServiceGroup=RMobilePhone::EPacketDataService;

   379 	

   380 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EPacketDataService"));

   381 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSBearerServiceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EPacketDataService failed"));

   382 		

   383 		// Repeat test with aInfo.iServiceGroup= EFaxService...

   384 		newSetting.iServiceGroup=RMobilePhone::EFaxService;

   385 	

   386 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EFaxService"));

   387 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EFaxService failed"));

   388 			

   389 		// Repeat test with aInfo.iServiceGroup= EShortMessageService...

   390 		newSetting.iServiceGroup=RMobilePhone::EShortMessageService;

   391 	

   392 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EShortMessageService"));

   393 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EShortMessageService failed"));

   394 		

   395 		// Repeat test with aInfo.iServiceGroup= ETelephony...

   396 		newSetting.iServiceGroup=RMobilePhone::ETelephony;

   397 	

   398 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ETelephony"));

   399 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ETelephony failed"));

   400 		}

   401 	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)

   402 		{

   403 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EVoiceService"));

   404 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EVoiceService failed"));

   405 	

   406 		// Repeat test with aInfo.iServiceGroup= EAuxVoiceService...	

   407 		newSetting.iServiceGroup=RMobilePhone::EAuxVoiceService;

   408 		

   409 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAuxVoiceService"));

   410 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAuxVoiceService failed"));

   411 		

   412 		// Repeat test with aInfo.iServiceGroup= ECircuitDataService...	

   413 		newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;

   414 	

   415 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService"));

   416 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService failed"));

   417 		

   418 		// Repeat test with aInfo.iServiceGroup= EPacketDataService...

   419 		newSetting.iServiceGroup=RMobilePhone::EPacketDataService;

   420 	

   421 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EPacketDataService"));

   422 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EPacketDataService failed"));

   423 		

   424 		// Repeat test with aInfo.iServiceGroup= EFaxService...

   425 		newSetting.iServiceGroup=RMobilePhone::EFaxService;

   426 	

   427 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EFaxService"));

   428 		

   429 		if(operatorName==EOperatorTMobile)

   430 			{

   431 			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EFaxService failed"));

   432 			}

   433 		else if(operatorName==EOperatorOrange || operatorName==EOperatorO2)

   434 			{

   435 			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EFaxService failed"));			

   436 			}

   437 		

   438 		// Repeat test with aInfo.iServiceGroup= EShortMessageService...

   439 		newSetting.iServiceGroup=RMobilePhone::EShortMessageService;

   440 	

   441 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EShortMessageService"));

   442 		

   443 		if(operatorName==EOperatorTMobile || operatorName==EOperatorO2)

   444 			{

   445 			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIncompatibility), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EShortMessageService failed"));

   446 			}

   447 		else if(operatorName==EOperatorOrange)

   448 			{

   449 			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSCallBarred), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EShortMessageService failed"));

   450 			}

   451 		

   452 		// Repeat test with aInfo.iServiceGroup= ETelephony...

   453 		newSetting.iServiceGroup=RMobilePhone::ETelephony;

   454 	

   455 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ETelephony"));

   456 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ETelephony failed"));

   457 		}

   458 	else

   459 		{	

   460 		ASSERT_EQUALS(1,0,_L("Failed to identify current network"));

   461 		TEST_CHECK_POINT_L(_L("Failed to identify current network."));

   462 		}

   463 		

   464 	//

   465 	// TEST END

   466 	//

   467 

   468     StartCleanup();

   469 	

   470 	// Ensure all call forwarding setting are erased

   471 	newSetting.iServiceGroup=RMobilePhone::EAllServices;

   472 	newSetting.iAction=RMobilePhone::EServiceActionErase;

   473 	

   474 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));

   475 	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));

   476 

   477 	return TestStepResult();

   478 	}

   479 

   480 TPtrC CCTSYIntegrationTestCallForwarding0002::GetTestStepName()

   481 /**

   482  * @return The test step name.

   483  */

   484 	{

   485 	return _L("CCTSYIntegrationTestCallForwarding0002");

   486 	}

   487 

   488 

   489 

   490 CCTSYIntegrationTestCallForwarding0003::CCTSYIntegrationTestCallForwarding0003(CEtelSessionMgr& aEtelSessionMgr)

   491 	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)

   492 /**

   493  * Constructor.

   494  */

   495 	{

   496 	SetTestStepName(CCTSYIntegrationTestCallForwarding0003::GetTestStepName());

   497 	}

   498 

   499 CCTSYIntegrationTestCallForwarding0003::~CCTSYIntegrationTestCallForwarding0003()

   500 /**

   501  * Destructor.

   502  */

   503 	{

   504 	}

   505 

   506 TVerdict CCTSYIntegrationTestCallForwarding0003::doTestStepL()

   507 /**

   508  * @SYMTestCaseID BA-CTSY-INT-CFOR-0003

   509  * @SYMFssID BA/CTSY/CFOR-0003

   510  * @SYMTestCaseDesc Erase call forwarding for all services.

   511  * @SYMTestPriority High

   512  * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange

   513  * @SYMTestExpectedResults Pass - Call forwarding is erased for all services.

   514  * @SYMTestType CIT

   515  * @SYMTestCaseDependencies live/automatic

   516  *

   517  * Reason for test: Verify call forwarding is erased and notification completes.

   518  *

   519  * @return - TVerdict code

   520  */

   521 	{

   522 

   523 	//

   524 	// SET UP

   525 	//

   526 

   527 	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 

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

   529 	TUint32 callServiceCaps = 0;

   530 	TPtrC number;

   531 	

   532 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

   533 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   534 

   535 	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));

   536 	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;

   537 	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));

   538 

   539 	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));

   540 	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);

   541 	

   542 	RMobilePhone::TMobilePhoneNetworkInfoV1 info;

   543 	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);

   544 	RMobilePhone::TMobilePhoneLocationAreaV1 area;

   545 	TOperatorName operatorName = EOperatorUnknown;

   546 	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	

   547 	CHECK_EQUALS_L(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));

   548 	

   549 	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;

   550 	newSetting.iServiceGroup=RMobilePhone::EAllServices;

   551 	newSetting.iNumber.iTelNumber=number;

   552 	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;

   553 	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;

   554 	newSetting.iTimeout=-1;

   555 	

   556 	if(operatorName==EOperatorVodafone)

   557 		{

   558 		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EAllServices and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 

   559 		newSetting.iAction=RMobilePhone::EServiceActionActivate;

   560 		

   561 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EAllServices"));

   562 		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EAllServices failed"));

   563 		}

   564 	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)

   565 		{

   566 		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionRegister and aInfo.iServiceGroup=RMobilePhone::EAllServices and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 

   567 		newSetting.iAction=RMobilePhone::EServiceActionRegister;

   568 		

   569 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAllServices"));

   570 		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAllServices failed"));

   571 		}

   572 	else

   573 		{	

   574 		CHECK_EQUALS_L(1,0,_L("Failed to identify current network"));

   575 		}

   576 	

   577 	//

   578 	// SET UP END

   579 	//

   580 	

   581 	StartTest();

   582 	

   583 	//

   584 	// TEST START

   585 	//

   586 	

   587 	// ===  Erase call forwarding ===

   588 

   589 	// RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeout=-1 

   590 	// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingUnconditional

   591 	newSetting.iServiceGroup=RMobilePhone::EAllServices;

   592 	newSetting.iAction=RMobilePhone::EServiceActionErase;

   593 	newSetting.iTimeout=-1;

   594 	

   595 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));

   596 	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));

   597 

   598 	//

   599 	// TEST END

   600 	//

   601 

   602     StartCleanup();

   603 	

   604 	return TestStepResult();

   605 	}

   606 

   607 TPtrC CCTSYIntegrationTestCallForwarding0003::GetTestStepName()

   608 /**

   609  * @return The test step name.

   610  */

   611 	{

   612 	return _L("CCTSYIntegrationTestCallForwarding0003");

   613 	}

   614 

   615 

   616 

   617 CCTSYIntegrationTestCallForwarding0004::CCTSYIntegrationTestCallForwarding0004(CEtelSessionMgr& aEtelSessionMgr)

   618 	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)

   619 /**

   620  * Constructor.

   621  */

   622 	{

   623 	SetTestStepName(CCTSYIntegrationTestCallForwarding0004::GetTestStepName());

   624 	}

   625 

   626 CCTSYIntegrationTestCallForwarding0004::~CCTSYIntegrationTestCallForwarding0004()

   627 /**

   628  * Destructor.

   629  */

   630 	{

   631 	}

   632 

   633 TVerdict CCTSYIntegrationTestCallForwarding0004::doTestStepL()

   634 /**

   635  * @SYMTestCaseID BA-CTSY-INT-CFOR-0004

   636  * @SYMFssID BA/CTSY/CFOR-0004

   637  * @SYMTestCaseDesc Erase call forwarding for each provisioned basic service.

   638  * @SYMTestPriority High

   639  * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange

   640  * @SYMTestExpectedResults Pass - Call forwarding is erased for each provisioned service group.

   641  * @SYMTestType CIT

   642  * @SYMTestCaseDependencies live/automatic

   643  *

   644  * Reason for test: Verify call forwarding is erased and notification completes.

   645  *

   646  * @return - TVerdict code

   647  */

   648 	{

   649 

   650 	//

   651 	// SET UP

   652 	//

   653 

   654 	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 

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

   656 	TUint32 callServiceCaps = 0;

   657 	TPtrC number;

   658 	

   659 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

   660 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   661 

   662 	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));

   663 	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;

   664 	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));

   665 

   666 	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));

   667 	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);

   668 	

   669 	RMobilePhone::TMobilePhoneNetworkInfoV1 info;

   670 	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);

   671 	RMobilePhone::TMobilePhoneLocationAreaV1 area;

   672 	TOperatorName operatorName = EOperatorUnknown;

   673 	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	

   674 	CHECK_EQUALS_L(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));

   675 	

   676 	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;

   677 	newSetting.iServiceGroup=RMobilePhone::EAllServices;

   678 	newSetting.iNumber.iTelNumber=number;

   679 	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;

   680 	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;

   681 	newSetting.iTimeout=-1;

   682 	

   683 	if(operatorName==EOperatorVodafone)

   684 		{

   685 		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EAllServices and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 

   686 		newSetting.iAction=RMobilePhone::EServiceActionActivate;

   687 		

   688 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EAllServices"));

   689 		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EAllServices failed"));

   690 		}

   691 	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)

   692 		{

   693 		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionRegister and aInfo.iServiceGroup=RMobilePhone::EAllServices and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 

   694 		newSetting.iAction=RMobilePhone::EServiceActionRegister;

   695 		

   696 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAllServices"));

   697 		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAllServices failed"));

   698 		}

   699 	else

   700 		{	

   701 		CHECK_EQUALS_L(1,0,_L("Failed to identify current network"));

   702 		TEST_CHECK_POINT_L(_L("Failed to identify current network."));

   703 		}

   704 	

   705 	//

   706 	// SET UP END

   707 	//

   708 	

   709 	StartTest();

   710 	

   711 	//

   712 	// TEST START

   713 	//

   714 	

   715 	// ===  Erase call forwarding ===

   716 

   717 	// RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EVoiceService, aInfo.iTimeOut=-1 

   718 	// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingUnconditional

   719 	newSetting.iServiceGroup=RMobilePhone::EVoiceService;

   720 	newSetting.iAction=RMobilePhone::EServiceActionErase;

   721 	newSetting.iTimeout=-1;

   722 	

   723 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EVoiceService"));

   724 	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EVoiceService failed"));

   725 

   726 	newSetting.iServiceGroup=RMobilePhone::EAuxVoiceService;

   727 

   728 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAuxVoiceService"));

   729 	

   730 	if(operatorName==EOperatorVodafone)

   731 		{

   732 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAuxVoiceService failed"));

   733 		}

   734 	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)

   735 		{

   736 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAuxVoiceService failed"));

   737 		}

   738 	

   739 	newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;

   740 	

   741 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for ECircuitDataService"));

   742 	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for ECircuitDataService failed"));

   743 	

   744 	newSetting.iServiceGroup=RMobilePhone::EPacketDataService;

   745 	

   746 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EPacketDataService"));

   747 	

   748 	if(operatorName==EOperatorVodafone)

   749 		{

   750 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIllegalOperation), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EPacketDataService failed"));

   751 		}

   752 	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)

   753 		{

   754 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EPacketDataService failed"));

   755 		}

   756 	

   757 	newSetting.iServiceGroup=RMobilePhone::EFaxService;

   758 	

   759 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EFaxService"));

   760 	

   761 	if(operatorName==EOperatorVodafone || operatorName==EOperatorTMobile)

   762 		{

   763 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EFaxService failed"));

   764 		}

   765 	else if(operatorName==EOperatorOrange || operatorName==EOperatorO2)

   766 		{

   767 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EFaxService failed"));

   768 		}

   769 	

   770 	newSetting.iServiceGroup=RMobilePhone::EShortMessageService;

   771 	

   772 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EShortMessageService"));

   773 	

   774 	if(operatorName==EOperatorVodafone)

   775 		{

   776 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIllegalOperation), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EShortMessageService failed"));

   777 		}

   778 	else if(operatorName==EOperatorTMobile)

   779 		{

   780 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EShortMessageService failed"));

   781 		}

   782 	else if(operatorName==EOperatorO2)

   783 		{

   784 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EShortMessageService failed")); 

   785 		}

   786 	else if(operatorName==EOperatorOrange)

   787 		{

   788 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSCallBarred), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EShortMessageService failed"));

   789 		}

   790 	

   791 	newSetting.iServiceGroup=RMobilePhone::ETelephony;

   792 	

   793 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for ETelephony"));

   794 	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for ETelephony failed"));

   795 	

   796 	//

   797 	// TEST END

   798 	//

   799 

   800     StartCleanup();

   801 	

   802 	return TestStepResult();

   803 	}

   804 

   805 TPtrC CCTSYIntegrationTestCallForwarding0004::GetTestStepName()

   806 /**

   807  * @return The test step name.

   808  */

   809 	{

   810 	return _L("CCTSYIntegrationTestCallForwarding0004");

   811 	}

   812 

   813 

   814 

   815 CCTSYIntegrationTestCallForwarding0005::CCTSYIntegrationTestCallForwarding0005(CEtelSessionMgr& aEtelSessionMgr)

   816 	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)

   817 /**

   818  * Constructor.

   819  */

   820 	{

   821 	SetTestStepName(CCTSYIntegrationTestCallForwarding0005::GetTestStepName());

   822 	}

   823 

   824 CCTSYIntegrationTestCallForwarding0005::~CCTSYIntegrationTestCallForwarding0005()

   825 /**

   826  * Destructor.

   827  */

   828 	{

   829 	}

   830 

   831 TVerdict CCTSYIntegrationTestCallForwarding0005::doTestStepL()

   832 /**

   833  * @SYMTestCaseID BA-CTSY-INT-CFOR-0005

   834  * @SYMFssID BA/CTSY/CFOR-0005

   835  * @SYMTestCaseDesc Activate call forwarding for all services.

   836  * @SYMTestPriority High

   837  * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange

   838  * @SYMTestExpectedResults Pass - Call forwarding is activated for all services.

   839  * @SYMTestType CIT

   840  * @SYMTestCaseDependencies live/automatic

   841  *

   842  * Reason for test: Verify call forwarding activated and notification completes.

   843  *

   844  * @return - TVerdict code

   845  */

   846 	{

   847 

   848 	//

   849 	// SET UP

   850 	//

   851 

   852 	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 

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

   854 	

   855 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

   856 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   857 

   858 	TUint32 callServiceCaps = 0;

   859 	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));

   860 	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;

   861 	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));

   862 

   863 	// Ensure all call forwarding is erased by calling 

   864 

   865 	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeout=-1 

   866 	TPtrC number; 

   867 	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));

   868 	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);

   869 

   870 	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;

   871 	newSetting.iServiceGroup=RMobilePhone::EAllServices;

   872 	newSetting.iAction=RMobilePhone::EServiceActionErase;

   873 	newSetting.iNumber.iTelNumber=number;

   874 	newSetting.iTimeout=-1;

   875 		

   876 	TExtEtelRequestStatus setCallForwardStatus(mobilePhone, EMobilePhoneSetCallForwardingStatus);

   877 	CleanupStack::PushL(setCallForwardStatus);

   878 	mobilePhone.SetCallForwardingStatus(setCallForwardStatus, RMobilePhone::ECallForwardingAllCases, newSetting);

   879 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(setCallForwardStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SetCallForwardingStatus timed-out"));

   880 	CHECK_EQUALS_L(setCallForwardStatus.Int(), KErrNone, _L("RMobilePhone::SetCallForwardingStatus setCallForwardStatus completed with incorrect error"));

   881    

   882 	//

   883 	// SET UP END

   884 	//

   885 	

   886 	StartTest();

   887 	

   888 	//

   889 	// TEST START

   890 	//

   891 

   892 	RMobilePhone::TMobilePhoneNetworkInfoV1 info;

   893 	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);

   894 	RMobilePhone::TMobilePhoneLocationAreaV1 area;

   895 	TOperatorName operatorName = EOperatorUnknown;

   896 	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	

   897 	CHECK_EQUALS_L(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));

   898 	

   899 	// ===  Activate call forwarding and check notification completes ===

   900 	

   901 	// RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 

   902 	

   903 	newSetting.iServiceGroup=RMobilePhone::EAllServices;

   904 	newSetting.iAction=RMobilePhone::EServiceActionActivate;

   905 	newSetting.iNumber.iTelNumber=number;

   906 	newSetting.iTimeout=-1;

   907 

   908 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EAllServices"));	

   909 	

   910 	if(operatorName==EOperatorVodafone)

   911 		{		

   912 		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EAllServices failed"));

   913 		}

   914 	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)

   915 		{

   916 		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSErrorStatus), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAllServices failed"));

   917 		}

   918 	else

   919 		{	

   920 		CHECK_EQUALS_L(1,0,_L("Failed to identify current network"));

   921 		}

   922  

   923 	//

   924 	// TEST END

   925 	//

   926 

   927     StartCleanup();

   928 	

   929 	// Ensure all call forwarding setting are erased

   930 	newSetting.iServiceGroup=RMobilePhone::EAllServices;

   931 	newSetting.iAction=RMobilePhone::EServiceActionErase;

   932 	

   933 	mobilePhone.SetCallForwardingStatus(setCallForwardStatus, RMobilePhone::ECallForwardingAllCases, newSetting);

   934 	CHECK_EQUALS_L(WaitForRequestWithTimeOut(setCallForwardStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SetCallForwardingStatus timed-out"));

   935 	CHECK_EQUALS_L(setCallForwardStatus.Int(), KErrNone, _L("RMobilePhone::SetCallForwardingStatus setCallForwardStatus completed with incorrect error"));

   936 

   937 	CleanupStack::PopAndDestroy(&setCallForwardStatus);

   938 	

   939 	return TestStepResult();

   940 	}

   941 

   942 TPtrC CCTSYIntegrationTestCallForwarding0005::GetTestStepName()

   943 /**

   944  * @return The test step name.

   945  */

   946 	{

   947 	return _L("CCTSYIntegrationTestCallForwarding0005");

   948 	}

   949 

   950 

   951 

   952 CCTSYIntegrationTestCallForwarding0006::CCTSYIntegrationTestCallForwarding0006(CEtelSessionMgr& aEtelSessionMgr)

   953 	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)

   954 /**

   955  * Constructor.

   956  */

   957 	{

   958 	SetTestStepName(CCTSYIntegrationTestCallForwarding0006::GetTestStepName());

   959 	}

   960 

   961 CCTSYIntegrationTestCallForwarding0006::~CCTSYIntegrationTestCallForwarding0006()

   962 /**

   963  * Destructor.

   964  */

   965 	{

   966 	}

   967 

   968 TVerdict CCTSYIntegrationTestCallForwarding0006::doTestStepL()

   969 /**

   970  * @SYMTestCaseID BA-CTSY-INT-CFOR-0006

   971  * @SYMFssID BA/CTSY/CFOR-0006

   972  * @SYMTestCaseDesc Activate call forwarding for each provisioned basic service.

   973  * @SYMTestPriority High

   974  * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange

   975  * @SYMTestExpectedResults Pass - Call forwarding is activated for each provisioned basic service.

   976  * @SYMTestType CIT

   977  * @SYMTestCaseDependencies live/automatic

   978  *

   979  * Reason for test: Verify call forwarding activated and notification completes.

   980  *

   981  * @return - TVerdict code

   982  */

   983 	{

   984 

   985 	//

   986 	// SET UP

   987 	//

   988 

   989 	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 

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

   991 	TUint32 callServiceCaps = 0;

   992 	TPtrC number; 

   993 	

   994 	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

   995 	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

   996 	

   997 	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));

   998 	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;

   999 	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));

  1000 

  1001 	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));

  1002 	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);

  1003 

  1004 	// Ensure all call forwarding is erased by calling 

  1005 

  1006 	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 

  1007 

  1008 	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 

  1009 	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;

  1010 	newSetting.iServiceGroup=RMobilePhone::EAllServices;

  1011 	newSetting.iAction=RMobilePhone::EServiceActionErase;

  1012 	newSetting.iTimeout=-1;

  1013 		

  1014 	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));

  1015 	CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));

  1016 

  1017 	//

  1018 	// SET UP END

  1019 	//

  1020 	

  1021 	StartTest();

  1022 	

  1023 	//

  1024 	// TEST START

  1025 	//

  1026 	

  1027 	RMobilePhone::TMobilePhoneNetworkInfoV1 info;

  1028 	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);

  1029 	RMobilePhone::TMobilePhoneLocationAreaV1 area;

  1030 	TOperatorName operatorName = EOperatorUnknown;

  1031 	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	

  1032 	ASSERT_EQUALS(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));

  1033 	

  1034 	// ===  Activate call forwarding and check notification completes ===

  1035 

  1036 	// RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EVoiceService, aInfo.iTimeOut=-1 

  1037 

  1038 	// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingUnconditional

  1039 	newSetting.iServiceGroup=RMobilePhone::EVoiceService;

  1040 	newSetting.iAction=RMobilePhone::EServiceActionActivate;

  1041 	newSetting.iNumber.iTelNumber=number;

  1042 	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;

  1043 	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;

  1044 

  1045 	// $CTSYProblem The status returned from SetCallForwardingStatus does not return KErrNone.

  1046 	// Instead the status varies depending on what iAction is requested. It is presumed that this is LTSY / network problem.

  1047 

  1048 	if(operatorName==EOperatorVodafone)

  1049 		{

  1050 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EVoiceService"));

  1051 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EVoiceService failed"));

  1052 	

  1053 		// Repeat test with aInfo.iServiceGroup=EAuxVoiceService, ECircuitDataService, EPacketDataService, EFaxService, EShortMessageService, ETelephony 	

  1054 		newSetting.iServiceGroup=RMobilePhone::EAuxVoiceService;

  1055 		

  1056 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EAuxVoiceService"));

  1057 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EAuxVoiceService failed"));

  1058 		

  1059 		newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;

  1060 		

  1061 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService"));

  1062 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService failed"));

  1063 		

  1064 		newSetting.iServiceGroup=RMobilePhone::EPacketDataService;

  1065 		

  1066 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EPacketDataService"));

  1067 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIllegalOperation), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EPacketDataService failed"));

  1068 		

  1069 		newSetting.iServiceGroup=RMobilePhone::EFaxService;

  1070 		

  1071 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EFaxService"));

  1072 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EFaxService failed"));

  1073 		

  1074 		newSetting.iServiceGroup=RMobilePhone::EShortMessageService;

  1075 		

  1076 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EShortMessageService"));

  1077 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIllegalOperation), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EShortMessageService failed"));

  1078 		

  1079 		newSetting.iServiceGroup=RMobilePhone::ETelephony;

  1080 		

  1081 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ETelephony"));

  1082 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ETelephony failed"));

  1083 		}

  1084 	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)

  1085 		{

  1086 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EVoiceService"));

  1087 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSErrorStatus), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EVoiceService failed"));

  1088 	

  1089 		// Repeat test with aInfo.iServiceGroup=EAuxVoiceService, ECircuitDataService, EPacketDataService, EFaxService, EShortMessageService, ETelephony 	

  1090 		newSetting.iServiceGroup=RMobilePhone::EAuxVoiceService;

  1091 		

  1092 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EAuxVoiceService"));

  1093 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned ), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EAuxVoiceService failed"));

  1094 		

  1095 		newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;

  1096 		

  1097 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService"));

  1098 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSErrorStatus), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService failed"));

  1099 

  1100 		newSetting.iServiceGroup=RMobilePhone::EPacketDataService;

  1101 		

  1102 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EPacketDataService"));

  1103 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EPacketDataService failed"));

  1104 		

  1105 		newSetting.iServiceGroup=RMobilePhone::EFaxService;

  1106 		

  1107 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EFaxService"));

  1108 		

  1109 		if(operatorName==EOperatorOrange || operatorName==EOperatorO2)

  1110 			{

  1111 			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned ), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EFaxService failed"));

  1112 			}

  1113 		else if(operatorName==EOperatorTMobile)

  1114 			{

  1115 			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSErrorStatus), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EFaxService failed"));

  1116 			}

  1117 		

  1118 		newSetting.iServiceGroup=RMobilePhone::EShortMessageService;

  1119 		

  1120 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EShortMessageService"));

  1121 		

  1122 		if(operatorName==EOperatorTMobile || operatorName==EOperatorO2)

  1123 			{

  1124 			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIncompatibility), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EShortMessageService failed"));

  1125 			}

  1126 		else if(operatorName==EOperatorOrange)

  1127 			{

  1128 			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSCallBarred), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EShortMessageService failed"));

  1129 			}

  1130 		

  1131 		newSetting.iServiceGroup=RMobilePhone::ETelephony;

  1132 		

  1133 		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ETelephony"));

  1134 		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSErrorStatus), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ETelephony failed"));