diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsycallcontrolfu.cpp --- /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 +#include +#include +#include +#include +#include +#include +#include "testconstants.h" + +#include "mockltsyindicatorids.h" +#include // For phone power P&S key needed by Etel3rdParty testing +#include +#include +#include + +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 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 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 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 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 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 + 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 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 paramData(callId, hscsdParams); + paramData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId, data); + + TMockLtsyData1 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 + 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::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 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 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 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 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 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 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 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 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 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(&KPhoneNumber); + TBool isEmergency = EFalse; + TMockLtsyData2 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 dialData(emergencyNumber); + dialData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchCallControlDialEmergency::KLtsyDispatchCallControlDialEmergencyApiId, data); + + TInt callId = 1; + TMockLtsyData1 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 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 mockData(callId, callId2); + data.Close(); + mockData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchCallControlTransfer::KLtsyDispatchCallControlTransferApiId, data); + + iMockLTSY.CompleteL(MLtsyDispatchCallControlTransfer::KLtsyDispatchCallControlTransferApiId, KErrNone); + + RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusIdle; + TMockLtsyCallData1 mockCallData( + callId, RMobilePhone::EServiceUnspecified, callStatus); + data.Close(); + mockCallData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data); + + TMockLtsyCallData1 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 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 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 > 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 > 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 > 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 > 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 expLtsyData(expService); + data.Close(); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchCallControlGetIdentityServiceStatus::KLtsyDispatchCallControlGetIdentityServiceStatusApiId, data); + + RMobilePhone::TMobilePhoneIdServiceStatus completeStatus(RMobilePhone::EIdServiceActivePermanent); + TMockLtsyData1 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(&KEmergencyPhoneNumber); + TBool isEmergency = ETrue; + TMockLtsyData2 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 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 toneLtsyData(callId, tone); + toneLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, data, KErrNone); + + iMockLTSY.CompleteL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, KErrNone); + + TMockLtsyData1 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 toneLtsyData(callId, tones); + toneLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId, data, KErrNone); + + TMockLtsyData1 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 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 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 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 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 > 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 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 toneLtsyData(callId, tone); + toneLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, data, KErrNone); + + iMockLTSY.ExpectL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, data, KErrNone); + + iMockLTSY.CompleteL(MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId, KErrNone); + + TMockLtsyData1 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 cfIndicatorsPckg(cfIndicators); + + + RMobilePhone::TMobileAddress phoneNumber; + phoneNumber.iTelNumber = _L("012345"); + RMobilePhone::TCFUIndicatorStatusFlags indicators = RMobilePhone::KCFUIndicatorFax | RMobilePhone::KCFUIndicatorData; + RMmCustomAPI::TMultipleSubscriberProfileID subscriberId (RMmCustomAPI::KProfileIdentityThree); + + TMockLtsyData3 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 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 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 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 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 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 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 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 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 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 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 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 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 + 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 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 paramData(callId, hscsdParams); + paramData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId, data); + + TMockLtsyData1 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 + 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::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 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 data1(aCallId, aIsIsvCall); + data.Close(); + data1.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchCallControlAnswer::KLtsyDispatchCallControlAnswerApiId, data); + + TMockLtsyData1 data2(aCallId); + data.Close(); + data2.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchCallControlAnswer::KLtsyDispatchCallControlAnswerApiId, aAnswerError, data); + + if (aAnswerError == KErrNone) + { + RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusAnswering; + TMockLtsyCallData1 mockCallData3(aCallId, aMode, callStatus); + data.Close(); + mockCallData3.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data); + + callStatus = RMobileCall::EStatusConnected; + TMockLtsyCallData1 mockCallData4(aCallId, aMode, callStatus); + data.Close(); + mockCallData4.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data); + } + else + { + RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusIdle; + TMockLtsyCallData1 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 mockData2(aCallId); + data.Close(); + mockData2.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchCallControlResume::KLtsyDispatchCallControlResumeApiId, data); + + TMockLtsyData1 resumeData(aCallId); + data.Close(); + resumeData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchCallControlResume::KLtsyDispatchCallControlResumeApiId, aResumeError, data); + + if (aResumeError == KErrNone) + { + RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusConnected; + TMockLtsyCallData1 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 mockData2(aCallId1, aCallId2); + data.Close(); + mockData2.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchCallControlSwap::KLtsyDispatchCallControlSwapApiId, data); + + iMockLTSY.CompleteL(MLtsyDispatchCallControlSwap::KLtsyDispatchCallControlSwapApiId, aSwapError); + + if (aSwapError == KErrNone) + { + TMockLtsyCallData1 mockCallData2( + aCallId1, RMobilePhone::EServiceUnspecified, aNewCall1Status); + data.Close(); + mockCallData2.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data); + + TMockLtsyCallData1 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 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 +