telephonyserverplugins/common_tsy/test/integration/src/cctsyintegrationtestcallwaiting.cpp
// 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"))
const RMobilePhone::TMobilePhoneCWInfoEntryV1& cwInfoEntry = cwList->GetEntryL(0);
const RMobilePhone::TMobilePhoneCWInfoEntryV1& cwInfoEntry1 = cwList->GetEntryL(1);
// Check CMobilePhoneCWList::GetEntryL with aIndex=0 returns a RMobilePhone::TMobilePhoneCWInfoEntryV1 with iServiceGroup=EVoiceService and iStatus=ECallWaitingStatusActive
// Check CMobilePhoneCWList::GetEntryL with aIndex=1 returns a RMobilePhone::TMobilePhoneCWInfoEntryV1 with iServiceGroup=ECircuitDataService and iStatus=ECallWaitingStatusActive
// or opposite.
TBool serviceGroupFlag1(EFalse);
TBool serviceGroupFlag2(EFalse);
serviceGroupFlag1 = ((cwInfoEntry.iServiceGroup == RMobilePhone::EVoiceService
|| cwInfoEntry.iServiceGroup == RMobilePhone::ETelephony)
&& ( cwInfoEntry1.iServiceGroup == RMobilePhone::ECircuitDataService
|| cwInfoEntry1.iServiceGroup == RMobilePhone::ESyncData
|| cwInfoEntry1.iServiceGroup == RMobilePhone::EAsyncData) );
serviceGroupFlag2 = ((cwInfoEntry1.iServiceGroup == RMobilePhone::EVoiceService
|| cwInfoEntry1.iServiceGroup == RMobilePhone::ETelephony)
&& ( cwInfoEntry.iServiceGroup == RMobilePhone::ECircuitDataService
|| cwInfoEntry.iServiceGroup == RMobilePhone::ESyncData
|| cwInfoEntry.iServiceGroup == RMobilePhone::EAsyncData) );
ASSERT_TRUE((serviceGroupFlag1 || serviceGroupFlag2),
_L("CRetrieveMobilePhoneCWList::GetEntryL returned wrong iServiceGroup"));
ASSERT_EQUALS(cwInfoEntry.iStatus, RMobilePhone::ECallWaitingStatusActive,
_L("CRetrieveMobilePhoneCWList::GetEntryL returned wrong iStatus"));
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");
}