diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/common_tsy/test/integration/src/cctsyintegrationtestcallwaiting.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/common_tsy/test/integration/src/cctsyintegrationtestcallwaiting.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,1920 @@ +// 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 CallWaiting functional unit. +// +// + +/** + @internalTechnology +*/ + +#include "cctsyintegrationtestcallwaiting.h" +#include "cctsyinidata.h" +#include + +CCTSYIntegrationTestCallWaitingBase::CCTSYIntegrationTestCallWaitingBase(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), iCallControlTsyTestHelper(*this), iSupplementalTsyTestHelper(*this), iNetworkTsyTestHelper(*this) +/** + * Constructor + */ + { + + } + +CCTSYIntegrationTestCallWaitingBase::~CCTSYIntegrationTestCallWaitingBase() +/* + * Destructor + */ + { + } + +CCTSYIntegrationTestCallWaiting0001::CCTSYIntegrationTestCallWaiting0001(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestCallWaitingBase(aEtelSessionMgr) +/** + * Constructor. + */ + { + SetTestStepName(CCTSYIntegrationTestCallWaiting0001::GetTestStepName()); + } + +CCTSYIntegrationTestCallWaiting0001::~CCTSYIntegrationTestCallWaiting0001() +/** + * Destructor. + */ + { + } + +TVerdict CCTSYIntegrationTestCallWaiting0001::doTestStepL() +/** + * @SYMTestCaseID BA-CTSY-INT-CWAT-0001 + * @SYMFssID BA/CTSY/CWAT-0001 + * @SYMTestCaseDesc Activate and deactivate call waiting for all services. + * @SYMTestPriority High + * @SYMTestActions RMobilePhone::NotifyCallWaitingStatusChange + * @SYMTestExpectedResults Pass - Call waiting is activated for all services. + * @SYMTestType CIT + * @SYMTestCaseDependencies live/automatic + * + * Reason for test: Verify call waiting status change notification completes. + * + * @return - TVerdict code + */ + { + + // + // SET UP + // + + // Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCWStatus | KCapsNotifyCWStatus + RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone); + TUint32 callServiceCaps; + TInt err = mobilePhone.GetCallServiceCaps(callServiceCaps); + CHECK_EQUALS_L(err, KErrNone, + _L("RMobilePhone::GetCallServiceCaps returned with an error")) + TUint32 expectedCaps = RMobilePhone::KCapsSetCWStatus | RMobilePhone::KCapsNotifyCWStatus; + TUint32 unwantedCaps = 0; + CHECK_BITS_SET_L(callServiceCaps, expectedCaps, unwantedCaps, _L("RMobilePhone::GetCallServiceCaps returned incorrect caps")) + + TInt ret = iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone); + CHECK_EQUALS_L(ret, KErrNone, + _L("RMobilePhone::NotifyNetworkRegistrationStatusChange network registration failed")); + + // Deactivate all call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=RMobilePhone::EAllServices and aAction=RMobilePhone::EServiceActionDeactivate + RMobilePhone::TMobileService mobileService = RMobilePhone::EAllServices; + RMobilePhone::TMobilePhoneServiceAction mobilePhoneServiceAction = RMobilePhone::EServiceActionDeactivate; + TExtEtelRequestStatus mobilePhoneSetCallWaitingStatus(mobilePhone, EMobilePhoneSetCallWaitingStatus); + CleanupStack::PushL(mobilePhoneSetCallWaitingStatus); + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + CHECK_EQUALS_L(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + CHECK_EQUALS_L(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // + // SET UP END + // + + StartTest(); + + // + // TEST START + // + + // post notification for setCallWaitingStatus + TExtEtelRequestStatus notifyCallWaitingStatusChangeStatus(mobilePhone,EMobilePhoneNotifyCallWaitingStatusChange); + CleanupStack::PushL(notifyCallWaitingStatusChangeStatus); + RMobilePhone::TMobilePhoneCWInfoEntryV1 mobilePhoneCWInfoEntryV1; + RMobilePhone::TMobilePhoneCWInfoEntryV1Pckg mobilePhoneCWInfoEntryV1Pckg(mobilePhoneCWInfoEntryV1); + mobilePhone.NotifyCallWaitingStatusChange(notifyCallWaitingStatusChangeStatus,mobilePhoneCWInfoEntryV1Pckg); + + // Activate call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EAllServices and aAction=EServiceActionActivate + mobilePhoneServiceAction = RMobilePhone::EServiceActionActivate; + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")); + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")); + + // Check RMobilePhone::NotifyCallWaitingStatusChange completes with iServiceGroup=EAllServices and iStatus=ECallWaitingStatusActive + TCmpBase mobilePhoneCWInfoEntryV1CmpBase(mobilePhoneCWInfoEntryV1,mobilePhoneCWInfoEntryV1,*this); + iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallWaitingStatusChange(mobilePhone, + notifyCallWaitingStatusChangeStatus,mobilePhoneCWInfoEntryV1CmpBase, KErrNone); + ASSERT_EQUALS(mobilePhoneCWInfoEntryV1.iServiceGroup , mobileService, + _L("RMobilePhone::NotifyCallWaitingStatusChange returned with an error")); + ASSERT_EQUALS(mobilePhoneCWInfoEntryV1.iStatus, RMobilePhone::ECallWaitingStatusActive, + _L("RMobilePhone::NotifyCallWaitingStatusChange returned wrong iStatus")); + + // Deactivate call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EAllServices and aAction=EServiceActionDeactivate + mobilePhone.NotifyCallWaitingStatusChange(notifyCallWaitingStatusChangeStatus,mobilePhoneCWInfoEntryV1Pckg); + mobilePhoneServiceAction = RMobilePhone::EServiceActionDeactivate; + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")); + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")); + + // Check RMobilePhone::NotifyCallWaitingStatusChange completes with iServiceGroup=EAllServices and iStatus=ECallWaitingStatusNotActive + iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallWaitingStatusChange(mobilePhone,notifyCallWaitingStatusChangeStatus,mobilePhoneCWInfoEntryV1CmpBase, KErrNone); + ASSERT_EQUALS(mobilePhoneCWInfoEntryV1.iServiceGroup , mobileService, + _L("RMobilePhone::NotifyCallWaitingStatusChange returned with an error")); + ASSERT_EQUALS(mobilePhoneCWInfoEntryV1.iStatus, RMobilePhone::ECallWaitingStatusNotActive, + _L("RMobilePhone::NotifyCallWaitingStatusChange returned wrong iStatus")); + + // + // TEST END + // + + StartCleanup(); + + // 1 mobilePhoneSetCallWaitingStatus + // 2 notifyCallWaitingStatusChangeStatus + CleanupStack::PopAndDestroy(2,&mobilePhoneSetCallWaitingStatus); + + return TestStepResult(); + } + +TPtrC CCTSYIntegrationTestCallWaiting0001::GetTestStepName() +/** + * @return The test step name. + */ + { + return _L("CCTSYIntegrationTestCallWaiting0001"); + } + + + +CCTSYIntegrationTestCallWaiting0002::CCTSYIntegrationTestCallWaiting0002(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestCallWaitingBase(aEtelSessionMgr) +/** + * Constructor. + */ + { + SetTestStepName(CCTSYIntegrationTestCallWaiting0002::GetTestStepName()); + } + +CCTSYIntegrationTestCallWaiting0002::~CCTSYIntegrationTestCallWaiting0002() +/** + * Destructor. + */ + { + } + +TVerdict CCTSYIntegrationTestCallWaiting0002::doTestStepL() +/** + * @SYMTestCaseID BA-CTSY-INT-CWAT-0002 + * @SYMFssID BA/CTSY/CWAT-0002 + * @SYMTestCaseDesc Activate and deactivate call waiting for each provisioned basic service + * @SYMTestPriority High + * @SYMTestActions RMobilePhone::NotifyCallWaitingStatusChange + * @SYMTestExpectedResults Pass - Call waiting is activated for provisioned basic services. + * @SYMTestType CIT + * @SYMTestCaseDependencies live/automatic + * + * Reason for test: Verify call waiting status change notification completes. + * + * @return - TVerdict code + */ + { + + // + // SET UP + // + + + // Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCWStatus | KCapsNotifyCWStatus + RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone); + TUint32 callServiceCaps; + TInt err = mobilePhone.GetCallServiceCaps(callServiceCaps); + CHECK_EQUALS_L(err, KErrNone, + _L("RMobilePhone::GetCallServiceCaps returned with an error")) + TUint32 expectedCaps = RMobilePhone::KCapsSetCWStatus | RMobilePhone::KCapsNotifyCWStatus; + TUint32 unwantedCaps = 0; + CHECK_BITS_SET_L(callServiceCaps, expectedCaps, unwantedCaps, _L("RMobilePhone::GetCallServiceCaps returned incorrect caps")) + + TInt ret = iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone); + CHECK_EQUALS_L(ret, KErrNone, + _L("RMobilePhone::NotifyNetworkRegistrationStatusChange network registration failed")); + + // Deactivate all call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=RMobilePhone::EAllServices and aAction=RMobilePhone::EServiceActionDeactivate + RMobilePhone::TMobileService mobileService = RMobilePhone::EAllServices; + RMobilePhone::TMobilePhoneServiceAction mobilePhoneServiceAction = RMobilePhone::EServiceActionDeactivate; + TExtEtelRequestStatus mobilePhoneSetCallWaitingStatus(mobilePhone, EMobilePhoneSetCallWaitingStatus); + CleanupStack::PushL(mobilePhoneSetCallWaitingStatus); + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + CHECK_EQUALS_L(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")); + CHECK_EQUALS_L(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")); + + // + // SET UP END + // + + StartTest(); + + // + // TEST START + // + + // Repeat whole test with aServiceGroup= EVoiceService,ECircuitDataService, EFaxService, ETelephony + + TUint32 count = 4; + RArray mobileServiceList; + ASSERT_EQUALS(mobileServiceList.Append(RMobilePhone::EVoiceService), + KErrNone,_L("RArray::Append returned with an error")); + ASSERT_EQUALS(mobileServiceList.Append(RMobilePhone::ECircuitDataService), + KErrNone,_L("RArray::Append returned with an error")); + ASSERT_EQUALS(mobileServiceList.Append(RMobilePhone::EFaxService), + KErrNone,_L("RArray::Append returned with an error")); + ASSERT_EQUALS(mobileServiceList.Append(RMobilePhone::ETelephony), + KErrNone,_L("RArray::Append returned with an error")); + + RMobilePhone::TMobilePhoneNetworkInfoV1 info; + RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info); + RMobilePhone::TMobilePhoneLocationAreaV1 area; + TOperatorName operatorName = EOperatorUnknown; + err = iNetworkTsyTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName ); + ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)")); + + switch ( operatorName ) + { + case EOperatorO2: + count = 1; //O2 supports only speech + break; + case EOperatorVodafone: + case EOperatorOrange: + case EOperatorTMobile: + count = 4; //vodafone, orange and tmobile support speech, voice and data + break; + case EOperatorUnknown: + default: + ASSERT_EQUALS(1,0,_L("Failed to identify current network")); + TEST_CHECK_POINT_L(_L("Failed to identify current network.")); + break; + } + + + + for(TInt i = 0; i < count; i++) + { + DEBUG_PRINTF2(_L("loop iteration for service : %d"),mobileServiceList[i]); + // post notification for setCallWaiting status + TExtEtelRequestStatus notifyCallWaitingStatusChangeStatus(mobilePhone,EMobilePhoneNotifyCallWaitingStatusChange); + CleanupStack::PushL(notifyCallWaitingStatusChangeStatus); + RMobilePhone::TMobilePhoneCWInfoEntryV1 mobilePhoneCWInfoEntryV1; + RMobilePhone::TMobilePhoneCWInfoEntryV1Pckg mobilePhoneCWInfoEntryV1Pckg(mobilePhoneCWInfoEntryV1); + mobilePhone.NotifyCallWaitingStatusChange(notifyCallWaitingStatusChangeStatus,mobilePhoneCWInfoEntryV1Pckg); + + // Activate call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup= and aAction=EServiceActionActivate + mobileService = mobileServiceList[i]; + mobilePhoneServiceAction = RMobilePhone::EServiceActionActivate; + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeLong), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // Check RMobilePhone::NotifyCallWaitingStatusChange completes with iServiceGroup= and iStatus=ECallWaitingStatusActive + TCmpBase mobilePhoneCWInfoEntryV1CmpBase(mobilePhoneCWInfoEntryV1, + mobilePhoneCWInfoEntryV1,*this); + iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallWaitingStatusChange(mobilePhone, + notifyCallWaitingStatusChangeStatus,mobilePhoneCWInfoEntryV1CmpBase, KErrNone); + ASSERT_EQUALS(mobilePhoneCWInfoEntryV1.iServiceGroup , mobileService, + _L("RMobilePhone::NotifyCallWaitingStatusChange returned with an error")) + ASSERT_EQUALS(mobilePhoneCWInfoEntryV1.iStatus, RMobilePhone::ECallWaitingStatusActive, + _L("RMobilePhone::NotifyCallWaitingStatusChange returned wrong iStatus")) + + // Deactivate call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup= and aAction=EServiceActionDeactivate + mobilePhone.NotifyCallWaitingStatusChange(notifyCallWaitingStatusChangeStatus,mobilePhoneCWInfoEntryV1Pckg); + mobilePhoneServiceAction = RMobilePhone::EServiceActionDeactivate; + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // Check RMobilePhone::NotifyCallWaitingStatusChange completes with iServiceGroup= and iStatus=ECallWaitingStatusNotActive + iSupplementalTsyTestHelper.WaitForMobilePhoneNotifyCallWaitingStatusChange(mobilePhone,notifyCallWaitingStatusChangeStatus,mobilePhoneCWInfoEntryV1CmpBase, KErrNone); + ASSERT_EQUALS(mobilePhoneCWInfoEntryV1.iServiceGroup , mobileService, + _L("RMobilePhone::NotifyCallWaitingStatusChange returned with an error")) + ASSERT_EQUALS(mobilePhoneCWInfoEntryV1.iStatus, RMobilePhone::ECallWaitingStatusNotActive, + _L("RMobilePhone::NotifyCallWaitingStatusChange returned with an error")) + + CleanupStack::PopAndDestroy(¬ifyCallWaitingStatusChangeStatus); + } + + // + // TEST END + // + + StartCleanup(); + CleanupStack::PopAndDestroy(&mobilePhoneSetCallWaitingStatus); + + return TestStepResult(); + } + +TPtrC CCTSYIntegrationTestCallWaiting0002::GetTestStepName() +/** + * @return The test step name. + */ + { + return _L("CCTSYIntegrationTestCallWaiting0002"); + } + + + +CCTSYIntegrationTestCallWaiting0003::CCTSYIntegrationTestCallWaiting0003(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestCallWaitingBase(aEtelSessionMgr) +/** + * Constructor. + */ + { + SetTestStepName(CCTSYIntegrationTestCallWaiting0003::GetTestStepName()); + } + +CCTSYIntegrationTestCallWaiting0003::~CCTSYIntegrationTestCallWaiting0003() +/** + * Destructor. + */ + { + } + +TVerdict CCTSYIntegrationTestCallWaiting0003::doTestStepL() +/** + * @SYMTestCaseID BA-CTSY-INT-CWAT-0003 + * @SYMFssID BA/CTSY/CWAT-0003 + * @SYMTestCaseDesc Attempt to activate and deactivate Call Waiting when it is not provisioned on the SIM. + * @SYMTestPriority High + * @SYMTestActions + * @SYMTestExpectedResults Pass - Call waiting cannot be activated. + * @SYMTestType CIT + * @SYMTestCaseDependencies live/manual + * + * Reason for test: Verify error is returned. + * + * @return - TVerdict code + */ + { + + // + // SET UP + // + + + + // + // SET UP END + // + + StartTest(); + + // + // TEST START + // + + + // Activate call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EVoiceService and aAction=EServiceActionActivate + + // Check error is returned. + + // Deactivate call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EVoiceService and aAction=EServiceActionDeactivate + + // Check error is returned. + + + // + // TEST END + // + + StartCleanup(); + + // Put any required test clean up here, then remove this comment + + return TestStepResult(); + } + +TPtrC CCTSYIntegrationTestCallWaiting0003::GetTestStepName() +/** + * @return The test step name. + */ + { + return _L("CCTSYIntegrationTestCallWaiting0003"); + } + + + +CCTSYIntegrationTestCallWaiting0004::CCTSYIntegrationTestCallWaiting0004(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestCallWaitingBase(aEtelSessionMgr) +/** + * Constructor. + */ + { + SetTestStepName(CCTSYIntegrationTestCallWaiting0004::GetTestStepName()); + } + +CCTSYIntegrationTestCallWaiting0004::~CCTSYIntegrationTestCallWaiting0004() +/** + * Destructor. + */ + { + } + +TVerdict CCTSYIntegrationTestCallWaiting0004::doTestStepL() +/** + * @SYMTestCaseID BA-CTSY-INT-CWAT-0004 + * @SYMFssID BA/CTSY/CWAT-0004 + * @SYMTestCaseDesc Attempt to register, invoke and erase call waiting. + * @SYMTestPriority High + * @SYMTestActions + * @SYMTestExpectedResults Pass - KErrArgument is 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 KCapsSetCWStatus + RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone); + TUint32 callServiceCaps; + TInt err = mobilePhone.GetCallServiceCaps(callServiceCaps); + CHECK_EQUALS_L(err, KErrNone, + _L("RMobilePhone::GetCallServiceCaps returned with an error")) + TUint32 expectedCaps = RMobilePhone::KCapsSetCWStatus; + TUint32 unwantedCaps = 0; + CHECK_BITS_SET_L(callServiceCaps, expectedCaps, unwantedCaps, _L("RMobilePhone::GetCallServiceCaps returned incorrect caps")) + + TInt ret = iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone); + CHECK_EQUALS_L(ret, KErrNone, + _L("RMobilePhone::NotifyNetworkRegistrationStatusChange network registration failed")); + + // + // SET UP END + // + + StartTest(); + + // + // TEST START + // + + + // Register call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EVoiceService and aAction=EServiceActionRegister + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + RMobilePhone::TMobilePhoneServiceAction mobilePhoneServiceAction = RMobilePhone::EServiceActionRegister; + TExtEtelRequestStatus mobilePhoneSetCallWaitingStatus(mobilePhone, EMobilePhoneSetCallWaitingStatus); + CleanupStack::PushL(mobilePhoneSetCallWaitingStatus); + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")); + + // Check KErrArgument is returned. + CHECK_EQUALS_L(mobilePhoneSetCallWaitingStatus.Int(), KErrArgument, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // Invoke call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EVoiceService and aAction=EServiceActionInvoke + mobilePhoneServiceAction = RMobilePhone::EServiceActionInvoke; + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")); + + // Check KErrArgument is returned. + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrArgument, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")); + + // Erase call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EVoiceService and aAction=EServiceActionErase + mobilePhoneServiceAction = RMobilePhone::EServiceActionErase; + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")); + + // Check KErrArgument is returned. + CHECK_EQUALS_L(mobilePhoneSetCallWaitingStatus.Int(), KErrArgument, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // + // TEST END + // + + StartCleanup(); + + CleanupStack::PopAndDestroy(&mobilePhoneSetCallWaitingStatus); + + return TestStepResult(); + } + +TPtrC CCTSYIntegrationTestCallWaiting0004::GetTestStepName() +/** + * @return The test step name. + */ + { + return _L("CCTSYIntegrationTestCallWaiting0004"); + } + + + +CCTSYIntegrationTestCallWaiting0005::CCTSYIntegrationTestCallWaiting0005(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestCallWaitingBase(aEtelSessionMgr) +/** + * Constructor. + */ + { + SetTestStepName(CCTSYIntegrationTestCallWaiting0005::GetTestStepName()); + } + +CCTSYIntegrationTestCallWaiting0005::~CCTSYIntegrationTestCallWaiting0005() +/** + * Destructor. + */ + { + } + +TVerdict CCTSYIntegrationTestCallWaiting0005::doTestStepL() +/** + * @SYMTestCaseID BA-CTSY-INT-CWAT-0005 + * @SYMFssID BA/CTSY/CWAT-0005 + * @SYMTestCaseDesc Interrogate call waiting for all services. + * @SYMTestPriority High + * @SYMTestActions RMobilePhone::SetCallWaitingStatus + * @SYMTestExpectedResults Pass - Call waiting status list is retrieved. + * @SYMTestType CIT + * @SYMTestCaseDependencies live/automatic + * + * Reason for test: Verify call waiting status list is correct. + * + * @return - TVerdict code + */ + { + // + // SET UP + // + + // Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCWStatus | KCapsGetCWStatusNetwork + RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone); + TUint32 callServiceCaps; + TInt err = mobilePhone.GetCallServiceCaps(callServiceCaps); + CHECK_EQUALS_L(err, KErrNone, + _L("RMobilePhone::GetCallServiceCaps returned with an error")) + TUint32 expectedCaps = RMobilePhone::KCapsSetCWStatus + | RMobilePhone::KCapsGetCWStatusNetwork; + TUint32 unwantedCaps = 0; + CHECK_BITS_SET_L(callServiceCaps, expectedCaps, unwantedCaps, _L("RMobilePhone::GetCallServiceCaps returned incorrect caps")) + + TInt ret = iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone); + CHECK_EQUALS_L(ret, KErrNone, + _L("RMobilePhone::NotifyNetworkRegistrationStatusChange network registration failed")); + + // Deactivate all call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=RMobilePhone::EAllServices and aAction=RMobilePhone::EServiceActionDeactivate + RMobilePhone::TMobileService mobileService = RMobilePhone::EAllServices; + RMobilePhone::TMobilePhoneServiceAction mobilePhoneServiceAction = RMobilePhone::EServiceActionDeactivate; + TExtEtelRequestStatus mobilePhoneSetCallWaitingStatus(mobilePhone, EMobilePhoneSetCallWaitingStatus); + CleanupStack::PushL(mobilePhoneSetCallWaitingStatus); + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + CHECK_EQUALS_L(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + CHECK_EQUALS_L(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // + // SET UP END + // + + StartTest(); + + // + // TEST START + // + + // Activate call waiting for all services with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EAllServices and aAction=EServiceActionActivate + mobilePhoneServiceAction = RMobilePhone::EServiceActionActivate; + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // Retrieve the call waiting status list using the helper class for CRetrieveMobilePhoneCWList with aLocation=RMobilePhone::EInfoLocationCachePreferred + CRetrieveMobilePhoneCWListExec *cwListExec; + cwListExec = CRetrieveMobilePhoneCWListHelper::NewL(mobilePhone); + CleanupStack::PushL(cwListExec); + CMobilePhoneCWList* cwList; + TInt error = 0; + cwList = cwListExec->DoGetList(error); + ASSERT_EQUALS(error, KErrNone, _L("CRetrieveMobilePhoneCWList::RetrieveListL returned with an error")) + + // Check CMobilePhoneCWList::Enumerate on the retrieved list returns number of entries > 0 + TInt noOfEntries = cwList->Enumerate(); + ASSERT_TRUE( noOfEntries > 0, + _L("CRetrieveMobilePhoneCWList::Enumerate returned zero entries")) + + // Check CMobilePhoneCWList::GetEntryL with aIndex=0 returns a RMobilePhone::TMobilePhoneCWInfoEntryV1 with iStatus=ECallWaitingStatusActive for atleast ETelephony and EFaxService + TBool faxFlag = EFalse; + TBool telFlag = EFalse; + for(TInt i = 0; i < noOfEntries; ++i) + { + const RMobilePhone::TMobilePhoneCWInfoEntryV1& cwInfoEntry = cwList->GetEntryL(i); + switch(cwInfoEntry.iServiceGroup) + { + case RMobilePhone::EFaxService: + ASSERT_EQUALS(cwInfoEntry.iServiceGroup, RMobilePhone::EFaxService, + _L("CRetrieveMobilePhoneCWList::GetEntryL returned wrong iServiceGroup")) + ASSERT_EQUALS(cwInfoEntry.iStatus, RMobilePhone::ECallWaitingStatusActive, + _L("CRetrieveMobilePhoneCWList::GetEntryL returned wrong iStatus")) + faxFlag = ETrue; + break; + case RMobilePhone::ETelephony: + ASSERT_EQUALS(cwInfoEntry.iServiceGroup, RMobilePhone::ETelephony, + _L("CRetrieveMobilePhoneCWList::GetEntryL returned wrong iServiceGroup")) + ASSERT_EQUALS(cwInfoEntry.iStatus, RMobilePhone::ECallWaitingStatusActive, + _L("CRetrieveMobilePhoneCWList::GetEntryL returned wrong iStatus")) + telFlag = ETrue; + break; + default: + break; + } + } + ASSERT_TRUE(telFlag && faxFlag, _L("CRetrieveMobilePhoneCWList::GetEntryL EFaxService or ETelephony are not activated")) + + // Deactivate all call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=RMobilePhone::EAllServices and aAction=RMobilePhone::EServiceActionDeactivate + mobilePhoneServiceAction = RMobilePhone::EServiceActionDeactivate; + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // Retrieve the call waiting status list using the helper class for CRetrieveMobilePhoneCWList with aLocation=RMobilePhone::EInfoLocationCachePreferred + error = 0; + cwList = cwListExec->DoGetList(error); + ASSERT_EQUALS(error, KErrNone, _L("CRetrieveMobilePhoneCWList::RetrieveListL is not able to get the list")) + + // Check CMobilePhoneCWList::Enumerate returns number of entries > 0 + noOfEntries = cwList->Enumerate(); + ASSERT_TRUE( noOfEntries > 0, + _L("CRetrieveMobilePhoneCWList::Enumerate returned with an error")); + + // Check CMobilePhoneCWList::GetEntryL with aIndex=0 returns a RMobilePhone::TMobilePhoneCWInfoEntryV1 with iServiceGroup=EAllServices and iStatus=ECallWaitingStatusNotActive + const RMobilePhone::TMobilePhoneCWInfoEntryV1& cwInfoEntry1 = cwList->GetEntryL(0); + ASSERT_EQUALS(cwInfoEntry1.iServiceGroup, mobileService, + _L("CRetrieveMobilePhoneCWList::GetEntryL returned with an error")) + ASSERT_EQUALS(cwInfoEntry1.iStatus, RMobilePhone::ECallWaitingStatusNotActive, + _L("CRetrieveMobilePhoneCWList::GetEntryL returned with an error")) + + // + // TEST END + // + + StartCleanup(); + + CleanupStack::PopAndDestroy(2, &mobilePhoneSetCallWaitingStatus); + + return TestStepResult(); + } + +TPtrC CCTSYIntegrationTestCallWaiting0005::GetTestStepName() +/** + * @return The test step name. + */ + { + return _L("CCTSYIntegrationTestCallWaiting0005"); + } + + + +CCTSYIntegrationTestCallWaiting0006::CCTSYIntegrationTestCallWaiting0006(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestCallWaitingBase(aEtelSessionMgr) +/** + * Constructor. + */ + { + SetTestStepName(CCTSYIntegrationTestCallWaiting0006::GetTestStepName()); + } + +CCTSYIntegrationTestCallWaiting0006::~CCTSYIntegrationTestCallWaiting0006() +/** + * Destructor. + */ + { + } + +TVerdict CCTSYIntegrationTestCallWaiting0006::doTestStepL() +/** + * @SYMTestCaseID BA-CTSY-INT-CWAT-0006 + * @SYMFssID BA/CTSY/CWAT-0006 + * @SYMTestCaseDesc Interrogate call waiting for provisioned basic services. + * @SYMTestPriority High + * @SYMTestActions RMobilePhone::SetCallWaitingStatus + * @SYMTestExpectedResults Pass - Call waiting status list is retrieved and is correct. + * @SYMTestType CIT + * @SYMTestCaseDependencies live/automatic + * + * Reason for test: Verify call waiting status list is correct. + * + * @return - TVerdict code + */ + { + + // + // SET UP + // + + // Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCWStatus | KCapsGetCWStatusNetwork + RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone); + TUint32 callServiceCaps; + TInt err = mobilePhone.GetCallServiceCaps(callServiceCaps); + CHECK_EQUALS_L(err, KErrNone, + _L("RMobilePhone::GetCallServiceCaps returned with an error")) + TUint32 expectedCaps = RMobilePhone::KCapsSetCWStatus | RMobilePhone::KCapsNotifyCWStatus; + TUint32 unwantedCaps = 0; + CHECK_BITS_SET_L(callServiceCaps, expectedCaps, unwantedCaps, _L("RMobilePhone::GetCallServiceCaps returned incorrect caps")) + + TInt ret = iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone); + CHECK_EQUALS_L(ret, KErrNone, + _L("RMobilePhone::NotifyNetworkRegistrationStatusChange network registration failed")); + + // Deactivate all call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=RMobilePhone::EAllServices and aAction=RMobilePhone::EServiceActionDeactivate + RMobilePhone::TMobileService mobileService = RMobilePhone::EAllServices; + RMobilePhone::TMobilePhoneServiceAction mobilePhoneServiceAction = RMobilePhone::EServiceActionDeactivate; + TExtEtelRequestStatus mobilePhoneSetCallWaitingStatus(mobilePhone, EMobilePhoneSetCallWaitingStatus); + CleanupStack::PushL(mobilePhoneSetCallWaitingStatus); + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + CHECK_EQUALS_L(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")); + CHECK_EQUALS_L(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")); + + // + // SET UP END + // + + StartTest(); + + // + // TEST START + // + + // Repeat whole test with aServiceGroup=EVoiceService, ECircuitDataService, EFaxService, active and checking for the appropriate active and not active services. + TUint32 count = 3; + RArray mobileServiceList; + ASSERT_EQUALS(mobileServiceList.Append(RMobilePhone::EVoiceService), + KErrNone,_L("RArray::Append returned with an error")); + ASSERT_EQUALS(mobileServiceList.Append(RMobilePhone::ECircuitDataService), + KErrNone,_L("RArray::Append returned with an error")); + ASSERT_EQUALS(mobileServiceList.Append(RMobilePhone::EFaxService), + KErrNone,_L("RArray::Append returned with an error")); + + + RMobilePhone::TMobilePhoneNetworkInfoV1 info; + RMobilePhone::TMobilePhoneNetworkInfoV1Pckg infopckg(info); + RMobilePhone::TMobilePhoneLocationAreaV1 area; + TOperatorName operatorName = EOperatorUnknown; + err = iNetworkTsyTestHelper.GetCurrentNetworkL( mobilePhone, infopckg, area, operatorName ); + ASSERT_EQUALS( err, KErrNone, _L("RMobilePhone::GetCurrentNetwork failed to get current network id (1)")); + + switch ( operatorName ) + { + case EOperatorO2: + count = 1; //O2 supports only speech + break; + case EOperatorVodafone: + case EOperatorOrange: + case EOperatorTMobile: + count = 3; //vodafone, orange and tmobile support speech, voice and data + break; + case EOperatorUnknown: + default: + CHECK_TRUE_L( EFail, _L("Failed to identify current network")); + break; + } + + CRetrieveMobilePhoneCWListExec *cwListExec; + cwListExec = CRetrieveMobilePhoneCWListHelper::NewL(mobilePhone); + CleanupStack::PushL(cwListExec); + + for(TInt i=0; i < count; ++i) + { + DEBUG_PRINTF2(_L("loop iteration for service : %d"),mobileServiceList[i]); + // Activate call waiting for all services with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EVoiceService and aAction=EServiceActionActivate + mobileService = mobileServiceList[i]; + mobilePhoneServiceAction = RMobilePhone::EServiceActionActivate; + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // Retrieve the call waiting status list with CRetrieveMobilePhoneCWList::Start with aLocation=RMobilePhone::EInfoLocationCachePreferred + + // === Retrieve the call waiting status list and check that it is active === + // === for the voice service and not active for the other basic services === + // Use the helper class for CRetrieveMobilePhoneCWList to retrieve call waiting list + TInt error = 0; + CMobilePhoneCWList* cwList; + cwList = cwListExec->DoGetList(error); + ASSERT_EQUALS(error, KErrNone, _L("CRetrieveMobilePhoneCWList::RetrieveListL is not able to get the list")) + + // Check CMobilePhoneCWList::Enumerate returns number of entries >= 1 + TInt noOfEntries = cwList->Enumerate(); + ASSERT_TRUE( noOfEntries >= 1 , + _L("CRetrieveMobilePhoneCWList::Enumerate returned incorrect information")) + + // Check CMobilePhoneCWList::GetEntryL returns status of service as active + const RMobilePhone::TMobilePhoneCWInfoEntryV1& cwInfoEntry = cwList->GetEntryL(0); + ASSERT_EQUALS(cwInfoEntry.iStatus, RMobilePhone::ECallWaitingStatusActive, + _L("CRetrieveMobilePhoneCWList::GetEntryL returned wrong iStatus")) + + // === Deactivate all call waiting and repeat === + // Deactivate all call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=RMobilePhone::EAllServices and aAction=RMobilePhone::EServiceActionDeactivate + mobileService = RMobilePhone::EAllServices; + mobilePhoneServiceAction = RMobilePhone::EServiceActionDeactivate; + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + } + + // + // TEST END + // + + StartCleanup(); + + CleanupStack::PopAndDestroy(2,&mobilePhoneSetCallWaitingStatus); + + return TestStepResult(); + } + +TPtrC CCTSYIntegrationTestCallWaiting0006::GetTestStepName() +/** + * @return The test step name. + */ + { + return _L("CCTSYIntegrationTestCallWaiting0006"); + } + + + +CCTSYIntegrationTestCallWaiting0007::CCTSYIntegrationTestCallWaiting0007(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestCallWaitingBase(aEtelSessionMgr) +/** + * Constructor. + */ + { + SetTestStepName(CCTSYIntegrationTestCallWaiting0007::GetTestStepName()); + } + +CCTSYIntegrationTestCallWaiting0007::~CCTSYIntegrationTestCallWaiting0007() +/** + * Destructor. + */ + { + } + +TVerdict CCTSYIntegrationTestCallWaiting0007::doTestStepL() +/** + * @SYMTestCaseID BA-CTSY-INT-CWAT-0007 + * @SYMFssID BA/CTSY/CWAT-0007 + * @SYMTestCaseDesc Interrogate call waiting status after activation and deactivation. + * @SYMTestPriority High + * @SYMTestActions RMobilePhone::SetCallWaitingStatus + * @SYMTestExpectedResults Pass - Call waiting status is correct. + * @SYMTestType CIT + * @SYMTestCaseDependencies live/automatic + * + * Reason for test: Verify call waiting status list is correct. + * + * @return - TVerdict code + */ + { + + // + // SET UP + // + + // Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCWStatus | KCapsGetCWStatusNetwork + RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone); + TUint32 callServiceCaps; + TInt err = mobilePhone.GetCallServiceCaps(callServiceCaps); + CHECK_EQUALS_L(err, KErrNone, + _L("RMobilePhone::GetCallServiceCaps returned with an error")) + TUint32 expectedCaps = RMobilePhone::KCapsSetCWStatus | RMobilePhone::KCapsNotifyCWStatus; + TUint32 unwantedCaps = 0; + CHECK_BITS_SET_L(callServiceCaps, expectedCaps, unwantedCaps, _L("RMobilePhone::GetCallServiceCaps returned incorrect caps")) + + TInt ret = iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone); + CHECK_EQUALS_L(ret, KErrNone, + _L("RMobilePhone::NotifyNetworkRegistrationStatusChange network registration failed")); + + // Deactivate all call waiting with RMobilePhone::SetCallWaitingStatus with aServiceGroup=RMobilePhone::EAllServices and aAction=RMobilePhone::EServiceActionDeactivate + RMobilePhone::TMobileService mobileService = RMobilePhone::EAllServices; + RMobilePhone::TMobilePhoneServiceAction mobilePhoneServiceAction = RMobilePhone::EServiceActionDeactivate; + TExtEtelRequestStatus mobilePhoneSetCallWaitingStatus(mobilePhone, EMobilePhoneSetCallWaitingStatus); + CleanupStack::PushL(mobilePhoneSetCallWaitingStatus); + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + CHECK_EQUALS_L(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")); + CHECK_EQUALS_L(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")); + + // + // SET UP END + // + + StartTest(); + + // + // TEST START + // + + + // === Activate call waiting for voice, circuit data === + + // Activate call waiting for all services with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EVoiceService and aAction=EServiceActionActivate + mobileService = RMobilePhone::EVoiceService; + mobilePhoneServiceAction = RMobilePhone::EServiceActionActivate; + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // Activate call waiting for all services with RMobilePhone::SetCallWaitingStatus with aServiceGroup=ECircuitDataService and aAction=EServiceActionActivate + mobileService = RMobilePhone::ECircuitDataService; + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // Retrieve the call waiting status list with CRetrieveMobilePhoneCWList::Start with aLocation=RMobilePhone::EInfoLocationCachePreferred + CRetrieveMobilePhoneCWListExec *cwListExec; + cwListExec = CRetrieveMobilePhoneCWListHelper::NewL(mobilePhone); + CleanupStack::PushL(cwListExec); + CMobilePhoneCWList* cwList; + TInt error = 0; + cwList = cwListExec->DoGetList(error); + ASSERT_EQUALS(error, KErrNone, _L("CRetrieveMobilePhoneCWList::RetrieveListL returned with an error")) + + // === Retrieve the call waiting status list and check that it is active === + + // === for the voice service and not active for the other basic services === + + // Retrieve the call waiting status list using the helper class for CRetrieveMobilePhoneCWList + + // Check CMobilePhoneCWList::Enumerate returns number of entries >= 2 + TInt noOfEntries = cwList->Enumerate(); + ASSERT_TRUE( noOfEntries >= 2, _L("CRetrieveMobilePhoneCWList::Enumerate returned incorrect information")) + + // Check CMobilePhoneCWList::GetEntryL with aIndex=0 returns a RMobilePhone::TMobilePhoneCWInfoEntryV1 with iServiceGroup=EVoiceService and iStatus=ECallWaitingStatusActive + const RMobilePhone::TMobilePhoneCWInfoEntryV1& cwInfoEntry = cwList->GetEntryL(0); + ASSERT_TRUE((cwInfoEntry.iServiceGroup == RMobilePhone::EVoiceService + || cwInfoEntry.iServiceGroup == RMobilePhone::ETelephony) , + _L("CRetrieveMobilePhoneCWList::GetEntryL returned wrong iServiceGroup")) + ASSERT_EQUALS(cwInfoEntry.iStatus, RMobilePhone::ECallWaitingStatusActive, + _L("CRetrieveMobilePhoneCWList::GetEntryL returned wrong iStatus")); + + // Check CMobilePhoneCWList::GetEntryL with aIndex=1 returns a RMobilePhone::TMobilePhoneCWInfoEntryV1 with iServiceGroup=ECircuitDataService and iStatus=ECallWaitingStatusActive + const RMobilePhone::TMobilePhoneCWInfoEntryV1& cwInfoEntry1 = cwList->GetEntryL(1); + ASSERT_TRUE( ( cwInfoEntry1.iServiceGroup == RMobilePhone::ECircuitDataService + || cwInfoEntry1.iServiceGroup == RMobilePhone::ESyncData + || cwInfoEntry1.iServiceGroup == RMobilePhone::EAsyncData), + _L("CRetrieveMobilePhoneCWList::GetEntryL returned wrong iServiceGroup")) + ASSERT_EQUALS(cwInfoEntry1.iStatus, RMobilePhone::ECallWaitingStatusActive, + _L("CRetrieveMobilePhoneCWList::GetEntryL returned wrong iStatus")) + + // + // TEST END + // + + StartCleanup(); + + // 1 mobilePhoneSetCallWaitingStatus + // 2 cwListExec + CleanupStack::PopAndDestroy(2,&mobilePhoneSetCallWaitingStatus); + + return TestStepResult(); + } + +TPtrC CCTSYIntegrationTestCallWaiting0007::GetTestStepName() +/** + * @return The test step name. + */ + { + return _L("CCTSYIntegrationTestCallWaiting0007"); + } + + + +CCTSYIntegrationTestCallWaiting0008::CCTSYIntegrationTestCallWaiting0008(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestCallWaitingBase(aEtelSessionMgr) +/** + * Constructor. + */ + { + SetTestStepName(CCTSYIntegrationTestCallWaiting0008::GetTestStepName()); + } + +CCTSYIntegrationTestCallWaiting0008::~CCTSYIntegrationTestCallWaiting0008() +/** + * Destructor. + */ + { + } + +TVerdict CCTSYIntegrationTestCallWaiting0008::doTestStepL() +/** + * @SYMTestCaseID BA-CTSY-INT-CWAT-0008 + * @SYMFssID BA/CTSY/CWAT-0008 + * @SYMTestCaseDesc Interrogation of Call Waiting status where CW is not provisioned on the SIM + * @SYMTestPriority High + * @SYMTestActions + * @SYMTestExpectedResults Pass - NULL status list returned. + * @SYMTestType CIT + * @SYMTestCaseDependencies live/manual + * + * Reason for test: Verify no call waiting status list is returned. + * + * @return - TVerdict code + */ + { + + // + // SET UP + // + + + + // + // SET UP END + // + + StartTest(); + + // + // TEST START + // + + + // Retrieve the call waiting status list with helper class for CRetrieveMobilePhoneCWList with aLocation=RMobilePhone::EInfoLocationCachePreferred + + // === Retrieve the call waiting status list and check that it is active === + + // === for the voice service and not active for the other basic services === + + // Check retrieved list is NULL + + + // + // TEST END + // + + StartCleanup(); + + // Put any required test clean up here, then remove this comment + + return TestStepResult(); + } + +TPtrC CCTSYIntegrationTestCallWaiting0008::GetTestStepName() +/** + * @return The test step name. + */ + { + return _L("CCTSYIntegrationTestCallWaiting0008"); + } + + + +CCTSYIntegrationTestCallWaiting0009::CCTSYIntegrationTestCallWaiting0009(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestCallWaitingBase(aEtelSessionMgr) +/** + * Constructor. + */ + { + SetTestStepName(CCTSYIntegrationTestCallWaiting0009::GetTestStepName()); + } + +CCTSYIntegrationTestCallWaiting0009::~CCTSYIntegrationTestCallWaiting0009() +/** + * Destructor. + */ + { + } + +TVerdict CCTSYIntegrationTestCallWaiting0009::doTestStepL() +/** + * @SYMTestCaseID BA-CTSY-INT-CWAT-0009 + * @SYMFssID BA/CTSY/CWAT-0009 + * @SYMTestCaseDesc Accept waiting call after active call is hung up. + * @SYMTestPriority High + * @SYMTestActions RCall::AnswerIncomingCall, RCall::HangUp, RCall::Dial, RLine::NotifyIncomingCall, RMobilePhone::SetCallWaitingStatus + * @SYMTestExpectedResults Pass - Call that is waiting can be answered when the original active call terminates. + * @SYMTestType CIT + * @SYMTestCaseDependencies live/rps + * + * Reason for test: Verify incoming call notification completes and waiting call can be answered. + * + * @return - TVerdict code + */ + { + + // + // SET UP + // + + + // Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCWStatus capabilities. + RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone); + TUint32 callServiceCaps; + TInt err = mobilePhone.GetCallServiceCaps(callServiceCaps); + CHECK_EQUALS_L(err, KErrNone, + _L("RMobilePhone::GetCallServiceCaps returned with an errorr")) + + TUint32 expectedCaps = RMobilePhone::KCapsSetCWStatus; + TUint32 unwantedCaps = 0; + CHECK_BITS_SET_L(callServiceCaps, expectedCaps, unwantedCaps, _L("RMobilePhone::GetCallServiceCaps returned incorrect caps")) + + // register on home network + TInt ret = iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone); + CHECK_EQUALS_L(ret, KErrNone, + _L("RMobilePhone::NotifyNetworkRegistrationStatusChange network registration failed")); + + // Get voice line 1. + RMobileLine& mobileLine1 = iEtelSessionMgr.GetLineL(KMainServer,KMainPhone,KVoiceLine); + + // Get call 1. + RMobileCall& mobileCall1 = iEtelSessionMgr.GetCallL(KMainServer,KMainPhone,KVoiceLine,KCall1); + + // Get voice line 2. + RMobileLine& mobileLine2 = iEtelSessionMgr.GetLineL(KMainServer,KMainPhone,KVoiceLine); + + // Get call 2. + RMobileCall& mobileCall2 = iEtelSessionMgr.GetCallL(KMainServer,KMainPhone,KVoiceLine,KCall2); + + // + // SET UP END + // + + StartTest(); + + // + // TEST START + // + + // Activate call waiting for all services with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EVoiceService and aAction=EServiceActionActivate + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + RMobilePhone::TMobilePhoneServiceAction mobilePhoneServiceAction = RMobilePhone::EServiceActionActivate; + TExtEtelRequestStatus mobilePhoneSetCallWaitingStatus(mobilePhone, EMobilePhoneSetCallWaitingStatus); + CleanupStack::PushL(mobilePhoneSetCallWaitingStatus); + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // post notification for call status change + TExtEtelRequestStatus notifyDialStatus(mobileCall1,EMobileCallNotifyMobileCallStatusChange); + CleanupStack::PushL(notifyDialStatus); + RMobileCall::TMobileCallStatus callStatus; + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + + // Dial a number that answers on call 1 with RCall::Dial + TCoreEtelRequestStatus dialStatus(mobileCall1, &RCall::DialCancel); + CleanupStack::PushL(dialStatus); + TPtrC number; + ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig returned with an error")); + mobileCall1.Dial(dialStatus, number); + + // Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected. + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus did not complete as expected")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusDialling,KErrNone); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus did not complete as expected")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusConnecting,KErrNone); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out")) + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus returned with an error")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusConnected,KErrNone); + + // check status of dail api + ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RCall::Dial returned with an error")) + + // Register for notification of an incoming call on line 2 with RLine::NotifyIncomingCall + TCoreEtelRequestStatus incomingCallStatus(mobileLine2, &RLine::NotifyIncomingCallCancel); + CleanupStack::PushL(incomingCallStatus); + TName callName; + mobileLine2.NotifyIncomingCall(incomingCallStatus,callName); + + // Request incoming call from RPS. + RPSRequestIncomingCallL(EVoiceLine); + + // Check RLine::NotifyIncomingCall on line 2 completes with valid call name in aName. + ASSERT_EQUALS(WaitForRequestWithTimeOut(incomingCallStatus,ETimeMedium), KErrNone, + _L("RLine::NotifyIncomingCall did not complete without error")); + ASSERT_EQUALS(incomingCallStatus.Int(), KErrNone, + _L("RLine::NotifyIncomingCall set requestStatus to an error")); + ASSERT_TRUE(callName.Length() > 0, + _L("RLine::NotifyIncomingCall did not set the name")); + + // post notification for call status change + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + + // Hang up call 1 with RCall::HangUp + mobileCall1.HangUp(); + + // Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDisconnecting -> EStatusIdle + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusDisconnecting,KErrNone); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusIdle,KErrNone); + + + // obtain reference to incoming call object + TCallId incomingCallId; + RMobileCall& incomingCall = iEtelSessionMgr.GetIncomingCallL(KMainServer, KMainPhone, KVoiceLine, callName, incomingCallId); + + // post notification for call status change + TExtEtelRequestStatus notifyIncomingCallStatus(incomingCall,EMobileCallNotifyMobileCallStatusChange); + CleanupStack::PushL(notifyIncomingCallStatus); + incomingCall.NotifyMobileCallStatusChange(notifyIncomingCallStatus,callStatus); + + // Answer call on call 2 with RCall::AnswerIncomingCall + TExtEtelRequestStatus answerIncomingCalllStatus(incomingCall,EEtelCallAnswer); + CleanupStack::PushL(answerIncomingCalllStatus); + incomingCall.AnswerIncomingCall(answerIncomingCalllStatus); + + // Check RMobileCall::NotifyMobileCallStatusChange on call 2 completes with EStatusAnswering -> EStatusConnected + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(incomingCall, + notifyIncomingCallStatus,callStatus,RMobileCall::EStatusAnswering,KErrNone); + incomingCall.NotifyMobileCallStatusChange(notifyIncomingCallStatus,callStatus); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(incomingCall, + notifyIncomingCallStatus,callStatus,RMobileCall::EStatusConnected,KErrNone); + + ASSERT_EQUALS(answerIncomingCalllStatus.Int(), KErrNone, _L("RCall::AnswerIncomingCall returned with an error")) + + // Hang up call 2 with RCall::HangUp + ASSERT_EQUALS(incomingCall.HangUp(), KErrNone, + _L("RCall::HangUp returned with and error")); + + // + // TEST END + // + + StartCleanup(); + + //1 mobilePhoneSetCallWaitingStatus + //2 notifyDialStatus + //3 dialStatus + //4 incomingCallStatus + //5 notifyIncomingCallStatus + //6 AnswerIncomingCall + + CleanupStack::PopAndDestroy(6, &mobilePhoneSetCallWaitingStatus); + + StartCleanup(); + + return TestStepResult(); + } + +TPtrC CCTSYIntegrationTestCallWaiting0009::GetTestStepName() +/** + * @return The test step name. + */ + { + return _L("CCTSYIntegrationTestCallWaiting0009"); + } + + + +CCTSYIntegrationTestCallWaiting0010::CCTSYIntegrationTestCallWaiting0010(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestCallWaitingBase(aEtelSessionMgr) +/** + * Constructor. + */ + { + SetTestStepName(CCTSYIntegrationTestCallWaiting0010::GetTestStepName()); + } + +CCTSYIntegrationTestCallWaiting0010::~CCTSYIntegrationTestCallWaiting0010() +/** + * Destructor. + */ + { + } + +TVerdict CCTSYIntegrationTestCallWaiting0010::doTestStepL() +/** + * @SYMTestCaseID BA-CTSY-INT-CWAT-0010 + * @SYMFssID BA/CTSY/CWAT-0010 + * @SYMTestCaseDesc Accept waiting call after active call is held. + * @SYMTestPriority High + * @SYMTestActions RCall::HangUp, RCall::AnswerIncomingCall, RCall::Dial, RMobileCall::Hold, RLine::NotifyIncomingCall, RMobilePhone::SetCallWaitingStatus + * @SYMTestExpectedResults Pass - Can put a call on hold and answer a waiting call. + * @SYMTestType CIT + * @SYMTestCaseDependencies live/rps + * + * Reason for test: Verify incoming call notification completes and waiting call can be answered + * + * @return - TVerdict code + */ + { + + // + // SET UP + // + + // Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCWStatus capabilities. + RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone); + TUint32 callServiceCaps; + TInt err = mobilePhone.GetCallServiceCaps(callServiceCaps); + CHECK_EQUALS_L(err, KErrNone, + _L("RMobilePhone::GetCallServiceCaps returned with an errorr")) + + TUint32 expectedCaps = RMobilePhone::KCapsSetCWStatus; + TUint32 unwantedCaps = 0; + CHECK_BITS_SET_L(callServiceCaps, expectedCaps, unwantedCaps, _L("RMobilePhone::GetCallServiceCaps returned incorrect caps")) + + // register on home network + TInt ret = iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone); + CHECK_EQUALS_L(ret, KErrNone, + _L("RMobilePhone::NotifyNetworkRegistrationStatusChange network registration failed")); + + // Get voice line 1. + RMobileLine& mobileLine1 = iEtelSessionMgr.GetLineL(KMainServer,KMainPhone,KVoiceLine); + + // Get call 1. + RMobileCall& mobileCall1 = iEtelSessionMgr.GetCallL(KMainServer,KMainPhone,KVoiceLine,KCall1); + + // Get voice line 2. + RMobileLine& mobileLine2 = iEtelSessionMgr.GetLineL(KMainServer,KMainPhone,KVoiceLine); + + // Get call 2. + RMobileCall& mobileCall2 = iEtelSessionMgr.GetCallL(KMainServer,KMainPhone,KVoiceLine,KCall2); + + // + // SET UP END + // + + StartTest(); + + // + // TEST START + // + + // Activate call waiting for all services with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EVoiceService and aAction=EServiceActionActivate + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + RMobilePhone::TMobilePhoneServiceAction mobilePhoneServiceAction = RMobilePhone::EServiceActionActivate; + TExtEtelRequestStatus mobilePhoneSetCallWaitingStatus(mobilePhone, EMobilePhoneSetCallWaitingStatus); + CleanupStack::PushL(mobilePhoneSetCallWaitingStatus); + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // post notification for call status change + RMobileCall::TMobileCallStatus callStatus; + TExtEtelRequestStatus notifyDialStatus(mobileCall1,EMobileCallNotifyMobileCallStatusChange); + CleanupStack::PushL(notifyDialStatus); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + + // Dial a number that answers on call 1 with RCall::Dial + TCoreEtelRequestStatus dialStatus(mobileCall1, &RCall::DialCancel); + CleanupStack::PushL(dialStatus); + TPtrC number; + ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig returned with an error")); + mobileCall1.Dial(dialStatus, number); + + // Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected. + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus did not complete as expected")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusDialling,KErrNone); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus did not complete as expected")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusConnecting,KErrNone); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out")) + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus returned with an error")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusConnected,KErrNone); + + // Register for notification of an incoming call on line 2 with RLine::NotifyIncomingCall + TCoreEtelRequestStatus incomingCallStatus(mobileLine2, &RLine::NotifyIncomingCallCancel); + CleanupStack::PushL(incomingCallStatus); + TName callName; + mobileLine2.NotifyIncomingCall(incomingCallStatus,callName); + + // Request incoming call from RPS. + RPSRequestIncomingCallL(EVoiceLine); + + // Check RLine::NotifyIncomingCall on line 2 completes with valid call name in aName. + ASSERT_EQUALS(WaitForRequestWithTimeOut(incomingCallStatus,ETimeMedium), KErrNone, + _L("RLine::NotifyIncomingCall did not complete without error")); + ASSERT_EQUALS(incomingCallStatus.Int(), KErrNone, + _L("RLine::NotifyIncomingCall set requestStatus to an error")); + ASSERT_TRUE(callName.Length() > 0, + _L("RLine::NotifyIncomingCall did not set the name")); + + // post notification for call status change + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + + // Hold call 1 with RMobileCall::Hold + TExtEtelRequestStatus holdStatus(mobileCall1,EMobileCallHold); + CleanupStack::PushL(holdStatus); + mobileCall1.Hold(holdStatus); + + // Check RMobileCall::NotifyMobileCallStatusChange on call 1 completes with EStatusHold + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusHold,KErrNone); + ASSERT_EQUALS(WaitForRequestWithTimeOut(holdStatus, ETimeMedium), KErrNone, _L("RMobileCall::Hold timed-out")) + ASSERT_EQUALS(holdStatus.Int(), KErrNone, + _L("RMobileCall::Hold returned with an error")); + + // obtain reference to incoming call object + TCallId incomingCallId; + RMobileCall& incomingCall = iEtelSessionMgr.GetIncomingCallL(KMainServer, KMainPhone, KVoiceLine, callName, incomingCallId); + + // post notification for call status change + TExtEtelRequestStatus notifyIncomingCallStatus(incomingCall,EMobileCallNotifyMobileCallStatusChange); + CleanupStack::PushL(notifyIncomingCallStatus); + incomingCall.NotifyMobileCallStatusChange(notifyIncomingCallStatus,callStatus); + + // Answer call on call 2 with RCall::AnswerIncomingCall + TExtEtelRequestStatus answerIncomingCalllStatus(incomingCall,EEtelCallAnswer); + CleanupStack::PushL(answerIncomingCalllStatus); + incomingCall.AnswerIncomingCall(answerIncomingCalllStatus); + + // Check RMobileCall::NotifyMobileCallStatusChange on call 2 completes with EStatusAnswering -> EStatusConnected + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(incomingCall, + notifyIncomingCallStatus,callStatus,RMobileCall::EStatusAnswering,KErrNone); + incomingCall.NotifyMobileCallStatusChange(notifyIncomingCallStatus,callStatus); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(incomingCall, + notifyIncomingCallStatus,callStatus,RMobileCall::EStatusConnected,KErrNone); + + ASSERT_EQUALS(answerIncomingCalllStatus.Int(), KErrNone, _L("RCall::AnswerIncomingCall returned with an error")) + + // Hang up call 2 with RCall::HangUp + ASSERT_EQUALS(incomingCall.HangUp(), KErrNone, + _L("RCall::HangUp returned with and error")); + ASSERT_EQUALS(mobileCall1.HangUp(), KErrNone, + _L("RCall::HangUp returned with and error")); + + // + // TEST END + // + + StartCleanup(); + + // 1 mobilePhoneSetCallWaitingStatus + // 2 notifyDialStatus + // 3 dialStatus + // 4 incomingCallStatus + // 5 holdStatus + // 6 notifyIncomingCallStatus + // 7 answerIncomingCalllStatus + + CleanupStack::PopAndDestroy(7, &mobilePhoneSetCallWaitingStatus); + + return TestStepResult(); + } + +TPtrC CCTSYIntegrationTestCallWaiting0010::GetTestStepName() +/** + * @return The test step name. + */ + { + return _L("CCTSYIntegrationTestCallWaiting0010"); + } + + + +CCTSYIntegrationTestCallWaiting0011::CCTSYIntegrationTestCallWaiting0011(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestCallWaitingBase(aEtelSessionMgr) +/** + * Constructor. + */ + { + SetTestStepName(CCTSYIntegrationTestCallWaiting0011::GetTestStepName()); + } + +CCTSYIntegrationTestCallWaiting0011::~CCTSYIntegrationTestCallWaiting0011() +/** + * Destructor. + */ + { + } + +TVerdict CCTSYIntegrationTestCallWaiting0011::doTestStepL() +/** + * @SYMTestCaseID BA-CTSY-INT-CWAT-0011 + * @SYMFssID BA/CTSY/CWAT-0011 + * @SYMTestCaseDesc Accept waiting call after active call is hung up by remote party. + * @SYMTestPriority High + * @SYMTestActions RCall::HangUp, RCall::AnswerIncomingCall, RCall::Dial, RLine::NotifyIncomingCall, RMobilePhone::SetCallWaitingStatus + * @SYMTestExpectedResults Pass - Waiting call can be answered. + * @SYMTestType CIT + * @SYMTestCaseDependencies live/manual + * + * Reason for test: Verify incoming call notification completes and waiting call can be answered + * + * @return - TVerdict code + */ + { + + // + // SET UP + // + + // Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCWStatus capabilities. + RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone); + TUint32 callServiceCaps; + TInt err = mobilePhone.GetCallServiceCaps(callServiceCaps); + CHECK_EQUALS_L(err, KErrNone, + _L("RMobilePhone::GetCallServiceCaps returned with an errorr")) + + TUint32 expectedCaps = RMobilePhone::KCapsSetCWStatus; + TUint32 unwantedCaps = 0; + CHECK_BITS_SET_L(callServiceCaps, expectedCaps, unwantedCaps, _L("RMobilePhone::GetCallServiceCaps returned incorrect caps")) + + // register on home network + TInt ret = iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone); + CHECK_EQUALS_L(ret, KErrNone, + _L("RMobilePhone::NotifyNetworkRegistrationStatusChange network registration failed")); + + // Get voice line 1. + RMobileLine& mobileLine1 = iEtelSessionMgr.GetLineL(KMainServer,KMainPhone,KVoiceLine); + + // Get call 1. + RMobileCall& mobileCall1 = iEtelSessionMgr.GetCallL(KMainServer,KMainPhone,KVoiceLine,KCall1); + + // Get voice line 2. + RMobileLine& mobileLine2 = iEtelSessionMgr.GetLineL(KMainServer,KMainPhone,KVoiceLine); + + // Get call 2. + RMobileCall& mobileCall2 = iEtelSessionMgr.GetCallL(KMainServer,KMainPhone,KVoiceLine,KCall2); + + // + // SET UP END + // + + StartTest(); + + // + // TEST START + // + + + // Activate call waiting for all services with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EVoiceService and aAction=EServiceActionActivate + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + RMobilePhone::TMobilePhoneServiceAction mobilePhoneServiceAction = RMobilePhone::EServiceActionActivate; + TExtEtelRequestStatus mobilePhoneSetCallWaitingStatus(mobilePhone, EMobilePhoneSetCallWaitingStatus); + CleanupStack::PushL(mobilePhoneSetCallWaitingStatus); + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // post notification for call status change + RMobileCall::TMobileCallStatus callStatus; + TExtEtelRequestStatus notifyDialStatus(mobileCall1,EMobileCallNotifyMobileCallStatusChange); + CleanupStack::PushL(notifyDialStatus); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + + // Dial a number and answer the call on call 1 with RCall::Dial + TCoreEtelRequestStatus dialStatus(mobileCall1, &RCall::DialCancel); + CleanupStack::PushL(dialStatus); + TPtrC number; + ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig returned with an error")); + mobileCall1.Dial(dialStatus, number); + + // Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected. + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus did not complete as expected")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusDialling,KErrNone); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus did not complete as expected")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusConnecting,KErrNone); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out")) + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus returned with an error")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusConnected,KErrNone); + + // Register for notification of an incoming call on line 2 with RLine::NotifyIncomingCall + TCoreEtelRequestStatus incomingCallStatus(mobileLine2, &RLine::NotifyIncomingCallCancel); + CleanupStack::PushL(incomingCallStatus); + TName callName; + mobileLine2.NotifyIncomingCall(incomingCallStatus,callName); + + // Dial the board manually. + RPSRequestIncomingCallL(EVoiceLine); + + // Check RLine::NotifyIncomingCall on line 2 completes with valid call name in aName. + ASSERT_EQUALS(WaitForRequestWithTimeOut(incomingCallStatus,ETimeMedium), KErrNone, + _L("RLine::NotifyIncomingCall did not complete without error")); + ASSERT_EQUALS(incomingCallStatus.Int(), KErrNone, + _L("RLine::NotifyIncomingCall set requestStatus to an error")); + ASSERT_TRUE(callName.Length() > 0, + _L("RLine::NotifyIncomingCall did not set the name")); + + // post notification for call status change + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + + // Hang up call 1 as the remote party. + DisplayUserInteractionPromptL(_L("Please hangup the active call")); + + // Check RMobileCall::NotifyMobileCallStatusChange on call 1 completes with EStatusDisconnecting -> EStatusIdle + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusDisconnecting,KErrNone); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus did not complete as expected")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusIdle,KErrNone); + + // obtain reference to incoming call object + TCallId incomingCallId; + RMobileCall& incomingCall = iEtelSessionMgr.GetIncomingCallL(KMainServer, KMainPhone, KVoiceLine, callName, incomingCallId); + + // post notification for call status change + TExtEtelRequestStatus notifyIncomingCallStatus(incomingCall,EMobileCallNotifyMobileCallStatusChange); + CleanupStack::PushL(notifyIncomingCallStatus); + incomingCall.NotifyMobileCallStatusChange(notifyIncomingCallStatus,callStatus); + + // Answer call on call 2 with RCall::AnswerIncomingCall + TExtEtelRequestStatus answerIncomingCalllStatus(incomingCall,EEtelCallAnswer); + CleanupStack::PushL(answerIncomingCalllStatus); + incomingCall.AnswerIncomingCall(answerIncomingCalllStatus); + + // Check RMobileCall::NotifyMobileCallStatusChange on call 2 completes with EStatusAnswering -> EStatusConnected + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(incomingCall, + notifyIncomingCallStatus,callStatus,RMobileCall::EStatusAnswering,KErrNone); + incomingCall.NotifyMobileCallStatusChange(notifyIncomingCallStatus,callStatus); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(incomingCall, + notifyIncomingCallStatus,callStatus,RMobileCall::EStatusConnected,KErrNone); + ASSERT_EQUALS(answerIncomingCalllStatus.Int(), KErrNone, _L("RCall::AnswerIncomingCall returned with an error")) + + // Hang up call 2 with RCall::HangUp + ASSERT_EQUALS(incomingCall.HangUp(), KErrNone, + _L("RCall::HangUp returned with and error")); + + // + // TEST END + // + + StartCleanup(); + + // 1 mobilePhoneSetCallWaitingStatus + // 2 notifyDialStatus + // 3 dialStatus + // 4 incomingCallStatus + // 5 notifyIncomingCallStatus + // 6 answerIncomingCalllStatus + + CleanupStack::PopAndDestroy(6, &mobilePhoneSetCallWaitingStatus); + + return TestStepResult(); + } + +TPtrC CCTSYIntegrationTestCallWaiting0011::GetTestStepName() +/** + * @return The test step name. + */ + { + return _L("CCTSYIntegrationTestCallWaiting0011"); + } + + + +CCTSYIntegrationTestCallWaiting0012::CCTSYIntegrationTestCallWaiting0012(CEtelSessionMgr& aEtelSessionMgr) + : CCTSYIntegrationTestCallWaitingBase(aEtelSessionMgr) +/** + * Constructor. + */ + { + SetTestStepName(CCTSYIntegrationTestCallWaiting0012::GetTestStepName()); + } + +CCTSYIntegrationTestCallWaiting0012::~CCTSYIntegrationTestCallWaiting0012() +/** + * Destructor. + */ + { + } + +TVerdict CCTSYIntegrationTestCallWaiting0012::doTestStepL() +/** + * @SYMTestCaseID BA-CTSY-INT-CWAT-0012 + * @SYMFssID BA/CTSY/CWAT-0012 + * @SYMTestCaseDesc Reject a waiting call. + * @SYMTestPriority High + * @SYMTestActions RCall::HangUp, RCall::Dial, RLine::NotifyIncomingCall, RMobilePhone::SetCallWaitingStatus + * @SYMTestExpectedResults Pass - Waiting call can be rejected. + * @SYMTestType CIT + * @SYMTestCaseDependencies live/rps + * + * Reason for test: Verify incoming call notification completes and line status is correct after reject. + * + * @return - TVerdict code + */ + { + + // + // SET UP + // + // Ensure RMobilePhone::GetCallServiceCaps returns caps in set of KCapsSetCWStatus capabilities. + RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone); + TUint32 callServiceCaps; + TInt err = mobilePhone.GetCallServiceCaps(callServiceCaps); + CHECK_EQUALS_L(err, KErrNone, + _L("RMobilePhone::GetCallServiceCaps returned with an error")) + + TUint32 expectedCaps = RMobilePhone::KCapsSetCWStatus; + TUint32 unwantedCaps = 0; + CHECK_BITS_SET_L(callServiceCaps, expectedCaps, unwantedCaps, _L("RMobilePhone::GetCallServiceCaps returned incorrect caps")) + + // register on home network + TInt ret = iNetworkTsyTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone); + CHECK_EQUALS_L(ret, KErrNone, + _L("RMobilePhone::NotifyNetworkRegistrationStatusChange network registration failed")); + + // Get voice line 1. + RMobileLine& mobileLine1 = iEtelSessionMgr.GetLineL(KMainServer,KMainPhone,KVoiceLine); + + // Get call 1. + RMobileCall& mobileCall1 = iEtelSessionMgr.GetCallL(KMainServer,KMainPhone,KVoiceLine,KCall1); + + // Get voice line 2. + RMobileLine& mobileLine2 = iEtelSessionMgr.GetLineL(KMainServer,KMainPhone,KVoiceLine); + + // Get call 2. + RMobileCall& mobileCall2 = iEtelSessionMgr.GetCallL(KMainServer,KMainPhone,KVoiceLine,KCall2); + + // + // SET UP END + // + + StartTest(); + + // + // TEST START + // + + // Activate call waiting for all services with RMobilePhone::SetCallWaitingStatus with aServiceGroup=EVoiceService and aAction=EServiceActionActivate + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + RMobilePhone::TMobilePhoneServiceAction mobilePhoneServiceAction = RMobilePhone::EServiceActionActivate; + TExtEtelRequestStatus mobilePhoneSetCallWaitingStatus(mobilePhone, EMobilePhoneSetCallWaitingStatus); + CleanupStack::PushL(mobilePhoneSetCallWaitingStatus); + mobilePhone.SetCallWaitingStatus(mobilePhoneSetCallWaitingStatus, mobileService, mobilePhoneServiceAction); + ASSERT_EQUALS(WaitForRequestWithTimeOut(mobilePhoneSetCallWaitingStatus, ETimeMedium), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus timed-out")) + ASSERT_EQUALS(mobilePhoneSetCallWaitingStatus.Int(), KErrNone, + _L("RMobilePhone::SetCallWaitingStatus returned with an error")) + + // post notification for call status change + RMobileCall::TMobileCallStatus callStatus; + TExtEtelRequestStatus notifyDialStatus(mobileCall1,EMobileCallNotifyMobileCallStatusChange); + CleanupStack::PushL(notifyDialStatus); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + + // Dial a number that answers call 1 with RCall::Dial + TCoreEtelRequestStatus dialStatus(mobileCall1, &RCall::DialCancel); + CleanupStack::PushL(dialStatus); + TPtrC number; + ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig returned with an error")); + mobileCall1.Dial(dialStatus, number); + + // Check RMobileCall::NotifyMobileCallStatusChange completes with EStatusDialling -> EStatusConnecting -> EStatusConnected. + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus did not complete as expected")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusDialling,KErrNone); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus did not complete as expected")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusConnecting,KErrNone); + mobileCall1.NotifyMobileCallStatusChange(notifyDialStatus,callStatus); + ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out")) + ASSERT_EQUALS(mobileCall1.GetMobileCallStatus(callStatus), KErrNone, + _L("RMobileCall::GetMobileCallStatus returned with an error")); + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(mobileCall1, + notifyDialStatus,callStatus,RMobileCall::EStatusConnected,KErrNone); + + // Register for notification of an incoming call on line 2 with RLine::NotifyIncomingCall + TCoreEtelRequestStatus incomingCallStatus(mobileLine2, &RLine::NotifyIncomingCallCancel); + CleanupStack::PushL(incomingCallStatus); + TName callName; + mobileLine2.NotifyIncomingCall(incomingCallStatus,callName); + + // Request incoming call from RPS. + RPSRequestIncomingCallL(EVoiceLine); + + // Check RLine::NotifyIncomingCall on line 2 completes with valid call name in aName. + ASSERT_EQUALS(WaitForRequestWithTimeOut(incomingCallStatus,ETimeMedium), KErrNone, + _L("RLine::NotifyIncomingCall did not complete without error")); + ASSERT_EQUALS(incomingCallStatus.Int(), KErrNone, + _L("RLine::NotifyIncomingCall set requestStatus to an error")); + ASSERT_TRUE(callName.Length() > 0, + _L("RLine::NotifyIncomingCall did not set the name")); + + // post notification for call status change + TCallId incomingCallId; + RMobileCall& incomingCall = iEtelSessionMgr.GetIncomingCallL(KMainServer, KMainPhone, KVoiceLine, callName, incomingCallId); + + // post notification for call status change + TExtEtelRequestStatus notifyIncomingCallStatus(incomingCall,EMobileCallNotifyMobileCallStatusChange); + CleanupStack::PushL(notifyIncomingCallStatus); + incomingCall.NotifyMobileCallStatusChange(notifyIncomingCallStatus,callStatus); + + // Hang up call 2 with RCall::HangUp + ASSERT_EQUALS(incomingCall.HangUp(), KErrNone, + _L("RCall::HangUp returned with and error")); + + // Check RMobileCall::NotifyMobileCallStatusChange on call 2 completes with EStatusIdle + iCallControlTsyTestHelper.WaitForMobileCallNotifyMobileCallStatusChange(incomingCall, + notifyIncomingCallStatus,callStatus,RMobileCall::EStatusIdle,KErrNone); + + // + // TEST END + // + + StartCleanup(); + + mobileCall1.HangUp(); + + // 1 mobilePhoneSetCallWaitingStatus + // 2 notifyDialStatus + // 3 dialStatus + // 4 incomingCallStatus + // 5 notifyIncomingCallStatus + + CleanupStack::PopAndDestroy(5, &mobilePhoneSetCallWaitingStatus); + + return TestStepResult(); + } + +TPtrC CCTSYIntegrationTestCallWaiting0012::GetTestStepName() +/** + * @return The test step name. + */ + { + return _L("CCTSYIntegrationTestCallWaiting0012"); + } + + +