--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsycallcontrolfu.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,3649 @@
+// Copyright (c) 2008-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:
+// The TEFUnit test suite for CallControlControl in the Common TSY.
+//
+
+
+
+#include "cctsycallcontrolfu.h"
+#include "isvao.h"
+
+#include <etel.h>
+#include <etelmm.h>
+#include <et_clsvr.h>
+#include <ctsy/mmtsy_names.h>
+#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
+#include <test/tmockltsydata.h>
+#include <ctsy/ltsy/mltsydispatchcallcontrolinterface.h>
+#include "testconstants.h"
+
+#include "mockltsyindicatorids.h"
+#include <sacls.h> // For phone power P&S key needed by Etel3rdParty testing
+#include <e32property.h>
+#include <ctsy/rmmcustomapi.h>
+#include <centralrepository.h>
+
+CTestSuite* CCTsyCallControlFU::CreateSuiteL(const TDesC& aName)
+ {
+ SUB_SUITE;
+
+ // Add use-case tests
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0005L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0010L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0013L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0015L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0016L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0017L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0018L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0019L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0020L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0021L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0022L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0023L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0024L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0025L);
+
+ // Add other unit tests
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0005L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0010L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0013L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0015L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0016L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0017L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0018L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0019L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0020L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0021L);
+
+
+ END_SUITE;
+ }
+
+
+//
+// Use-case tests
+//
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for mobile originated voice call accepted and hang up
+@SYMTestPriority High
+@SYMTestActions Make a voice call, receive status change notifications, hang up
+@SYMTestExpectedResults Pass - Call reaches connected state and call is hung up
+@SYMTestType CT
+*/
+void CCTsyCallControlFU::TestUseCase0001L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TRequestStatus reqStatus;
+ iMockLTSY.NotifyTerminated(reqStatus);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client Side Test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ ClientHangUpCallL(mobileCall);
+
+ mobileCall.Close();
+ mobileLine.Close();
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); //mobileCall, mobileLine, this
+ } // CCTsyCallControlFU::TestUseCase0001L
+
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for failed dialling of a mobile originated call
+@SYMTestPriority High
+@SYMTestActions Dials a voice call, receives error from LTSY
+@SYMTestExpectedResults Pass - Dial request fails
+@SYMTestType CT
+*/
+void CCTsyCallControlFU::TestUseCase0002L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverExpectDialCallRequestL(callId, mobileService, KErrGeneral);
+
+ // Client Side Test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ASSERT_EQUALS(KErrNone, OpenLineAndCallL(mobileLine, mobileCall, RMobilePhone::EVoiceService));
+
+ RMobileCall::TMobileCallParamsV1 callParams;
+ RMobileCall::TMobileCallParamsV1Pckg callParamsPckg(callParams);
+ callParams.iAutoRedial = ETrue;
+ callParams.iIdRestrict = RMobileCall::ESendMyId;
+ TRequestStatus dialStatus;
+ mobileCall.Dial(dialStatus, callParamsPckg, KPhoneNumber);
+ User::WaitForRequest(dialStatus);
+ ASSERT_EQUALS(KErrGeneral, dialStatus.Int());
+
+ RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusUnknown;
+ mobileCall.GetMobileCallStatus(callStatus);
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, callStatus);
+
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0002L
+
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for remote party rejecting a dialled call
+@SYMTestPriority High
+@SYMTestActions Dials a call, remote party rejects it, check call status and notifications are correct
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallControlFU::TestUseCase0003L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverExpectDialCallRequestL(callId, mobileService, KErrNone);
+
+ // Complete KLtsyDispatchCallControlNotifyCallStatusChangeApiId
+ RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusDialling;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(
+ callId, RMobilePhone::EServiceUnspecified, callStatus);
+ data.Close();
+ mockCallData.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data);
+
+ // Complete events expected when remote party rejects call
+
+ // Complete KLtsyDispatchCallControlNotifyCallStatusChangeApiId
+ DriverCompleteSuccessfulHangUpNotificationsL(callId, EFalse, KErrGsmCCCallRejected, EFalse);
+
+ // Client Side Test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ASSERT_EQUALS(KErrNone, OpenLineAndCallL(mobileLine, mobileCall, RMobilePhone::EVoiceService));
+
+ TRequestStatus notifyCallStatus;
+ callStatus = RMobileCall::EStatusUnknown;
+ mobileCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);
+
+ RMobileCall::TMobileCallParamsV1 callParams;
+ RMobileCall::TMobileCallParamsV1Pckg callParamsPckg(callParams);
+ callParams.iAutoRedial = ETrue;
+ callParams.iIdRestrict = RMobileCall::ESendMyId;
+ TRequestStatus dialStatus;
+ mobileCall.Dial(dialStatus, callParamsPckg, KPhoneNumber);
+ User::WaitForRequest(dialStatus);
+ ASSERT_EQUALS(KErrGsmCCCallRejected, dialStatus.Int());
+
+ RArray<RMobileCall::TMobileCallStatus> expectedCallStatuses;
+ CleanupClosePushL(expectedCallStatuses);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusDialling);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusDisconnecting);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusIdle);
+ ClientWaitForCallStatusNotifications(mobileCall, notifyCallStatus, callStatus, expectedCallStatuses, KErrNone);
+
+ callStatus = RMobileCall::EStatusUnknown;
+ mobileCall.GetMobileCallStatus(callStatus);
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, callStatus);
+
+ expectedCallStatuses.Close();
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this); // expectedCallStatuses, mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0003L
+
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for remote party hang up without inband info
+@SYMTestPriority High
+@SYMTestActions Invokes dialling voice call, receive remote party hang up
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallControlFU::TestUseCase0004L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ RMobileCall::TMobileCallEvent callEvent = RMobileCall::ERemoteTerminated;
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> callEventData(callId, mobileService, callEvent);
+ callEventData.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallEventIndId, KErrNone, data);
+
+ DriverCompleteSuccessfulHangUpNotificationsL(callId, EFalse, KErrGsmCCNormalCallClearing);
+
+ TRequestStatus notifyCallEventStatus;
+ RMobileCall::TMobileCallEvent receivedCallEvent;
+ mobileCall.NotifyCallEvent(notifyCallEventStatus, receivedCallEvent);
+
+ TRequestStatus notifyCallStatus;
+ RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusUnknown;
+ mobileCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);
+
+ RArray<RMobileCall::TMobileCallStatus> expectedCallStatuses;
+ CleanupClosePushL(expectedCallStatuses);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusDisconnecting);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusIdle);
+ ClientWaitForCallStatusNotifications(mobileCall, notifyCallStatus, callStatus, expectedCallStatuses, KErrNone);
+
+ User::WaitForRequest(notifyCallEventStatus);
+ ASSERT_EQUALS(KErrNone, notifyCallEventStatus.Int());
+ ASSERT_EQUALS(callEvent, receivedCallEvent);
+
+ expectedCallStatuses.Close();
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this); // expectedCallStatuses, mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0004L
+
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0005
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for remote party hang up with inband info
+@SYMTestPriority High
+@SYMTestActions Dial a voice call, remote party hangs up with inband info
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallControlFU::TestUseCase0005L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ DriverCompleteSuccessfulHangUpNotificationsL(callId, ETrue, KErrGsmCCNormalCallClearing);
+
+ TRequestStatus notifyCallStatus;
+ RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusUnknown;
+ mobileCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);
+
+ RArray<RMobileCall::TMobileCallStatus> expectedCallStatuses;
+ CleanupClosePushL(expectedCallStatuses);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusDisconnectingWithInband);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusIdle);
+ ClientWaitForCallStatusNotifications(mobileCall, notifyCallStatus, callStatus, expectedCallStatuses, KErrNone);
+
+ expectedCallStatuses.Close();
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this); // expectedCallStatuses, mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0005L
+
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for mobile originated data call
+@SYMTestPriority High
+@SYMTestActions Invokes Dials a data call, receives call status notifications, loan and recover the data port, hang up call.
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallControlFU::TestUseCase0006L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ DriverDialCallL(callId, mobileService);
+
+ // KMockLtsyDispatchCallControlNotifyDataCallCapsChangeIndId
+ RMobileCall::TMobileCallDataCapsV1 completeCallCaps;
+ completeCallCaps.iSpeedCaps = RMobileCall::KCapsSpeed48000;
+ completeCallCaps.iProtocolCaps = RMobileCall::KCapsProtocolV34;
+ completeCallCaps.iServiceCaps = RMobileCall::KCapsPacketAccessSyncUDI;
+ completeCallCaps.iQoSCaps = RMobileCall::KCapsTransparentPreferred;
+ completeCallCaps.iHscsdSupport = ETrue;
+ completeCallCaps.iMClass = 2;
+ completeCallCaps.iMaxRxTimeSlots = 4;
+ completeCallCaps.iMaxTxTimeSlots = 8;
+ completeCallCaps.iTotalRxTxTimeSlots = 10;
+ completeCallCaps.iCodingCaps = RMobileCall::KCapsAiurCoding96;
+ completeCallCaps.iAsymmetryCaps = RMobileCall::KCapsAsymmetryDownlink;
+ completeCallCaps.iUserInitUpgrade = ETrue;
+ completeCallCaps.iRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion1;
+ completeCallCaps.iV42bisCaps = RMobileCall::KCapsV42bisRxDirection;
+ data.Close();
+ TMockLtsyCallData1<RMobileCall::TMobileCallDataCapsV1>
+ completeDataCapsData(callId, RMobilePhone::EServiceUnspecified, completeCallCaps);
+ completeDataCapsData.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyDataCallCapsChangeIndId, KErrNone, data);
+
+
+ _LIT(KDataPort, "DATAPORT::0");
+ RCall::TCommPort commPort;
+ commPort.iPort = KDataPort;
+ data.Close();
+ TMockLtsyData2<TInt,RCall::TCommPort> loanDataPortExpData(callId,commPort);
+ loanDataPortExpData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlLoanDataPort::KLtsyDispatchCallControlLoanDataPortApiId, data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlRecoverDataPort::KLtsyDispatchCallControlRecoverDataPortApiId, data);
+
+
+ // MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId
+ RMobileCall::TMobileHscsdCallParamsV8 hscsdParams;
+ hscsdParams.iWantedAiur = RMobileCall::EAiurBps38400;
+ hscsdParams.iWantedRxTimeSlots = 2;
+ data.Close();
+ TMockLtsyData2<TInt, RMobileCall::TMobileHscsdCallParamsV8> paramData(callId, hscsdParams);
+ paramData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId, data);
+
+ TMockLtsyData1<TInt> mockParamData(callId);
+ data.Close();
+ mockParamData.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId, KErrNone, data);
+
+ // KMockLtsyDispatchCallControlNotifyHscsdInfoChangeIndId
+ RMobileCall::TMobileCallHscsdInfoV8 hscsdInfo;
+ hscsdInfo.iCodings = RMobileCall::ETchCoding320;
+ hscsdInfo.iAiur = RMobileCall::EAiurBps38400;
+ hscsdInfo.iRxTimeSlots = 2;
+ hscsdInfo.iTxTimeSlots = 2;
+
+ RMobileCall::TMobileCallDataCapsV1 completeCallCaps2 = completeCallCaps;
+ completeCallCaps2.iHscsdSupport = ETrue;
+ completeCallCaps2.iSpeedCaps = RMobileCall::KCapsSpeed57600;
+ completeCallCaps2.iMaxRxTimeSlots = 3;
+ completeCallCaps2.iMaxTxTimeSlots = 5;
+
+ TMockLtsyCallData2<RMobileCall::TMobileCallHscsdInfoV8, RMobileCall::TMobileCallDataCapsV1>
+ hscsdData(1, RMobilePhone::ECircuitDataService, hscsdInfo, completeCallCaps2);
+ data.Close();
+ hscsdData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyHscsdInfoChangeIndId, KErrNone, data);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing;
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client Side Test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ RCall::TCommPort dataPort;
+ TRequestStatus reqStatus;
+ mobileCall.LoanDataPort(reqStatus, dataPort);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ ASSERT_EQUALS(0, dataPort.iPort.Compare(KDataPort()));
+
+ TInt err = mobileCall.RecoverDataPort();
+ ASSERT_EQUALS(KErrNone, err);
+
+ RMobileCall::TMobileCallDataCapsV1 callCaps;
+ RMobileCall::TMobileCallDataCapsV1Pckg callCapsPckg(callCaps);
+ mobileCall.GetMobileDataCallCaps(callCapsPckg);
+ ASSERT_TRUE(TComparator<RMobileCall::TMobileCallDataCapsV1>::IsEqual(completeCallCaps, callCaps));
+
+ TRequestStatus hscsdInfoStatus;
+ RMobileCall::TMobileCallHscsdInfoV8 hscsdInfo2;
+ RMobileCall::TMobileCallHscsdInfoV8Pckg hscsdInfoPckg(hscsdInfo2);
+ mobileCall.NotifyHscsdInfoChange(hscsdInfoStatus, hscsdInfoPckg);
+
+ TRequestStatus dataCallCapsStatus;
+ RMobileCall::TMobileCallDataCapsV1 dataCallCaps2;
+ RMobileCall::TMobileCallDataCapsV1Pckg dataCallCapsPckg(dataCallCaps2);
+ mobileCall.NotifyMobileDataCallCapsChange(dataCallCapsStatus, dataCallCapsPckg);
+
+ TRequestStatus hscsdParamStatus;
+ mobileCall.SetDynamicHscsdParams(hscsdParamStatus, hscsdParams.iWantedAiur, hscsdParams.iWantedRxTimeSlots);
+ User::WaitForRequest(hscsdParamStatus);
+
+ User::WaitForRequest(hscsdInfoStatus);
+ ASSERT_EQUALS(KErrNone, hscsdInfoStatus.Int());
+ ASSERT_EQUALS(hscsdInfo2.iAiur, hscsdInfo.iAiur);
+ ASSERT_EQUALS(hscsdInfo2.iRxTimeSlots, hscsdInfo.iRxTimeSlots);
+ ASSERT_EQUALS(hscsdInfo2.iTxTimeSlots, hscsdInfo.iTxTimeSlots);
+ ASSERT_EQUALS(hscsdInfo2.iCodings, hscsdInfo.iCodings);
+
+ User::WaitForRequest(dataCallCapsStatus);
+ ASSERT_EQUALS(KErrNone, dataCallCapsStatus.Int());
+ ASSERT_EQUALS(completeCallCaps2.iSpeedCaps, dataCallCaps2.iSpeedCaps);
+ ASSERT_EQUALS(completeCallCaps2.iHscsdSupport, dataCallCaps2.iHscsdSupport);
+ ASSERT_EQUALS(completeCallCaps2.iMaxRxTimeSlots, dataCallCaps2.iMaxRxTimeSlots);
+ ASSERT_EQUALS(completeCallCaps2.iMaxTxTimeSlots, dataCallCaps2.iMaxTxTimeSlots);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+ ClientHangUpCallL(mobileCall);
+
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0006L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0007
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for incoming voice call accepted
+ @SYMTestPriority High
+ @SYMTestActions Requests notification of an incoming call, incoming call arrives, answer the call, hang up
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0007L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ TName incomingCallName;
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ASSERT_EQUALS(KErrNone, OpenLineAndCallL(mobileLine, mobileCall, RMobilePhone::EVoiceService));
+ mobileCall.Close();
+ CleanupStack::Pop(&mobileCall);
+
+ // Create an incoming call and answer it
+
+ DriverCreateIncomingCallL(callId, mobileService);
+
+ DriverCompleteGetMobileCallInfoL(callId, mobileService);
+
+ DriverAnswerIncomingCallL(callId, mobileService);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing;
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Create another incoming call but fail to answer this one
+
+ DriverCreateIncomingCallL(callId, mobileService);
+
+ DriverCompleteGetMobileCallInfoL(callId, mobileService);
+
+ DriverAnswerIncomingCallL(callId, mobileService, EFalse, KErrGeneral);
+
+ // Client side test
+
+ ClientWaitForIncomingCallNotificationLC(mobileCall, mobileLine, incomingCallName);
+
+ ClientAnswerIncomingCallL(mobileCall);
+
+ ClientHangUpCallL(mobileCall);
+
+ mobileCall.Close();
+ CleanupStack::Pop(&mobileCall);
+
+ ClientWaitForIncomingCallNotificationLC(mobileCall, mobileLine, incomingCallName);
+
+ ClientAnswerIncomingCallL(mobileCall, KErrGeneral);
+
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0007L
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0008
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for incoming voice call rejected
+ @SYMTestPriority High
+ @SYMTestActions Invokes actions
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0008L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ TName incomingCallName;
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ASSERT_EQUALS(KErrNone, OpenLineAndCallL(mobileLine, mobileCall, RMobilePhone::EVoiceService));
+ mobileCall.Close();
+ CleanupStack::Pop(&mobileCall);
+
+ DriverCreateIncomingCallL(callId, mobileService);
+
+ DriverCompleteGetMobileCallInfoL(callId, mobileService);
+
+ // KErrGsmBusyUserRequest hardcoded to be sent by CTSY to LTSY,
+ // mapped to KErrGsmCCUserBusy
+ TInt hangUpCause = KErrGsmCCUserBusy;
+ TMockLtsyData2<TInt, TInt> mockData2(callId, hangUpCause);
+ data.Close();
+ mockData2.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlHangUp::KLtsyDispatchCallControlHangUpApiId, data);
+ DriverCompleteSuccessfulHangUpNotificationsL(callId, EFalse, KErrGsmCCCallRejected, EFalse);
+
+ // Client side test
+
+ ClientWaitForIncomingCallNotificationLC(mobileCall, mobileLine, incomingCallName);
+
+ ClientHangUpCallL(mobileCall);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0008L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0009
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for cancel dialling a call when it is still in dialling state.
+ @SYMTestPriority High
+ @SYMTestActions Invokes dialling a call and then cancelling the dial during dialling process.
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0009L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ DriverExpectDialCallRequestL(callId, mobileService, KErrNone);
+
+ // Complete KLtsyDispatchCallControlNotifyCallStatusChangeApiId with dialling
+ RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusDialling;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(
+ callId, RMobilePhone::EServiceUnspecified, callStatus);
+ data.Close();
+ mockCallData.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // This cause always passed by CTSY in this situation
+ TMockLtsyData2<TInt, TInt> mockData2(callId, hangUpCause);
+ data.Close();
+ mockData2.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlHangUp::KLtsyDispatchCallControlHangUpApiId, data);
+
+ DriverCompleteSuccessfulHangUpNotificationsL(callId, EFalse, KErrGsmCCNormalCallClearing, EFalse);
+
+ // Client side test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ASSERT_EQUALS(KErrNone, OpenLineAndCallL(mobileLine, mobileCall, RMobilePhone::EVoiceService));
+
+ TRequestStatus notifyCallStatus;
+ callStatus = RMobileCall::EStatusUnknown;
+ mobileCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);
+
+ RMobileCall::TMobileCallParamsV1 callParams;
+ RMobileCall::TMobileCallParamsV1Pckg callParamsPckg(callParams);
+ callParams.iAutoRedial = ETrue;
+ callParams.iIdRestrict = RMobileCall::ESendMyId;
+ TRequestStatus dialStatus;
+ mobileCall.Dial(dialStatus, callParamsPckg, KPhoneNumber);
+
+ User::WaitForRequest(notifyCallStatus);
+ ASSERT_EQUALS(KErrNone, notifyCallStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusDialling, callStatus);
+
+ mobileCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);
+
+ mobileCall.DialCancel();
+
+ RArray<RMobileCall::TMobileCallStatus> expectedCallStatuses;
+ CleanupClosePushL(expectedCallStatuses);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusDisconnecting);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusIdle);
+ ClientWaitForCallStatusNotifications(mobileCall, notifyCallStatus, callStatus, expectedCallStatuses, KErrNone);
+
+ User::WaitForRequest(dialStatus);
+ ASSERT_EQUALS(KErrCancel, dialStatus.Int());
+
+ expectedCallStatuses.Close();
+ mobileLine.Close();
+ mobileCall.Close();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this); // expectedCallStatuses, mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0009L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0010
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for cancelling dial request when call is connecting
+ @SYMTestPriority High
+ @SYMTestActions Invokes dialling a call and cancelling the dial request when call reaches connecting state
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0010L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ DriverExpectDialCallRequestL(callId, mobileService, KErrNone);
+
+ // Complete KLtsyDispatchCallControlNotifyCallStatusChangeApiId with dialling
+ RArray<RMobileCall::TMobileCallStatus> arrayCallStatus;
+ CleanupClosePushL(arrayCallStatus);
+ arrayCallStatus.AppendL(RMobileCall::EStatusDialling);
+ arrayCallStatus.AppendL(RMobileCall::EStatusConnecting);
+ DriverCompleteCallStatusChangeNotificationsL(arrayCallStatus, callId, KErrNone);
+ arrayCallStatus.Close();
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // This cause always passed by CTSY in this situation
+ TMockLtsyData2<TInt, TInt> mockData2(callId, hangUpCause);
+ data.Close();
+ mockData2.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlHangUp::KLtsyDispatchCallControlHangUpApiId, data);
+
+ DriverCompleteSuccessfulHangUpNotificationsL(callId, EFalse, KErrGsmCCNormalCallClearing, EFalse);
+
+ // Client side test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ASSERT_EQUALS(KErrNone, OpenLineAndCallL(mobileLine, mobileCall, RMobilePhone::EVoiceService));
+
+ TRequestStatus notifyCallStatus;
+ RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusUnknown;
+ mobileCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);
+
+ RMobileCall::TMobileCallParamsV1 callParams;
+ RMobileCall::TMobileCallParamsV1Pckg callParamsPckg(callParams);
+ callParams.iAutoRedial = ETrue;
+ callParams.iIdRestrict = RMobileCall::ESendMyId;
+ TRequestStatus dialStatus;
+ mobileCall.Dial(dialStatus, callParamsPckg, KPhoneNumber);
+
+ RArray<RMobileCall::TMobileCallStatus> expectedCallStatuses;
+ CleanupClosePushL(expectedCallStatuses);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusDialling);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusConnecting);
+ ClientWaitForCallStatusNotifications(mobileCall, notifyCallStatus, callStatus, expectedCallStatuses, KErrNone);
+
+ mobileCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);
+
+ mobileCall.DialCancel();
+
+ expectedCallStatuses.Close();
+ expectedCallStatuses.AppendL(RMobileCall::EStatusDisconnecting);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusIdle);
+ ClientWaitForCallStatusNotifications(mobileCall, notifyCallStatus, callStatus, expectedCallStatuses, KErrNone);
+
+ User::WaitForRequest(dialStatus);
+ ASSERT_EQUALS(KErrCancel, dialStatus.Int());
+
+ expectedCallStatuses.Close();
+ arrayCallStatus.Close();
+ mobileLine.Close();
+ mobileCall.Close();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(6, this); // expectedCallStatuses, mobileCall, mobileLine, arrayCallStatus, data, this
+ } // CCTsyCallControlFU::TestUseCase0010L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0011
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for missed incoming call
+ @SYMTestPriority High
+ @SYMTestActions Invokes requesting an incoming call, line rings, call is not answered, call disconnects
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0011L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ TName incomingCallName;
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ASSERT_EQUALS(KErrNone, OpenLineAndCallL(mobileLine, mobileCall, RMobilePhone::EVoiceService));
+ mobileCall.Close();
+ CleanupStack::Pop(&mobileCall);
+
+ DriverCreateIncomingCallL(callId, mobileService);
+
+ DriverCompleteGetMobileCallInfoL(callId, mobileService);
+
+ ClientWaitForIncomingCallNotificationLC(mobileCall, mobileLine, incomingCallName);
+
+ DriverCompleteSuccessfulHangUpNotificationsL(callId, EFalse, KErrGsmCCNormalCallClearing, EFalse);
+
+ TRequestStatus notifyCallStatus;
+ RMobileCall::TMobileCallStatus callStatus;
+ mobileCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);
+
+ RArray<RMobileCall::TMobileCallStatus> expectedCallStatuses;
+ CleanupClosePushL(expectedCallStatuses);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusDisconnecting);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusIdle);
+
+ ClientWaitForCallStatusNotifications(mobileCall, notifyCallStatus, callStatus, expectedCallStatuses, KErrNone);
+
+ expectedCallStatuses.Close();
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this); // expectedCallStatuses, mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0011L
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0012
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for holding, resuming a call
+ @SYMTestPriority High
+ @SYMTestActions Invokes dialling a call, holding it, then resuming it
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0012L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ // Hold call
+ DriverHoldCallL(callId, KErrNone);
+
+ // Resume call
+ DriverResumeCallL(callId, KErrNone);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing;
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client Side Test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ TRequestStatus notifyStatus;
+ RMobileCall::TMobileCallStatus callStatus;
+ mobileCall.NotifyMobileCallStatusChange(notifyStatus, callStatus);
+
+ TRequestStatus holdStatus;
+ mobileCall.Hold(holdStatus);
+ User::WaitForRequest(holdStatus);
+ ASSERT_EQUALS(KErrNone, holdStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusHold, callStatus);
+
+ mobileCall.NotifyMobileCallStatusChange(notifyStatus, callStatus);
+
+ TRequestStatus resumeStatus;
+ mobileCall.Resume(resumeStatus);
+ User::WaitForRequest(resumeStatus);
+ ASSERT_EQUALS(KErrNone, resumeStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusConnected, callStatus);
+
+ // Attempt to swap it when it is the sole call (not supported by CTSY)
+ TRequestStatus swapStatus;
+ mobileCall.Swap(swapStatus);
+ User::WaitForRequest(swapStatus);
+ ASSERT_EQUALS(KErrNotSupported, swapStatus.Int());
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0012L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0013
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for failure to hold a connected call
+ @SYMTestPriority High
+ @SYMTestActions Invokes dialling a call, attempting to hold it, receiving an error
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0013L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ DriverHoldCallL(callId, KErrGeneral);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing;
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client side test
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ TRequestStatus holdStatus;
+ mobileCall.Hold(holdStatus);
+ User::WaitForRequest(holdStatus);
+ ASSERT_EQUALS(KErrGeneral, holdStatus.Int());
+
+ RMobileCall::TMobileCallStatus callStatus;
+ ASSERT_EQUALS(KErrNone, mobileCall.GetMobileCallStatus(callStatus));
+ ASSERT_EQUALS(RMobileCall::EStatusConnected, callStatus);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0013L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0014
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for failure to resume
+ @SYMTestPriority High
+ @SYMTestActions Invokes holding a call, attempting to resume it and receiving a failure.
+ @SYMTestExpectedResults Pass - Call still on hold
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0014L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ DriverHoldCallL(callId, KErrNone);
+
+ DriverResumeCallL(callId, KErrGeneral);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing;
+ TMockLtsyData2<TInt, TInt> mockData2(callId, hangUpCause);
+ data.Close();
+ mockData2.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlHangUp::KLtsyDispatchCallControlHangUpApiId, data);
+
+ // Client side test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ TRequestStatus holdStatus;
+ mobileCall.Hold(holdStatus);
+ User::WaitForRequest(holdStatus);
+ ASSERT_EQUALS(KErrNone, holdStatus.Int());
+
+ TRequestStatus resumeStatus;
+ mobileCall.Resume(resumeStatus);
+ User::WaitForRequest(resumeStatus);
+ ASSERT_EQUALS(KErrGeneral, resumeStatus.Int());
+
+ RMobileCall::TMobileCallStatus callStatus;
+ ASSERT_EQUALS(KErrNone, mobileCall.GetMobileCallStatus(callStatus));
+ ASSERT_EQUALS(RMobileCall::EStatusHold, callStatus);
+
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0014L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0015
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for failure to swap a call
+ @SYMTestPriority High
+ @SYMTestActions Invokes swapping a call and receiving error
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0015L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId1 = 1;
+ TInt callId2 = 2;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ DriverDialAndHoldFirstCallDialSecondCallL(mobileService, callId1, callId2);
+
+ DriverSwapCallL(callId1, callId2, KErrGeneral, RMobileCall::EStatusConnected, RMobileCall::EStatusHold);
+
+ DriverSwapCallL(callId1, callId2, KErrGeneral, RMobileCall::EStatusConnected, RMobileCall::EStatusHold);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing;
+ DriverHangUpCallL(callId1, hangUpCause, EFalse);
+
+ DriverHangUpCallL(callId2, hangUpCause, ETrue);
+
+ // Client side test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+
+ RMobileLine mobileLine2;
+ CleanupClosePushL(mobileLine2);
+ RMobileCall mobileCall2;
+ CleanupClosePushL(mobileCall2);
+
+ ClientDialAndHoldFirstCallDialSecondCallL(mobileService, mobileCall, mobileLine,
+ mobileCall2, mobileLine2);
+
+ TRequestStatus swapStatus;
+ mobileCall.Swap(swapStatus);
+ User::WaitForRequest(swapStatus);
+ ASSERT_EQUALS(KErrGeneral, swapStatus.Int());
+
+ mobileCall2.Swap(swapStatus);
+ User::WaitForRequest(swapStatus);
+ ASSERT_EQUALS(KErrGeneral, swapStatus.Int());
+
+ RMobileCall::TMobileCallStatus callStatus;
+ ASSERT_EQUALS(KErrNone, mobileCall.GetMobileCallStatus(callStatus));
+ ASSERT_EQUALS(RMobileCall::EStatusHold, callStatus);
+
+ ASSERT_EQUALS(KErrNone, mobileCall2.GetMobileCallStatus(callStatus));
+ ASSERT_EQUALS(RMobileCall::EStatusConnected, callStatus);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+ ClientHangUpCallL(mobileCall2);
+
+ mobileCall.Close();
+ mobileLine.Close();
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(6, this); //mobileCall2, mobileLine2, mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0015L
+
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0016
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for holding a call then dialling a second and swapping them
+ @SYMTestPriority High
+ @SYMTestActions Invokes dialling then holding a call and dialling a second call and swapping them
+ @SYMTestExpectedResults Pass - Second call can be dialled
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0016L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId1 = 1;
+ TInt callId2 = 2;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ DriverDialAndHoldFirstCallDialSecondCallL(mobileService, callId1, callId2);
+
+ DriverSwapCallL(callId1, callId2, KErrNone, RMobileCall::EStatusConnected, RMobileCall::EStatusHold);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing;
+ DriverHangUpCallL(callId2, hangUpCause, EFalse);
+
+ hangUpCause = KErrGsmCCNormalCallClearing;
+ DriverHangUpCallL(callId1, hangUpCause, ETrue);
+
+ // Client side test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+
+ RMobileLine mobileLine2;
+ CleanupClosePushL(mobileLine2);
+ RMobileCall mobileCall2;
+ CleanupClosePushL(mobileCall2);
+
+ ClientDialAndHoldFirstCallDialSecondCallL(mobileService, mobileCall, mobileLine,
+ mobileCall2, mobileLine2);
+
+ TRequestStatus notifyStatus;
+ RMobileCall::TMobileCallStatus callStatus;
+ mobileCall.NotifyMobileCallStatusChange(notifyStatus, callStatus);
+
+ TRequestStatus notifyStatus2;
+ RMobileCall::TMobileCallStatus callStatus2;
+ mobileCall2.NotifyMobileCallStatusChange(notifyStatus2, callStatus2);
+
+ TRequestStatus swapStatus;
+ mobileCall.Swap(swapStatus);
+ User::WaitForRequest(swapStatus);
+ ASSERT_EQUALS(KErrNone, swapStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusConnected, callStatus);
+
+ User::WaitForRequest(notifyStatus2);
+ ASSERT_EQUALS(KErrNone, notifyStatus2.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusHold, callStatus2);
+
+ ClientHangUpCallL(mobileCall2);
+
+ ASSERT_EQUALS(KErrNone, mobileCall.GetMobileCallStatus(callStatus));
+ ASSERT_EQUALS(RMobileCall::EStatusConnected, callStatus);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ ASSERT_EQUALS(KErrNone, mobileCall.GetMobileCallStatus(callStatus));
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, callStatus);
+
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(6, this); // mobileCall2, mobileLine2, mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0016L
+
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0017
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for dialling and hanging up an ISV call
+ @SYMTestPriority High
+ @SYMTestActions Invokes dialling then hanging up a voice call using CTelephony
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0017L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RMmCustomAPI customApi;
+ OpenCustomApiLC(customApi);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TDesC* phoneNumberPtr = const_cast<TDesC*>(&KPhoneNumber);
+ TBool isEmergency = EFalse;
+ TMockLtsyData2<TDesC*, TBool> queryIsEmergencyNumberExpData(phoneNumberPtr,isEmergency);
+ queryIsEmergencyNumberExpData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlQueryIsEmergencyNumber::KLtsyDispatchCallControlQueryIsEmergencyNumberApiId, data);
+ data.Close();
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mode = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mode, ETrue);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ ClientSetIsvPubSubKeyL();
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ CIsvAO* isvAO = CIsvAO::NewL();
+ CleanupStack::PushL(isvAO);
+
+ isvAO->DoOperation(CIsvAO::EIsvDial);
+ ASSERT_EQUALS(KErrNone, isvAO->Status().Int());
+
+ isvAO->DoOperation(CIsvAO::EIsvHangUp);
+ ASSERT_EQUALS(KErrNone, isvAO->Status().Int());
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); //isvAO, data, customApi, this
+ } // CCTsyCallControlFU::TestUseCase0017L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0018
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for getting notification of and answering an incoming call using CTelephony
+ @SYMTestPriority High
+ @SYMTestActions Invokes CTelephony APIs to get notification of an incoming call, answer it.
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0018L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ ClientSetIsvPubSubKeyL();
+
+ CIsvAO* isvAO = CIsvAO::NewL();
+ CleanupStack::PushL(isvAO);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverCreateIncomingCallL(callId, mobileService);
+
+ isvAO->DoOperation(CIsvAO::EIsvNotifyIncomingCall);
+ ASSERT_EQUALS(KErrNone, isvAO->Status().Int());
+
+ DriverCompleteGetMobileCallInfoL(callId, mobileService);
+
+ DriverAnswerIncomingCallL(callId, mobileService, ETrue);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing;
+ DriverHangUpCallL(callId, hangUpCause);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ isvAO->DoOperation(CIsvAO::EIsvAnswer);
+ ASSERT_EQUALS(KErrNone, isvAO->Status().Int());
+
+ isvAO->DoOperation(CIsvAO::EIsvHangUp);
+ ASSERT_EQUALS(KErrNone, isvAO->Status().Int());
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // isvAO, this
+ } // CCTsyCallControlFU::TestUseCase0018L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0019
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for dialling an emergency call
+ @SYMTestPriority High
+ @SYMTestActions Invokes dialling of an emergency call
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0019L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileENStore::TEmergencyNumber emergencyNumber = _L("911");
+ TMockLtsyData1<RMobileENStore::TEmergencyNumber> dialData(emergencyNumber);
+ dialData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlDialEmergency::KLtsyDispatchCallControlDialEmergencyApiId, data);
+
+ TInt callId = 1;
+ TMockLtsyData1<TInt> dialData2(callId);
+ data.Close();
+ dialData2.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlDialEmergency::KLtsyDispatchCallControlDialEmergencyApiId, KErrNone, data);
+
+ RMobilePhone::TMobileService mode = RMobilePhone::EVoiceService;
+ DriverCompleteGetMobileCallInfoL(callId, mode);
+ DriverCompleteSuccessfulDialNotificationsL(callId);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client side test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+
+ ClientDialCallL(mobileLine, mobileCall, mode, ETrue);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // mobileLine, mobileCall, data, this
+ } // CCTsyCallControlFU::TestUseCase0019L
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0020
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for failed dialling an emergency call
+ @SYMTestPriority High
+ @SYMTestActions Invokes dialling an emergency call
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0020L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileENStore::TEmergencyNumber emergencyNumber = _L("911");
+ TMockLtsyData1<RMobileENStore::TEmergencyNumber> dialData(emergencyNumber);
+ dialData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlDialEmergency::KLtsyDispatchCallControlDialEmergencyApiId, data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mode = RMobilePhone::EVoiceService;
+ TMockLtsyCallData0 dialData2(callId, mode); // Mode not actually used
+ data.Close();
+ dialData2.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlDialEmergency::KLtsyDispatchCallControlDialEmergencyApiId, KErrGeneral, data);
+
+ // Client side test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+
+ OpenLineAndCallL(mobileLine, mobileCall, mode);
+
+ TRequestStatus dialStatus;
+ mobileCall.DialEmergencyCall(dialStatus, emergencyNumber);
+ User::WaitForRequest(dialStatus);
+ ASSERT_EQUALS(KErrGeneral, dialStatus.Int());
+
+ RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusUnknown;
+ mobileCall.GetMobileCallStatus(callStatus);
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, callStatus);
+
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // mobileLine, mobileCall, data, this
+ } // CCTsyCallControlFU::TestUseCase0020L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0021
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for transferring a call
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobileCall::Transfer
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0021L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ DriverHoldCallL(callId, KErrNone);
+
+ TInt callId2 = 2;
+ DriverDialCallL(callId2, mobileService);
+
+ TMockLtsyData2<TInt, TInt> mockData(callId, callId2);
+ data.Close();
+ mockData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlTransfer::KLtsyDispatchCallControlTransferApiId, data);
+
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlTransfer::KLtsyDispatchCallControlTransferApiId, KErrNone);
+
+ RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusIdle;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(
+ callId, RMobilePhone::EServiceUnspecified, callStatus);
+ data.Close();
+ mockCallData.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(
+ callId2, RMobilePhone::EServiceUnspecified, callStatus);
+ data.Close();
+ mockCallData2.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data);
+
+ data.Close();
+
+ TUint32 duration = 3; //this is the length of the call and its not possible to be certain of this due to
+ //e.g. logging statements so this argument is not actually checked in the mockltsy
+ TMockLtsyData1<TUint32> durationLtsyData(duration);
+ durationLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlUpdateLifeTimer::KLtsyDispatchCallControlUpdateLifeTimerApiId, data, KErrNone);
+ data.Close();
+
+ TRequestStatus termiantedReqStatus;
+ iMockLTSY.NotifyTerminated(termiantedReqStatus);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlUpdateLifeTimer::KLtsyDispatchCallControlUpdateLifeTimerApiId, KErrNone);
+
+ // Client side test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+
+ RMobileLine mobileLine2;
+ CleanupClosePushL(mobileLine2);
+ RMobileCall mobileCall2;
+ CleanupClosePushL(mobileCall2);
+
+ ClientDialAndHoldFirstCallDialSecondCallL(mobileService, mobileCall, mobileLine,
+ mobileCall2, mobileLine2);
+
+ TRequestStatus notifyStatus;
+ mobileCall.NotifyMobileCallStatusChange(notifyStatus, callStatus);
+
+ TRequestStatus notifyStatus2;
+ RMobileCall::TMobileCallStatus callStatus2;
+ mobileCall2.NotifyMobileCallStatusChange(notifyStatus2, callStatus2);
+
+ TRequestStatus transferStatus;
+ mobileCall.Transfer(transferStatus);
+ User::WaitForRequest(transferStatus);
+ ASSERT_EQUALS(KErrNone, transferStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, callStatus);
+
+ User::WaitForRequest(notifyStatus2);
+ ASSERT_EQUALS(KErrNone, notifyStatus2.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, callStatus2);
+
+ User::WaitForRequest(termiantedReqStatus);
+ ASSERT_EQUALS(KErrNone, termiantedReqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(6, this); //mobileCall2, mobileLine2, mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0021L
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0022
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for failure to transfer a call
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobileCall::Transfer
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0022L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ DriverHoldCallL(callId, KErrNone);
+
+ TInt callId2 = 2;
+ DriverDialCallL(callId2, mobileService);
+
+ TMockLtsyData2<TInt, TInt> mockData(callId, callId2);
+ data.Close();
+ mockData.SerialiseL(data);
+
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlTransfer::KLtsyDispatchCallControlTransferApiId, data);
+
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlTransfer::KLtsyDispatchCallControlTransferApiId, KErrGeneral);
+
+ // Client side test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+
+ RMobileLine mobileLine2;
+ CleanupClosePushL(mobileLine2);
+ RMobileCall mobileCall2;
+ CleanupClosePushL(mobileCall2);
+
+ ClientDialAndHoldFirstCallDialSecondCallL(mobileService, mobileCall, mobileLine,
+ mobileCall2, mobileLine2);
+
+ // Transfer call, which fails, check first call is still on hold and second
+ // is still connected
+ TRequestStatus notifyStatus;
+ RMobileCall::TMobileCallStatus callStatus;
+ mobileCall.NotifyMobileCallStatusChange(notifyStatus, callStatus);
+
+ TRequestStatus notifyStatus2;
+ RMobileCall::TMobileCallStatus callStatus2;
+ mobileCall2.NotifyMobileCallStatusChange(notifyStatus2, callStatus2);
+
+ TRequestStatus transferStatus;
+ mobileCall.Transfer(transferStatus);
+ User::WaitForRequest(transferStatus);
+ ASSERT_EQUALS(KErrGeneral, transferStatus.Int());
+
+ ASSERT_EQUALS(KRequestPending, notifyStatus.Int());
+ mobileCall.CancelAsyncRequest(EMobileCallNotifyMobileCallStatusChange);
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrCancel, notifyStatus.Int());
+
+ mobileCall.GetMobileCallStatus(callStatus);
+ ASSERT_EQUALS(RMobileCall::EStatusHold, callStatus);
+
+ ASSERT_EQUALS(KRequestPending, notifyStatus2.Int());
+ mobileCall2.CancelAsyncRequest(EMobileCallNotifyMobileCallStatusChange);
+ ASSERT_EQUALS(KErrCancel, notifyStatus2.Int());
+
+ mobileCall2.GetMobileCallStatus(callStatus2);
+ ASSERT_EQUALS(RMobileCall::EStatusConnected, callStatus2);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+
+ DriverHangUpCallL(callId, hangUpCause, EFalse);
+ ClientHangUpCallL(mobileCall);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ DriverHangUpCallL(callId2, hangUpCause, ETrue);
+ ClientHangUpCallL(mobileCall2);
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(6, this); //mobileCall2, mobileLine2, mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0022L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0023
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for sending a DTMF string containing a 'w' and continuing after the 'w'
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobilePhone::SendDTMFTones with a 'w' in the string then RMobilePhone::ContinueDTMFStringSending
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0023L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ TInfoName fullTonesString = _L("12345w67890wABCD");
+ TBuf<5> tonesFirstPart;
+ tonesFirstPart.Copy(fullTonesString.Left(5)); // 12345
+ TMockLtsyData2<TInt, TBuf<5> > toneLtsyData(callId, tonesFirstPart);
+ toneLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, KErrNone);
+
+ TBuf<5> tonesSecondPart;
+ tonesSecondPart.Copy(fullTonesString.Mid(6, 5)); // 67890
+ data.Close();
+ TMockLtsyData2<TInt, TBuf<5> > toneLtsyData2(callId, tonesSecondPart);
+ toneLtsyData2.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, KErrNone);
+
+ TBuf<4> tonesThirdPart;
+ tonesThirdPart.Copy(fullTonesString.Mid(12, 4)); // ABCD
+ data.Close();
+ TMockLtsyData2<TInt, TBuf<4> > toneLtsyData3(callId, tonesThirdPart);
+ toneLtsyData3.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, KErrNone);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client side test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ TRequestStatus notifyStopStatus;
+ iPhone.NotifyStopInDTMFString(notifyStopStatus);
+
+ TRequestStatus sendStatus;
+ iPhone.SendDTMFTones(sendStatus, fullTonesString);
+
+ User::WaitForRequest(notifyStopStatus);
+ ASSERT_EQUALS(KErrNone, notifyStopStatus.Int());
+ iPhone.NotifyStopInDTMFString(notifyStopStatus);
+
+ ASSERT_EQUALS(KErrNone, iPhone.ContinueDTMFStringSending(ETrue));
+
+ User::WaitForRequest(notifyStopStatus);
+ ASSERT_EQUALS(KErrNone, notifyStopStatus.Int());
+
+ ASSERT_EQUALS(KErrNone, iPhone.ContinueDTMFStringSending(ETrue));
+
+ User::WaitForRequest(sendStatus);
+ ASSERT_EQUALS(KErrNone, sendStatus.Int());
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0023L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0024
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for RMobilePhone::SendDTMFTones with 'w' and not continuing
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobilePhone::SendDTMFTones with 'w' and RMobilePhone::ContinueDTMFStringSending with EFalse
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0024L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ TInfoName fullTonesString = _L("12345w67890");
+ TBuf<5> tonesFirstPart;
+ tonesFirstPart.Copy(fullTonesString.Left(5)); // 12345
+ TMockLtsyData2<TInt, TBuf<5> > toneLtsyData(callId, tonesFirstPart);
+ toneLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, KErrNone);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client side test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ TRequestStatus notifyStopStatus;
+ iPhone.NotifyStopInDTMFString(notifyStopStatus);
+
+ TRequestStatus sendStatus;
+ iPhone.SendDTMFTones(sendStatus, fullTonesString);
+
+ User::WaitForRequest(notifyStopStatus);
+ ASSERT_EQUALS(KErrNone, notifyStopStatus.Int());
+
+ ASSERT_EQUALS(KErrNone, iPhone.ContinueDTMFStringSending(EFalse));
+
+ User::WaitForRequest(sendStatus);
+ ASSERT_EQUALS(KErrAbort, sendStatus.Int());
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); //mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0024L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0025
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for dialling a call using the alternate line
+ @SYMTestPriority High
+ @SYMTestActions Invokes dialling a call using the alternate line
+ @SYMTestExpectedResults Pass
+ @SYMTestType CT
+ */
+void CCTsyCallControlFU::TestUseCase0025L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EAuxVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client Side Test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); //mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUseCase0025L
+
+
+//
+// Other unit tests
+//
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY Dispatcher for RMobilePhone::GetIdentityServiceStatus
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::GetIdentityServiceStatus
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+*/
+void CCTsyCallControlFU::TestUnit0001L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobilePhone::TMobilePhoneIdService expService(RMobilePhone::EIdServiceCallerPresentation);
+ TMockLtsyData1<RMobilePhone::TMobilePhoneIdService> expLtsyData(expService);
+ data.Close();
+ expLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlGetIdentityServiceStatus::KLtsyDispatchCallControlGetIdentityServiceStatusApiId, data);
+
+ RMobilePhone::TMobilePhoneIdServiceStatus completeStatus(RMobilePhone::EIdServiceActivePermanent);
+ TMockLtsyData1<RMobilePhone::TMobilePhoneIdServiceStatus> completeLtsyData(completeStatus);
+ data.Close();
+ completeLtsyData.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlGetIdentityServiceStatus::KLtsyDispatchCallControlGetIdentityServiceStatusApiId, KErrNone, data);
+
+ // Client Side Test
+
+ TRequestStatus reqStatus;
+ RMobilePhone::TMobilePhoneIdServiceStatus status;
+ iPhone.GetIdentityServiceStatus(reqStatus, expService, status);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ ASSERT_EQUALS(completeStatus, status);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(2, this); // data, this
+
+ } // CCTsyCallControlFU::TestUnit0001L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0002
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMmCustomApi::CheckEmergencyNumber to check emergency number querying
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMmCustomApi::CheckEmergencyNumber to check emergency number querying
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0002L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RMmCustomAPI customApi;
+ OpenCustomApiLC(customApi);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TDesC* phoneNumberPtr = const_cast<TDesC*>(&KEmergencyPhoneNumber);
+ TBool isEmergency = ETrue;
+ TMockLtsyData2<TDesC*, TBool> queryIsEmergencyNumberExpData(phoneNumberPtr, isEmergency);
+ queryIsEmergencyNumberExpData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlQueryIsEmergencyNumber::KLtsyDispatchCallControlQueryIsEmergencyNumberApiId, data);
+ data.Close();
+
+ TRequestStatus reqStatus;
+ RMmCustomAPI::TEmerNumberCheckMode numCheckMode;
+ numCheckMode.iCheckMode = RMmCustomAPI::EEmerNumberCheckNormal;
+ numCheckMode.iNumber = KEmergencyPhoneNumber;
+ TBool emergencyNumCheckResult = EFalse;
+ customApi.CheckEmergencyNumber(reqStatus, numCheckMode, emergencyNumCheckResult);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ ASSERT_EQUALS(emergencyNumCheckResult, isEmergency);
+
+ customApi.Close();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // customApi, data, this
+
+ } // CCTsyCallControlFU::TestUnit0002L
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN003
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMobilePhone::SetALSLine
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobilePhone::SetALSLine
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0003L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobilePhone::TMobilePhoneALSLine alsLine = RMobilePhone::EAlternateLineAuxiliary;
+ TMockLtsyData1<RMobilePhone::TMobilePhoneALSLine> expLtsyData(alsLine);
+ data.Close();
+ expLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSetActiveAlsLine::KLtsyDispatchCallControlSetActiveAlsLineApiId, data);
+
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSetActiveAlsLine::KLtsyDispatchCallControlSetActiveAlsLineApiId, KErrNone);
+
+ // Client Side Test
+
+ const TUid KCRUidCtsyMEAlsLine = { 0x102029A2 };
+ const TUint KCtsyMEAlsSupported = { 0x00000002 };
+
+ // Create centRep to change repository
+ CRepository* centRep = CRepository::NewL( KCRUidCtsyMEAlsLine );
+ CleanupStack::PushL(centRep);
+
+ TInt ret = centRep->Set( KCtsyMEAlsSupported, ETrue );
+ ASSERT_EQUALS(KErrNone, ret);
+
+ TRequestStatus notifyStatus;
+ RMobilePhone::TMobilePhoneALSLine newAlsLine;
+ iPhone.NotifyALSLineChange(notifyStatus, newAlsLine);
+
+ TRequestStatus requestStatus;
+ iPhone.SetALSLine(requestStatus, alsLine);
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_EQUALS(alsLine, newAlsLine);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // centRep, data, this
+
+ } // CCTsyCallControlFU::TestUnit0003L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0004
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMobilePhone::StartDTMFTone and RMobilePhone::StopDTMFTone
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobilePhone::StartDTMFTone and RMobilePhone::StopDTMFTone
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0004L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ TChar tone('1');
+ TMockLtsyData2<TInt, TChar> toneLtsyData(callId, tone);
+ toneLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, data, KErrNone);
+
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, KErrNone);
+
+ TMockLtsyData1<TInt> toneLtsyData2(callId);
+ toneLtsyData2.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId, data, KErrNone);
+
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId, KErrNone);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client Side Test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ ASSERT_EQUALS(KErrNone, iPhone.StartDTMFTone(tone));
+
+ ASSERT_EQUALS(KErrNone, iPhone.StopDTMFTone());
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); //mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUnit0004L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0005
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for cancelling sending of a DTMF string
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobilePhone::SendDTMFTones and cancels it
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0005L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ TInfoName tones(_L("123456789"));
+ TMockLtsyData2<TInt, TInfoName> toneLtsyData(callId, tones);
+ toneLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, data, KErrNone);
+
+ TMockLtsyData1<TInt> cancelMockData(callId);
+ cancelMockData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSendDtmfTonesCancel::KLtsyDispatchCallControlSendDtmfTonesCancelApiId, data, KErrNone);
+
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSendDtmfTonesCancel::KLtsyDispatchCallControlSendDtmfTonesCancelApiId, KErrNone);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client Side Test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+
+ // First test sending cancel when there is no active call in progress
+ iPhone.CancelAsyncRequest(EMobilePhoneSendDTMFTones);
+
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ // Test sending cancel when there is no SendDTMFTones in progress
+ iPhone.CancelAsyncRequest(EMobilePhoneSendDTMFTones);
+
+ // Test sending DTMF tones and then cancelling
+
+ TRequestStatus reqStatus;
+ iPhone.SendDTMFTones(reqStatus, tones);
+ iPhone.CancelAsyncRequest(EMobilePhoneSendDTMFTones);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrCancel, reqStatus.Int());
+
+ // Test sending cancel when there is no SendDTMFTones in progress
+ // after a cancel
+ iPhone.CancelAsyncRequest(EMobilePhoneSendDTMFTones);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ // Test sending cancel when there is no SendDTMFTones in progress
+ // and no call in progress
+ iPhone.CancelAsyncRequest(EMobilePhoneSendDTMFTones);
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); //mobileCall, mobileLine, data, this
+
+ } // CCTsyCallControlFU::TestUnit0005L
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0006
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMobilePhone::StartDTMFTone
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobilePhone::StartDTMFTone
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0006L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // Set up so that there is an active call for testing sending of DTMF
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ TChar tone('1');
+ TMockLtsyData2<TInt, TChar> toneLtsyData(callId, tone);
+ toneLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, data, KErrNotSupported);
+
+ ASSERT_EQUALS(KErrNotSupported, iPhone.StartDTMFTone(tone));
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, KErrNotSupported);
+
+ ASSERT_EQUALS(KErrNotSupported, iPhone.StartDTMFTone(tone));
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobilePhone::StartDTMFTone
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, KErrNone);
+
+ ASSERT_EQUALS(KErrNone, iPhone.StartDTMFTone(tone));
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::StartDTMFTone
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus terminatedStatus;
+ iMockLTSY.NotifyTerminated(terminatedStatus);
+
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, KErrNone);
+
+ User::WaitForRequest(terminatedStatus);
+
+ //-------------------------------------------------------------------------
+ // TEST F: Extra coverage tests, extra scenarios
+ //-------------------------------------------------------------------------
+
+ // Test StartDTMFTone when there is no active call
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ ASSERT_EQUALS(KErrEtelCallNotActive, iPhone.StartDTMFTone(tone));
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); //mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUnit0006L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0007
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMobilePhone::StopDTMFTone
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobilePhone::StopDTMFTone
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0007L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // Set up so that there is an active call for testing stopping of DTMF
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ TMockLtsyData1<TInt> toneLtsyData(callId);
+ toneLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId, data, KErrNotSupported);
+
+ ASSERT_EQUALS(KErrNotSupported, iPhone.StopDTMFTone());
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId, KErrNotSupported);
+
+ ASSERT_EQUALS(KErrNotSupported, iPhone.StopDTMFTone());
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobilePhone::StopDTMFTone
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId, KErrNone);
+
+ ASSERT_EQUALS(KErrNone, iPhone.StopDTMFTone());
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::StopDTMFTone
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus terminatedStatus;
+ iMockLTSY.NotifyTerminated(terminatedStatus);
+
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId, KErrNone);
+
+ User::WaitForRequest(terminatedStatus);
+
+ //-------------------------------------------------------------------------
+ // TEST F: Coverage test(s) for RMobilePhone::StopDTMFTone
+ //-------------------------------------------------------------------------
+
+ // Test StopDTMFTone when there is no active call
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ ASSERT_EQUALS(KErrEtelCallNotActive, iPhone.StopDTMFTone());
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); //mobileCall, mobileLine, data, this
+
+ } // CCTsyCallControlFU::TestUnit0007L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0008
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMobilePhone::SendDTMFTones
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobilePhone::SendDTMFTones
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0008L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // Set up so that there is an active call for testing sending of DTMF
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ TInfoName tones = _L("12345");
+ TMockLtsyData2<TInt, TInfoName> toneLtsyData(callId, tones);
+ toneLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, data, KErrNotSupported);
+
+ TRequestStatus reqStatus;
+ iPhone.SendDTMFTones(reqStatus, tones);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, KErrNotSupported);
+
+ iPhone.SendDTMFTones(reqStatus, tones);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int());
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobilePhone::SendDTMFTones
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, KErrNone);
+
+ iPhone.SendDTMFTones(reqStatus, tones);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobilePhone::SendDTMFTones
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus terminatedStatus;
+ iMockLTSY.NotifyTerminated(terminatedStatus);
+
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, KErrNone);
+
+ User::WaitForRequest(terminatedStatus);
+
+ //-------------------------------------------------------------------------
+ // TEST F: Coverage test(s) for RMobilePhone::SendDTMFTones
+ //-------------------------------------------------------------------------
+
+ // Test second clients requesting to send DTMF tones when one request is still
+ // pending returns KErrServerBusy
+
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, KErrNone);
+
+ // Open second client
+ RTelServer telServer2;
+ TInt ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2,KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+ iPhone.SendDTMFTones(reqStatus, tones);
+ TRequestStatus reqStatus2;
+ phone2.SendDTMFTones(reqStatus2, tones);
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrServerBusy, reqStatus2.Int());
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ // Test SendDtmfTone when there is no active call
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ iPhone.SendDTMFTones(reqStatus, tones);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrEtelCallNotActive, reqStatus.Int());
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(6, this);//phone2, telserver2, mobileCall, mobileLine, data, this
+
+ } // CCTsyCallControlFU::TestUnit0008L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0009
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMobileCall::ReceiveUUI
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobileCall::ReceiveUUI
+ @SYMTestExpectedResults Pass - client receives data from LTSY
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0009L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ _LIT(KUUI, "important");
+ RMobileCall::TMobileCallUUI receiveUui;
+ receiveUui.Append(KUUI);
+ data.Close();
+ TMockLtsyCallData1<RMobileCall::TMobileCallUUI> mockData(callId, mobileService, receiveUui);
+ mockData.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlReceiveUuiIndId, KErrNone, data);
+
+ TRequestStatus uuiStatus;
+ RMobileCall::TMobileCallUUI receivedUui;
+ mobileCall.ReceiveUUI(uuiStatus, receivedUui);
+ User::WaitForRequest(uuiStatus);
+ ASSERT_EQUALS(KErrNone, uuiStatus.Int());
+ ASSERT_EQUALS(0, receivedUui.Compare(receiveUui));
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+
+ DriverHangUpCallL(callId, hangUpCause);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this); //mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUnit0009L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0010
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for RMobilePhone::SendDTMFTones and waits for it to timeout
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobilePhone::SendDTMFTones and waits for it to timeout
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0010L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+
+ TBuf<5> tones = _L("12345");
+ TMockLtsyData2<TInt, TBuf<5> > toneLtsyData(callId, tones);
+ toneLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, data, KErrNone);
+ data.Close();
+
+ TRequestStatus reqStatus;
+ iPhone.SendDTMFTones(reqStatus, tones);
+
+ //KMmPhoneSendDTMFTonesTimeOut = 125,
+ //Life timers come every 10s thus 125s / 10s = 12 expects to queue.
+ TUint32 duration = 10; //this is the length of the call and its not possible to be certain of this due to
+ //e.g. logging statements so this argument is not actually checked in the mockltsy
+ TMockLtsyData1<TUint32> durationLtsyData(duration);
+ durationLtsyData.SerialiseL(data);
+
+ for(TInt i = 0; i < 12; ++i)
+ {
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlUpdateLifeTimer::KLtsyDispatchCallControlUpdateLifeTimerApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlUpdateLifeTimer::KLtsyDispatchCallControlUpdateLifeTimerApiId, KErrNone);
+ }
+ data.Close();
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrTimedOut, reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(reqStatusTerminated.Int(),KErrNone);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); //mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUnit0010L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0011
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for RMobilePhone::StartDTMFTone and RMobilePhone::StopDTMFTone timeout
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMobilePhone::StartDTMFTone and RMobilePhone::StopDTMFTone waits for it to timeout
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0011L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+ TChar tone('1');
+ TMockLtsyData2<TInt, TChar> toneLtsyData(callId, tone);
+ toneLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, data, KErrNone);
+
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, data, KErrNone);
+
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, KErrNone);
+
+ TMockLtsyData1<TInt> toneLtsyData2(callId);
+ toneLtsyData2.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId, data, KErrNone);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client Side Test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+ ASSERT_EQUALS(KErrTimedOut, iPhone.StartDTMFTone(tone));
+
+ // Now test timeout of stop
+ ASSERT_EQUALS(KErrNone, iPhone.StartDTMFTone(tone));
+ ASSERT_EQUALS(KErrTimedOut, iPhone.StopDTMFTone());
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); //mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUnit0011L
+
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSYDispatch for ICC Call Forwarding Status Change Indicator
+@SYMTestPriority High
+@SYMTestActions Invokes RMmCustomAPI::NotifyIccCallForwardingStatusChange()
+@SYMTestExpectedResults Pass
+@SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0012L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+
+ OpenPhoneL();
+
+ RMmCustomAPI customApi;
+ OpenCustomApiLC(customApi);
+
+ TRequestStatus reqStatus;
+
+ TInt error = KErrNone;
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+ RMmCustomAPI::TCFIndicators cfIndicators;
+ TPckg<RMmCustomAPI::TCFIndicators> cfIndicatorsPckg(cfIndicators);
+
+
+ RMobilePhone::TMobileAddress phoneNumber;
+ phoneNumber.iTelNumber = _L("012345");
+ RMobilePhone::TCFUIndicatorStatusFlags indicators = RMobilePhone::KCFUIndicatorFax | RMobilePhone::KCFUIndicatorData;
+ RMmCustomAPI::TMultipleSubscriberProfileID subscriberId (RMmCustomAPI::KProfileIdentityThree);
+
+ TMockLtsyData3<RMobilePhone::TMobileAddress,
+ RMobilePhone::TCFUIndicatorStatusFlags,
+ RMmCustomAPI::TMultipleSubscriberProfileID> mockLtsyData(phoneNumber, indicators, subscriberId);
+
+ mockLtsyData.SerialiseL(data);
+
+ customApi.NotifyIccCallForwardingStatusChange(reqStatus,cfIndicatorsPckg);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyIccCallForwardingStatusChangeIndId,error,data);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(reqStatus.Int(),error);
+ ASSERT_EQUALS(cfIndicators.iIndicator,indicators);
+ ASSERT_EQUALS(cfIndicators.iMultipleSubscriberProfileID, subscriberId);
+ ASSERT_TRUE(cfIndicators.iCFNumber.iTelNumber.Compare(phoneNumber.iTelNumber) == 0);
+ AssertMockLtsyStatusL();
+
+
+ CleanupStack::PopAndDestroy(&data);
+ CleanupStack::PopAndDestroy(&customApi);
+ CleanupStack::PopAndDestroy(this);
+ }
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0013
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMmCustomAPI::GetAlsBlocked and RMmCustomAPI::SetAlsBlocked
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMmCustomAPI::GetAlsBlocked and RMmCustomAPI::SetAlsBlocked
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0013L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMmCustomAPI customApi;
+ OpenCustomApiLC(customApi);
+
+ // A. Get Status
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlGetAlsBlockedStatus::KLtsyDispatchCallControlGetAlsBlockedStatusApiId, KErrNone);
+ RMmCustomAPI::TGetAlsBlockStatus compData = RMmCustomAPI::EBlockStatusInactive;
+ TMockLtsyData1<RMmCustomAPI::TGetAlsBlockStatus> alsLtsyData1(compData);
+ alsLtsyData1.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlGetAlsBlockedStatus::KLtsyDispatchCallControlGetAlsBlockedStatusApiId, KErrNone, data);
+
+ RMmCustomAPI::TGetAlsBlockStatus status;
+ ASSERT_EQUALS(KErrNone, customApi.GetAlsBlocked(status));
+ ASSERT_EQUALS(compData, status);
+
+ // B. Set blocked
+ data.Close();
+ RMmCustomAPI::TSetAlsBlock setData = RMmCustomAPI::EActivateBlock;
+ TMockLtsyData1<RMmCustomAPI::TSetAlsBlock> alsLtsyData2(setData);
+ alsLtsyData2.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSetAlsBlocked::KLtsyDispatchCallControlSetAlsBlockedApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSetAlsBlocked::KLtsyDispatchCallControlSetAlsBlockedApiId, KErrNone);
+
+ ASSERT_EQUALS(KErrNone, customApi.SetAlsBlocked(setData));
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // customApi, data, this
+ } // CCTsyCallControlFU::TestUnit0013L
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0014
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMmCustomAPI::GetLifeTime
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMmCustomAPI::GetLifeTime
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0014L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMmCustomAPI customApi;
+ OpenCustomApiLC(customApi);
+
+ // A. Test when there is no life time data
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId, KErrNone);
+
+ RMmCustomAPI::TLifeTimeData compData;
+ compData.iCaps = 0;
+ TMockLtsyData1<RMmCustomAPI::TLifeTimeData> ltLtsyData1(compData);
+ ltLtsyData1.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId, KErrNone, data);
+
+ RMmCustomAPI::TLifeTimeData lifeTime;
+ RMmCustomAPI::TLifeTimeDataPckg lifeTimePckg(lifeTime);
+ ASSERT_EQUALS(KErrNone, customApi.GetLifeTime(lifeTimePckg));
+ ASSERT_EQUALS(compData.iCaps, lifeTime.iCaps);
+
+
+ // B. Test when there is only life time data
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId, KErrNone);
+
+ compData.iCaps = RMmCustomAPI::TLifeTimeData::ELifeTimeDataCapsLifeTime;
+ compData.iHours = 12234;
+ compData.iMinutes = 14;
+ data.Close();
+ TMockLtsyData1<RMmCustomAPI::TLifeTimeData> ltLtsyData2(compData);
+ ltLtsyData2.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId, KErrNone, data);
+
+ ASSERT_EQUALS(KErrNone, customApi.GetLifeTime(lifeTimePckg));
+ ASSERT_EQUALS(compData.iHours, lifeTime.iHours);
+ ASSERT_EQUALS(compData.iMinutes, lifeTime.iMinutes);
+
+ // C. Test when there is only manufacturing date data
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId, KErrNone);
+
+ compData.iCaps = RMmCustomAPI::TLifeTimeData::ELifeTimeDataCapsManufacturerDate;
+ compData.iManufacturingDate.SetYear(1995);
+ compData.iManufacturingDate.SetMonth(EAugust);
+ compData.iManufacturingDate.SetDay(21);
+ data.Close();
+ TMockLtsyData1<RMmCustomAPI::TLifeTimeData> ltLtsyData3(compData);
+ ltLtsyData3.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId, KErrNone, data);
+
+ ASSERT_EQUALS(KErrNone, customApi.GetLifeTime(lifeTimePckg));
+ ASSERT_EQUALS(compData.iManufacturingDate.Year(), lifeTime.iManufacturingDate.Year());
+ ASSERT_EQUALS(compData.iManufacturingDate.Month(), lifeTime.iManufacturingDate.Month());
+ ASSERT_EQUALS(compData.iManufacturingDate.Day(), lifeTime.iManufacturingDate.Day());
+
+ // D. Test when there is manufacturing date data and lifetime data
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId, KErrNone);
+
+ compData.iCaps = RMmCustomAPI::TLifeTimeData::ELifeTimeDataCapsManufacturerDate | RMmCustomAPI::TLifeTimeData::ELifeTimeDataCapsLifeTime;
+ compData.iManufacturingDate.SetYear(2000);
+ compData.iManufacturingDate.SetMonth(EJune);
+ compData.iManufacturingDate.SetDay(12);
+ compData.iHours = 31234;
+ compData.iMinutes = 43;
+ data.Close();
+ TMockLtsyData1<RMmCustomAPI::TLifeTimeData> ltLtsyData4(compData);
+ ltLtsyData3.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId, KErrNone, data);
+
+ ASSERT_EQUALS(KErrNone, customApi.GetLifeTime(lifeTimePckg));
+ ASSERT_EQUALS(compData.iHours, lifeTime.iHours);
+ ASSERT_EQUALS(compData.iMinutes, lifeTime.iMinutes);
+ ASSERT_EQUALS(compData.iManufacturingDate.Year(), lifeTime.iManufacturingDate.Year());
+ ASSERT_EQUALS(compData.iManufacturingDate.Month(), lifeTime.iManufacturingDate.Month());
+ ASSERT_EQUALS(compData.iManufacturingDate.Day(), lifeTime.iManufacturingDate.Day());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); //customApi, data, this
+ } // CCTsyCallControlFU::TestUnit0014L
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0015
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMmCustomAPI::TerminateCall
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMmCustomAPI::TerminateCall
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0015L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMmCustomAPI customApi;
+ OpenCustomApiLC(customApi);
+
+ // A. Terminate a specific call
+ // Create an active call
+ TInt callId = 1;
+ DriverDialCallL(callId, RMobilePhone::EVoiceService);
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, RMobilePhone::EVoiceService);
+
+ // Getting the call information
+ RMobileCall::TMobileCallInfoV1 callInfo;
+ RMobileCall::TMobileCallInfoV1Pckg callInfoPckg(callInfo);
+ ASSERT_EQUALS(KErrNone, mobileCall.GetMobileCallInfo(callInfoPckg));
+ ASSERT_EQUALS(callId , callInfo.iCallId);
+
+ // Getting mock ltsy ready
+ data.Close();
+ TMockLtsyData1<TInt> termLtsyData1(callId);
+ termLtsyData1.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlTerminateErrorCall::KLtsyDispatchCallControlTerminateErrorCallApiId, data, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlTerminateErrorCall::KLtsyDispatchCallControlTerminateErrorCallApiId, KErrNone, data);
+
+ // Activate the API
+ ASSERT_EQUALS(KErrNone, customApi.TerminateCall(callInfo.iCallName));
+
+ // Hang up the call
+ DriverHangUpCallL(callId, KErrGsmCCNormalCallClearing);
+ ClientHangUpCallL(mobileCall);
+
+ // B. All calls
+ // Create an active call
+ callId = 71;
+ DriverDialCallL(callId, RMobilePhone::EVoiceService);
+ RMobileLine mobileLine2;
+ CleanupClosePushL(mobileLine2);
+ RMobileCall mobileCall2;
+ CleanupClosePushL(mobileCall2);
+ ClientDialCallL(mobileLine2, mobileCall2, RMobilePhone::EVoiceService);
+
+ // Getting mock ltsy ready
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlTerminateAllCalls::KLtsyDispatchCallControlTerminateAllCallsApiId, KErrNone);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlTerminateAllCalls::KLtsyDispatchCallControlTerminateAllCallsApiId, KErrNone);
+
+ // Activate the API
+ TName terminateAll(KTerminateAllCalls);
+ ASSERT_EQUALS(KErrNone, customApi.TerminateCall(terminateAll));
+
+ // Hang up the call
+ DriverHangUpCallL(callId, KErrGsmCCNormalCallClearing);
+
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall2);
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(7, this); //mobileCall2, mobileLine2, mobileCall, mobileLine, customApi, data, this
+ } // CCTsyCallControlFU::TestUnit0015L
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0016
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMmCustomAPI::GetRemoteAlertingToneStatus and RMmCustomAPI::NotifyRemoteAlertingToneStatusChange
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMmCustomAPI::GetRemoteAlertingToneStatus and RMmCustomAPI::NotifyRemoteAlertingToneStatusChange
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0016L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMmCustomAPI customApi;
+ OpenCustomApiLC(customApi);
+
+ // A. Test without notification from the LTSY
+ RMmCustomAPI::TRemoteAlertingToneStatus status;
+ ASSERT_EQUALS(KErrNone, customApi.GetRemoteAlertingToneStatus(status));
+ ASSERT_EQUALS(RMmCustomAPI::EUiNoTone, status);
+
+ // B. LTSY notify that the status was set
+ TRequestStatus terminatedStatus;
+ iMockLTSY.NotifyTerminated(terminatedStatus);
+ RMmCustomAPI::TRemoteAlertingToneStatus compStatus = RMmCustomAPI::EUiRbtTone;
+ TMockLtsyData1<RMmCustomAPI::TRemoteAlertingToneStatus> compData1(compStatus);
+ data.Close();
+ compData1.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlRemoteAlertingToneChangeIndId, KErrNone, data);
+ User::WaitForRequest(terminatedStatus);
+
+ // Activate the API
+ ASSERT_EQUALS(KErrNone, customApi.GetRemoteAlertingToneStatus(status));
+ ASSERT_EQUALS(compStatus, status);
+
+
+ // C. Check the change notification
+ TRequestStatus notifyStatus;
+ customApi.NotifyRemoteAlertingToneStatusChange(notifyStatus, status);
+ compStatus = RMmCustomAPI::EUiStopTone;
+ TMockLtsyData1<RMmCustomAPI::TRemoteAlertingToneStatus> compData2(compStatus);
+ data.Close();
+ compData1.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlRemoteAlertingToneChangeIndId, KErrNone, data);
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(compStatus, status);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); //customApi, data, this
+ } // CCTsyCallControlFU::TestUnit0016L
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0017
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMmCustomAPI::GetIccCallForwardingIndicatorStatus
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMmCustomAPI::GetIccCallForwardingIndicatorStatus
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0017L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMmCustomAPI customApi;
+ OpenCustomApiLC(customApi);
+ // Getting mock ltsy ready
+ data.Close();
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlGetCallForwardingIndicator::KLtsyDispatchCallControlGetCallForwardingIndicatorApiId);
+ RMobilePhone::TMobilePhoneCFUIndicatorV6 compIndicator;
+ compIndicator.iMultipleSubscriberProfileID = RMobilePhone::KProfileIdentityThree;
+ compIndicator.iIndicator = RMobilePhone::KCFUIndicatorVoice | RMobilePhone::KCFUIndicatorData;
+ compIndicator.iCFNumber.iNumberPlan = RMobilePhone::ENationalNumberPlan;
+ compIndicator.iCFNumber.iTypeOfNumber = RMobilePhone::EAlphanumericNumber;
+ _LIT(KTelNumber, "020102010201");
+ compIndicator.iCFNumber.iTelNumber = KTelNumber;
+ TMockLtsyData1<RMobilePhone::TMobilePhoneCFUIndicatorV6> indicatorData(compIndicator);
+ data.Close();
+ indicatorData.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlGetCallForwardingIndicator::KLtsyDispatchCallControlGetCallForwardingIndicatorApiId,KErrNone,data,0);
+
+ // Activate the API
+ RMmCustomAPI::TCFIndicators indicator;
+ RMmCustomAPI::TCFIndicatorsPckg indicatorPckg(indicator);
+ TRequestStatus apiStatus;
+ customApi.GetIccCallForwardingIndicatorStatus(apiStatus, indicatorPckg);
+ User::WaitForRequest(apiStatus);
+ ASSERT_EQUALS(KErrNone, apiStatus.Int());
+ ASSERT_EQUALS(compIndicator.iCFNumber.iTelNumber, indicator.iCFNumber.iTelNumber);
+ ASSERT_EQUALS(compIndicator.iCFNumber.iTypeOfNumber, indicator.iCFNumber.iTypeOfNumber);
+ ASSERT_EQUALS(compIndicator.iCFNumber.iNumberPlan, indicator.iCFNumber.iNumberPlan);
+ ASSERT_EQUALS(compIndicator.iIndicator, indicator.iIndicator);
+ // CTSY sets the value of iMultipleSubscriberProfileID into a private repository, but not to the API struct.
+ // ASSERT_EQUALS(RMmCustomAPI::KProfileIdentityThree, indicator.iMultipleSubscriberProfileID);
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); //customApi, data, this
+ } // CCTsyCallControlFU::TestUnit0017L
+
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0018
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY Dispatcher for RMmCustomAPI::CheckAlsPpSupport
+ @SYMTestPriority High
+ @SYMTestActions Invokes RMmCustomAPI::CheckAlsPpSupport
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0018L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMmCustomAPI customApi;
+ OpenCustomApiLC(customApi);
+
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlGetAlsPpSupport::KLtsyDispatchCallControlGetAlsPpSupportApiId, KErrNone);
+
+
+ RMmCustomAPI::TAlsSupport compData = RMmCustomAPI::EAlsSupportOff;
+ TMockLtsyData1<RMmCustomAPI::TAlsSupport> alsLtsyData1(compData);
+ alsLtsyData1.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlGetAlsPpSupport::KLtsyDispatchCallControlGetAlsPpSupportApiId, KErrNone, data);
+
+ RMmCustomAPI::TAlsSupport support;
+ ASSERT_EQUALS(KErrNone, customApi.CheckAlsPpSupport(support));
+ ASSERT_EQUALS(compData, support);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); //customApi, data, this
+ } // CCTsyCallControlFU::TestUnit0018L
+
+/**
+ @SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0019
+ @SYMComponent telephony_ctsy
+ @SYMTestCaseDesc Test support in CTSY for ECtsyUpdateLifeTimeReq/ECtsyUpdateLifeTimeComp IPCs by keeping a call open for longer than 10s
+ @SYMTestPriority High
+ @SYMTestActions Invokes ECtsyUpdateLifeTimeReq/ECtsyUpdateLifeTimeComp
+ @SYMTestExpectedResults Pass
+ @SYMTestType UT
+ */
+void CCTsyCallControlFU::TestUnit0019L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService);
+
+
+
+
+ // Client Side Test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService);
+
+
+ AssertMockLtsyStatusL();
+
+ //expect the lifetimer call to come through
+
+ TUint32 duration = 10;
+ TMockLtsyData1<TUint32> durationLtsyData(duration);
+ durationLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlUpdateLifeTimer::KLtsyDispatchCallControlUpdateLifeTimerApiId, data, KErrNone);
+ data.Close();
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlUpdateLifeTimer::KLtsyDispatchCallControlUpdateLifeTimerApiId, KErrNone);
+
+ User::After(12500000);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+
+ ClientHangUpCallL(mobileCall);
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatusTerminated.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3, &data); //mobileCall, mobileLine, data
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(this);
+ } // CCTsyCallControlFU::TestUnit0019L
+
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UN0020
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for mobile originated voice call with no FDN check
+@SYMTestPriority High
+@SYMTestActions RMobileCall::DialNoFdnCheck() for a voice call
+@SYMTestExpectedResults Pass - Call reaches connected state and call is hung up
+@SYMTestType CT
+*/
+void CCTsyCallControlFU::TestUnit0020L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TRequestStatus reqStatus;
+
+ //Test voice call
+
+ iMockLTSY.NotifyTerminated(reqStatus);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+ DriverDialCallL(callId, mobileService, EFalse, EFalse, EFalse);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client Side Test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+ ClientDialCallL(mobileLine, mobileCall, mobileService, EFalse, EFalse);
+
+ ClientHangUpCallL(mobileCall);
+
+
+ mobileCall.Close();
+ mobileLine.Close();
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); //mobileCall, mobileLine, this
+ } // CCTsyCallControlFU::TestUnit0020L
+
+
+/**
+@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UT0021
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for mobile originated data call with no FDN check
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::DialNoFdnCheck() for a data call
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallControlFU::TestUnit0021L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup, this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ DriverDialCallL(callId, mobileService, EFalse, EFalse, EFalse);
+
+ // KMockLtsyDispatchCallControlNotifyDataCallCapsChangeIndId
+ RMobileCall::TMobileCallDataCapsV1 completeCallCaps;
+ completeCallCaps.iSpeedCaps = RMobileCall::KCapsSpeed48000;
+ completeCallCaps.iProtocolCaps = RMobileCall::KCapsProtocolV34;
+ completeCallCaps.iServiceCaps = RMobileCall::KCapsPacketAccessSyncUDI;
+ completeCallCaps.iQoSCaps = RMobileCall::KCapsTransparentPreferred;
+ completeCallCaps.iHscsdSupport = ETrue;
+ completeCallCaps.iMClass = 2;
+ completeCallCaps.iMaxRxTimeSlots = 4;
+ completeCallCaps.iMaxTxTimeSlots = 8;
+ completeCallCaps.iTotalRxTxTimeSlots = 10;
+ completeCallCaps.iCodingCaps = RMobileCall::KCapsAiurCoding96;
+ completeCallCaps.iAsymmetryCaps = RMobileCall::KCapsAsymmetryDownlink;
+ completeCallCaps.iUserInitUpgrade = ETrue;
+ completeCallCaps.iRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion1;
+ completeCallCaps.iV42bisCaps = RMobileCall::KCapsV42bisRxDirection;
+ data.Close();
+ TMockLtsyCallData1<RMobileCall::TMobileCallDataCapsV1>
+ completeDataCapsData(callId, RMobilePhone::EServiceUnspecified, completeCallCaps);
+ completeDataCapsData.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyDataCallCapsChangeIndId, KErrNone, data);
+
+ _LIT(KDataPort, "DATAPORT::0");
+ RCall::TCommPort commPort;
+ commPort.iPort = KDataPort;
+ data.Close();
+ TMockLtsyData2<TInt,RCall::TCommPort> loanDataPortExpData(callId,commPort);
+ loanDataPortExpData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlLoanDataPort::KLtsyDispatchCallControlLoanDataPortApiId, data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlRecoverDataPort::KLtsyDispatchCallControlRecoverDataPortApiId, data);
+
+
+ // MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId
+ RMobileCall::TMobileHscsdCallParamsV8 hscsdParams;
+ hscsdParams.iWantedAiur = RMobileCall::EAiurBps38400;
+ hscsdParams.iWantedRxTimeSlots = 2;
+ data.Close();
+ TMockLtsyData2<TInt, RMobileCall::TMobileHscsdCallParamsV8> paramData(callId, hscsdParams);
+ paramData.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId, data);
+
+ TMockLtsyData1<TInt> mockParamData(callId);
+ data.Close();
+ mockParamData.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId, KErrNone, data);
+
+ // KMockLtsyDispatchCallControlNotifyHscsdInfoChangeIndId
+ RMobileCall::TMobileCallHscsdInfoV8 hscsdInfo;
+ hscsdInfo.iCodings = RMobileCall::ETchCoding320;
+ hscsdInfo.iAiur = RMobileCall::EAiurBps38400;
+ hscsdInfo.iRxTimeSlots = 2;
+ hscsdInfo.iTxTimeSlots = 2;
+
+ RMobileCall::TMobileCallDataCapsV1 completeCallCaps2 = completeCallCaps;
+ completeCallCaps2.iHscsdSupport = ETrue;
+ completeCallCaps2.iSpeedCaps = RMobileCall::KCapsSpeed57600;
+ completeCallCaps2.iMaxRxTimeSlots = 3;
+ completeCallCaps2.iMaxTxTimeSlots = 5;
+
+ TMockLtsyCallData2<RMobileCall::TMobileCallHscsdInfoV8, RMobileCall::TMobileCallDataCapsV1>
+ hscsdData(1, RMobilePhone::ECircuitDataService, hscsdInfo, completeCallCaps2);
+ data.Close();
+ hscsdData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyHscsdInfoChangeIndId, KErrNone, data);
+
+ TInt hangUpCause = KErrGsmCCNormalCallClearing;
+ DriverHangUpCallL(callId, hangUpCause);
+
+ // Client Side Test
+
+ RMobileLine mobileLine;
+ CleanupClosePushL(mobileLine);
+ RMobileCall mobileCall;
+ CleanupClosePushL(mobileCall);
+
+ ClientDialCallL(mobileLine, mobileCall, mobileService, EFalse, EFalse);
+
+ RCall::TCommPort dataPort;
+ TRequestStatus reqStatus;
+ mobileCall.LoanDataPort(reqStatus, dataPort);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ ASSERT_EQUALS(0, dataPort.iPort.Compare(KDataPort()));
+
+ TInt err = mobileCall.RecoverDataPort();
+ ASSERT_EQUALS(KErrNone, err);
+
+ RMobileCall::TMobileCallDataCapsV1 callCaps;
+ RMobileCall::TMobileCallDataCapsV1Pckg callCapsPckg(callCaps);
+ mobileCall.GetMobileDataCallCaps(callCapsPckg);
+ ASSERT_TRUE(TComparator<RMobileCall::TMobileCallDataCapsV1>::IsEqual(completeCallCaps, callCaps));
+
+ TRequestStatus hscsdInfoStatus;
+ RMobileCall::TMobileCallHscsdInfoV8 hscsdInfo2;
+ RMobileCall::TMobileCallHscsdInfoV8Pckg hscsdInfoPckg(hscsdInfo2);
+ mobileCall.NotifyHscsdInfoChange(hscsdInfoStatus, hscsdInfoPckg);
+
+ TRequestStatus dataCallCapsStatus;
+ RMobileCall::TMobileCallDataCapsV1 dataCallCaps2;
+ RMobileCall::TMobileCallDataCapsV1Pckg dataCallCapsPckg(dataCallCaps2);
+ mobileCall.NotifyMobileDataCallCapsChange(dataCallCapsStatus, dataCallCapsPckg);
+
+ TRequestStatus hscsdParamStatus;
+ mobileCall.SetDynamicHscsdParams(hscsdParamStatus, hscsdParams.iWantedAiur, hscsdParams.iWantedRxTimeSlots);
+ User::WaitForRequest(hscsdParamStatus);
+
+ User::WaitForRequest(hscsdInfoStatus);
+ ASSERT_EQUALS(KErrNone, hscsdInfoStatus.Int());
+ ASSERT_EQUALS(hscsdInfo2.iAiur, hscsdInfo.iAiur);
+ ASSERT_EQUALS(hscsdInfo2.iRxTimeSlots, hscsdInfo.iRxTimeSlots);
+ ASSERT_EQUALS(hscsdInfo2.iTxTimeSlots, hscsdInfo.iTxTimeSlots);
+ ASSERT_EQUALS(hscsdInfo2.iCodings, hscsdInfo.iCodings);
+
+ User::WaitForRequest(dataCallCapsStatus);
+ ASSERT_EQUALS(KErrNone, dataCallCapsStatus.Int());
+ ASSERT_EQUALS(completeCallCaps2.iSpeedCaps, dataCallCaps2.iSpeedCaps);
+ ASSERT_EQUALS(completeCallCaps2.iHscsdSupport, dataCallCaps2.iHscsdSupport);
+ ASSERT_EQUALS(completeCallCaps2.iMaxRxTimeSlots, dataCallCaps2.iMaxRxTimeSlots);
+ ASSERT_EQUALS(completeCallCaps2.iMaxTxTimeSlots, dataCallCaps2.iMaxTxTimeSlots);
+
+ TRequestStatus reqStatusTerminated;
+ iMockLTSY.NotifyTerminated(reqStatusTerminated);
+ ClientHangUpCallL(mobileCall);
+
+ mobileCall.Close();
+ mobileLine.Close();
+ data.Close();
+
+ User::WaitForRequest(reqStatusTerminated);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // mobileCall, mobileLine, data, this
+ } // CCTsyCallControlFU::TestUnit0021L
+
+
+//
+// Other helper functions
+//
+
+
+void CCTsyCallControlFU::ClientSetIsvPubSubKeyL()
+ {
+ // CTelephony requires property to be set otherwise it thinks flight mode
+ // is on.
+ TInt err = RProperty::Set(KUidSystemCategory, KUidPhonePwr.iUid, ESAPhoneOn);
+ User::LeaveIfError(err);
+ } // CCTsyCallControlFU::ClientSetIsvPubSubKeyL
+
+
+
+void CCTsyCallControlFU::DriverCreateIncomingCallL(TInt aCallId, RMobilePhone::TMobileService aMode)
+ {
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iService = aMode;
+ mobileCallInfo.iCallId = aCallId;
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(aCallId, aMode, mobileCallInfo);
+ mockCallData1.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyIncomingCallIndId, KErrNone, data);
+
+ data.Close();
+ CleanupStack::PopAndDestroy(1, &data);
+ } // CCTsyCallControlFU::DriverCreateIncomingCallL
+
+void CCTsyCallControlFU::DriverAnswerIncomingCallL(TInt aCallId, RMobilePhone::TMobileService aMode, TBool aIsIsvCall,TInt aAnswerError)
+ {
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TMockLtsyData2<TInt, TInt> data1(aCallId, aIsIsvCall);
+ data.Close();
+ data1.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlAnswer::KLtsyDispatchCallControlAnswerApiId, data);
+
+ TMockLtsyData1<TInt> data2(aCallId);
+ data.Close();
+ data2.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlAnswer::KLtsyDispatchCallControlAnswerApiId, aAnswerError, data);
+
+ if (aAnswerError == KErrNone)
+ {
+ RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusAnswering;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(aCallId, aMode, callStatus);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data);
+
+ callStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(aCallId, aMode, callStatus);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data);
+ }
+ else
+ {
+ RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusIdle;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(aCallId, aMode, callStatus);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId , KErrNone, data);
+ }
+
+ data.Close();
+ CleanupStack::PopAndDestroy(1, &data);
+ } // CCTsyCallControlFU::DriverAnswerIncomingCallL
+
+
+void CCTsyCallControlFU::DriverResumeCallL(TInt aCallId, TInt aResumeError)
+ {
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TMockLtsyData1<TInt> mockData2(aCallId);
+ data.Close();
+ mockData2.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlResume::KLtsyDispatchCallControlResumeApiId, data);
+
+ TMockLtsyData1<TInt> resumeData(aCallId);
+ data.Close();
+ resumeData.SerialiseL(data);
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlResume::KLtsyDispatchCallControlResumeApiId, aResumeError, data);
+
+ if (aResumeError == KErrNone)
+ {
+ RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(
+ aCallId, RMobilePhone::EServiceUnspecified, callStatus);
+ data.Close();
+ mockCallData2.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data);
+ }
+
+ data.Close();
+ CleanupStack::PopAndDestroy(1, &data);
+ } // CCTsyCallControlFU::DriverResumeCallL
+
+/**
+ * Swap the call.
+ *
+ * @param aCallId1 Call ID of held call to swap.
+ * @param aCallId2 Call ID of connected call to swap.
+ * @param aSwapError Error returned by LTSY in response to the swap request.
+ * @param aNewCall1Status New status of the call 1 if aSwapError = KErrNone
+ * @param aNewCall2Status New status of the call 2 if aSwapError = KErrNone
+ *
+ * In the case where aSwapError passed is not KErrNone, the new call statuses
+ * are irrelevant as the calls don't change state.
+ */
+void CCTsyCallControlFU::DriverSwapCallL(TInt aCallId1, TInt aCallId2,
+ TInt aSwapError, RMobileCall::TMobileCallStatus aNewCall1Status,
+ RMobileCall::TMobileCallStatus aNewCall2Status)
+ {
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TMockLtsyData2<TInt, TInt> mockData2(aCallId1, aCallId2);
+ data.Close();
+ mockData2.SerialiseL(data);
+ iMockLTSY.ExpectL(MLtsyDispatchCallControlSwap::KLtsyDispatchCallControlSwapApiId, data);
+
+ iMockLTSY.CompleteL(MLtsyDispatchCallControlSwap::KLtsyDispatchCallControlSwapApiId, aSwapError);
+
+ if (aSwapError == KErrNone)
+ {
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(
+ aCallId1, RMobilePhone::EServiceUnspecified, aNewCall1Status);
+ data.Close();
+ mockCallData2.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(
+ aCallId2, RMobilePhone::EServiceUnspecified, aNewCall2Status);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+ iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data);
+ }
+
+ data.Close();
+ CleanupStack::PopAndDestroy(1, &data);
+ } // CCTsyCallControlFU::DriverSwapCallL
+
+
+
+
+/**
+ * Waits for an incoming call notification and opens the call.
+ *
+ * @param aMobileCall RMobileCall subsession, should not be open before calling this function.
+ * Pushed on CleanupStack in this function.
+ *
+ * @param aMobileLine Line that will ring.
+ * @param aCallName Populated with the call name when incoming call arrives.
+ */
+void CCTsyCallControlFU::ClientWaitForIncomingCallNotificationLC(
+ RMobileCall& aMobileCall, RMobileLine& aMobileLine, TName& aCallName)
+ {
+ TRequestStatus notifyStatus;
+ aMobileLine.NotifyIncomingCall(notifyStatus, aCallName);
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+
+ TInt err = aMobileCall.OpenExistingCall(aMobileLine, aCallName);
+ CleanupClosePushL(aMobileCall);
+ ASSERT_EQUALS(KErrNone, err);
+
+ RMobileCall::TMobileCallStatus callStatus;
+ aMobileCall.GetMobileCallStatus(callStatus);
+ ASSERT_EQUALS(RMobileCall::EStatusRinging, callStatus);
+ } // CCTsyCallControlFU::ClientWaitForIncomingCallNotificationLC
+
+void CCTsyCallControlFU::ClientAnswerIncomingCallL(RMobileCall& aMobileCall, TInt aExpectedAnswerError)
+ {
+ TRequestStatus notifyStatus;
+ RMobileCall::TMobileCallStatus callStatus;
+ aMobileCall.NotifyMobileCallStatusChange(notifyStatus, callStatus);
+
+ TRequestStatus ansStatus;
+ aMobileCall.AnswerIncomingCall(ansStatus);
+
+ RArray<RMobileCall::TMobileCallStatus> expectedCallStatuses;
+ CleanupClosePushL(expectedCallStatuses);
+
+ if (aExpectedAnswerError == KErrNone)
+ {
+ expectedCallStatuses.AppendL(RMobileCall::EStatusAnswering);
+ expectedCallStatuses.AppendL(RMobileCall::EStatusConnected);
+ }
+ else
+ {
+ expectedCallStatuses.AppendL(RMobileCall::EStatusIdle);
+ }
+
+ ClientWaitForCallStatusNotifications(aMobileCall, notifyStatus, callStatus, expectedCallStatuses, KErrNone);
+
+ User::WaitForRequest(ansStatus);
+ ASSERT_EQUALS(aExpectedAnswerError, ansStatus.Int());
+
+ aMobileCall.GetMobileCallStatus(callStatus);
+
+ if (aExpectedAnswerError == KErrNone)
+ {
+ ASSERT_EQUALS(RMobileCall::EStatusConnected, callStatus);
+ }
+ else
+ {
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, callStatus);
+ }
+
+ expectedCallStatuses.Close();
+ CleanupStack::PopAndDestroy(1, &expectedCallStatuses);
+ } // CCTsyCallControlFU::ClientAnswerIncomingCallL
+