--- /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 <etelmm.h>
+
+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<RMobilePhone::TMobilePhoneCWInfoEntryV1> 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<RMobilePhone::TMobileService> 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=<current service being tested> 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=<current service being tested> and iStatus=ECallWaitingStatusActive
+ TCmpBase<RMobilePhone::TMobilePhoneCWInfoEntryV1> 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=<current service being tested> 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=<current service being tested> 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<RMobilePhone::TMobileService> 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<RMobileCall> 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<RLine> 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<RMobileCall> 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<RLine> 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<RMobileCall> 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<RLine> 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<RMobileCall> 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<RLine> 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");
+ }
+
+
+