--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/common_tsy/test/integration/src/cctsyintegrationtestcallforwarding.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,3600 @@
+// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Test step definitions for the CallForwarding functional unit.
+// 
+//
+
+/**
+ @internalTechnology
+*/
+
+#include "cctsyintegrationtestcallforwarding.h"
+
+#include "cctsyinidata.h"
+
+#include "listretrievalhelpers.h"
+
+
+CCTSYIntegrationTestCallForwardingBase::CCTSYIntegrationTestCallForwardingBase(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), iCallForwardingSupplementalHelper(*this), iCallForwardingControlHelper(*this), iNetworkTestHelper(*this)
+/**
+ * Constructor
+ */
+	{
+	}
+
+CCTSYIntegrationTestCallForwardingBase::~CCTSYIntegrationTestCallForwardingBase()
+/*
+ * Destructor
+ */
+	{
+	}
+
+TBool CCTSYIntegrationTestCallForwardingBase::SetCallForwardingStatusUtilL(RMobilePhone& aMobilePhone, RMobilePhone::TMobilePhoneCFChangeV1 aNewSetting, RMobilePhone::TMobilePhoneCFCondition aCFConditionSet, TInt aExpected=KErrNone)
+/**
+ * Util function which performs a SetCallForwardingStatus operation and relevant
+ * checks using the arguments passed.
+ *
+ * @param aMobilePhone Mobile phone
+ * @param aNewSetting The new setting to be set
+ * @param aCFConditionSet The call forwarding condition.
+ * @param aExpected A expect value for the status
+ * @return TBool which represents whether cfCondition==aCFConditionSet
+ */
+	{
+	// Post notification for RMobilePhone::NotifyCallForwardingStatusChange
+
+	TExtEtelRequestStatus notifyCallForwardStatus(aMobilePhone, EMobilePhoneNotifyCallForwardingStatusChange);
+	RMobilePhone::TMobilePhoneCFCondition cfCondition;
+	CleanupStack::PushL(notifyCallForwardStatus);
+	
+	if(aExpected==KErrNone)
+		{
+		aMobilePhone.NotifyCallForwardingStatusChange(notifyCallForwardStatus, cfCondition);	
+		}
+	
+	TExtEtelRequestStatus setCallForwardStatus(aMobilePhone, EMobilePhoneSetCallForwardingStatus);
+	CleanupStack::PushL(setCallForwardStatus);
+	aMobilePhone.SetCallForwardingStatus(setCallForwardStatus, aCFConditionSet, aNewSetting);
+	
+	ASSERT_EQUALS(WaitForRequestWithTimeOut(setCallForwardStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SetCallForwardingStatus timed-out"));
+	ASSERT_EQUALS(setCallForwardStatus.Int(), aExpected, _L("RMobilePhone::SetCallForwardingStatus setCallForwardStatus completed with incorrect error"));
+	
+	// Check RMobilePhone::NotifyCallForwardingStatusChange completes with cfcondition==aCFConditionSet
+	if(aExpected==KErrNone)
+		{
+		iCallForwardingSupplementalHelper.WaitForMobilePhoneNotifyCallForwardingStatusChange(aMobilePhone,
+																						 notifyCallForwardStatus,
+																						 cfCondition,
+																						 aCFConditionSet,
+																					 	 KErrNone);	
+		}
+		CleanupStack::PopAndDestroy(&setCallForwardStatus);
+		CleanupStack::PopAndDestroy(&notifyCallForwardStatus);
+	
+	if(aExpected==KErrNone)
+		{	
+		return cfCondition==aCFConditionSet;
+		}
+	else
+		{
+		return ETrue;
+		}	
+	}
+
+CCTSYIntegrationTestCallForwarding0001::CCTSYIntegrationTestCallForwarding0001(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0001::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0001::~CCTSYIntegrationTestCallForwarding0001()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0001::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0001
+ * @SYMFssID BA/CTSY/CFOR-0001
+ * @SYMTestCaseDesc Register call forwarding for all services.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange
+ * @SYMTestExpectedResults Pass - Call forwarding is registered for all services with each condition.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding is registered and call forwarding notification completes.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);		
+	TUint32 callServiceCaps = 0;
+	
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+	
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	TPtrC number; 
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+	
+	// Ensure all call forwarding is erased by calling 
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 
+
+	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices 
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+	
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	
+	ASSERT_EQUALS(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+	
+	// ===  Register call forwarding and check notification completes ===
+
+	// 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 
+	
+	// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingUnconditional
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iAction=RMobilePhone::EServiceActionRegister;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	newSetting.iTimeout=-1;
+
+	// $CTSYProblem The status returned from SetCallForwardingStatus does not return KErrNone.
+	// Instead the status varies depending on what iAction is requested. It is presumed that this is CTSY problem.
+	// Have had to change the test to expect the current retrieved value. 
+	// The error codes are being returned by the LTSY and the CTSY is propagating them back to the client correctly
+	// therefore these error codes do not indicate an error in the CTSY but rather that the LTSY / network is not supporting the requested operation. 
+	if(operatorName==EOperatorVodafone)
+		{
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAllServices"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAllServices failed"));
+	
+		// Repeat whole test with aCondition in RMobilePhone::SetCallForwardingStatus and RMobilePhone::NotifyCallForwardingStatusChange =ECallForwardingBusy, ECallForwardingNoReply, ECallForwardingNotReachable, ECallForwardingAllConditionalCases 
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingBusy for EAllServices"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingBusy for EAllServices failed"));
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingNoReply for EAllServices"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNoReply, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingNoReply for EAllServices failed"));
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingNotReachable for EAllServices"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNotReachable, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingNotReachable for EAllServices failed"));
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingAllConditionalCases for EAllServices"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllConditionalCases, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingAllConditionalCases for EAllServices failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAllServices"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAllServices failed"));
+	
+		// Repeat whole test with aCondition in RMobilePhone::SetCallForwardingStatus and RMobilePhone::NotifyCallForwardingStatusChange =ECallForwardingBusy, ECallForwardingNoReply, ECallForwardingNotReachable, ECallForwardingAllConditionalCases 
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingBusy for EAllServices"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy, KErrGsmSSIncompatibility), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingBusy for EAllServices failed"));
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingNoReply for EAllServices"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNoReply, KErrGsmSSIncompatibility), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingNoReply for EAllServices failed"));
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingNotReachable for EAllServices"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNotReachable, KErrGsmSSIncompatibility), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingNotReachable for EAllServices failed"));
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingAllConditionalCases for EAllServices"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllConditionalCases, KErrGsmSSIncompatibility), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingAllConditionalCases for EAllServices failed"));	
+		}
+	else
+		{	
+		ASSERT_EQUALS(1,0,_L("Failed to identify current network"));
+		TEST_CHECK_POINT_L(_L("Failed to identify current network."));
+		}
+	
+	//
+	// TEST END
+	//
+
+    StartCleanup();
+	
+	// Ensure all call forwarding setting are erased
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+	
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0001::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0001");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0002::CCTSYIntegrationTestCallForwarding0002(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0002::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0002::~CCTSYIntegrationTestCallForwarding0002()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0002::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0002
+ * @SYMFssID BA/CTSY/CFOR-0002
+ * @SYMTestCaseDesc Register call forwarding for each provisioned basic service.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange
+ * @SYMTestExpectedResults Pass - Call forwarding is registered for each provisioned basic service.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding is registered and call forwarding notification completes.
+ *
+ * @return - TVerdict code
+ */
+	{
+	
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);		
+
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+	TUint32 callServiceCaps = 0;	
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsGetCFStatusNetwork;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	TPtrC number; 
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+
+	// Ensure all call forwarding is erased by calling 
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 
+	
+	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));
+	  
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	
+	ASSERT_EQUALS(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+	
+	// ===  Register call forwarding and check notification completes ===
+	
+	// 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 
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iAction=RMobilePhone::EServiceActionRegister;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	newSetting.iTimeout=-1;
+	
+	// $CTSYProblem The status returned from SetCallForwardingStatus does not return KErrNone.
+	// Instead the status varies depending on what iAction is requested. It is presumed that this is CTSY problem.
+	// Have had to change the test to expect the current retrieved value. 
+	// The error codes are being returned by the LTSY and the CTSY is propagating them back to the client correctly
+	// therefore these error codes do not indicate an error in the CTSY but rather that the LTSY / network is not supporting the requested operation. 
+	if(operatorName==EOperatorVodafone)
+		{
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EVoiceService failed"));
+	
+		// Repeat test with aInfo.iServiceGroup= EAuxVoiceService...	
+		newSetting.iServiceGroup=RMobilePhone::EAuxVoiceService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAuxVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAuxVoiceService failed"));
+		
+		// Repeat test with aInfo.iServiceGroup= ECircuitDataService...	
+		newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService failed"));
+		
+		// Repeat test with aInfo.iServiceGroup= EPacketDataService...
+		newSetting.iServiceGroup=RMobilePhone::EPacketDataService;
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EPacketDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSBearerServiceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EPacketDataService failed"));
+		
+		// Repeat test with aInfo.iServiceGroup= EFaxService...
+		newSetting.iServiceGroup=RMobilePhone::EFaxService;
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EFaxService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EFaxService failed"));
+			
+		// Repeat test with aInfo.iServiceGroup= EShortMessageService...
+		newSetting.iServiceGroup=RMobilePhone::EShortMessageService;
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EShortMessageService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EShortMessageService failed"));
+		
+		// Repeat test with aInfo.iServiceGroup= ETelephony...
+		newSetting.iServiceGroup=RMobilePhone::ETelephony;
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ETelephony"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ETelephony failed"));
+		}
+	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)
+		{
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EVoiceService failed"));
+	
+		// Repeat test with aInfo.iServiceGroup= EAuxVoiceService...	
+		newSetting.iServiceGroup=RMobilePhone::EAuxVoiceService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAuxVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAuxVoiceService failed"));
+		
+		// Repeat test with aInfo.iServiceGroup= ECircuitDataService...	
+		newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService failed"));
+		
+		// Repeat test with aInfo.iServiceGroup= EPacketDataService...
+		newSetting.iServiceGroup=RMobilePhone::EPacketDataService;
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EPacketDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EPacketDataService failed"));
+		
+		// Repeat test with aInfo.iServiceGroup= EFaxService...
+		newSetting.iServiceGroup=RMobilePhone::EFaxService;
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EFaxService"));
+		
+		if(operatorName==EOperatorTMobile)
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EFaxService failed"));
+			}
+		else if(operatorName==EOperatorOrange || operatorName==EOperatorO2)
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EFaxService failed"));			
+			}
+		
+		// Repeat test with aInfo.iServiceGroup= EShortMessageService...
+		newSetting.iServiceGroup=RMobilePhone::EShortMessageService;
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EShortMessageService"));
+		
+		if(operatorName==EOperatorTMobile || operatorName==EOperatorO2)
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIncompatibility), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EShortMessageService failed"));
+			}
+		else if(operatorName==EOperatorOrange)
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSCallBarred), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EShortMessageService failed"));
+			}
+		
+		// Repeat test with aInfo.iServiceGroup= ETelephony...
+		newSetting.iServiceGroup=RMobilePhone::ETelephony;
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ETelephony"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ETelephony failed"));
+		}
+	else
+		{	
+		ASSERT_EQUALS(1,0,_L("Failed to identify current network"));
+		TEST_CHECK_POINT_L(_L("Failed to identify current network."));
+		}
+		
+	//
+	// TEST END
+	//
+
+    StartCleanup();
+	
+	// Ensure all call forwarding setting are erased
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));
+
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0002::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0002");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0003::CCTSYIntegrationTestCallForwarding0003(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0003::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0003::~CCTSYIntegrationTestCallForwarding0003()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0003::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0003
+ * @SYMFssID BA/CTSY/CFOR-0003
+ * @SYMTestCaseDesc Erase call forwarding for all services.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange
+ * @SYMTestExpectedResults Pass - Call forwarding is erased for all services.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding is erased and notification completes.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);		
+	TUint32 callServiceCaps = 0;
+	TPtrC number;
+	
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+	
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	
+	CHECK_EQUALS_L(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+	
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	newSetting.iTimeout=-1;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		// 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 
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EAllServices"));
+		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EAllServices failed"));
+		}
+	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)
+		{
+		// 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 
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAllServices"));
+		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAllServices failed"));
+		}
+	else
+		{	
+		CHECK_EQUALS_L(1,0,_L("Failed to identify current network"));
+		}
+	
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+	
+	// ===  Erase call forwarding ===
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeout=-1 
+	// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingUnconditional
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));
+
+	//
+	// TEST END
+	//
+
+    StartCleanup();
+	
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0003::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0003");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0004::CCTSYIntegrationTestCallForwarding0004(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0004::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0004::~CCTSYIntegrationTestCallForwarding0004()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0004::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0004
+ * @SYMFssID BA/CTSY/CFOR-0004
+ * @SYMTestCaseDesc Erase call forwarding for each provisioned basic service.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange
+ * @SYMTestExpectedResults Pass - Call forwarding is erased for each provisioned service group.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding is erased and notification completes.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);		
+	TUint32 callServiceCaps = 0;
+	TPtrC number;
+	
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+	
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	
+	CHECK_EQUALS_L(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+	
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	newSetting.iTimeout=-1;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		// 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 
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EAllServices"));
+		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EAllServices failed"));
+		}
+	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)
+		{
+		// 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 
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAllServices"));
+		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAllServices failed"));
+		}
+	else
+		{	
+		CHECK_EQUALS_L(1,0,_L("Failed to identify current network"));
+		TEST_CHECK_POINT_L(_L("Failed to identify current network."));
+		}
+	
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+	
+	// ===  Erase call forwarding ===
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EVoiceService, aInfo.iTimeOut=-1 
+	// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingUnconditional
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EVoiceService"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EVoiceService failed"));
+
+	newSetting.iServiceGroup=RMobilePhone::EAuxVoiceService;
+
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAuxVoiceService"));
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAuxVoiceService failed"));
+		}
+	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)
+		{
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAuxVoiceService failed"));
+		}
+	
+	newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for ECircuitDataService"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for ECircuitDataService failed"));
+	
+	newSetting.iServiceGroup=RMobilePhone::EPacketDataService;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EPacketDataService"));
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIllegalOperation), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EPacketDataService failed"));
+		}
+	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)
+		{
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EPacketDataService failed"));
+		}
+	
+	newSetting.iServiceGroup=RMobilePhone::EFaxService;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EFaxService"));
+	
+	if(operatorName==EOperatorVodafone || operatorName==EOperatorTMobile)
+		{
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EFaxService failed"));
+		}
+	else if(operatorName==EOperatorOrange || operatorName==EOperatorO2)
+		{
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EFaxService failed"));
+		}
+	
+	newSetting.iServiceGroup=RMobilePhone::EShortMessageService;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EShortMessageService"));
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIllegalOperation), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EShortMessageService failed"));
+		}
+	else if(operatorName==EOperatorTMobile)
+		{
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EShortMessageService failed"));
+		}
+	else if(operatorName==EOperatorO2)
+		{
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EShortMessageService failed")); 
+		}
+	else if(operatorName==EOperatorOrange)
+		{
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSCallBarred), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EShortMessageService failed"));
+		}
+	
+	newSetting.iServiceGroup=RMobilePhone::ETelephony;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for ETelephony"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for ETelephony failed"));
+	
+	//
+	// TEST END
+	//
+
+    StartCleanup();
+	
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0004::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0004");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0005::CCTSYIntegrationTestCallForwarding0005(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0005::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0005::~CCTSYIntegrationTestCallForwarding0005()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0005::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0005
+ * @SYMFssID BA/CTSY/CFOR-0005
+ * @SYMTestCaseDesc Activate call forwarding for all services.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange
+ * @SYMTestExpectedResults Pass - Call forwarding is activated for all services.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding activated and notification completes.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);	
+	
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+	TUint32 callServiceCaps = 0;
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	// Ensure all call forwarding is erased by calling 
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeout=-1 
+	TPtrC number; 
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iTimeout=-1;
+		
+	TExtEtelRequestStatus setCallForwardStatus(mobilePhone, EMobilePhoneSetCallForwardingStatus);
+	CleanupStack::PushL(setCallForwardStatus);
+	mobilePhone.SetCallForwardingStatus(setCallForwardStatus, RMobilePhone::ECallForwardingAllCases, newSetting);
+	CHECK_EQUALS_L(WaitForRequestWithTimeOut(setCallForwardStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SetCallForwardingStatus timed-out"));
+	CHECK_EQUALS_L(setCallForwardStatus.Int(), KErrNone, _L("RMobilePhone::SetCallForwardingStatus setCallForwardStatus completed with incorrect error"));
+   
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	
+	CHECK_EQUALS_L(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+	
+	// ===  Activate call forwarding and check notification completes ===
+	
+	// RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionActivate;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iTimeout=-1;
+
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EAllServices"));	
+	
+	if(operatorName==EOperatorVodafone)
+		{		
+		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EAllServices failed"));
+		}
+	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)
+		{
+		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSErrorStatus), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAllServices failed"));
+		}
+	else
+		{	
+		CHECK_EQUALS_L(1,0,_L("Failed to identify current network"));
+		}
+ 
+	//
+	// TEST END
+	//
+
+    StartCleanup();
+	
+	// Ensure all call forwarding setting are erased
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	
+	mobilePhone.SetCallForwardingStatus(setCallForwardStatus, RMobilePhone::ECallForwardingAllCases, newSetting);
+	CHECK_EQUALS_L(WaitForRequestWithTimeOut(setCallForwardStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SetCallForwardingStatus timed-out"));
+	CHECK_EQUALS_L(setCallForwardStatus.Int(), KErrNone, _L("RMobilePhone::SetCallForwardingStatus setCallForwardStatus completed with incorrect error"));
+
+	CleanupStack::PopAndDestroy(&setCallForwardStatus);
+	
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0005::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0005");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0006::CCTSYIntegrationTestCallForwarding0006(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0006::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0006::~CCTSYIntegrationTestCallForwarding0006()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0006::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0006
+ * @SYMFssID BA/CTSY/CFOR-0006
+ * @SYMTestCaseDesc Activate call forwarding for each provisioned basic service.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange
+ * @SYMTestExpectedResults Pass - Call forwarding is activated for each provisioned basic service.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding activated and notification completes.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);	
+	TUint32 callServiceCaps = 0;
+	TPtrC number; 
+	
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+	
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+
+	// Ensure all call forwarding is erased by calling 
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 
+
+	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+		
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+	
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	
+	ASSERT_EQUALS(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+	
+	// ===  Activate call forwarding and check notification completes ===
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EVoiceService, aInfo.iTimeOut=-1 
+
+	// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingUnconditional
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iAction=RMobilePhone::EServiceActionActivate;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+
+	// $CTSYProblem The status returned from SetCallForwardingStatus does not return KErrNone.
+	// Instead the status varies depending on what iAction is requested. It is presumed that this is LTSY / network problem.
+
+	if(operatorName==EOperatorVodafone)
+		{
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EVoiceService failed"));
+	
+		// Repeat test with aInfo.iServiceGroup=EAuxVoiceService, ECircuitDataService, EPacketDataService, EFaxService, EShortMessageService, ETelephony 	
+		newSetting.iServiceGroup=RMobilePhone::EAuxVoiceService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EAuxVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EAuxVoiceService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::EPacketDataService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EPacketDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIllegalOperation), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EPacketDataService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::EFaxService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EFaxService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EFaxService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::EShortMessageService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EShortMessageService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIllegalOperation), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EShortMessageService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::ETelephony;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ETelephony"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ETelephony failed"));
+		}
+	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)
+		{
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSErrorStatus), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EVoiceService failed"));
+	
+		// Repeat test with aInfo.iServiceGroup=EAuxVoiceService, ECircuitDataService, EPacketDataService, EFaxService, EShortMessageService, ETelephony 	
+		newSetting.iServiceGroup=RMobilePhone::EAuxVoiceService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EAuxVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned ), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EAuxVoiceService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSErrorStatus), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService failed"));
+
+		newSetting.iServiceGroup=RMobilePhone::EPacketDataService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EPacketDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EPacketDataService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::EFaxService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EFaxService"));
+		
+		if(operatorName==EOperatorOrange || operatorName==EOperatorO2)
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned ), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EFaxService failed"));
+			}
+		else if(operatorName==EOperatorTMobile)
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSErrorStatus), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EFaxService failed"));
+			}
+		
+		newSetting.iServiceGroup=RMobilePhone::EShortMessageService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EShortMessageService"));
+		
+		if(operatorName==EOperatorTMobile || operatorName==EOperatorO2)
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIncompatibility), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EShortMessageService failed"));
+			}
+		else if(operatorName==EOperatorOrange)
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSCallBarred), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EShortMessageService failed"));
+			}
+		
+		newSetting.iServiceGroup=RMobilePhone::ETelephony;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ETelephony"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSErrorStatus), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ETelephony failed"));
+		}
+	else
+		{	
+		ASSERT_EQUALS(1,0,_L("Failed to identify current network"));
+		TEST_CHECK_POINT_L(_L("Failed to identify current network."));
+		}
+	
+	//
+	// TEST END
+	//
+
+    StartCleanup();
+	
+	// Ensure all call forwarding setting are erased
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+		
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+	
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0006::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0006");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0007::CCTSYIntegrationTestCallForwarding0007(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0007::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0007::~CCTSYIntegrationTestCallForwarding0007()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0007::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0007
+ * @SYMFssID BA/CTSY/CFOR-0007
+ * @SYMTestCaseDesc Deactivate call forwarding for all services.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange
+ * @SYMTestExpectedResults Pass - Call forwarding is deactivated.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding deactivated and notification completes.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);	
+	
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+	TUint32 callServiceCaps = 0;
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	TPtrC number; 
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	
+	CHECK_EQUALS_L(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+	
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	newSetting.iTimeout=-1;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EAllServices"));
+		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EAllServices failed"));
+		}
+	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)
+		{
+		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAllServices"));
+		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAllServices failed"));
+		}
+	else
+		{	
+		CHECK_EQUALS_L(1,0,_L("Failed to identify current network"));
+		}
+	
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+	
+	// ===  Deactivate call forwarding and check notification completes ===
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionDeactivate and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut = -1 
+	newSetting.iAction=RMobilePhone::EServiceActionDeactivate;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EAllServices failed"));
+
+	//
+	// TEST END
+	//
+
+    StartCleanup();
+	
+	// Ensure all call forwarding setting are erased
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+	
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0007::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0007");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0008::CCTSYIntegrationTestCallForwarding0008(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0008::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0008::~CCTSYIntegrationTestCallForwarding0008()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0008::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0008
+ * @SYMFssID BA/CTSY/CFOR-0008
+ * @SYMTestCaseDesc Deactivate call forwarding for each provisioned basic service.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange
+ * @SYMTestExpectedResults Pass - Call forwarding is deactivated for each provisioned basic service.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding deactivated and notification completes.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus 
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);	
+	TUint32 callServiceCaps = 0;
+	TPtrC number;
+	
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+	
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	TInt err = iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName );	
+	CHECK_EQUALS_L(err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+	
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	newSetting.iTimeout=-1;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EAllServices"));
+		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EAllServices failed"));
+		}
+	else if(operatorName==EOperatorTMobile || operatorName==EOperatorOrange || operatorName==EOperatorO2)
+		{
+		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EAllServices"));
+		CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EAllServices failed"));
+		}
+	else
+		{	
+		CHECK_EQUALS_L(1,0,_L("Failed to identify current network"));
+		}
+		
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+	
+	// $CTSYProblem The status returned from SetCallForwardingStatus does not return KErrNone.
+	// Instead the status varies depending on what iAction is requested. It is presumed that this is LTSY / network problem.
+	
+	// ===  Deactivate call forwarding ===
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionDeactivate and aInfo.iServiceGroup=RMobilePhone::EVoiceService, aInfo.iTimeOut=-1 
+	// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingUnconditional
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iAction=RMobilePhone::EServiceActionDeactivate;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EVoiceService failed"));
+		
+		// Repeat test with aInfo.iServiceGroup=EAuxVoiceService, ECircuitDataService, EPacketDataService, EFaxService, EShortMessageService, ETelephony 	
+		newSetting.iServiceGroup=RMobilePhone::EAuxVoiceService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for EAuxVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EAuxVoiceService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for ECircuitDataService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::EPacketDataService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for EPacketDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIllegalOperation), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EPacketDataService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::EFaxService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for EFaxService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EFaxService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::EShortMessageService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for EShortMessageService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSIllegalOperation), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EShortMessageService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::ETelephony;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for ETelephony"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for ETelephony failed"));
+		}	
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EVoiceService failed"));
+		
+		// Repeat test with aInfo.iServiceGroup=EAuxVoiceService, ECircuitDataService, EPacketDataService, EFaxService, EShortMessageService, ETelephony 	
+		newSetting.iServiceGroup=RMobilePhone::EAuxVoiceService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for EAuxVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EAuxVoiceService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for ECircuitDataService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::EPacketDataService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for EPacketDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EPacketDataService failed"));
+		
+		newSetting.iServiceGroup=RMobilePhone::EFaxService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for EFaxService"));
+
+		if(operatorName==EOperatorO2 || operatorName==EOperatorOrange)
+			{	
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSTeleserviceNotProvisioned), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EFaxService failed"));
+			}
+		else if(operatorName==EOperatorTMobile)
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EFaxService failed"));
+			}
+
+		newSetting.iServiceGroup=RMobilePhone::EShortMessageService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for EShortMessageService"));
+
+		if(operatorName==EOperatorO2 || operatorName==EOperatorTMobile) 
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EShortMessageService failed"));
+			}
+		else if(operatorName==EOperatorOrange)
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrGsmSSCallBarred), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EShortMessageService failed"));
+			}
+		
+		newSetting.iServiceGroup=RMobilePhone::ETelephony;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for ETelephony"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for ETelephony failed"));
+		}
+	
+	//
+	// TEST END
+	//
+	
+	StartCleanup();
+	
+	// Ensure all call forwarding setting are erased
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+		
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+	
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0008::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0008");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0009::CCTSYIntegrationTestCallForwarding0009(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0009::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0009::~CCTSYIntegrationTestCallForwarding0009()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0009::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0009
+ * @SYMFssID BA/CTSY/CFOR-0009
+ * @SYMTestCaseDesc Interrogate call forwarding status when all services have the same status.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::SetCallForwardingStatus, CRetrieveMobilePhoneCFList::NewL
+ * @SYMTestExpectedResults Pass - Call forwarding status is retrieved, contains one entry and is correct.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding supplementary service list contains one entry and is correct.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsGetCFStatusNetwork | KCapsGetCFStatusCache capabilities.
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);	
+	
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+	
+	TUint32 callServiceCaps = 0;	
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsGetCFStatusNetwork;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	TPtrC number; 
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+
+	// Ensure all call forwarding is erased by calling 
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 
+
+	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+		
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));
+	
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+	
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	ASSERT_EQUALS(iNetworkTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName), KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+	
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	newSetting.iTimeout=-1;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		// ===  Activate call forwarding unconditional for all services ===
+	
+		// 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 
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EVoiceService failed"));
+	
+		newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService failed"));
+	
+		newSetting.iServiceGroup=RMobilePhone::ETelephony;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ETelephony"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ETelephony failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		// ===  Register call forwarding unconditional for all services ===
+		
+		// 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 
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EVoiceService failed"));
+	
+		newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService failed"));
+	
+		newSetting.iServiceGroup=RMobilePhone::ETelephony;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ETelephony"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ETelephony failed"));
+		}
+	else
+		{	
+		ASSERT_EQUALS(1,0,_L("Failed to identify current network"));
+		TEST_CHECK_POINT_L(_L("Failed to identify current network."));
+		}
+	
+	// ===  Retrieve the call forwarding status list ===
+
+	// Use helper class for CRetrieveMobilePhoneCFList to get the call forwarding status list with aCondition=RMobilePhone::ECallForwardingUnconditional, aServiceGroup=RMobilePhone::EAllServices, aLocation=RMobilePhone::EInfoLocationCachePreferred 
+	TInt err;
+
+	CRetrieveMobilePhoneCFListExec* mainCfList = CRetrieveMobilePhoneCFListHelper::NewL(mobilePhone, RMobilePhone::ECallForwardingUnconditional, RMobilePhone::EAllServices, RMobilePhone::EInfoLocationCachePreferred);
+	CleanupStack::PushL(mainCfList);
+	CMobilePhoneCFList* callForwardingList = mainCfList->DoGetList(err);
+	ASSERT_EQUALS(err, KErrNone, _L("CRetrieveMobilePhoneCFListExec::DoGetList is not able to get the list"));
+	
+	ASSERT_TRUE(callForwardingList != NULL, _L("CRetrieveMobilePhoneCFListExec::DoGetList callForwardingList is NULL"));
+	TEST_CHECK_POINT_L(_L("CRetrieveMobilePhoneCFListExec::DoGetList callForwardingList is NULL"));
+	
+	// ===  Get the entries from the call forwarding status list and check the entries are correct ===
+
+	// Check CMobilePhoneCFList::Enumerate returns > 0
+	RMobilePhone::TMobilePhoneCFInfoEntryV1 entry;
+		
+	TInt entries = callForwardingList->Enumerate();
+		
+	ASSERT_TRUE(entries>0, _L("CMobilePhoneCFList::Enumerate return value not greater than 0"));
+	
+	// Check CMobilePhoneCFList::GetEntryL with aIndex=0 returns a RMobilePhone::TMobilePhoneCFInfoEntryV1 with iServiceGroup=RMobilePhone::EAllServices, iStatus=RMobilePhone::ECallForwardingStatusActive, iNumber=same number used to register		
+	TBuf<20> numberToCompare;
+	
+	if(number.Locate('0')==0)
+		{
+		// For the case when 0 is added
+		numberToCompare=number.Mid(1);
+		}
+	else if(number.Locate('4')==0 || number.Locate('4')==1)
+		{
+		// For the case when +440 is added (or something like this)
+		numberToCompare=number.Mid(5);
+		}
+
+	for(TInt i = 0; i<entries; i++)
+		{
+		DEBUG_PRINTF2(_L("Performing CMobilePhoneCFList::GetEntryL on entry at position %d"), i);
+			
+		entry=callForwardingList->GetEntryL(i);
+			
+		switch(entry.iServiceGroup)
+			{
+			case RMobilePhone::EVoiceService:
+			case RMobilePhone::ECircuitDataService:
+			case RMobilePhone::ETelephony:
+				{
+				ASSERT_EQUALS(entry.iStatus, RMobilePhone::ECallForwardingStatusActive, _L("CMobilePhoneCFList::GetEntryL iStatus did not get RMobilePhone::ECallForwardingStatusActive"));
+				DEBUG_PRINTF2(_L("Value for entry.iNumber.iTelNumber: %S"), &entry.iNumber.iTelNumber);
+				ASSERT_TRUE(entry.iNumber.iTelNumber.Find(numberToCompare)>=0, _L("CMobilePhoneCFList::GetEntryL iTelNumber did not find number"));
+				
+				break;
+				}
+			case RMobilePhone::EFaxService:
+			case RMobilePhone::EAuxVoiceService:
+			case RMobilePhone::EPacketDataService:
+				{
+				ASSERT_EQUALS(entry.iStatus, RMobilePhone::ECallForwardingStatusNotRegistered, _L("CMobilePhoneCFList::GetEntryL iStatus did not get RMobilePhone::ECallForwardingStatusNotRegistered"));			
+				break;
+				}
+			default:
+				{
+				DEBUG_PRINTF2(_L("Service %d not accounted for"), entry.iServiceGroup);
+				break;
+				}
+			}
+		}
+				
+	// ===  Erase all call forwarding unconditional ===
+
+	// Erase all call forwarding by calling RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));	
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));
+
+	// ===  Retrieve the call forwarding status list ===
+	
+	// Use the helper class for CRetrieveMobilePhoneCFList to get the call forwarding status list with aCondition=RMobilePhone::ECallForwardingUnconditional, aServiceGroup=RMobilePhone::EAllServices, aLocation=RMobilePhone::EInfoLocationCachePreferred 
+	CRetrieveMobilePhoneCFListExec* mainCfList2 = CRetrieveMobilePhoneCFListHelper::NewL(mobilePhone, RMobilePhone::ECallForwardingUnconditional, RMobilePhone::EAllServices, RMobilePhone::EInfoLocationCachePreferred);
+	CleanupStack::PushL(mainCfList2);
+	callForwardingList = mainCfList2->DoGetList(err);
+	ASSERT_EQUALS(err, KErrNone, _L("CRetrieveMobilePhoneCFListExec::DoGetList is not able to get the list"));
+	
+	ASSERT_TRUE(callForwardingList != NULL, _L("CRetrieveMobilePhoneCFListExec::DoGetList callForwardingList is NULL"));
+	
+	// ===  Get the entries from the call forwarding status list and check the entries are correct ===
+
+	// Check CMobilePhoneCFList::Enumerate returns > 0
+	
+	entries = callForwardingList->Enumerate();
+		
+	ASSERT_TRUE(entries>0, _L("CMobilePhoneCFList::Enumerate return value not greater than 0"));
+			
+	// Check CMobilePhoneCFList::GetEntryL with aIndex=0 returns a RMobilePhone::TMobilePhoneCFInfoEntryV1 with iServiceGroup=RMobilePhone::EAllServices and iStatus=RMobilePhone::ECallForwardingStatusNotRegistered		
+	for(TInt i = 0; i<entries; i++)
+		{
+		DEBUG_PRINTF2(_L("Performing CMobilePhoneCFList::GetEntryL on entry at position %d"), i);
+			
+		entry=callForwardingList->GetEntryL(i);
+			
+		switch(entry.iServiceGroup)
+			{
+			case RMobilePhone::EVoiceService:
+			case RMobilePhone::ECircuitDataService:
+			case RMobilePhone::EFaxService:	
+			case RMobilePhone::EAuxVoiceService:
+			case RMobilePhone::EPacketDataService:
+			case RMobilePhone::ETelephony:
+				{
+				ASSERT_EQUALS(entry.iStatus, RMobilePhone::ECallForwardingStatusNotRegistered, _L("CMobilePhoneCFList::GetEntryL iStatus did not get RMobilePhone::ECallForwardingStatusNotRegistered"));			
+				break;
+				}
+			default:
+				{
+				DEBUG_PRINTF2(_L("Service %d not accounted for"), entry.iServiceGroup);
+				break;
+				}
+			}
+		}
+			
+	//
+	// TEST END
+	//
+	
+    StartCleanup();
+	
+	// Ensure all call forwarding setting are erased
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));
+	
+	CleanupStack::PopAndDestroy(2,mainCfList);
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0009::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0009");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0010::CCTSYIntegrationTestCallForwarding0010(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0010::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0010::~CCTSYIntegrationTestCallForwarding0010()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0010::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0010
+ * @SYMFssID BA/CTSY/CFOR-0010
+ * @SYMTestCaseDesc Interrogate call forwarding status for different conditions and provisioned basic services.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::SetCallForwardingStatus, CRetrieveMobilePhoneCFList::NewL
+ * @SYMTestExpectedResults Pass - Call forwarding status is retrieved and status is that set.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding status list is retrieved with correct entries.
+ *
+ * @return - TVerdict code
+ */
+	{
+	
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsGetCFStatusNetwork | KCapsGetCFStatusCache capabilities.
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);		
+
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+	TUint32 callServiceCaps = 0;	
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsGetCFStatusNetwork;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	TPtrC number; 
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+
+	// Ensure all call forwarding is erased by calling 
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 
+	
+	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));
+	
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+	
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	ASSERT_EQUALS(iNetworkTestHelper.GetCurrentNetworkL(mobilePhone, infopckg, area, operatorName), KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+		
+	// ===   1. Register/Activate call forwarding busy for voice ===
+
+	// Register/Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate (or RMobilePhone::EServiceActionRegister) and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+
+	// ===  Retrieve the call forwarding busy status list and check that voice is active and other provisioned basic services are not registered ===
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		// aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingBusy for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingBusy for EVoiceService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		// 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 
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingBusy for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingBusy for EVoiceService failed"));
+		}
+	else
+		{	
+		ASSERT_EQUALS(1,0,_L("Failed to identify current network"));
+		TEST_CHECK_POINT_L(_L("Failed to identify current network."));
+		}
+
+	// Use the helper class for CRetrieveMobilePhoneCFList::Start to get the call forwarding status list with aCondition=RMobilePhone::ECallForwardingBusy, aServiceGroup=RMobilePhone::EAllServices, aLocation=RMobilePhone::EInfoLocationCachePreferred 
+	TInt err;
+
+	CRetrieveMobilePhoneCFListExec* mainCfList = CRetrieveMobilePhoneCFListHelper::NewL(mobilePhone, RMobilePhone::ECallForwardingBusy, RMobilePhone::EAllServices, RMobilePhone::EInfoLocationCachePreferred);
+	CMobilePhoneCFList* callForwardingList = mainCfList->DoGetList(err);
+	ASSERT_EQUALS(err, KErrNone, _L("CRetrieveMobilePhoneCFListExec::DoGetList is not able to get the list"));
+
+	ASSERT_TRUE(callForwardingList != NULL, _L("CRetrieveMobilePhoneCFListExec::DoGetList callForwardingList is NULL"));
+
+	// Check CMobilePhoneCFList::Enumerate returns > 0
+	RMobilePhone::TMobilePhoneCFInfoEntryV1 entry;
+	TBuf<20> numberToCompare;
+	
+	if(number.Locate('0')==0)
+		{
+		// For the case when 0 is added
+		numberToCompare=number.Mid(1);
+		}
+	else if(number.Locate('4')==0 || number.Locate('4')==1)
+		{
+		// For the case when +440 is added (or something like this)
+		numberToCompare=number.Mid(5);
+		}
+	
+	TInt entries = callForwardingList->Enumerate();
+		
+	ASSERT_TRUE(entries>0, _L("CMobilePhoneCFList::Enumerate return value not greater than 0"));
+		
+	for(TInt i = 0; i<entries; i++)
+		{
+		DEBUG_PRINTF2(_L("Performing CMobilePhoneCFList::GetEntryL on entry at position %d"), i);
+			
+		entry=callForwardingList->GetEntryL(i);
+				
+		switch(entry.iServiceGroup)
+			{
+			case RMobilePhone::EVoiceService:
+				{
+				ASSERT_EQUALS(entry.iStatus, RMobilePhone::ECallForwardingStatusActive, _L("CMobilePhoneCFList::GetEntryL iStatus did not get RMobilePhone::ECallForwardingStatusActive"));
+				DEBUG_PRINTF2(_L("Value for entry.iNumber.iTelNumber: %S"), &entry.iNumber.iTelNumber);
+				ASSERT_TRUE(entry.iNumber.iTelNumber.Find(numberToCompare)>=0, _L("CMobilePhoneCFList::GetEntryL iTelNumber did not find number"));
+			
+				break;
+				}
+			case RMobilePhone::EAuxVoiceService:
+			case RMobilePhone::ECircuitDataService:
+			case RMobilePhone::EPacketDataService:
+			case RMobilePhone::EFaxService:
+				{
+				ASSERT_EQUALS(entry.iStatus, RMobilePhone::ECallForwardingStatusNotRegistered, _L("CMobilePhoneCFList::GetEntryL iStatus did not get RMobilePhone::ECallForwardingStatusNotRegistered"));
+				break;
+				}				
+			default:
+				{
+				DEBUG_PRINTF2(_L("Service %d not accounted for"), entry.iServiceGroup);
+				break;
+				}
+			}
+		}
+
+	// ===  Erase all call forwarding and repeat test ===
+
+	// Erase all call forwarding by calling RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+
+	// Repeat from step 1. registering call forwarding with aInfo.iServiceGroup=RMobilePhone::ECircuitDataService, 
+	// checking that call forwarding is registered for that basic service and not registered for the others.
+	newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService failed"));
+		}
+	
+	mainCfList = CRetrieveMobilePhoneCFListHelper::NewL(mobilePhone, RMobilePhone::ECallForwardingUnconditional, RMobilePhone::EAllServices, RMobilePhone::EInfoLocationCachePreferred);
+	callForwardingList = mainCfList->DoGetList(err);
+	ASSERT_EQUALS(err, KErrNone, _L("CRetrieveMobilePhoneCFListExec::DoGetList is not able to get the list"));
+	
+	ASSERT_TRUE(callForwardingList != NULL, _L("CRetrieveMobilePhoneCFListExec::DoGetList callForwardingList is NULL"));
+	
+	// Check CMobilePhoneCFList::Enumerate returns > 0
+	
+	entries = callForwardingList->Enumerate();
+		
+	ASSERT_TRUE(entries>0, _L("CMobilePhoneCFList::Enumerate return value not greater than 0"));
+		
+	for(TInt i = 0; i<entries; i++)
+		{
+		DEBUG_PRINTF2(_L("Performing CMobilePhoneCFList::GetEntryL on entry at position %d"), i);
+			
+		entry=callForwardingList->GetEntryL(i);
+			
+		switch(entry.iServiceGroup)
+			{
+			case RMobilePhone::ECircuitDataService:
+				{
+				ASSERT_EQUALS(entry.iStatus, RMobilePhone::ECallForwardingStatusActive, _L("CMobilePhoneCFList::GetEntryL iStatus did not get RMobilePhone::ECallForwardingStatusActive"));
+				DEBUG_PRINTF2(_L("Value for entry.iNumber.iTelNumber: %S"), &entry.iNumber.iTelNumber);
+				ASSERT_TRUE(entry.iNumber.iTelNumber.Find(numberToCompare)>=0, _L("CMobilePhoneCFList::GetEntryL iTelNumber did not find number"));
+	
+				break;
+				}
+			case RMobilePhone::EVoiceService:
+			case RMobilePhone::EAuxVoiceService:
+			case RMobilePhone::EPacketDataService:
+			case RMobilePhone::EFaxService:
+				{
+				ASSERT_EQUALS(entry.iStatus, RMobilePhone::ECallForwardingStatusNotRegistered, _L("CMobilePhoneCFList::GetEntryL iStatus did not get RMobilePhone::ECallForwardingStatusNotRegistered"));			
+				break;
+				}
+			default:
+				{
+				DEBUG_PRINTF2(_L("Service %d not accounted for"), entry.iServiceGroup);
+				break;
+				}
+			}
+		}
+	
+	// Erase ECallForwardingAllCases...
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));	
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+	
+	// Repeat the whole test with aCondition=RMobilePhone::ECallForwardingNoReply...
+	newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+
+	if(operatorName==EOperatorVodafone)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingNoReply for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNoReply), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingNoReply for ECircuitDataService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingNoReply for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNoReply), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingNoReply for ECircuitDataService failed"));		
+		}
+	
+	// Retrieve List	
+	mainCfList = CRetrieveMobilePhoneCFListHelper::NewL(mobilePhone, RMobilePhone::ECallForwardingNoReply, RMobilePhone::EAllServices, RMobilePhone::EInfoLocationCachePreferred);
+	callForwardingList = mainCfList->DoGetList(err);
+	ASSERT_EQUALS(err, KErrNone, _L("CRetrieveMobilePhoneCFListExec::DoGetList is not able to get the list"));
+	
+	ASSERT_TRUE(callForwardingList != NULL, _L("CRetrieveMobilePhoneCFListExec::DoGetList callForwardingList is NULL"));
+	
+	// Check CMobilePhoneCFList::Enumerate returns > 0
+	entries = callForwardingList->Enumerate();
+		
+	ASSERT_TRUE(entries>0, _L("CMobilePhoneCFList::Enumerate return value not greater than 0"));
+		
+	for(TInt i = 0; i<entries; i++)
+		{
+		DEBUG_PRINTF2(_L("Performing CMobilePhoneCFList::GetEntryL on entry at position %d"), i);
+			
+		entry=callForwardingList->GetEntryL(i);
+			
+		switch(entry.iServiceGroup)
+			{
+			case RMobilePhone::ECircuitDataService:
+				{
+				ASSERT_EQUALS(entry.iStatus, RMobilePhone::ECallForwardingStatusActive, _L("CMobilePhoneCFList::GetEntryL iStatus did not get RMobilePhone::ECallForwardingStatusActive"));
+				DEBUG_PRINTF2(_L("Value for entry.iNumber.iTelNumber: %S"), &entry.iNumber.iTelNumber);
+				ASSERT_TRUE(entry.iNumber.iTelNumber.Find(numberToCompare)>=0, _L("CMobilePhoneCFList::GetEntryL iTelNumber did not find number"));
+	
+				break;
+				}
+			case RMobilePhone::EVoiceService:
+			case RMobilePhone::EAuxVoiceService:
+			case RMobilePhone::EPacketDataService:
+			case RMobilePhone::EFaxService:
+				{
+				ASSERT_EQUALS(entry.iStatus, RMobilePhone::ECallForwardingStatusNotRegistered, _L("CMobilePhoneCFList::GetEntryL iStatus did not get RMobilePhone::ECallForwardingStatusNotRegistered"));			
+				break;
+				}
+			default:
+				{
+				DEBUG_PRINTF2(_L("Service %d not accounted for"), entry.iServiceGroup);
+				break;
+				}
+			}
+		}
+	
+	// Erase ECallForwardingAllCases...
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+	
+	// Repeat the whole test with aCondition=RMobilePhone::ECallForwardingNotReachable...
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingNotReachable for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNotReachable), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingNotReachable for EVoiceService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingNotReachable for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNotReachable), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingNotReachable for EVoiceService failed"));
+		}
+	
+	// Retrieve List
+	mainCfList = CRetrieveMobilePhoneCFListHelper::NewL(mobilePhone, RMobilePhone::ECallForwardingNotReachable, RMobilePhone::EAllServices, RMobilePhone::EInfoLocationCachePreferred);
+	callForwardingList = mainCfList->DoGetList(err);
+	ASSERT_EQUALS(err, KErrNone, _L("CRetrieveMobilePhoneCFListExec::DoGetList is not able to get the list"));
+	
+	ASSERT_TRUE(callForwardingList != NULL, _L("CRetrieveMobilePhoneCFListExec::DoGetList callForwardingList is NULL"));
+	
+	// Check CMobilePhoneCFList::Enumerate returns > 0
+	entries = callForwardingList->Enumerate();
+		
+	ASSERT_TRUE(entries>0, _L("CMobilePhoneCFList::Enumerate return value not greater than 0"));
+		
+	for(TInt i = 0; i<entries; i++)
+		{
+		DEBUG_PRINTF2(_L("Performing CMobilePhoneCFList::GetEntryL on entry at position %d"), i);
+			
+		entry=callForwardingList->GetEntryL(i);
+			
+		switch(entry.iServiceGroup)
+			{
+			case RMobilePhone::EVoiceService:
+				{
+				ASSERT_EQUALS(entry.iStatus, RMobilePhone::ECallForwardingStatusActive, _L("CMobilePhoneCFList::GetEntryL iStatus did not get RMobilePhone::ECallForwardingStatusActive"));
+				DEBUG_PRINTF2(_L("Value for entry.iNumber.iTelNumber: %S"), &entry.iNumber.iTelNumber);
+				ASSERT_TRUE(entry.iNumber.iTelNumber.Find(numberToCompare)>=0, _L("CMobilePhoneCFList::GetEntryL iTelNumber did not find number"));
+	
+				break;
+				}
+			case RMobilePhone::EFaxService:
+			case RMobilePhone::EAuxVoiceService:
+			case RMobilePhone::ECircuitDataService:
+			case RMobilePhone::EPacketDataService:
+				{
+				ASSERT_EQUALS(entry.iStatus, RMobilePhone::ECallForwardingStatusNotRegistered, _L("CMobilePhoneCFList::GetEntryL iStatus did not get RMobilePhone::ECallForwardingStatusNotRegistered"));			
+				break;
+				}
+			default:
+				{
+				DEBUG_PRINTF2(_L("Service %d not accounted for"), entry.iServiceGroup);
+				break;
+				}
+			}
+		}
+	
+	//
+	// TEST END
+	//
+
+    StartCleanup();
+	
+	// Ensure all call forwarding setting are erased
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));
+
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0010::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0010");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0011::CCTSYIntegrationTestCallForwarding0011(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0011::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0011::~CCTSYIntegrationTestCallForwarding0011()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0011::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0011
+ * @SYMFssID BA/CTSY/CFOR-0011
+ * @SYMTestCaseDesc Dial a call on a line with call forwarding unconditional active on it.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::SetCallForwardingStatus, RCall::Dial, RCall::HangUp, RMobileCall::NotifyMobileCallStatusChange
+ * @SYMTestExpectedResults Pass - Call forwarding active notification completes.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding active notification compeltes.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus  
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+	
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+	
+	TUint32 callServiceCaps = 0;
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+	
+	TPtrC number;
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	
+	// Ensure all call forwarding is erased by calling 
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 
+
+	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	TExtEtelRequestStatus setCallForwardStatus(mobilePhone, EMobilePhoneSetCallForwardingStatus);
+	CleanupStack::PushL(setCallForwardStatus);
+	mobilePhone.SetCallForwardingStatus(setCallForwardStatus, RMobilePhone::ECallForwardingAllCases, newSetting);
+	CHECK_EQUALS_L(WaitForRequestWithTimeOut(setCallForwardStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SetCallForwardingStatus timed-out"));
+	CHECK_EQUALS_L(setCallForwardStatus.Int(), KErrNone, _L("RMobilePhone::SetCallForwardingStatus setCallForwardStatus completed with incorrect error"));
+
+	// Get Voice Line 1.
+	RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);
+
+	// Get Call 1.
+	RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);	
+
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+
+	// ===  Activate/Register call forwarding unconditional for voice ===
+	
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	ASSERT_EQUALS(iNetworkTestHelper.GetCurrentNetworkL(mobilePhone, infopckg, area, operatorName), KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+		
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EVoiceService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		// Register call forwarding using 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 
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EVoiceService failed"));
+		}
+	else
+		{	
+		ASSERT_EQUALS(1,0,_L("Failed to identify current network"));
+		TEST_CHECK_POINT_L(_L("Failed to identify current network."));
+		}
+
+	// Post notifier for RMobileCall::NotifyMobileCallStatusChange
+	TExtEtelRequestStatus notifyMobileCallStatus(mobileCall, EMobileCallNotifyMobileCallStatusChange);
+	CleanupStack::PushL(notifyMobileCallStatus);
+	RMobileCall::TMobileCallStatus mobileCallStatus;
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	// Post notifier for RMobilePhone::NotifyCallForwardingActive
+	TExtEtelRequestStatus notifyCallForwardStatus(mobilePhone, EMobilePhoneNotifyCallForwardingActive);
+	CleanupStack::PushL(notifyCallForwardStatus);
+	RMobilePhone::TMobileService serviceGroup;
+	RMobilePhone::TMobilePhoneCFActive activeType;
+	mobilePhone.NotifyCallForwardingActive(notifyCallForwardStatus, serviceGroup, activeType);
+	
+	// Dial a number that answers on call 1 with RCall::Dial.
+	TPtrC outgoingnumber; 
+	ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber2, outgoingnumber) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Board Now Dialling: %S"), &outgoingnumber);
+	TCoreEtelRequestStatus<RCall> dialStatus(mobileCall, &RCall::DialCancel);
+	CleanupStack::PushL(dialStatus);
+	mobileCall.Dial(dialStatus, outgoingnumber);
+	
+	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RMobileCall::Dial timed-out"));
+	ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RMobileCall::Dial error whilst dialing"));
+	
+	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected.
+	RMobileCall::TMobileCallStatus expectedMobileCallStatus=RMobileCall::EStatusDialling;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	expectedMobileCallStatus=RMobileCall::EStatusConnecting;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+		
+	expectedMobileCallStatus=RMobileCall::EStatusConnected;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	// $CTSYProblem Currently NotifyCallForwardingActive is not being completed by LTSY. Hence
+	// this will not return the correct values which are expected for this test.
+	// If this API becomes supported, then the following code can be uncommented.
+    
+	// Check RMobilePhone::NotifyCallForwardingActive completes with aServiceGroup=EVoiceService , aActiveType=ECFUnconditionalActive
+	/*iCallForwardingSupplementalHelper.WaitForMobilePhoneNotifyCallForwardingActive(mobilePhone,
+																				   notifyCallForwardStatus,
+																				   serviceGroup,
+																				   RMobilePhone::EVoiceService,
+																				   activeType,
+																				   KErrNone);*/
+
+	//ASSERT_EQUALS(activeType, RMobilePhone::ECFUnconditionalActive, _L("activeType is not RMobilePhone::ECFUnconditionalActive"));
+	
+	
+	// ===  Check call forwarding active indication completes ===
+
+	// Hang up call with RCall::HangUp
+	DEBUG_PRINTF1(_L("Hangup call"));
+	ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RCall::HangUp return value not KErrNone"));
+	
+	// Check RCall::NotifyMobileCallStatusChange completes with EStatusDisconnecting -> EStatusIdle.
+	expectedMobileCallStatus=RMobileCall::EStatusDisconnecting;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	expectedMobileCallStatus=RMobileCall::EStatusIdle;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+
+	// ===  Erase all call forwarding for next part of test ===
+
+	// Erase call forwarding by calling RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+	
+	//
+	// TEST END
+	//
+	
+    StartCleanup();
+    
+	CleanupStack::PopAndDestroy(&dialStatus);
+	CleanupStack::PopAndDestroy(&notifyCallForwardStatus);
+	CleanupStack::PopAndDestroy(&notifyMobileCallStatus);
+	CleanupStack::PopAndDestroy(&setCallForwardStatus);
+	
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0011::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0011");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0012::CCTSYIntegrationTestCallForwarding0012(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0012::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0012::~CCTSYIntegrationTestCallForwarding0012()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0012::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0012
+ * @SYMFssID BA/CTSY/CFOR-0012
+ * @SYMTestCaseDesc Dial a call on a line with call forwarding active.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::SetCallForwardingStatus, RCall::Dial, RCall::HangUp, RMobileCall::NotifyMobileCallStatusChange
+ * @SYMTestExpectedResults Pass - Call forwarding active notification completes.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding active notification compeltes.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus  
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+	TUint32 callServiceCaps = 0;
+	TPtrC number;
+	
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+	
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+	
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+
+	// Ensure all call forwarding is erased by calling 
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 
+
+	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+
+	// Get voice line 1. 	
+	RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);
+	
+	// Get call 1. 			
+	RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer,KMainPhone, KVoiceLine, KCall1);
+	
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+	
+	// ===  Activate/Register call forwarding ===
+
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	ASSERT_EQUALS(iNetworkTestHelper.GetCurrentNetworkL(mobilePhone, infopckg, area, operatorName), KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingBusy and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingBusy for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingBusy for EVoiceService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingBusy 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 
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingBusy for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingBusy for EVoiceService failed"));
+		}
+	else
+		{	
+		ASSERT_EQUALS(1,0,_L("Failed to identify current network"));
+		TEST_CHECK_POINT_L(_L("Failed to identify current network."));
+		}
+	
+	// Post notifier for RMobileCall::NotifyMobileCallStatusChange
+	TExtEtelRequestStatus notifyMobileCallStatus(mobileCall, EMobileCallNotifyMobileCallStatusChange);
+	CleanupStack::PushL(notifyMobileCallStatus);
+	RMobileCall::TMobileCallStatus mobileCallStatus;
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+
+	// Post notifier for RMobilePhone::NotifyCallForwardingActive
+	TExtEtelRequestStatus notifyCallForwardStatus(mobilePhone, EMobilePhoneNotifyCallForwardingActive);
+	CleanupStack::PushL(notifyCallForwardStatus);
+	RMobilePhone::TMobileService serviceGroup;
+	RMobilePhone::TMobilePhoneCFActive activeType;
+	mobilePhone.NotifyCallForwardingActive(notifyCallForwardStatus, serviceGroup, activeType);
+	
+	// Dial a number that answers on call 1 with RCall::Dial. 
+	TPtrC outGoingNumber; 
+	ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber2, outGoingNumber) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Board Now Dialling: %S"), &outGoingNumber);
+	TCoreEtelRequestStatus<RCall> dialStatus(mobileCall, &RCall::DialCancel);
+	CleanupStack::PushL(dialStatus);
+	mobileCall.Dial(dialStatus, outGoingNumber);
+	
+	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RMobileCall::Dial timed-out"));
+	ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RMobileCall::Dial error whilst dialing"));
+
+	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected.
+	RMobileCall::TMobileCallStatus expectedMobileCallStatus=RMobileCall::EStatusDialling;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	expectedMobileCallStatus=RMobileCall::EStatusConnecting;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+		
+	expectedMobileCallStatus=RMobileCall::EStatusConnected;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	// ===  Check call forwarding active indication completes ===
+
+	// $CTSYProblem Currently NotifyCallForwardingActive is not being completed by LTSY. Hence
+	// this will not return the correct values which are expected for this test.
+	// The following section can be uncommented if RMobilePhone::NotifyCallForwardingActive is correctly implemented.
+	// The request is sent from CTSY to the LTSY, but the CTSY never gets a response back from the LTSY.
+	/*
+	// Check RMobilePhone::NotifyCallForwardingActive completes with aServiceGroup=EVoiceService , aActiveType=ECFConditionalActive
+	iCallForwardingSupplementalHelper.WaitForMobilePhoneNotifyCallForwardingActive(mobilePhone,
+																				   notifyCallForwardStatus,
+																				   serviceGroup,
+																				   RMobilePhone::EVoiceService,
+																				   activeType,
+																				   KErrNone);
+	
+	ASSERT_EQUALS(activeType, RMobilePhone::ECFUnconditionalActive, _L("activeType is not RMobilePhone::ECFUnconditionalActive"));
+	*/
+	
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	// Hang up call with RCall::HangUp 
+	DEBUG_PRINTF1(_L("Hangup call"));
+	ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RCall::HangUp return value not KErrNone"));
+	
+	// Check RCall::NotifyStatusChange completes with EStatusDisconnecting -> EStatusIdle.
+	expectedMobileCallStatus=RMobileCall::EStatusDisconnecting;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	expectedMobileCallStatus=RMobileCall::EStatusIdle;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	// ===  Erase all call forwarding for next part of test ===
+
+	// Erase call forwarding by calling RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+	
+	// Repeat test with ECallForwardingNotReachable
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingNotReachable for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNotReachable), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingNotReachable for EVoiceService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingNotReachable for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNotReachable), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingNotReachable for EVoiceService failed"));
+		}
+
+	// Repost notifiers
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	// $CTSYProblem Currently NotifyCallForwardingActive is not being completed by LTSY. Hence
+	// this will not return the correct values which are expected for this test.
+	// The following section can be uncommented if RMobilePhone::NotifyCallForwardingActive is correctly implemented.
+	// The request is sent from CTSY to the LTSY, but the CTSY never gets a response back from the LTSY.
+	/*
+	mobilePhone.NotifyCallForwardingActive(notifyCallForwardStatus, serviceGroup, activeType);
+	*/
+	mobileCall.Dial(dialStatus, outGoingNumber);
+	
+	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RMobileCall::Dial timed-out"));
+	ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RMobileCall::Dial error whilst dialing"));
+	
+	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected.
+	expectedMobileCallStatus=RMobileCall::EStatusDialling;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	expectedMobileCallStatus=RMobileCall::EStatusConnecting;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+		
+	expectedMobileCallStatus=RMobileCall::EStatusConnected;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	// ===  Check call forwarding active indication completes ===
+
+	// $CTSYProblem Currently NotifyCallForwardingActive is not being completed by LTSY. Hence
+	// this will not return the correct values which are expected for this test.
+	// The following section can be uncommented if RMobilePhone::NotifyCallForwardingActive is correctly implemented.
+	// The request is sent from CTSY to the LTSY, but the CTSY never gets a response back from the LTSY.
+	
+	/*
+	// Check RMobilePhone::NotifyCallForwardingActive completes with aServiceGroup=EVoiceService , aActiveType=ECFConditionalActive
+	iCallForwardingSupplementalHelper.WaitForMobilePhoneNotifyCallForwardingActive(mobilePhone,
+			   																	   notifyCallForwardStatus,
+			   																	   serviceGroup,
+			   																	   RMobilePhone::EVoiceService,
+			   																	   activeType,
+			   																	   KErrNone);
+
+	ASSERT_EQUALS(activeType, RMobilePhone::ECFUnconditionalActive, _L("activeType is not RMobilePhone::ECFUnconditionalActive"));
+	*/
+	
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	// Hang up call with RCall::HangUp 
+	DEBUG_PRINTF1(_L("Hangup call"));
+	ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RCall::HangUp return value not KErrNone"));
+	
+	// Check RCall::NotifyStatusChange completes with EStatusDisconnecting -> EStatusIdle.
+	expectedMobileCallStatus=RMobileCall::EStatusDisconnecting;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	expectedMobileCallStatus=RMobileCall::EStatusIdle;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	// Erase call forwarding by calling RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+
+	// Repeat test with ECallForwardingNoReply and aInfo.iTimeOut=20 
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	newSetting.iTimeout=20;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingNoReply for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNoReply), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingNoReply for EVoiceService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingNoReply for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingNoReply), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingNoReply for EVoiceService failed"));
+		}
+	
+	// Repost notifiers
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	// $CTSYProblem Currently NotifyCallForwardingActive is not being completed by LTSY. Hence
+	// this will not return the correct values which are expected for this test.
+	// The following section can be uncommented if RMobilePhone::NotifyCallForwardingActive is correctly implemented.
+	// The request is sent from CTSY to the LTSY, but the CTSY never gets a response back from the LTSY.
+	
+	/*
+	mobilePhone.NotifyCallForwardingActive(notifyCallForwardStatus, serviceGroup, activeType);
+	*/
+	mobileCall.Dial(dialStatus, outGoingNumber);
+	
+	ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RMobileCall::Dial timed-out"));
+	ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RMobileCall::Dial error whilst dialing"));
+	
+	// Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected.
+	expectedMobileCallStatus=RMobileCall::EStatusDialling;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	expectedMobileCallStatus=RMobileCall::EStatusConnecting;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+		
+	expectedMobileCallStatus=RMobileCall::EStatusConnected;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	// ===  Check call forwarding active indication completes ===
+	
+	// $CTSYProblem Currently NotifyCallForwardingActive is not being completed by LTSY. Hence
+	// this will not return the correct values which are expected for this test.
+	// The following section can be uncommented if RMobilePhone::NotifyCallForwardingActive is correctly implemented.
+	// The request is sent from CTSY to the LTSY, but the CTSY never gets a response back from the LTSY.
+	
+	/*
+	// Check RMobilePhone::NotifyCallForwardingActive completes with aServiceGroup=EVoiceService , aActiveType=ECFConditionalActive
+	iCallForwardingSupplementalHelper.WaitForMobilePhoneNotifyCallForwardingActive(mobilePhone,
+			   																	   notifyCallForwardStatus,
+			   																	   serviceGroup,
+			   																	   RMobilePhone::EVoiceService,
+			   																	   activeType,
+			   																	   KErrNone);
+
+	ASSERT_EQUALS(activeType, RMobilePhone::ECFUnconditionalActive, _L("activeType is not RMobilePhone::ECFUnconditionalActive"));
+	*/
+	
+	// Hang up call with RCall::HangUp 
+	DEBUG_PRINTF1(_L("Hangup call"));
+	ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RCall::HangUp return value not KErrNone"));
+	
+	// Check RCall::NotifyStatusChange completes with EStatusDisconnecting -> EStatusIdle.
+	expectedMobileCallStatus=RMobileCall::EStatusDisconnecting;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+
+	mobileCall.NotifyMobileCallStatusChange(notifyMobileCallStatus, mobileCallStatus);
+	
+	expectedMobileCallStatus=RMobileCall::EStatusIdle;
+	iCallForwardingControlHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall,
+																			   notifyMobileCallStatus,
+																			   mobileCallStatus,
+																			   expectedMobileCallStatus,
+																			   KErrNone);
+	
+	//
+	// TEST END
+	//
+
+    StartCleanup(); 
+	
+    CleanupStack::PopAndDestroy(&dialStatus);
+	CleanupStack::PopAndDestroy(&notifyCallForwardStatus);
+    CleanupStack::PopAndDestroy(&notifyMobileCallStatus);
+	
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0012::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0012");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0013::CCTSYIntegrationTestCallForwarding0013(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0013::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0013::~CCTSYIntegrationTestCallForwarding0013()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0013::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0013
+ * @SYMFssID BA/CTSY/CFOR-0013
+ * @SYMTestCaseDesc Change the 'forward to' number.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange
+ * @SYMTestExpectedResults Pass - Call forwarding status change notification completes when forward to number is changed.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding status change notification completes.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+	
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);	
+	TUint32 callServiceCaps = 0;
+
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+	
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	TPtrC number; 
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+
+	// Ensure all call forwarding is erased by calling 
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 
+
+	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));
+	
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+
+	// ===  Activate/Register call forwarding busy for voice ===
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	ASSERT_EQUALS(iNetworkTestHelper.GetCurrentNetworkL(mobilePhone, infopckg, area, operatorName), KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+	
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with ECallForwardingUnconditional for EVoiceService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::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 
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with ECallForwardingUnconditional for EVoiceService failed"));
+		}
+	else
+		{	
+		ASSERT_EQUALS(1,0,_L("Failed to identify current network"));
+		TEST_CHECK_POINT_L(_L("Failed to identify current network."));
+		}
+
+	// aInfo.iAction=RMobilePhone::EServiceActionDeactivate and aInfo.iServiceGroup=RMobilePhone::EVoiceService, aInfo.iTimeOut=-1 
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iAction=RMobilePhone::EServiceActionDeactivate;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionDeactivate ECallForwardingUnconditional for EVoiceService"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionDeactivate ECallForwardingUnconditional for EVoiceService failed"));
+	
+	// ===  Activate/Register call forwarding busy for voice with a different number ===
+	TPtrC anotherNumber; 
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber2, anotherNumber) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("New number obtained: %S"), &anotherNumber);
+	
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iNumber.iTelNumber=anotherNumber;
+
+	if(operatorName==EOperatorVodafone)
+		{
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=different valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EVoiceService"));	
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with ECallForwardingUnconditional for EVoiceService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionRegister and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=different valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EVoiceService"));	
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with ECallForwardingUnconditional for EVoiceService failed"));
+		}
+	//
+	// TEST END
+	//
+
+    StartCleanup();
+	
+	// Ensure all call forwarding setting are erased
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingUnconditional for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingUnconditional for EAllServices failed"));
+    
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0013::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0013");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0014::CCTSYIntegrationTestCallForwarding0014(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0014::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0014::~CCTSYIntegrationTestCallForwarding0014()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0014::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0014
+ * @SYMFssID BA/CTSY/CFOR-0014
+ * @SYMTestCaseDesc Change the 'no reply' time out.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::NotifyCallForwardingStatusChange
+ * @SYMTestExpectedResults Pass - Call forwarding status change notification completes when time out is changed.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding status change notification completes.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);	
+	TUint32 callServiceCaps = 0;
+
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+	
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	TPtrC number; 
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+
+	// Ensure all call forwarding is erased by calling 
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 
+
+	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	CHECK_TRUE_L(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+	
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+	
+	// === Activate/Register call forwarding no reply for voice ===
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	ASSERT_EQUALS(iNetworkTestHelper.GetCurrentNetworkL(mobilePhone, infopckg, area, operatorName), KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+	
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	newSetting.iTimeout=10;
+
+	if(operatorName==EOperatorVodafone)
+		{
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingNoReply and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=10 
+		// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingBusy
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingBusy for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingBusy for EVoiceService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{	
+		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingNoReply 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=10 
+		// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingBusy
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingBusy for EVoiceService"));
+		if(operatorName==EOperatorTMobile || operatorName==EOperatorO2)
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingBusy for EVoiceService failed"));			
+			}
+		else
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingBusy for EVoiceService failed"));			
+			}
+		}
+	else
+		{	
+		ASSERT_EQUALS(1,0,_L("Failed to identify current network"));
+		TEST_CHECK_POINT_L(_L("Failed to identify current network."));
+		}
+	
+	// ===  Activate/Register call forwarding no reply for voice with a different time out ===
+
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iAction=RMobilePhone::EServiceActionActivate;
+	newSetting.iTimeout=20;
+	
+	if(operatorName==EOperatorVodafone)
+		{	
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingNoReply and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=different valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=20 
+		// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingBusy
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingBusy for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingBusy for EVoiceService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingNoReply and aInfo.iAction=RMobilePhone::EServiceActionRegister and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=different valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=20 
+		// Check RMobilePhone::NotifyCallForwardingStatusChange completes with aCondition=ECallForwardingBusy
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingBusy for EVoiceService"));
+		if(operatorName==EOperatorTMobile || operatorName==EOperatorO2)
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy, KErrGsmSSUnexpectedDataValue), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingBusy for EVoiceService failed"));
+			}
+		else
+			{
+			ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingBusy), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingBusy for EVoiceService failed"));
+			}
+		}
+	
+	//
+	// TEST END
+	//
+
+    StartCleanup();
+	
+	// Ensure all call forwarding setting are erased
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionErase ECallForwardingAllCases for EAllServices"));
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingAllCases), _L("SetCallForwardingStatusUtil with EServiceActionErase ECallForwardingAllCases for EAllServices failed"));
+	
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0014::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0014");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0015::CCTSYIntegrationTestCallForwarding0015(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0015::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0015::~CCTSYIntegrationTestCallForwarding0015()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0015::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0015
+ * @SYMFssID BA/CTSY/CFOR-0015
+ * @SYMTestCaseDesc Get call forwarding indication status.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::SetCallForwardingStatus
+ * @SYMTestExpectedResults Pass - Call forwarding indicator is retrieved.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify call forwarding indication retrieved.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus | KCapsNotifyCFStatus
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);	
+	
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+	
+	TUint32 callServiceCaps = 0;
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus | RMobilePhone::KCapsNotifyCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	TPtrC number; 
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+
+	// Ensure all call forwarding is erased by calling 
+
+	// RMobilePhone::SetCallForwardingStatus with aCondition=RMobilePhone::ECallForwardingAllCases and 
+
+	// aInfo.iAction=RMobilePhone::EServiceActionErase and aInfo.iServiceGroup=RMobilePhone::EAllServices, aInfo.iTimeOut=-1 
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	newSetting.iTimeout=-1;
+	
+	TExtEtelRequestStatus setCallForwardStatus(mobilePhone, EMobilePhoneSetCallForwardingStatus);
+	CleanupStack::PushL(setCallForwardStatus);
+	mobilePhone.SetCallForwardingStatus(setCallForwardStatus, RMobilePhone::ECallForwardingAllCases, newSetting);
+	CHECK_EQUALS_L(WaitForRequestWithTimeOut(setCallForwardStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SetCallForwardingStatus timed-out"));
+	CHECK_EQUALS_L(setCallForwardStatus.Int(), KErrNone, _L("RMobilePhone::SetCallForwardingStatus setCallForwardStatus completed with incorrect error"));
+
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+		
+	// ===  Activate/Register call forwarding unconditional for voice ===
+	RMobilePhone::TMobilePhoneNetworkInfoV1 info;
+	RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info);
+	RMobilePhone::TMobilePhoneLocationAreaV1 area;
+	TOperatorName operatorName = EOperatorUnknown;
+	ASSERT_EQUALS(iNetworkTestHelper.GetCurrentNetworkL(mobilePhone, infopckg, area, operatorName), KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)"));
+	
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+
+	if(operatorName==EOperatorVodafone)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionActivate;
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for EVoiceService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		newSetting.iAction=RMobilePhone::EServiceActionRegister;
+		// Register call forwarding using 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 
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for EVoiceService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for EVoiceService failed"));
+		}
+	else
+		{	
+		ASSERT_EQUALS(1,0,_L("Failed to identify current network"));
+		TEST_CHECK_POINT_L(_L("Failed to identify current network."));
+		}
+		
+	// ===  Get call forwarding indicator ===
+
+	// Check RMobilePhone::GetCallForwardingIndicator returns KErrNotSupported
+	RMobilePhone::TMobilePhoneCFUIndicatorV6 cfuIndicator;
+    RMobilePhone::TMobilePhoneCFUIndicatorV6Pckg cfuIndicatorPackg(cfuIndicator);
+    
+	TExtEtelRequestStatus getCallForwardingStatus(mobilePhone, EMobilePhoneGetCallForwardingIndicator);
+	CleanupStack::PushL(getCallForwardingStatus);
+	mobilePhone.GetCallForwardingIndicator(getCallForwardingStatus, cfuIndicatorPackg);
+	
+	ASSERT_EQUALS(WaitForRequestWithTimeOut(getCallForwardingStatus, ETimeMedium), KErrNone, _L("RMobilePhone::GetCallForwardingIndicator timed-out"));
+	ASSERT_EQUALS(getCallForwardingStatus.Int(), KErrNotSupported, _L("RMobilePhone::GetCallForwardingStatus getCallForwardStatus completed with incorrect error"));
+	
+	expectedServiceCaps = 0;
+	
+	ASSERT_BITS_SET(cfuIndicator.iIndicator, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallForwardingIndicator returned wrong caps"));
+
+	// === Activate/Register call forwarding unconditional for circuit switch data ===	
+	newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::ECircuitDataService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService"));	
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionRegister and aInfo.iServiceGroup=RMobilePhone::ECircuitDataService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService"));	
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService failed"));
+		}
+
+	// ===  Get call forwarding indicator ===
+
+	// Check RMobilePhone::GetCallForwardingIndicator returns KErrNotSupported
+	mobilePhone.GetCallForwardingIndicator(getCallForwardingStatus, cfuIndicatorPackg);
+	
+	ASSERT_EQUALS(WaitForRequestWithTimeOut(getCallForwardingStatus, ETimeMedium), KErrNone, _L("RMobilePhone::GetCallForwardingIndicator timed-out."));
+	ASSERT_EQUALS(getCallForwardingStatus.Int(), KErrNotSupported, _L("RMobilePhone::GetCallForwardingStatus getCallForwardStatus completed with incorrect error"));	
+	
+	expectedServiceCaps = 0;
+	
+	ASSERT_BITS_SET(cfuIndicator.iIndicator, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallForwardingIndicator returned wrong caps"));
+
+	// ===  Activate/Register call forwarding unconditional for circuit switch data ===
+	newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::ECircuitDataService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionRegister and aInfo.iServiceGroup=RMobilePhone::ECircuitDataService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService failed"));		
+		}
+	
+	// ===  Get call forwarding indicator ===
+
+	// Check RMobilePhone::GetCallForwardingIndicator returns KErrNotSupported
+	mobilePhone.GetCallForwardingIndicator(getCallForwardingStatus, cfuIndicatorPackg);
+	
+	ASSERT_EQUALS(WaitForRequestWithTimeOut(getCallForwardingStatus, ETimeMedium), KErrNone, _L("RMobilePhone::GetCallForwardingIndicator timed-out"));
+	ASSERT_EQUALS(getCallForwardingStatus.Int(), KErrNotSupported, _L("RMobilePhone::GetCallForwardingStatus getCallForwardStatus completed with incorrect error"));
+
+	expectedServiceCaps = 0;
+	
+	ASSERT_BITS_SET(cfuIndicator.iIndicator, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallForwardingIndicator returned wrong caps"));
+
+	// ===  Activate/Register call forwarding unconditional for circuit switch data ===
+	newSetting.iServiceGroup=RMobilePhone::ECircuitDataService;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::EPacketDataService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ECircuitDataService failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionRegister and aInfo.iServiceGroup=RMobilePhone::EPacketDataService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 	
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ECircuitDataService failed"));
+		}
+	
+	// ===  Get call forwarding indicator ===
+
+	// Check RMobilePhone::GetCallForwardingIndicator returns KErrNotSupported
+	mobilePhone.GetCallForwardingIndicator(getCallForwardingStatus, cfuIndicatorPackg);
+	
+	ASSERT_EQUALS(WaitForRequestWithTimeOut(getCallForwardingStatus, ETimeMedium), KErrNone, _L("RMobilePhone::GetCallForwardingIndicator timed-out."));
+	ASSERT_EQUALS(getCallForwardingStatus.Int(), KErrNotSupported, _L("RMobilePhone::GetCallForwardingStatus getCallForwardStatus completed with incorrect error"));
+	
+	expectedServiceCaps = 0;
+	
+	ASSERT_BITS_SET(cfuIndicator.iIndicator, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallForwardingIndicator returned wrong caps"));
+	
+	// ===  Activate/Register call forwarding unconditional for Telephony ===
+	
+	newSetting.iServiceGroup=RMobilePhone::ETelephony;
+	
+	if(operatorName==EOperatorVodafone)
+		{
+		// Activate call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionActivate and aInfo.iServiceGroup=RMobilePhone::ETelephony and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionActivate ECallForwardingUnconditional for ETelephony"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionActivate ECallForwardingUnconditional for ETelephony failed"));
+		}
+	else if(operatorName==EOperatorO2 || operatorName==EOperatorOrange || operatorName==EOperatorTMobile)
+		{
+		// Register call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionRegister and aInfo.iServiceGroup=RMobilePhone::ETelephony and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1
+		DEBUG_PRINTF1(_L("Setting call forward EServiceActionRegister ECallForwardingUnconditional for ETelephony"));
+		ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional), _L("SetCallForwardingStatusUtil with EServiceActionRegister ECallForwardingUnconditional for ETelephony failed"));
+		}
+	
+	// ===  Get call forwarding indicator ===
+
+	// Check RMobilePhone::GetCallForwardingIndicator returns KErrNotSupported
+	mobilePhone.GetCallForwardingIndicator(getCallForwardingStatus, cfuIndicatorPackg);
+	
+	ASSERT_EQUALS(WaitForRequestWithTimeOut(getCallForwardingStatus, ETimeMedium), KErrNone, _L("RMobilePhone::GetCallForwardingIndicator timed-out."));
+	ASSERT_EQUALS(getCallForwardingStatus.Int(), KErrNotSupported, _L("RMobilePhone::GetCallForwardingStatus getCallForwardStatus completed with incorrect error"));
+    	
+	expectedServiceCaps = 0;
+	
+	ASSERT_BITS_SET(cfuIndicator.iIndicator, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallForwardingIndicator returned wrong caps"));
+
+	//
+	// TEST END
+	//
+	
+    StartCleanup();
+	
+	// Ensure all call forwarding setting are erased
+	newSetting.iServiceGroup=RMobilePhone::EAllServices;
+	newSetting.iAction=RMobilePhone::EServiceActionErase;
+	
+	mobilePhone.SetCallForwardingStatus(setCallForwardStatus, RMobilePhone::ECallForwardingAllCases, newSetting);
+	ASSERT_EQUALS(WaitForRequestWithTimeOut(setCallForwardStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SetCallForwardingStatus timed-out"));
+	ASSERT_EQUALS(setCallForwardStatus.Int(), KErrNone, _L("RMobilePhone::SetCallForwardingStatus setCallForwardStatus completed with incorrect error"));
+		
+	CleanupStack::PopAndDestroy(&getCallForwardingStatus);
+	CleanupStack::PopAndDestroy(&setCallForwardStatus);
+	
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0015::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0015");
+	}
+
+
+
+CCTSYIntegrationTestCallForwarding0016::CCTSYIntegrationTestCallForwarding0016(CEtelSessionMgr& aEtelSessionMgr)
+	: CCTSYIntegrationTestCallForwardingBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+	{
+	SetTestStepName(CCTSYIntegrationTestCallForwarding0016::GetTestStepName());
+	}
+
+CCTSYIntegrationTestCallForwarding0016::~CCTSYIntegrationTestCallForwarding0016()
+/**
+ * Destructor.
+ */
+	{
+	}
+
+TVerdict CCTSYIntegrationTestCallForwarding0016::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-CFOR-0016
+ * @SYMFssID BA/CTSY/CFOR-0016
+ * @SYMTestCaseDesc Invoke call forwarding
+ * @SYMTestPriority High
+ * @SYMTestActions 
+ * @SYMTestExpectedResults Pass - KErrArgument returned.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify KErrArgument is returned.
+ *
+ * @return - TVerdict code
+ */
+	{
+
+	//
+	// SET UP
+	//
+	
+	// Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCFStatus
+	RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);	
+	
+	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		
+	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+	
+	TUint32 callServiceCaps = 0;
+	CHECK_EQUALS_L(mobilePhone.GetCallServiceCaps(callServiceCaps), KErrNone, _L("RMobilePhone::GetCallServiceCaps return value is not KErrNone"));
+	TUint32 expectedServiceCaps = RMobilePhone::KCapsSetCFStatus;
+	CHECK_BITS_SET_L(callServiceCaps, expectedServiceCaps, KNoUnwantedBits, _L("RMobilePhone::GetCallServiceCaps returned wrong caps"));
+
+	TPtrC number; 
+	CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+	DEBUG_PRINTF2(_L("Number obtained: %S"), &number);
+
+	//
+	// SET UP END
+	//
+	
+	StartTest();
+	
+	//
+	// TEST START
+	//
+		
+	// Invoke call forwarding using RMobilePhone::SetCallForwardingStatus with aCondition=ECallForwardingUnconditional and aInfo.iAction=RMobilePhone::EServiceActionInvoke and aInfo.iServiceGroup=RMobilePhone::EVoiceService and aInfo.iNumber.iNumberPlan=EIsdnNumberPlan, aInfo.iNumber.iTelNumber=valid number, aInfo.iNumber.iTypeOfNumber=ENationalNumber, aInfo.iTimeout=-1 
+	// Check KErrArgument is returned.
+	RMobilePhone::TMobilePhoneCFChangeV1 newSetting;
+	newSetting.iServiceGroup=RMobilePhone::EVoiceService;
+	newSetting.iAction=RMobilePhone::EServiceActionInvoke;
+	newSetting.iNumber.iTelNumber=number;
+	newSetting.iNumber.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
+	newSetting.iNumber.iTypeOfNumber=RMobilePhone::ENationalNumber;
+	newSetting.iTimeout=-1;
+	
+	DEBUG_PRINTF1(_L("Setting call forward EServiceActionInvoke ECallForwardingUnconditional for EVoiceService"));	
+	ASSERT_TRUE(SetCallForwardingStatusUtilL(mobilePhone, newSetting, RMobilePhone::ECallForwardingUnconditional, KErrArgument), _L("SetCallForwardingStatusUtil with EServiceActionInvoke ECallForwardingUnconditional for EVoiceService failed"));
+	
+	//
+	// TEST END
+	//
+
+    StartCleanup();
+	
+	return TestStepResult();
+	}
+
+TPtrC CCTSYIntegrationTestCallForwarding0016::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+	{
+	return _L("CCTSYIntegrationTestCallForwarding0016");
+	}