--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/common_tsy/test/component/src/cctsycallinformationfu.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,13176 @@
+// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// The TEFUnit test suite for CallInformation in the Common TSY.
+//
+//
+
+/**
+ @file
+*/
+
+#include "cctsycallinformationfu.h"
+#include <etel.h>
+#include <etelmm.h>
+#include <et_clsvr.h>
+#include <ctsy/mmtsy_names.h>
+#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
+#include "tmockltsydata.h"
+#include <ctsy/serviceapi/gsmerror.h>
+#include <sys/unistd.h>
+
+
+CTestSuite* CCTsyCallInformationFU::CreateSuiteL(const TDesC& aName)
+ {
+ SUB_SUITE;
+
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams0006bL);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams0006cL);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallDuration0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallDuration0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallDuration00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetOwnershipStatus0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetOwnershipStatus0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetOwnershipStatus00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCaps0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCaps0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCaps00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetInfo0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetInfo0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetInfo00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetStatus0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetStatus0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetStatus00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallInfo0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallInfo0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallInfo0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallInfo0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallInfo00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallInfo00013L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestEnumerateCall0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestEnumerateCall0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestEnumerateCall00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange00012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange00014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyHookChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyHookChange0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyHookChange00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange00012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange00014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange00012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange00014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded00012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded00014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall00012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall00014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent00012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent00014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallCaps0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallCaps0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallCaps0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallCaps0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallCaps00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallCaps00013L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo0006bL);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo00013L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallStatus0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallStatus0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallStatus00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyAudioToneEvent0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyAudioToneEvent0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyAudioToneEvent00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange00012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange00013L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange00014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0003L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange00012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange00013L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange00014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange0002L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange00012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange00014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetIncomingCallType0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetIncomingCallType0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetIncomingCallType00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCallTypeChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyLineHookChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyLineHookChange0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyLineHookChange00011L);
+
+ END_SUITE;
+ }
+
+
+//
+// Actual test cases
+//
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGCP-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCallParams for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallParams0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+ TBool activeCallFlag = EFalse;
+ //----------------------------------------
+
+ RMobileCall::TMobileCallParamsV1 callParams1;
+ RMobileCall::TMobileCallParamsV1Pckg paramPckg1(callParams1);
+
+ TInt ret = call.GetCallParams(paramPckg1);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateCallParams(¶mPckg1, activeCallFlag);
+
+ //----------------------------------------
+ RMobileCall::TMobileCallParamsV2 callParams2;
+ RMobileCall::TMobileCallParamsV2Pckg paramPckg2(callParams2);
+
+ ret = call.GetCallParams(paramPckg2);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateCallParams(¶mPckg2, activeCallFlag);
+
+
+ //----------------------------------------
+ RMobileCall::TMobileCallParamsV7 callParams7;
+ RMobileCall::TMobileCallParamsV7Pckg paramPckg7(callParams7);
+
+ ret = call.GetCallParams(paramPckg7);
+
+ ValidateCallParams(¶mPckg7, activeCallFlag);
+
+ AssertMockLtsyStatusL();
+
+ //-- now create incoming call and get params when dialing, just to show that they are changed
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RCall call2;
+ TInt callId = 1;
+ TName incomingCallName;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call2, incomingCallName,
+ lineName, callId, RMobileCall::EStatusIdle, mobileService);
+
+ TRequestStatus requestStatus;
+
+ //-- dial -----------------------------------------------------------------------
+
+ _LIT(KNum, "23467");
+ RCall::TTelNumberC num(KNum);
+
+ // TMobileCallParamsV1 params for Dial
+ RMobileCall::TMobileCallParamsV1 params;
+ RMobileCall::TMobileCallParamsV1Pckg paramsPckg(params);
+ params.iInterval = 2;
+ params.iCug.iCugIndex = 0;
+ params.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
+ params.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
+ params.iWaitForDialTone = RCall::EDialToneWait;
+
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callInfo.iDialledParty.iTelNumber.Copy(KNum);
+ callInfo.iRemoteParty.iDirection = RMobileCall::EMobileTerminated;
+ callInfo.iService = mobileService;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+
+ // Dialing and Verfication of params for TMobileCallParamsV1
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV8>
+ dialData(-1, mobileService, params, callInfo);
+ completeData.Close();
+ dialData.SerialiseL(completeData);
+ iMockLTSY.ExpectL(EEtelCallDial,completeData);
+
+ call2.Dial(requestStatus, paramsPckg, callInfo.iDialledParty.iTelNumber);
+ TMockLtsyCallData0 dialCompleteData(0,mobileService);
+ completeData.Close();
+ dialCompleteData.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData,0);
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+
+ RMobileCall::TMobileCallParamsV1 recParams;
+ RMobileCall::TMobileCallParamsV1Pckg recParamsPckg(recParams);
+ ret = call2.GetCallParams(recParamsPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+ activeCallFlag = ETrue;
+
+ ValidateCallParams(&recParamsPckg, activeCallFlag);
+
+ // TMobileCallParamsV2 params for Dial
+ RMobileCall::TMobileCallParamsV2 params2;
+ RMobileCall::TMobileCallParamsV2Pckg paramsPckg2(params2);
+ params2.iInterval = 2;
+ params2.iCug.iCugIndex = 0;
+ params2.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
+ params2.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
+ params2.iWaitForDialTone = RCall::EDialToneWait;
+ params2.iBearerMode = RMobileCall::EMulticallNotSupported;
+
+ // Dialing and Verfication of params for TMobileCallParamsV2
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV2, RMobileCall::TMobileCallInfoV8>
+ dialData2(-1, mobileService, params2, callInfo);
+ completeData.Close();
+ dialData2.SerialiseL(completeData);
+ iMockLTSY.ExpectL(EEtelCallDial,completeData);
+
+ call2.Dial(requestStatus, paramsPckg2, callInfo.iDialledParty.iTelNumber);
+ completeData.Close();
+ dialCompleteData.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData,0);
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+
+ RMobileCall::TMobileCallParamsV2 recParams2;
+ RMobileCall::TMobileCallParamsV2Pckg recParamsPckg2(recParams2);
+
+ ret = call2.GetCallParams(recParamsPckg2);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateCallParams(&recParamsPckg2, activeCallFlag);
+
+ // TMobileCallParamsV7 params for Dial
+ RMobileCall::TMobileCallParamsV7 params7;
+ RMobileCall::TMobileCallParamsV7Pckg paramsPckg7(params7);
+ params7.iInterval = 2;
+ params7.iCug.iCugIndex = 0;
+ params7.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
+ params7.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
+ params7.iWaitForDialTone = RCall::EDialToneWait;
+ params7.iBearerMode = RMobileCall::EMulticallNotSupported;
+ params7.iAlphaId.Copy(_L("Alpha Id"));
+
+ // Dialing and Verfication of params for TMobileCallParamsV7
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV7, RMobileCall::TMobileCallInfoV8>
+ dialData7(-1, mobileService, params7, callInfo);
+ completeData.Close();
+ dialData7.SerialiseL(completeData);
+ iMockLTSY.ExpectL(EEtelCallDial,completeData);
+
+ call2.Dial(requestStatus, paramsPckg7, callInfo.iDialledParty.iTelNumber);
+ completeData.Close();
+ dialCompleteData.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData,0);
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+ RMobileCall::TMobileCallParamsV7 recParams7;
+ RMobileCall::TMobileCallParamsV7Pckg recParamsPckg7(recParams7);
+ ret = call2.GetCallParams(recParamsPckg7);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateCallParams(&recParamsPckg7, activeCallFlag);
+
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGCP-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams with bad parameter data for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCallParams with bad parameter data for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallParams0003L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+ TInt8 callParams; // bad param
+ TPckg<TInt8> paramPckg(callParams);
+
+ TInt ret = call.GetCallParams(paramPckg);
+ ASSERT_EQUALS(KErrArgument, ret);
+
+ RCall::TCallParams callParams2;
+ RCall::TCallParamsPckg paramPckg2(callParams2);
+
+ ret = call.GetCallParams(paramPckg2);
+ ASSERT_EQUALS(KErrArgument, ret);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGCP-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCallParams for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallParams0006L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+
+ //- using different types of params struct---------------------------------------
+
+ RMobileCall::TMobileCallParamsV1 callParams1;
+ RMobileCall::TMobileCallParamsV1Pckg paramPckg1(callParams1);
+ TBool activeCallFlag = EFalse;
+ TInt ret = call.GetCallParams(paramPckg1);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateCallParams(¶mPckg1, activeCallFlag);
+
+ //----------------------------------------
+ RMobileCall::TMobileCallParamsV2 callParams2;
+ RMobileCall::TMobileCallParamsV2Pckg paramPckg2(callParams2);
+ ret = call.GetCallParams(paramPckg2);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateCallParams(¶mPckg2, activeCallFlag);
+
+ //---------------------------------------------
+ RMobileCall::TMobileCallParamsV7 callParams7;
+ RMobileCall::TMobileCallParamsV7Pckg paramPckg7(callParams7);
+
+ ret = call.GetCallParams(paramPckg7);
+ ASSERT_EQUALS(KErrNone, ret);
+ ValidateCallParams(¶mPckg7, activeCallFlag);
+ //-- data param --------------------------------------
+ RMobileCall::TMobileDataCallParamsV1 dataCallParams1;
+ RMobileCall::TMobileDataCallParamsV1Pckg dataCallParamPckg1(dataCallParams1);
+
+ ret = call.GetCallParams(dataCallParamPckg1);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateDataCallParams(&dataCallParamPckg1, activeCallFlag);
+
+ //--------------------------------------------------
+ RMobileCall::TMobileDataCallParamsV2 dataCallParams2;
+ RMobileCall::TMobileDataCallParamsV2Pckg dataCallParamPckg2(dataCallParams2);
+
+ ret = call.GetCallParams(dataCallParamPckg2);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateDataCallParams(&dataCallParamPckg2, activeCallFlag);
+
+ //------------------------------------------------------
+ RMobileCall::TMobileDataCallParamsV8 dataCallParams8;
+ RMobileCall::TMobileDataCallParamsV8Pckg dataCallParamPckg8(dataCallParams8);
+
+ ret = call.GetCallParams(dataCallParamPckg8);
+ ASSERT_EQUALS(KErrNone, ret);
+ ValidateDataCallParams(&dataCallParamPckg8, activeCallFlag);
+
+ //-- Dial -----------------------------------------------------------------------
+
+ TRequestStatus requestStatus;
+ _LIT(KNum, "23467");
+ RCall::TTelNumberC num(KNum);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+
+ RMobileCall::TMobileDataCallParamsV1 recDataCallParams1;
+ RMobileCall::TMobileDataCallParamsV1Pckg recDataCallParamPckg1(recDataCallParams1);
+
+ // TMobileDataCallParamsV1 params for Dial
+ dataCallParams1.iInterval = 2;
+ dataCallParams1.iCug.iCugIndex = 0xFFFF;
+ dataCallParams1.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
+ dataCallParams1.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
+ dataCallParams1.iWaitForDialTone = RCall::EDialToneWait;
+ dataCallParams1.iQoS = RMobileCall::EQosTransparentPreferred;
+ dataCallParams1.iV42bisReq = RMobileCall::EV42bisTxDirection;
+
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callInfo.iDialledParty.iTelNumber.Copy(KNum);
+ callInfo.iService = mobileService;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+
+ TMockLtsyCallData2<RMobileCall::TMobileDataCallParamsV1, RMobileCall::TMobileCallInfoV8>
+ dialDataCall(0, mobileService, dataCallParams1, callInfo);
+ completeData.Close();
+ dialDataCall.SerialiseL(completeData);
+ iMockLTSY.ExpectL(EEtelCallDial,completeData);
+
+ CallGetMobileCallInfoL(callId, mobileService, callInfo.iDialledParty.iTelNumber);
+
+ TMockLtsyCallData0 dialCompleteData(callId,mobileService);
+ completeData.Close();
+ dialCompleteData.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData);
+
+ call.Dial(requestStatus, dataCallParamPckg1, callInfo.iDialledParty.iTelNumber);
+
+ CompleteDialStatusNotificationsL(call, callId, mobileService );
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+
+ ret = call.GetCallParams(recDataCallParamPckg1);
+ ASSERT_EQUALS(KErrNone, ret);
+ activeCallFlag = ETrue;
+ ValidateDataCallParams(&recDataCallParamPckg1, activeCallFlag);
+
+ CompleteCallDisconnectNotificationsL(callId, mobileService);
+
+ call.Close();
+ //------------------------------------------------------------------------
+
+ RMobileCall::TMobileDataCallParamsV2 recDataCallParams2;
+ RMobileCall::TMobileDataCallParamsV2Pckg recDataCallParamPckg2(recDataCallParams2);
+
+ // TMobileDataCallParamsV2 params for Dial
+ dataCallParams2.iInterval = 2;
+ dataCallParams2.iCug.iCugIndex = 0xFFFF;
+ dataCallParams2.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
+ dataCallParams2.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
+ dataCallParams2.iWaitForDialTone = RCall::EDialToneWait;
+ dataCallParams2.iQoS = RMobileCall::EQosTransparentPreferred;
+ dataCallParams2.iV42bisReq = RMobileCall::EV42bisTxDirection;
+ dataCallParams2.iBearerMode = RMobileCall::EMulticallShareBearer;
+
+ // open new call
+ CleanupClosePushL(call);
+ TInt errorCode = call.OpenNewCall(line, name);
+ ASSERT_EQUALS(KErrNone, errorCode);
+
+ TMockLtsyCallData2<RMobileCall::TMobileDataCallParamsV2, RMobileCall::TMobileCallInfoV8>
+ dialDataCall2(0, mobileService, dataCallParams2, callInfo);
+ completeData.Close();
+ dialDataCall2.SerialiseL(completeData);
+ iMockLTSY.ExpectL(EEtelCallDial,completeData);
+
+ CallGetMobileCallInfoL(callId, mobileService, callInfo.iDialledParty.iTelNumber);
+
+ completeData.Close();
+ dialCompleteData.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData);
+
+ call.Dial(requestStatus, dataCallParamPckg2, callInfo.iDialledParty.iTelNumber);
+
+ CompleteDialStatusNotificationsL(call, callId, mobileService );
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+
+ ret = call.GetCallParams(recDataCallParamPckg2);
+ ASSERT_EQUALS(KErrNone, ret);
+ ValidateDataCallParams(&recDataCallParamPckg2, activeCallFlag);
+
+ CompleteCallDisconnectNotificationsL(callId, mobileService);
+ call.Close();
+
+ //--------------------------------------------------------------------
+
+ RMobileCall::TMobileDataCallParamsV8 recDataCallParams8;
+ RMobileCall::TMobileDataCallParamsV8Pckg recDataCallParamPckg8(recDataCallParams8);
+
+ RMobileCall::TMobileCallInfoV8 callInformation;
+ callInformation.iDialledParty.iTelNumber.Copy(KNum);
+ callInformation.iService = mobileService;
+ callInformation.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInformation.iAlphaId.Copy(_L("Alpha Id"));
+ callInformation.iValid |= RMobileCall::KCallAlphaId;
+ callInformation.iCallParamOrigin = RMobileCall::EOriginatorSIM;
+ callInformation.iValid |= RMobileCall::KCallParamOrigin;
+
+
+ // TMobileDataCallParamsV8 params for Dial
+ dataCallParams8.iInterval = 2;
+ dataCallParams8.iCug.iCugIndex = 0xFFFF;
+ dataCallParams8.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
+ dataCallParams8.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
+ dataCallParams8.iWaitForDialTone = RCall::EDialToneWait;
+ dataCallParams8.iQoS = RMobileCall::EQosTransparentPreferred;
+ dataCallParams8.iV42bisReq = RMobileCall::EV42bisTxDirection;
+ dataCallParams8.iBearerMode = RMobileCall::EMulticallShareBearer;
+ dataCallParams8.iSubAddress.Copy(_L("An Unknown SubAddress"));
+ dataCallParams8.iCallParamOrigin = RMobileCall::EOriginatorSIM;
+ dataCallParams8.iAlphaId.Copy(_L("Alpha Id"));
+
+ // open new call
+ CleanupClosePushL(call);
+ errorCode = call.OpenNewCall(line, name);
+ ASSERT_EQUALS(KErrNone, errorCode);
+
+ TMockLtsyCallData2<RMobileCall::TMobileDataCallParamsV8, RMobileCall::TMobileCallInfoV8>
+ dialDataCall8(0, mobileService, dataCallParams8, callInformation);
+ completeData.Close();
+ dialDataCall8.SerialiseL(completeData);
+ iMockLTSY.ExpectL(EEtelCallDial,completeData);
+
+ CallGetMobileCallInfoL(callId, mobileService, callInformation.iDialledParty.iTelNumber);
+
+ completeData.Close();
+ dialCompleteData.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ call.Dial(requestStatus, dataCallParamPckg8, callInformation.iDialledParty.iTelNumber);
+
+ CompleteDialStatusNotificationsL(call, callId, mobileService );
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+
+ ret = call.GetCallParams(recDataCallParamPckg8);
+ ASSERT_EQUALS(KErrNone, ret);
+ ValidateDataCallParams(&recDataCallParamPckg8, activeCallFlag);
+
+ CompleteCallDisconnectNotificationsL(callId, mobileService);
+
+ call.Close();
+
+ CleanupStack::PopAndDestroy(6, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGCP-0006b
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams for data calls with HscsdCallParams. It is in connection to BA-CTSY-CALLI-CGCP-0006
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCallParams for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallParams0006bL()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+
+ //- using different types of params struct---------------------------------------
+ TBool activeCallFlag = EFalse;
+
+
+ //-- Hscsd param --------------------------------------
+ RMobileCall::TMobileHscsdCallParamsV1 hscsdCallParams1;
+ RMobileCall::TMobileHscsdCallParamsV1Pckg hscsdCallParamPckg1(hscsdCallParams1);
+ TInt ret = call.GetCallParams(hscsdCallParamPckg1);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateHscsdCallParams(&hscsdCallParamPckg1, activeCallFlag);
+ //----------------------------------------
+
+ RMobileCall::TMobileHscsdCallParamsV2 hscsdCallParams2;
+ RMobileCall::TMobileHscsdCallParamsV2Pckg hscsdCallParamPckg2(hscsdCallParams2);
+
+ ret = call.GetCallParams(hscsdCallParamPckg2);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateHscsdCallParams(&hscsdCallParamPckg2, activeCallFlag);
+
+ //----------------------------------------
+
+ RMobileCall::TMobileHscsdCallParamsV7 hscsdCallParams7;
+ RMobileCall::TMobileHscsdCallParamsV7Pckg hscsdCallParamPckg7(hscsdCallParams7);
+
+ ret = call.GetCallParams(hscsdCallParamPckg7);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateHscsdCallParams(&hscsdCallParamPckg7, activeCallFlag);
+
+ call.Close();
+ //-- Dial -----------------------------------------------------------------------
+
+ TRequestStatus requestStatus;
+ _LIT(KNum, "23467");
+ RCall::TTelNumberC num(KNum);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ RMobileCall::TMobileHscsdCallParamsV1 recHscsdCallParams1;
+ RMobileCall::TMobileHscsdCallParamsV1Pckg recHscsdCallParamPckg1(recHscsdCallParams1);
+
+ // TMobileHscsdCallParamsV1 params for Dial
+ hscsdCallParams1.iInterval = 2;
+ hscsdCallParams1.iCug.iCugIndex = 0xFFFF;
+ hscsdCallParams1.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
+ hscsdCallParams1.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
+ hscsdCallParams1.iWaitForDialTone = RCall::EDialToneWait;
+ hscsdCallParams1.iQoS = RMobileCall::EQosTransparentPreferred;
+ hscsdCallParams1.iV42bisReq = RMobileCall::EV42bisTxDirection;
+ hscsdCallParams1.iWantedRxTimeSlots = 2;
+ hscsdCallParams1.iCodings = 3;
+
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callInfo.iDialledParty.iTelNumber.Copy(KNum);
+ callInfo.iService = mobileService;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+
+ // open new call
+ CleanupClosePushL(call);
+ TInt errorCode = call.OpenNewCall(line, name);
+ ASSERT_EQUALS(KErrNone, errorCode);
+
+ TMockLtsyCallData2<RMobileCall::TMobileHscsdCallParamsV1, RMobileCall::TMobileCallInfoV8>
+ dialHscsdCall(0, mobileService, hscsdCallParams1, callInfo);
+ completeData.Close();
+ dialHscsdCall.SerialiseL(completeData);
+ iMockLTSY.ExpectL(EEtelCallDial,completeData);
+
+ CallGetMobileCallInfoL(callId, mobileService, callInfo.iDialledParty.iTelNumber);
+
+ TMockLtsyCallData0 dialCompleteData(callId,mobileService);
+ completeData.Close();
+ dialCompleteData.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData);
+
+ call.Dial(requestStatus, hscsdCallParamPckg1, callInfo.iDialledParty.iTelNumber);
+
+ CompleteDialStatusNotificationsL(call, callId, mobileService );
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+
+ ret = call.GetCallParams(recHscsdCallParamPckg1);
+ ASSERT_EQUALS(KErrNone, ret);
+ activeCallFlag = ETrue;
+ ValidateHscsdCallParams(&recHscsdCallParamPckg1, activeCallFlag);
+
+ CompleteCallDisconnectNotificationsL(callId, mobileService);
+
+ call.Close();
+ //-----------------------------------------------------------
+
+ RMobileCall::TMobileHscsdCallParamsV2 recHscsdCallParams2;
+ RMobileCall::TMobileHscsdCallParamsV2Pckg recHscsdCallParamPckg2(recHscsdCallParams2);
+
+ // TMobileHscsdCallParamsV2 params for Dial
+ hscsdCallParams2.iInterval = 2;
+ hscsdCallParams2.iCug.iCugIndex = 0xFFFF;
+ hscsdCallParams2.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
+ hscsdCallParams2.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
+ hscsdCallParams2.iWaitForDialTone = RCall::EDialToneWait;
+ hscsdCallParams2.iQoS = RMobileCall::EQosTransparentPreferred;
+ hscsdCallParams2.iV42bisReq = RMobileCall::EV42bisTxDirection;
+ hscsdCallParams2.iWantedRxTimeSlots = 2;
+ hscsdCallParams2.iCodings = 3;
+ hscsdCallParams2.iBearerMode = RMobileCall::EMulticallShareBearer;
+
+ // open new call
+ CleanupClosePushL(call);
+ errorCode = call.OpenNewCall(line, name);
+ ASSERT_EQUALS(KErrNone, errorCode);
+
+ TMockLtsyCallData2<RMobileCall::TMobileHscsdCallParamsV2, RMobileCall::TMobileCallInfoV8>
+ dialHscsdCall2(0, mobileService, hscsdCallParams2, callInfo);
+ completeData.Close();
+ dialHscsdCall2.SerialiseL(completeData);
+ iMockLTSY.ExpectL(EEtelCallDial,completeData);
+
+ CallGetMobileCallInfoL(callId, mobileService, callInfo.iDialledParty.iTelNumber);
+
+ completeData.Close();
+ dialCompleteData.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData);
+
+ call.Dial(requestStatus, hscsdCallParamPckg2, callInfo.iDialledParty.iTelNumber);
+
+ CompleteDialStatusNotificationsL(call, callId, mobileService );
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+
+ ret = call.GetCallParams(recHscsdCallParamPckg2);
+ ASSERT_EQUALS(KErrNone, ret);
+ ValidateHscsdCallParams(&recHscsdCallParamPckg2, activeCallFlag);
+
+ CompleteCallDisconnectNotificationsL(callId, mobileService);
+
+ call.Close();
+ //---------------------------------------------------------------
+
+ RMobileCall::TMobileHscsdCallParamsV7 recHscsdCallParams7;
+ RMobileCall::TMobileHscsdCallParamsV7Pckg recHscsdCallParamPckg7(recHscsdCallParams7);
+
+ // TMobileHscsdCallParamsV7 params for Dial
+ hscsdCallParams7.iInterval = 2;
+ hscsdCallParams7.iCug.iCugIndex = 0xFFFF;
+ hscsdCallParams7.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
+ hscsdCallParams7.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
+ hscsdCallParams7.iWaitForDialTone = RCall::EDialToneWait;
+ hscsdCallParams7.iQoS = RMobileCall::EQosTransparentPreferred;
+ hscsdCallParams7.iV42bisReq = RMobileCall::EV42bisTxDirection;
+ hscsdCallParams7.iWantedRxTimeSlots = 2;
+ hscsdCallParams7.iCodings = 3;
+ hscsdCallParams7.iBearerMode = RMobileCall::EMulticallShareBearer;
+ hscsdCallParams7.iAlphaId.Copy(_L("Alpha Id"));
+ hscsdCallParams7.iCallParamOrigin = RMobileCall::EOriginatorSIM;
+
+ RMobileCall::TMobileCallInfoV8 callInformation;
+ callInformation.iDialledParty.iTelNumber.Copy(KNum);
+ callInformation.iService = mobileService;
+ callInformation.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInformation.iAlphaId.Copy(_L("Alpha Id"));
+ callInformation.iValid |= RMobileCall::KCallAlphaId;
+ callInformation.iCallParamOrigin = RMobileCall::EOriginatorSIM;
+ callInformation.iValid |= RMobileCall::KCallParamOrigin;
+
+ // open new call
+ CleanupClosePushL(call);
+ errorCode = call.OpenNewCall(line, name);
+ ASSERT_EQUALS(KErrNone, errorCode);
+
+ TMockLtsyCallData2<RMobileCall::TMobileHscsdCallParamsV7, RMobileCall::TMobileCallInfoV8>
+ dialHscsdCall7(0, mobileService, hscsdCallParams7, callInformation);
+ completeData.Close();
+ dialHscsdCall7.SerialiseL(completeData);
+ iMockLTSY.ExpectL(EEtelCallDial,completeData);
+
+ CallGetMobileCallInfoL(callId, mobileService, callInfo.iDialledParty.iTelNumber);
+
+ completeData.Close();
+ dialCompleteData.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData);
+
+ call.Dial(requestStatus, hscsdCallParamPckg7, callInfo.iDialledParty.iTelNumber);
+
+ CompleteDialStatusNotificationsL(call, callId, mobileService );
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+
+ ret = call.GetCallParams(recHscsdCallParamPckg7);
+ ASSERT_EQUALS(KErrNone, ret);
+ ValidateHscsdCallParams(&recHscsdCallParamPckg7, activeCallFlag);
+
+ CompleteCallDisconnectNotificationsL(callId, mobileService);
+ call.Close();
+
+ CleanupStack::PopAndDestroy(7, this);
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGCP-0006c
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams for data calls with HscsdCallParamsV8. It is in connection to BA-CTSY-CALLI-CGCP-0006b
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCallParams for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallParams0006cL()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+
+ //- using different types of params struct---------------------------------------
+ TBool activeCallFlag = EFalse;
+
+ RMobileCall::TMobileHscsdCallParamsV8 hscsdCallParams8;
+ RMobileCall::TMobileHscsdCallParamsV8Pckg hscsdCallParamPckg8(hscsdCallParams8);
+
+ TInt ret = call.GetCallParams(hscsdCallParamPckg8);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateHscsdCallParams(&hscsdCallParamPckg8, activeCallFlag);
+
+ call.Close();
+ //-- Dial -----------------------------------------------------------------------
+
+ TRequestStatus requestStatus;
+ _LIT(KNum, "23467");
+ RCall::TTelNumberC num(KNum);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ // TMobileHscsdCallParamsV8 params for Dial
+ hscsdCallParams8.iInterval = 2;
+ hscsdCallParams8.iCug.iCugIndex = 0xFFFF;
+ hscsdCallParams8.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
+ hscsdCallParams8.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
+ hscsdCallParams8.iWaitForDialTone = RCall::EDialToneWait;
+ hscsdCallParams8.iQoS = RMobileCall::EQosTransparentPreferred;
+ hscsdCallParams8.iV42bisReq = RMobileCall::EV42bisTxDirection;
+ hscsdCallParams8.iWantedRxTimeSlots = 2;
+ hscsdCallParams8.iCodings = 3;
+ hscsdCallParams8.iBearerMode = RMobileCall::EMulticallShareBearer;
+ hscsdCallParams8.iAlphaId.Copy(_L("Alpha Id"));
+ hscsdCallParams8.iSubAddress.Copy(_L("An Unknown SubAddress"));
+ hscsdCallParams8.iCallParamOrigin = RMobileCall::EOriginatorSIM;
+
+ RMobileCall::TMobileCallInfoV8 callInformation;
+ callInformation.iDialledParty.iTelNumber.Copy(KNum);
+ callInformation.iService = mobileService;
+ callInformation.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInformation.iAlphaId.Copy(_L("Alpha Id"));
+ callInformation.iValid |= RMobileCall::KCallAlphaId;
+ callInformation.iCallParamOrigin = RMobileCall::EOriginatorSIM;
+ callInformation.iValid |= RMobileCall::KCallParamOrigin;
+
+ RMobileCall::TMobileHscsdCallParamsV8 recHscsdCallParams8;
+ RMobileCall::TMobileHscsdCallParamsV8Pckg recHscsdCallParamPckg8(recHscsdCallParams8);
+
+ // open new call
+ CleanupClosePushL(call);
+ TInt errorCode = call.OpenNewCall(line, name);
+ ASSERT_EQUALS(KErrNone, errorCode);
+
+ TMockLtsyCallData2<RMobileCall::TMobileHscsdCallParamsV8, RMobileCall::TMobileCallInfoV8>
+ dialHscsdCall8(0, mobileService, hscsdCallParams8, callInformation);
+ completeData.Close();
+ dialHscsdCall8.SerialiseL(completeData);
+ iMockLTSY.ExpectL(EEtelCallDial,completeData);
+
+ CallGetMobileCallInfoL(callId, mobileService, callInformation.iDialledParty.iTelNumber);
+
+ TMockLtsyCallData0 dialCompleteData(callId,mobileService);
+ completeData.Close();
+ dialCompleteData.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData);
+
+ call.Dial(requestStatus, hscsdCallParamPckg8, callInformation.iDialledParty.iTelNumber);
+
+ CompleteDialStatusNotificationsL(call, callId, mobileService );
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+
+ ret = call.GetCallParams(recHscsdCallParamPckg8);
+ ASSERT_EQUALS(KErrNone, ret);
+ activeCallFlag = ETrue;
+ ValidateHscsdCallParams(&recHscsdCallParamPckg8, activeCallFlag);
+
+ CompleteCallDisconnectNotificationsL(callId, mobileService);
+ call.Close();
+
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGCP-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams with bad parameters data for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCallParams with bad parameters for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallParams0008L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+ //-------------------------------------------------------------------------
+ // Test B: Test passing wrong descriptor size to parameter in
+ // RCall::GetCallParams
+ //-------------------------------------------------------------------------
+
+ TBuf8<1> buf(KNullDesC8);
+ TInt ret = call.GetCallParams(buf);
+ // Passing a small buffer to function doesn't cause an error.
+ ASSERT_EQUALS(KErrArgument, ret)
+
+ RCall::TCallParams callParams;
+ RCall::TCallParamsPckg paramPckg(callParams);
+
+ ret = call.GetCallParams(paramPckg);
+ ASSERT_EQUALS(KErrArgument, ret)
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGCP-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCallParams for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallParams00011L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+
+ TBool activeCallFlag = EFalse;
+ //----------------------------------------
+
+ RMobileCall::TMobileCallParamsV1 callParams1;
+ RMobileCall::TMobileCallParamsV1Pckg paramPckg1(callParams1);
+
+ TInt ret = call.GetCallParams(paramPckg1);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateCallParams(¶mPckg1, activeCallFlag);
+
+ //----------------------------------------
+ RMobileCall::TMobileCallParamsV2 callParams2;
+ RMobileCall::TMobileCallParamsV2Pckg paramPckg2(callParams2);
+
+ ret = call.GetCallParams(paramPckg2);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateCallParams(¶mPckg2, activeCallFlag);
+
+ //---------------------------------------------
+ RMobileCall::TMobileCallParamsV7 callParams7;
+ RMobileCall::TMobileCallParamsV7Pckg paramPckg7(callParams7);
+
+ ret = call.GetCallParams(paramPckg7);
+
+ ValidateCallParams(¶mPckg7, activeCallFlag);
+
+ //-- now GetCallParams for an incoming dialing call -----
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RCall call2;
+ TInt callId = 1;
+ TName incomingCallName;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call2, incomingCallName,
+ lineName, callId, RMobileCall::EStatusIdle, mobileService);
+
+ //--- Dial ---------------------------------------------
+ TRequestStatus requestStatus;
+
+ _LIT(KNum, "23467");
+ RCall::TTelNumberC num(KNum);
+
+
+ // TMobileCallParamsV1 params for Dial
+ RMobileCall::TMobileCallParamsV1 params;
+ RMobileCall::TMobileCallParamsV1Pckg paramsPckg(params);
+ params.iInterval = 2;
+ params.iCug.iCugIndex = 0xFFFF;
+ params.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
+ params.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
+ params.iWaitForDialTone = RCall::EDialToneWait;
+
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callInfo.iDialledParty.iTelNumber.Copy(KNum);
+ callInfo.iRemoteParty.iDirection = RMobileCall::EMobileTerminated;
+ callInfo.iService = mobileService;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+
+ call2.Dial(requestStatus, paramsPckg, callInfo.iDialledParty.iTelNumber);
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ CleanupStack::PopAndDestroy(5, this);
+ }
+
+
+
+void CCTsyCallInformationFU::AuxGetCallDuration0001L(const TDesC& aLineName, RMobilePhone::TMobileService aMobileService)
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+
+ OpenLineLC(line, iPhone, aLineName);
+
+ TName name;
+ RCall call1;
+
+ OpenNewCallLC(call1, line, &name);
+
+ //--- check not active call -------------------------------------
+ const TTimeIntervalSeconds KZeroTime(0);
+
+ TTimeIntervalSeconds time;
+ TInt ret = call1.GetCallDuration(time);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_EQUALS(KZeroTime, time);
+
+ //--- try to make duration not zero ---------------------------------------
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+
+ RMobilePhone::TMobileService mobileService = aMobileService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ aLineName, callId, RMobileCall::EStatusAnswering, mobileService);
+
+ //-------------------------------------------------------------------------
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ //-------------------------------------------------------------------------
+
+ // this is to allow duration > 0
+ sleep(2);
+
+ ret = call.GetCallDuration(time);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE(KZeroTime != time);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGCD-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCallDuration for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCallDuration for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallDuration0001L()
+ {
+
+ AuxGetCallDuration0001L(KMmTsyVoice1LineName, RMobilePhone::EVoiceService);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGCD-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCallDuration for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCallDuration for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallDuration0006L()
+ {
+
+ AuxGetCallDuration0001L(KMmTsyDataLineName, RMobilePhone::ECircuitDataService);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGCD-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCallDuration for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCallDuration for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallDuration00011L()
+ {
+
+ AuxGetCallDuration0001L(KMmTsyFaxLineName, RMobilePhone::EFaxService);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGOS-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetOwnershipStatus for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetOwnershipStatus for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetOwnershipStatus0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);
+
+
+ RCall::TOwnershipStatus ownershipStatus;
+
+ // Ownership is not supported for voice calls, so we just check for UnOwned
+ TInt ret = call.GetOwnershipStatus(ownershipStatus);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_EQUALS(RCall::EOwnershipUnowned, ownershipStatus);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+
+void CCTsyCallInformationFU::AuxGetOwnershipStatus0001L(const TDesC& aLineName, RMobilePhone::TMobileService aMobileService)
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+
+ OpenLineLC(line, iPhone, aLineName);
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ aLineName, callId, RMobileCall::EStatusRinging, aMobileService);
+
+ //----------------------------------------
+
+ RCall::TOwnershipStatus ownershipStatus;
+
+ // UnOwned
+ TInt ret = call.GetOwnershipStatus(ownershipStatus);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_EQUALS(RCall::EOwnershipUnowned, ownershipStatus);
+
+ TRequestStatus requestStatus1;
+
+ RMobileCall::TMobileCallParamsV1 callParams;
+ RMobileCall::TMobileCallParamsV1Pckg callParamsPckg(callParams);
+ call.Connect(requestStatus1,callParamsPckg);
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ // EOwnershipOwnedByThisClient
+ ret = call.GetOwnershipStatus(ownershipStatus);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_EQUALS(RCall::EOwnershipOwnedByThisClient, ownershipStatus);
+
+
+ //- now set ownership to EOwnershipOwnedByAnotherClient -------------------
+
+ RTelServer telServer2;
+ ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2, KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+ RLine line2;
+
+ OpenLineLC(line2, phone2, aLineName);
+
+ RCall call2;
+
+ // open existing call to send take ownership request
+ ret = call2.OpenExistingCall(line2, incomingCallName);
+ ASSERT_EQUALS(KErrNone, ret)
+ CleanupClosePushL(call2);
+
+ TRequestStatus reqStatus;
+ call2.AcquireOwnership(reqStatus);
+
+ // TransferOwnership to call2
+ ret = call.TransferOwnership();
+ ASSERT_EQUALS(KErrNone, ret)
+ AssertMockLtsyStatusL();
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //EOwnershipOwnedByAnotherClient
+ ret = call.GetOwnershipStatus(ownershipStatus);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_EQUALS(RCall::EOwnershipOwnedByAnotherClient, ownershipStatus);
+
+
+ //-now set ownership to EOwnershipThisIsPriorityClient -------------------
+
+ // There must be "etel_KPriorityClientSid <SID>" in epoc.ini (emulator)
+ // or "patchdata etel.dll@KPriorityClientSid <SID>" in etel.iby (ROM)
+ // If this test fails, ensure that the lines:
+ // etel_KPriorityClientSid 0x101F777C
+ // etel_KSatEngineSid 0x101F777C
+ // are present in \epoc32\data\epoc.ini
+
+ ret = iTelServer.SetPriorityClientV2();
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ret = call.GetOwnershipStatus(ownershipStatus);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_EQUALS(RCall::EOwnershipThisIsPriorityClient, ownershipStatus);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(7, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGOS-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetOwnershipStatus for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetOwnershipStatus for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetOwnershipStatus0006L()
+ {
+
+ AuxGetOwnershipStatus0001L(KMmTsyDataLineName, RMobilePhone::ECircuitDataService);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGOS-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetOwnershipStatus for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetOwnershipStatus for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetOwnershipStatus00011L()
+ {
+
+ AuxGetOwnershipStatus0001L(KMmTsyFaxLineName, RMobilePhone::EFaxService);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCaps for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCaps for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCaps0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+ // get caps of a just created call
+ RCall::TCaps caps;
+ TInt ret = call.GetCaps(caps);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsDial) == caps.iFlags);
+
+ CleanupStack::PopAndDestroy(1);
+
+ // now get caps of an incoming call to ensure that they are changed
+
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);
+
+
+ ret = call.GetCaps(caps);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsAnswer) == caps.iFlags);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCaps for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCaps for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCaps0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+ // get caps of a just created call
+
+ RCall::TCaps caps;
+ TInt ret = call.GetCaps(caps);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE((RCall::KCapsData | RCall::KCapsDial | RCall::KCapsConnect) == caps.iFlags);
+
+ CleanupStack::PopAndDestroy(1);
+
+
+ // now get caps of an incoming call to ensure that they are changed
+
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::ECircuitDataService);
+
+ ret = call.GetCaps(caps);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE((RCall::KCapsData | RCall::KCapsAnswer | RCall::KCapsHangUp) == caps.iFlags);
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetCaps for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetCaps for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCaps00011L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+ // get caps of a just created call
+
+ RCall::TCaps caps;
+ TInt ret = call.GetCaps(caps);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE((RCall::KCapsConnect | RCall::KCapsFax) == caps.iFlags);
+
+ CleanupStack::PopAndDestroy(1);
+
+ // now get caps of an incoming call to ensure that they are changed
+
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EFaxService);
+
+ ret = call.GetCaps(caps);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE((RCall::KCapsFax | RCall::KCapsAnswer | RCall::KCapsConnect) == caps.iFlags);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+ }
+
+
+
+void CCTsyCallInformationFU::AuxGetInfo0001L(const TDesC& aLineName, RMobilePhone::TMobileService aMobileService)
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(aLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+ // get call info for a just created call
+ RCall::TCallInfo info;
+ TInt ret = call.GetInfo(info);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE(0 == info.iLineName.Compare(lineName));
+ ASSERT_TRUE(0 == info.iCallName.Compare(name));
+ ASSERT_TRUE(RCall::EHookStatusUnknown == info.iHookStatus);
+ ASSERT_TRUE(RCall::EStatusIdle == info.iStatus);
+ ASSERT_TRUE(0 == info.iDuration.Int());
+ CleanupStack::PopAndDestroy(1);
+
+ AssertMockLtsyStatusL();
+
+ // now get call info for an incoming call
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, aMobileService);
+
+ ret = call.GetInfo(info);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE(0 == info.iLineName.Compare(lineName));
+ ASSERT_TRUE(0 == info.iCallName.Compare(incomingCallName));
+ ASSERT_TRUE(RCall::EHookStatusUnknown == info.iHookStatus);
+ ASSERT_TRUE(RCall::EStatusRinging == info.iStatus);
+ ASSERT_TRUE(0 == info.iDuration.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGI-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetInfo for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetInfo for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetInfo0001L()
+ {
+
+ AuxGetInfo0001L(KMmTsyVoice1LineName, RMobilePhone::EVoiceService);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGI-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetInfo for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetInfo for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetInfo0006L()
+ {
+
+ AuxGetInfo0001L(KMmTsyDataLineName, RMobilePhone::ECircuitDataService);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGI-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetInfo for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetInfo for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetInfo00011L()
+ {
+
+ AuxGetInfo0001L(KMmTsyFaxLineName, RMobilePhone::EFaxService);
+
+ }
+
+
+void CCTsyCallInformationFU::AuxGetStatus0001L(const TDesC& aLineName, RMobilePhone::TMobileService aMobileService)
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(aLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+ // get call status for a just created call
+ RCall::TStatus status;
+ TInt ret = call.GetStatus(status);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_EQUALS(RCall::EStatusIdle, status);
+
+ CleanupStack::PopAndDestroy(1);
+
+ AssertMockLtsyStatusL();
+
+ // now get call info for an incoming call
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, aMobileService);
+
+ ret = call.GetStatus(status);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_EQUALS(RCall::EStatusRinging, status);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGS-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetStatus for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetStatus for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetStatus0001L()
+ {
+
+ AuxGetStatus0001L(KMmTsyVoice1LineName, RMobilePhone::EVoiceService);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGS-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetStatus for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetStatus for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetStatus0006L()
+ {
+
+ AuxGetInfo0001L(KMmTsyDataLineName, RMobilePhone::ECircuitDataService);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGS-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetStatus for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetStatus for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetStatus00011L()
+ {
+
+ AuxGetInfo0001L(KMmTsyFaxLineName, RMobilePhone::EFaxService);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LGCI-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::GetCallInfo for voice lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::GetCallInfo for voice lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallInfo0001L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+ // get call info for a just created call
+ RLine::TCallInfo callInfo;
+ TInt ret = line.GetCallInfo( 0, callInfo);
+
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE(0 == callInfo.iCallName.Compare(name));
+ ASSERT_EQUALS(RCall::EStatusIdle, callInfo.iStatus);
+ ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsDial) == callInfo.iCallCapsFlags);
+
+
+ //-- get call info for an incoming call ---------------------
+ RCall call1;
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call1, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);
+
+ ret = line.GetCallInfo( 1, callInfo);
+
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE(0 == callInfo.iCallName.Compare(incomingCallName));
+ ASSERT_EQUALS(RCall::EStatusRinging, callInfo.iStatus);
+ ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsAnswer) == callInfo.iCallCapsFlags);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+void CCTsyCallInformationFU::AuxGetCallInfo0003L(const TDesC& aLineName)
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+
+ OpenLineLC(line, iPhone, aLineName);
+
+ // try get info when there is no calls
+ RLine::TCallInfo callInfo;
+ TInt ret = line.GetCallInfo( 0, callInfo);
+
+ ASSERT_EQUALS(KErrNotFound, ret);
+
+ //----------------------------------------
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+ // try to get info of a call with negative Id
+ ret = line.GetCallInfo( -1, callInfo);
+
+ ASSERT_EQUALS(KErrNotFound, ret);
+
+ //----------------------------------------
+ // try to get info of a call a too big Id
+ ret = line.GetCallInfo( 3, callInfo);
+
+ ASSERT_EQUALS(KErrNotFound, ret);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LGCI-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::GetCallInfo with bad parameter data for voice lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::GetCallInfo with bad parameter data for voice lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallInfo0003L()
+ {
+
+ AuxGetCallInfo0003L(KMmTsyVoice1LineName);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LGCI-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::GetCallInfo for data lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::GetCallInfo for data lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallInfo0006L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+ // get call info for a just created call
+ RLine::TCallInfo callInfo;
+ TInt ret = line.GetCallInfo( 0, callInfo);
+
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE(0 == callInfo.iCallName.Compare(name));
+ ASSERT_EQUALS(RCall::EStatusIdle, callInfo.iStatus);
+ ASSERT_TRUE((RCall::KCapsData | RCall::KCapsDial | RCall::KCapsConnect) == callInfo.iCallCapsFlags);
+
+
+ //-- get call info for an incoming call ---------------------
+ RCall call1;
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call1, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::ECircuitDataService);
+
+ ret = line.GetCallInfo( 1, callInfo);
+
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE(0 == callInfo.iCallName.Compare(incomingCallName));
+ ASSERT_EQUALS(RCall::EStatusRinging, callInfo.iStatus);
+ ASSERT_TRUE((RCall::KCapsData | RCall::KCapsAnswer | RCall::KCapsHangUp) == callInfo.iCallCapsFlags);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LGCI-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::GetCallInfo with bad parameter data for data lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::GetCallInfo with bad parameter data for data lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallInfo0008L()
+ {
+
+ AuxGetCallInfo0003L(KMmTsyDataLineName);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LGCI-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::GetCallInfo for fax lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::GetCallInfo for fax lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallInfo00011L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+ // get call info for a just created call
+ RLine::TCallInfo callInfo;
+ TInt ret = line.GetCallInfo( 0, callInfo);
+
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE(0 == callInfo.iCallName.Compare(name));
+ ASSERT_EQUALS(RCall::EStatusIdle, callInfo.iStatus);
+ ASSERT_TRUE((RCall::KCapsFax | RCall::KCapsConnect) == callInfo.iCallCapsFlags);
+
+
+ //-- get call info for an incoming call ---------------------
+ RCall call1;
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call1, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EFaxService);
+
+ ret = line.GetCallInfo( 1, callInfo);
+
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE(0 == callInfo.iCallName.Compare(incomingCallName));
+ ASSERT_EQUALS(RCall::EStatusRinging, callInfo.iStatus);
+ ASSERT_TRUE((RCall::KCapsFax | RCall::KCapsAnswer | RCall::KCapsConnect) == callInfo.iCallCapsFlags);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LGCI-00013
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::GetCallInfo with bad parameter data for fax lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::GetCallInfo with bad parameter data for fax lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetCallInfo00013L()
+ {
+
+ AuxGetCallInfo0003L(KMmTsyFaxLineName);
+
+ }
+
+
+void CCTsyCallInformationFU::AuxEnumerateCall0001L(const TDesC& aLineName, RMobilePhone::TMobileService aMobileService)
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+
+ OpenLineLC(line, iPhone, aLineName);
+
+ // enumerate when there is no calls
+ TInt numCalls;
+ TInt ret = line.EnumerateCall(numCalls);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE(0 == numCalls);
+
+
+ TName name;
+ RCall call;
+
+ OpenNewCallLC(call, line, &name);
+
+ // get number of calls when we have one call
+ ret = line.EnumerateCall(numCalls);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE(1 == numCalls);
+
+
+ RCall call1;
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call1, incomingCallName,
+ aLineName, callId, RMobileCall::EStatusRinging, aMobileService);
+
+ // check if the number of calls incremented correctly
+ ret = line.EnumerateCall(numCalls);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE(2 == numCalls);
+
+ call.Close();
+
+ // check if the number of calls decremented correctly
+ ret = line.EnumerateCall(numCalls);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE(1 == numCalls);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LEC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::EnumerateCall for voice lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::EnumerateCall for voice lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestEnumerateCall0001L()
+ {
+
+ AuxEnumerateCall0001L(KMmTsyVoice1LineName, RMobilePhone::EVoiceService);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LEC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::EnumerateCall for data lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::EnumerateCall for data lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestEnumerateCall0006L()
+ {
+
+ AuxEnumerateCall0001L(KMmTsyDataLineName, RMobilePhone::ECircuitDataService);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LEC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::EnumerateCall for fax lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::EnumerateCall for fax lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestEnumerateCall00011L()
+ {
+
+ AuxEnumerateCall0001L(KMmTsyFaxLineName, RMobilePhone::EFaxService);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::NotifyCapsChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::NotifyCapsChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCapsChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus mockLtsyStatus;
+
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, mobileService);
+
+ TRequestStatus notifyStatus;
+ RCall::TCaps caps;
+
+ // test C1, completed from AnswerIncomingCall() ---------------------------------
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ call.NotifyCapsChange( notifyStatus, caps);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsHangUp) == caps.iFlags);
+
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ AssertMockLtsyStatusL();
+
+ // test C2, completed from HangUp() ---------------------------------
+
+ TInt hangUpCause = KErrGsmBusyUserRequest;
+ TBool autoStChangeDisable = ETrue;
+ TMockLtsyCallData2<TInt, TBool> mockData2x(callId, mobileService,
+ hangUpCause,
+ autoStChangeDisable);
+ data.Close();
+ mockData2x.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallHangUp, data);
+
+ call.NotifyCapsChange( notifyStatus, caps);
+
+ call.HangUp(requestStatus1);
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE((RCall::KCapsVoice) == caps.iFlags);
+
+ // test C3, completed from CompleteHangUp() ---------------------------------
+
+ TMockLtsyCallData0 mockData2(callId, mobileService);
+ data.Close();
+ mockData2.SerialiseL(data);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, data);
+
+ call.NotifyCapsChange( notifyStatus, caps);
+
+ User::WaitForRequest(requestStatus1);
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsDial) == caps.iFlags);
+
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ // test C4 ---------------------------------
+
+
+ call.NotifyCapsChange( notifyStatus, caps);
+
+ _LIT(KNum, "23467");
+ RCall::TTelNumberC num(KNum);
+
+ RMobileCall::TMobileCallParamsV7 callParams;
+ RMobileCall::TMobileCallParamsV7Pckg callParamsPckg(callParams);
+ callParams.iInterval = 0;
+ callParams.iCug.iCugIndex = 0xFFFF;
+ callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ callParams.iWaitForDialTone = RCall::EDialToneWait;
+
+ RMobileCall::TMobileCallInfoV8 callInfo;
+
+ callInfo.iDialledParty.iTelNumber.Copy(KNum);
+ callInfo.iRemoteParty.iDirection = RMobileCall::EMobileTerminated;
+ callInfo.iService = mobileService;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV7, RMobileCall::TMobileCallInfoV8>
+ dialData(-1, mobileService, callParams, callInfo);
+ data.Close();
+ dialData.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallDial,data);
+
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = _L("");
+
+ call.Dial(requestStatus,callParamsPckg, callInfo.iDialledParty.iTelNumber);
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsHangUp) == caps.iFlags);
+
+ // complete Dial
+ TMockLtsyCallData0 dialCompleteData(0,mobileService);
+ data.Close();
+ dialCompleteData.SerialiseL(data);
+ iMockLTSY.CompleteL(EEtelCallDial,KErrNone,data,0);
+
+ User::WaitForRequest(requestStatus);
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyCapsChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RCall::NotifyCapsChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCapsChange0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ TInt callId = 1;
+ TName incomingCallName;
+ RCall call;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);
+
+ TRequestStatus notifyStatus;
+ RCall::TCaps caps;
+
+ call.NotifyCapsChange( notifyStatus, caps);
+
+ call.NotifyCapsChangeCancel();
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrCancel, notifyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyCapsChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RCall::NotifyCapsChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCapsChange0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyVoice1LineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+ RCall call;
+ RCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName,
+ lineName2, callId2, RMobileCall::EStatusRinging, mobileService);
+
+ //----------------------------------------
+ RCall::TCaps caps;
+ RCall::TCaps caps2;
+
+ call.NotifyCapsChange( requestStatus, caps);
+
+ //----------------------------------------
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ //----------------------------------------
+ TMockLtsyCallData0 mockData02(callId2, mobileService);
+ data.Close();
+ mockData02.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call2.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ call2.NotifyCapsChange( requestStatus2, caps2);
+
+ TInt hangUpCause = KErrGsmBusyUserRequest;
+ TBool autoStChangeDisable = ETrue;
+ TMockLtsyCallData2<TInt, TBool> mockData2x(callId2, mobileService,
+ hangUpCause,
+ autoStChangeDisable);
+ data.Close();
+ mockData2x.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallHangUp, data);
+
+
+ TMockLtsyCallData0 mockData2(callId2, mobileService);
+ data.Close();
+ mockData2.SerialiseL(data);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, data);
+ call2.HangUp();
+
+
+ User::WaitForRequest(requestStatus);
+ User::WaitForRequest(requestStatus2);
+
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+
+ ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsHangUp) == caps.iFlags);
+ ASSERT_TRUE((RCall::KCapsVoice) == caps2.iFlags);
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::NotifyCapsChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::NotifyCapsChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCapsChange0006L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus mockLtsyStatus;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, mobileService);
+
+
+ //---------------------------------------------------------------------
+ //Test C1, completed from AnswerIncomingCall()
+ //---------------------------------------------------------------------
+ TRequestStatus notifyStatus;
+ RCall::TCaps caps;
+
+ call.NotifyCapsChange( notifyStatus, caps);
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE((RCall::KCapsData | RCall::KCapsHangUp) == caps.iFlags);
+
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ AssertMockLtsyStatusL();
+
+ //Test C2, completed from HangUp()
+
+ TInt hangUpCause = KErrGsmBusyUserRequest;
+ TBool autoStChangeDisable = EFalse;
+ TMockLtsyCallData2<TInt, TBool> mockData2x(callId, mobileService,
+ hangUpCause,
+ autoStChangeDisable);
+ data.Close();
+ mockData2x.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallHangUp, data);
+
+ call.NotifyCapsChange( notifyStatus, caps);
+
+ call.HangUp(requestStatus1);
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE((RCall::KCapsData) == caps.iFlags);
+
+ //Test C3, completed from CompleteHangUp()
+
+ TMockLtsyCallData0 mockData2(callId, mobileService);
+ data.Close();
+ mockData2.SerialiseL(data);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, data);
+
+ call.NotifyCapsChange( notifyStatus, caps);
+
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE((RCall::KCapsData | RCall::KCapsConnect | RCall::KCapsDial) == caps.iFlags);
+
+ //---------------------------------
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ //---------------------------------------------------------------------
+ //Test C4, completed from Dial()
+ //---------------------------------------------------------------------
+ call.NotifyCapsChange( notifyStatus, caps);
+
+ _LIT(KNum, "23467");
+ RCall::TTelNumberC num(KNum);
+
+ RMobileCall::TMobileDataCallParamsV1 dataCallParams;
+ RMobileCall::TMobileDataCallParamsV1Pckg dataCallParamsPckg(dataCallParams);
+ dataCallParams.iInterval = 0;
+ dataCallParams.iCug.iCugIndex = 0xFFFF;
+ dataCallParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ dataCallParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ dataCallParams.iWaitForDialTone = RCall::EDialToneWait;
+
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callInfo.iDialledParty.iTelNumber.Copy(KNum);
+ callInfo.iRemoteParty.iDirection = RMobileCall::EMobileTerminated;
+ callInfo.iService = mobileService;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+
+ TMockLtsyCallData2<RMobileCall::TMobileDataCallParamsV1, RMobileCall::TMobileCallInfoV8>
+ dialData(-1, mobileService, dataCallParams, callInfo);
+ data.Close();
+ dialData.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallDial,data);
+
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = _L("");
+
+ call.Dial(requestStatus, dataCallParamsPckg, callInfo.iDialledParty.iTelNumber);
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE((RCall::KCapsData | RCall::KCapsHangUp) == caps.iFlags);
+
+ TMockLtsyCallData0 dialCompleteData(0,mobileService);
+ data.Close();
+ dialCompleteData.SerialiseL(data);
+ iMockLTSY.CompleteL(EEtelCallDial,KErrNone,data,0);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+
+ //---------------------------------------------------------------------
+ //Test C5, completed from LoanDataPort
+ //---------------------------------------------------------------------
+ caps.iFlags = 0;
+ call.NotifyCapsChange( notifyStatus, caps);
+
+ callId = -1;
+
+ _LIT(KCom, "Com");
+ TFileName csy(KCom);
+ TName portName(KCom);
+ RCall::TCommPort port;
+ port.iCsy = csy;
+ port.iPort = portName;
+ TMockLtsyCallData1<RCall::TCommPort> mockLoanData(callId, mobileService, port);
+ data.Close();
+ mockLoanData.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallLoanDataPort, data);
+ call.LoanDataPort(requestStatus1, port);
+ User::WaitForRequest(requestStatus1);
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE( (RCall::KCapsData | RCall::KCapsHangUp | RCall::KCapsRecoverDataPort) == caps.iFlags);
+
+ AssertMockLtsyStatusL();
+
+ // Recover Data Port
+ iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data);
+ call.RecoverDataPort();
+ //---------------------------------------
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCC-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyCapsChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RCall::NotifyCapsChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCapsChange0007L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::ECircuitDataService);
+
+ TRequestStatus notifyStatus;
+ RCall::TCaps caps;
+
+ call.NotifyCapsChange( notifyStatus, caps);
+
+ call.NotifyCapsChangeCancel();
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrCancel, notifyStatus.Int());
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCC-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyCapsChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RCall::NotifyCapsChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCapsChange0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyDataLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+
+ RCall call;
+ RCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, RMobileCall::EStatusRinging, mobileService);
+
+ //----------------------------------------
+ RCall::TCaps caps;
+ RCall::TCaps caps2;
+
+ call.NotifyCapsChange( requestStatus, caps);
+
+ //----------------------------------------
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ //----------------------------------------
+ TMockLtsyCallData0 mockData02(callId2, mobileService);
+ data.Close();
+ mockData02.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call2.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ call2.NotifyCapsChange( requestStatus2, caps2);
+
+ TInt hangUpCause = KErrGsmBusyUserRequest;
+ TBool autoStChangeDisable = EFalse;
+ TMockLtsyCallData2<TInt, TBool> mockData2x(callId2, mobileService,
+ hangUpCause,
+ autoStChangeDisable);
+ data.Close();
+ mockData2x.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallHangUp, data);
+
+
+ TMockLtsyCallData0 mockData2(callId2, mobileService);
+ data.Close();
+ mockData2.SerialiseL(data);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, data);
+ call2.HangUp();
+
+
+ User::WaitForRequest(requestStatus);
+ User::WaitForRequest(requestStatus2);
+
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+
+ ASSERT_TRUE((RCall::KCapsData | RCall::KCapsHangUp) == caps.iFlags);
+ ASSERT_TRUE((RCall::KCapsData) == caps2.iFlags);
+
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::NotifyCapsChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::NotifyCapsChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCapsChange00011L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, mobileService);
+
+ //---------------------------------------
+
+ TRequestStatus notifyStatus;
+ RCall::TCaps caps;
+
+ call.NotifyCapsChange( requestStatus, caps);
+
+ _LIT(KCom, "Com");
+
+ TFileName csy(KCom);
+ TName portName(KCom);
+ RCall::TCommPort port;
+ port.iCsy = csy;
+ port.iPort = portName;
+
+ TMockLtsyCallData1<RCall::TCommPort> mockData01(callId, mobileService, port);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallLoanDataPort, data);
+
+ call.LoanDataPort(requestStatus1, port);
+
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ ASSERT_TRUE( (RCall::KCapsData |
+ RCall::KCapsFax |
+ RCall::KCapsConnect |
+ RCall::KCapsHangUp |
+ RCall::KCapsAnswer |
+ RCall::KCapsRecoverDataPort) == caps.iFlags);
+ //---------------------------------------
+
+ AssertMockLtsyStatusL();
+
+ TInt hangUpCause = KErrGsmBusyUserRequest;
+ TBool autoStChangeDisable = EFalse;
+ TMockLtsyCallData2<TInt, TBool> mockData2x(callId, mobileService,
+ hangUpCause,
+ autoStChangeDisable);
+ data.Close();
+ mockData2x.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallHangUp, data);
+
+ // test C2, completed from HangUp()
+ call.NotifyCapsChange( requestStatus, caps);
+
+ call.HangUp(requestStatus1);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE((RCall::KCapsData |
+ RCall::KCapsFax |
+ RCall::KCapsConnect |
+ RCall::KCapsAnswer) == caps.iFlags);
+
+
+
+ // test C3, completed from CompleteHangUp()
+
+ TMockLtsyCallData0 mockData2(callId, mobileService);
+ data.Close();
+ mockData2.SerialiseL(data);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, data);
+
+ call.NotifyCapsChange( requestStatus, caps);
+
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE((RCall::KCapsData |
+ RCall::KCapsFax |
+ RCall::KCapsConnect |
+ RCall::KCapsDial) == caps.iFlags);
+
+
+ //-- loaned port has to be recovered --------
+ TMockLtsyCallData1<RCall::TCommPort> mockData01x(callId, mobileService, port);
+ data.Close();
+ mockData01x.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data);
+
+ call.RecoverDataPort();
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCC-00012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyCapsChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RCall::NotifyCapsChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCapsChange00012L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EFaxService);
+
+ TRequestStatus notifyStatus;
+ RCall::TCaps caps;
+
+ call.NotifyCapsChange( notifyStatus, caps);
+
+ call.NotifyCapsChangeCancel();
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrCancel, notifyStatus.Int());
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCC-00014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyCapsChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RCall::NotifyCapsChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCapsChange00014L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyFaxLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+ RCall call;
+ RCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, mobileService);
+
+ //----------------------------------------
+ // create new incoming call
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, RMobileCall::EStatusRinging, mobileService);
+
+ //----------------------------------------
+ RCall::TCaps caps;
+ RCall::TCaps caps2;
+
+ _LIT(KCom, "Com");
+
+ TFileName csy(KCom);
+ TName portName(KCom);
+ RCall::TCommPort port;
+ port.iCsy = csy;
+ port.iPort = portName;
+
+ TMockLtsyCallData1<RCall::TCommPort> mockData01(callId, mobileService, port);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallLoanDataPort, data);
+
+ call.LoanDataPort(requestStatus1, port);
+
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+ AssertMockLtsyStatusL();
+ //---------------------------------------
+
+ call.NotifyCapsChange( requestStatus, caps);
+ call2.NotifyCapsChange( requestStatus2, caps2);
+
+ TMockLtsyCallData1<RCall::TCommPort> mockData02(callId2, mobileService, port);
+ data.Close();
+ mockData02.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallLoanDataPort, data);
+
+ call2.LoanDataPort(requestStatus1, port);
+
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+ AssertMockLtsyStatusL();
+ //---------------------------------------
+
+ TInt hangUpCause = KErrGsmBusyUserRequest;
+ TBool autoStChangeDisable = EFalse;
+ TMockLtsyCallData2<TInt, TBool> mockData2x(callId, mobileService,
+ hangUpCause,
+ autoStChangeDisable);
+ data.Close();
+ mockData2x.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallHangUp, data);
+
+ TMockLtsyCallData0 mockData2(callId, mobileService);
+ data.Close();
+ mockData2.SerialiseL(data);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, data);
+ call.HangUp();
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE((RCall::KCapsData |
+ RCall::KCapsFax |
+ RCall::KCapsConnect |
+ RCall::KCapsAnswer) == caps.iFlags);
+
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE((RCall::KCapsData |
+ RCall::KCapsFax |
+ RCall::KCapsConnect |
+ RCall::KCapsAnswer |
+ RCall::KCapsHangUp |
+ RCall::KCapsRecoverDataPort) == caps2.iFlags);
+ AssertMockLtsyStatusL();
+ //---------------------------------------
+
+ TMockLtsyCallData1<RCall::TCommPort> mockData03(callId, mobileService, port);
+ data.Close();
+ mockData03.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data);
+
+ call.RecoverDataPort();
+ AssertMockLtsyStatusL();
+
+ TMockLtsyCallData1<RCall::TCommPort> mockData04(callId2, mobileService, port);
+ data.Close();
+ mockData04.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data);
+
+ call2.RecoverDataPort();
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(8, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNHCC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::NotifyHookChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::NotifyHookChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyHookChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, mobileService);
+
+
+ TRequestStatus notifyStatus;
+ RCall::THookStatus hookStatus;
+
+ call.NotifyHookChange(requestStatus, hookStatus);
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ // this test is written supposing that NotifyHookChange() is supported
+ // however RCall::NotifyHookChange returns KErrNotSupported
+ // because CTSY does NOT support this feature
+ // the rationale would be that NotifyStatusChange performs the same function
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNHCC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::NotifyHookChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::NotifyHookChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyHookChange0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, mobileService);
+
+
+ TRequestStatus notifyStatus;
+ RCall::THookStatus hookStatus;
+ call.NotifyHookChange(requestStatus, hookStatus);
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ // this test is written supposing that NotifyHookChange() is supported
+ // however RCall::NotifyHookChange returns KErrNotSupported
+ // because CTSY does NOT support this feature
+ // the rationale would be that NotifyStatusChange performs the same function
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNHCC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::NotifyHookChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::NotifyHookChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyHookChange00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, RMobileCall::EStatusRinging, mobileService);
+
+ TRequestStatus notifyStatus;
+ RCall::THookStatus hookStatus;
+ call.NotifyHookChange(requestStatus, hookStatus);
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus1.Int());
+
+ // this test is written supposing that NotifyHookChange() is supported
+ // however RCall::NotifyHookChange returns KErrNotSupported
+ // because CTSY does NOT support this feature
+ // the rationale would be that NotifyStatusChange performs the same function
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this); // this, data, line, call
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNSC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::NotifyStatusChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::NotifyStatusChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyStatusChange0001L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //-- test cases for different status values----------------------------------------------
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+
+ RCall::TStatus statusToGet;
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusRinging, statusToGet);
+
+ //--------------------------------------------------
+ mobileCallStatus = RMobileCall::EStatusDialling;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusDialling, statusToGet);
+
+ //--------------------------------------------------
+
+ mobileCallStatus = RMobileCall::EStatusAnswering;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusAnswering, statusToGet);
+
+ //--------------------------------------------------
+
+ mobileCallStatus = RMobileCall::EStatusConnecting;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusConnecting, statusToGet);
+
+ //--------------------------------------------------
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusConnected, statusToGet);
+
+ //--------------------------------------------------
+
+ mobileCallStatus = RMobileCall::EStatusDisconnecting;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(RCall::EStatusHangingUp == statusToGet);
+
+ //--------------------------------------------------
+
+ mobileCallStatus = RMobileCall::EStatusDisconnectingWithInband;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(RCall::EStatusHangingUp == statusToGet);
+
+
+ // for other status values the CompleteNotifyStatusChange() does not complete request
+
+
+ //- making status Idle + emergencyCalled ----------------------------------------
+ mobileCallStatus = RMobileCall::EStatusIdle;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+
+ TUint32 duration = 4; // this dummy param will be ignored by mocksy engine validation check
+ TMockLtsyData1<TUint32> ltsyData( duration );
+ data.Close();
+ ltsyData.SerialiseL(data);
+ // when the call state becomes idle, there is update LifeTime param into LTSY:
+ iMockLTSY.ExpectL(EMmTsyUpdateLifeTimeIPC, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ // make this for callId > 0
+ line.NotifyIncomingCall(requestStatus, incomingCallName);
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iService = mobileService;
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> idleCallData(callId, mobileService, mobileCallInfo);
+ data.Close();
+ idleCallData.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ CleanupStack::PopAndDestroy(&call);
+
+ //---------------------------------------------------------
+
+ RMobileCall emerCall;
+
+ TInt ret = emerCall.OpenExistingCall(line, incomingCallName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(emerCall);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ TRfStateInfo rfInfo = ERfsStateInfoNormal;
+ TMockLtsyData1<TRfStateInfo> mockData1(rfInfo);
+
+ data.Close();
+ mockData1.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ RMobileENStore::TEmergencyNumber number(_L("911"));
+ TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData(number);
+ data.Close();
+ numberLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);
+
+ emerCall.DialEmergencyCall(requestStatus, number);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockEmCallData(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockEmCallData.SerialiseL(data);
+
+ TRequestStatus requestStatus2;
+ emerCall.NotifyStatusChange(requestStatus2, statusToGet);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> emerCallData(callId, mobileService, mobileCallStatus);
+ data.Close();
+ emerCallData.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGsmReleaseByUser, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrGsmReleaseByUser, requestStatus.Int());
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_EQUALS(RCall::EStatusIdle, statusToGet);
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(&emerCall);
+
+ //-- for checking branches with ghost calls, EStatusRinging --------------------------------------------
+ callId = 2;
+ mobileCallStatus = RMobileCall::EStatusRinging;
+
+ mobileCallInfo.iCallId = callId;
+ mobileCallInfo.iService = mobileService;
+ mobileCallInfo.iStatus = RMobileCall::EStatusDialling;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, mobileService, mobileCallInfo);
+ data.Close();
+ mockCallData1.SerialiseL(data);
+
+ line.NotifyCallAdded(requestStatus, incomingCallName);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ //-------------------------------------------------------------------------------------------------
+
+ RMobileCall call2;
+ ret = call2.OpenExistingCall(line, incomingCallName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call2);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ RMobileCall::TMobileCallStatus mStatusToGet;
+ TRequestStatus mRequestStatus;
+
+ call2.NotifyMobileCallStatusChange(mRequestStatus, mStatusToGet);
+ call2.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusDialling, statusToGet);
+
+ User::WaitForRequest(mRequestStatus);
+
+ CloseCallL(call2, callId, mobileService);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(&call2);
+
+
+ //-- EStatusIdle --------------------------------------------
+ callId = 3;
+ mobileCallStatus = RMobileCall::EStatusRinging;
+
+ mobileCallInfo.iCallId = callId;
+ mobileCallInfo.iService = mobileService;
+ mobileCallInfo.iStatus = RMobileCall::EStatusDialling;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData5(callId, mobileService, mobileCallInfo);
+ data.Close();
+ mockCallData5.SerialiseL(data);
+
+ line.NotifyCallAdded(requestStatus, incomingCallName);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+
+ RMobileCall call3;
+ ret = call3.OpenExistingCall(line, incomingCallName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call3);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData6(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData6.SerialiseL(data);
+
+ call3.NotifyMobileCallStatusChange(mRequestStatus, mStatusToGet);
+ call3.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusIdle, statusToGet);
+
+ User::WaitForRequest(mRequestStatus);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(&call3);
+
+ //-- EStatusDisconnecting ---------------------------------------------
+
+ callId = 4;
+ mobileCallStatus = RMobileCall::EStatusRinging;
+
+ mobileCallInfo.iCallId = callId;
+ mobileCallInfo.iService = mobileService;
+ mobileCallInfo.iStatus = RMobileCall::EStatusDialling;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData7(callId, mobileService, mobileCallInfo);
+ data.Close();
+ mockCallData7.SerialiseL(data);
+
+ line.NotifyCallAdded(requestStatus, incomingCallName);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ RMobileCall call4;
+ ret = call4.OpenExistingCall(line, incomingCallName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call4);
+
+ mobileCallStatus = RMobileCall::EStatusDisconnecting;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData8(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData8.SerialiseL(data);
+
+ call4.NotifyStatusChange(requestStatus, statusToGet);
+ call4.NotifyMobileCallStatusChange(mRequestStatus, mStatusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusHangingUp, statusToGet);
+
+ User::WaitForRequest(mRequestStatus);
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNSC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyStatusChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RCall::NotifyStatusChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyStatusChange0002L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RCall::TStatus statusToGet;
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ call.NotifyStatusChangeCancel();
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNSC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyStatusChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RCall::NotifyStatusChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyStatusChange0004L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyVoice1LineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+ RCall call;
+ RCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ RCall::TStatus statusToGet;
+ RCall::TStatus statusToGet2;
+ call.NotifyStatusChange(requestStatus, statusToGet);
+ call2.NotifyStatusChange(requestStatus2, statusToGet2);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId2, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusRinging, statusToGet);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_EQUALS(RCall::EStatusIdle, statusToGet2);
+
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNSC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::NotifyStatusChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::NotifyStatusChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyStatusChange0006L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RCall::TStatus statusToGet;
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusRinging, statusToGet);
+
+ //-- test cases for different status values----------------------------------------------
+ mobileCallStatus = RMobileCall::EStatusConnecting;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusConnecting, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusDialling;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusDialling, statusToGet);
+
+ RArray<RMobileCall::TMobileCallStatus> arrayStatus;
+ CleanupClosePushL(arrayStatus);
+
+ arrayStatus.AppendL(RMobileCall::EStatusUnknown);
+ arrayStatus.AppendL(RMobileCall::EStatusReconnectPending);
+ arrayStatus.AppendL(RMobileCall::EStatusWaitingAlternatingCallSwitch);
+ arrayStatus.AppendL(RMobileCall::EStatusTransferring);
+ arrayStatus.AppendL(RMobileCall::EStatusTransferAlerting);
+ arrayStatus.AppendL(static_cast<RMobileCall::TMobileCallStatus>(RMobileCall::EStatusTransferAlerting+1));
+
+ for (TInt i = 0; i < arrayStatus.Count(); i++)
+ {
+ mobileCallStatus = arrayStatus[i];
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ }
+
+ //- making status Idle + KErrNone != aResult ----------------------------------------
+ mobileCallStatus = RMobileCall::EStatusIdle;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGeneral, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusIdle, statusToGet);
+
+ //- making status Idle + KErrNone != KErrGsmReleaseByUser ----------------------------
+
+ // make this for callId > 0
+ line.NotifyIncomingCall(requestStatus, incomingCallName);
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iService = mobileService;
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> idleCallData4(callId, mobileService, mobileCallInfo);
+ data.Close();
+ idleCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ RMobileCall em_call;
+ TInt ret = em_call.OpenExistingCall(line, incomingCallName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(em_call);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ em_call.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGsmReleaseByUser, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusIdle, statusToGet);
+
+ //-- for checking branches with ghost calls, EStatusRinging --------------------------------------------
+ callId = 2;
+ mobileCallStatus = RMobileCall::EStatusRinging;
+
+ mobileCallInfo.iCallId = callId;
+ mobileCallInfo.iService = mobileService;
+ mobileCallInfo.iStatus = RMobileCall::EStatusDialling;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, mobileService, mobileCallInfo);
+ data.Close();
+ mockCallData1.SerialiseL(data);
+
+ line.NotifyCallAdded(requestStatus, incomingCallName);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ RMobileCall call3;
+ ret = call3.OpenExistingCall(line, incomingCallName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call3);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ RMobileCall::TMobileCallStatus mStatusToGet;
+ TRequestStatus mRequestStatus;
+
+ call3.NotifyMobileCallStatusChange(mRequestStatus, mStatusToGet);
+ call3.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusDialling, statusToGet);
+
+ User::WaitForRequest(mRequestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNSC-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyStatusChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RCall::NotifyStatusChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyStatusChange0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RCall::TStatus statusToGet;
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ call.NotifyStatusChangeCancel();
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNSC-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyStatusChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RCall::NotifyStatusChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyStatusChange0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyDataLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+ RCall call;
+ RCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+
+ RCall::TStatus statusToGet;
+ RCall::TStatus statusToGet2;
+ call.NotifyStatusChange(requestStatus, statusToGet);
+ call2.NotifyStatusChange(requestStatus2, statusToGet2);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId2, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusRinging, statusToGet);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_EQUALS(RCall::EStatusIdle, statusToGet2);
+
+
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNSC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::NotifyStatusChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::NotifyStatusChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyStatusChange00011L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RCall::TStatus statusToGet;
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusIdle, statusToGet);
+
+
+ //-- for checking branches with ghost calls, EStatusRinging --------------------------------------------
+ callId = 1;
+ mobileCallStatus = RMobileCall::EStatusRinging;
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iCallId = callId;
+ mobileCallInfo.iService = mobileService;
+ mobileCallInfo.iStatus = RMobileCall::EStatusDialling;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, mobileService, mobileCallInfo);
+ data.Close();
+ mockCallData1.SerialiseL(data);
+
+ line.NotifyCallAdded(requestStatus, incomingCallName);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ RMobileCall call2;
+ TInt ret = call2.OpenExistingCall(line, incomingCallName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call2);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ RMobileCall::TMobileCallStatus mStatusToGet;
+ TRequestStatus mRequestStatus;
+
+ call2.NotifyMobileCallStatusChange(mRequestStatus, mStatusToGet);
+ call2.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusDialling, statusToGet);
+
+ User::WaitForRequest(mRequestStatus);
+ AssertMockLtsyStatusL();
+
+ RArray<RMobileCall::TMobileCallStatus> arrayStatus;
+ CleanupClosePushL(arrayStatus);
+
+ arrayStatus.AppendL(RMobileCall::EStatusUnknown);
+ arrayStatus.AppendL(RMobileCall::EStatusReconnectPending);
+ arrayStatus.AppendL(RMobileCall::EStatusWaitingAlternatingCallSwitch);
+ arrayStatus.AppendL(RMobileCall::EStatusTransferring);
+ arrayStatus.AppendL(RMobileCall::EStatusTransferAlerting);
+ arrayStatus.AppendL(RMobileCall::EStatusDisconnectingWithInband);
+ arrayStatus.AppendL(RMobileCall::EStatusConnecting);
+ arrayStatus.AppendL(static_cast<RMobileCall::TMobileCallStatus>(RMobileCall::EStatusTransferAlerting+1));
+
+ for (TInt i = 0; i < arrayStatus.Count(); i++)
+ {
+ mobileCallStatus = arrayStatus[i];
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ }
+
+ //- making status Idle + aResult == KErrGsmReleaseByUser ----------------------------
+ mobileCallStatus = RMobileCall::EStatusIdle;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ call2.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGsmReleaseByUser, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ //- making status Idle + aResult != KErrGsmReleaseByUser + aResult != KErrGsmBusyUserRequest
+ call2.Close();
+
+ callId = 2;
+ mobileCallStatus = RMobileCall::EStatusRinging;
+
+ mobileCallInfo.iCallId = callId;
+ mobileCallInfo.iService = mobileService;
+ mobileCallInfo.iStatus = RMobileCall::EStatusDialling;
+
+ line.NotifyCallAdded(requestStatus, incomingCallName);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ data.Close();
+ mockCallData1.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ ret = call2.OpenExistingCall(line, incomingCallName);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ call2.NotifyStatusChange(requestStatus, statusToGet);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNotSupported, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(6, this);
+
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNSC-00012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyStatusChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RCall::NotifyStatusChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyStatusChange00012L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+
+ RCall::TStatus statusToGet;
+ call.NotifyStatusChange(requestStatus, statusToGet);
+
+ call.NotifyStatusChangeCancel();
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNSC-00014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyStatusChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RCall::NotifyStatusChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyStatusChange00014L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyFaxLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+
+ RCall call;
+ RCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ RCall::TStatus statusToGet;
+ RCall::TStatus statusToGet2;
+ call.NotifyStatusChange(requestStatus, statusToGet);
+ call2.NotifyStatusChange(requestStatus2, statusToGet2);
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId2, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RCall::EStatusConnected, statusToGet);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_EQUALS(RCall::EStatusIdle, statusToGet2);
+
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::NotifyCallDurationChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::NotifyCallDurationChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallDurationChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TTimeIntervalSeconds time;
+
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ call.NotifyCallDurationChange(requestStatus, time);
+
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ //-------------------------------------------------------------------------
+
+ const TTimeIntervalSeconds KZeroTime(0);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(KZeroTime != time);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyCallDurationChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RCall::NotifyCallDurationChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallDurationChange0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TTimeIntervalSeconds time;
+
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+
+ call.NotifyCallDurationChange(requestStatus, time);
+
+ call.NotifyCallDurationChangeCancel();
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyCallDurationChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RCall::NotifyCallDurationChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallDurationChange0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyVoice1LineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+ RCall call;
+ RCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId2, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ //-------------------------------------------------------------------------
+ TTimeIntervalSeconds time;
+ TTimeIntervalSeconds time2;
+
+ call.NotifyCallDurationChange(requestStatus, time);
+ call2.NotifyCallDurationChange(requestStatus2, time2);
+
+
+ const TTimeIntervalSeconds KZeroTime(0);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(KZeroTime != time);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE(KZeroTime != time2);
+
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::NotifyCallDurationChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::NotifyCallDurationChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallDurationChange0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ TTimeIntervalSeconds time;
+
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+ //-------------------------------------------------------------------------
+
+ call.NotifyCallDurationChange(requestStatus, time);
+
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ //-------------------------------------------------------------------------
+
+ const TTimeIntervalSeconds KZeroTime(0);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(KZeroTime != time);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyCallDurationChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RCall::NotifyCallDurationChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallDurationChange0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ TTimeIntervalSeconds time;
+
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+ //-------------------------------------------------------------------------
+
+ call.NotifyCallDurationChange(requestStatus, time);
+
+ call.NotifyCallDurationChangeCancel();
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ //-------------------------------------------------------------------------
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ // Stop the timer by calling NotifyCallDurationChangeCancel and then check that the last call duration returned is accurate.
+ call.NotifyCallDurationChange(requestStatus, time);
+ sleep(1);
+ call.NotifyCallDurationChangeCancel();
+ User::WaitForRequest(requestStatus);
+ TInt ret = call.GetCallDuration(time);
+ ASSERT_EQUALS(KErrNone, ret);
+ const TTimeIntervalSeconds KZeroTime(0);
+ ASSERT_TRUE(KZeroTime != time);
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyCallDurationChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RCall::NotifyCallDurationChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallDurationChange0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyDataLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+ RCall call;
+ RCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+ //----------------------------------------
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId2, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ //-------------------------------------------------------------------------
+ TTimeIntervalSeconds time;
+ TTimeIntervalSeconds time2;
+
+ call.NotifyCallDurationChange(requestStatus, time);
+ call2.NotifyCallDurationChange(requestStatus2, time2);
+
+
+ const TTimeIntervalSeconds KZeroTime(0);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(KZeroTime != time);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE(KZeroTime != time2);
+
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::NotifyCallDurationChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::NotifyCallDurationChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallDurationChange00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TTimeIntervalSeconds time;
+
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+ //-------------------------------------------------------------------------
+
+ call.NotifyCallDurationChange(requestStatus, time);
+
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ //-------------------------------------------------------------------------
+
+ const TTimeIntervalSeconds KZeroTime(0);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(KZeroTime != time);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-00012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyCallDurationChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RCall::NotifyCallDurationChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallDurationChange00012L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ TTimeIntervalSeconds time;
+
+ RCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+ //-------------------------------------------------------------------------
+
+ call.NotifyCallDurationChange(requestStatus, time);
+
+ call.NotifyCallDurationChangeCancel();
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ //-------------------------------------------------------------------------
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-00014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyCallDurationChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RCall::NotifyCallDurationChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallDurationChange00014L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyFaxLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+ RCall call;
+ RCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId2, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ //-------------------------------------------------------------------------
+ TTimeIntervalSeconds time;
+ TTimeIntervalSeconds time2;
+
+ call.NotifyCallDurationChange(requestStatus, time);
+ call2.NotifyCallDurationChange(requestStatus2, time2);
+
+
+ const TTimeIntervalSeconds KZeroTime(0);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(KZeroTime != time);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE(KZeroTime != time2);
+
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNCA-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::NotifyCallAdded for voice lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::NotifyCallAdded for voice lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallAdded0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TTimeIntervalSeconds time;
+
+ RCall call;
+
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+
+ TName tmpname;
+ RCall tmpcall;
+
+ TRequestStatus mockLtsyStatus;
+
+ // test C1, complete called from CMmVoiceLineTsy::OpenNewObjectL()
+ TName callName;
+ line.NotifyCallAdded(requestStatus, callName);
+
+ OpenNewCallLC(tmpcall, line, &tmpname);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(0 == callName.Compare(tmpname));
+
+
+ //test C2, complete called from CMmLineTsy::CompleteNotifyAddBypassingCall()
+ line.NotifyCallAdded(requestStatus, callName);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ callInfo.iStatus = RMobileCall::EStatusDialling;
+ callInfo.iService = mobileService;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> callInfoData(callId, mobileService, callInfo);
+ completeData.Close();
+ callInfoData.SerialiseL(completeData);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo,KErrNone,completeData,0);
+ User::WaitForRequest(mockLtsyStatus);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ TName callName3(lineName);
+ callName3.Append('3');
+ ASSERT_TRUE(0 == callName.Compare(callName3));
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNCA-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RLine::NotifyCallAdded for voice lines
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RLine::NotifyCallAdded for voice lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallAdded0002L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TTimeIntervalSeconds time;
+
+ RCall call;
+
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ TName tmpname;
+ RCall tmpcall;
+
+ TRequestStatus mockLtsyStatus;
+
+ TName callName;
+ line.NotifyCallAdded(requestStatus, callName);
+
+ line.NotifyCallAddedCancel();
+
+ OpenNewCallLC(tmpcall, line, &tmpname);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNCA-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RLine::NotifyCallAdded for voice lines
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RLine::NotifyCallAdded for voice lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallAdded0004L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ // 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);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyVoice1LineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+ //----------------------------------------
+
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+
+ TName callName;
+ TName callName2;
+
+ line.NotifyCallAdded(requestStatus, callName);
+ line2.NotifyCallAdded(requestStatus2, callName2);
+
+ RCall call;
+ TName tmpname;
+
+ OpenNewCallLC(call, line, &tmpname);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(0 == callName.Compare(tmpname));
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE(0 == callName2.Compare(tmpname));
+
+
+ CleanupStack::PopAndDestroy(6, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNCA-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::NotifyCallAdded for data lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::NotifyCallAdded for data lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallAdded0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TTimeIntervalSeconds time;
+
+ RCall call;
+
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+
+ TName tmpname;
+ RCall tmpcall;
+
+ TRequestStatus mockLtsyStatus;
+
+ // test C1, complete called from CMmDataLineTsy::OpenNewObjectL()
+ TName callName;
+ line.NotifyCallAdded(requestStatus, callName);
+
+ OpenNewCallLC(call, line, &tmpname);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(0 == callName.Compare(tmpname));
+
+ //test C2, complete called from CMmLineTsy::CompleteNotifyAddBypassingCall()
+ line.NotifyCallAdded(requestStatus, callName);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ callInfo.iStatus = RMobileCall::EStatusDialling;
+ callInfo.iService = mobileService;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> callInfoData(callId, mobileService, callInfo);
+ completeData.Close();
+ callInfoData.SerialiseL(completeData);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo,KErrNone,completeData,0);
+ User::WaitForRequest(mockLtsyStatus);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ TName callName3(lineName);
+ callName3.Append('3');
+ ASSERT_TRUE(0 == callName.Compare(callName3));
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNCA-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RLine::NotifyCallAdded for data lines
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RLine::NotifyCallAdded for data lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallAdded0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TTimeIntervalSeconds time;
+
+ RCall call;
+
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ TName tmpname;
+ RCall tmpcall;
+
+ TName callName;
+ line.NotifyCallAdded(requestStatus, callName);
+
+ line.NotifyCallAddedCancel();
+
+ OpenNewCallLC(tmpcall, line, &tmpname);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNCA-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RLine::NotifyCallAdded for data lines
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RLine::NotifyCallAdded for data lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallAdded0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyDataLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+ //----------------------------------------
+
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+
+ TName callName;
+ TName callName2;
+
+ line.NotifyCallAdded(requestStatus, callName);
+ line2.NotifyCallAdded(requestStatus2, callName2);
+
+ RCall call;
+ TName tmpname;
+
+ OpenNewCallLC(call, line, &tmpname);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(0 == callName.Compare(tmpname));
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE(0 == callName2.Compare(tmpname));
+
+ CleanupStack::PopAndDestroy(7, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNCA-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::NotifyCallAdded for fax lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::NotifyCallAdded for fax lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallAdded00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TTimeIntervalSeconds time;
+
+ RCall call;
+
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ TName tmpname;
+ RCall tmpcall;
+
+ TRequestStatus mockLtsyStatus;
+
+ // test C1, complete called from CMmFaxLineTsy::OpenNewObjectL()
+ TName callName;
+ line.NotifyCallAdded(requestStatus, callName);
+
+ OpenNewCallLC(tmpcall, line, &tmpname);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(0 == callName.Compare(tmpname));
+
+ AssertMockLtsyStatusL();
+
+ //test C2, complete called from CMmLineTsy::CompleteNotifyAddBypassingCall()
+ line.NotifyCallAdded(requestStatus, callName);
+
+ TInt callId = 1;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ callInfo.iStatus = RMobileCall::EStatusDialling;
+ callInfo.iService = mobileService;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> callInfoData(callId, mobileService, callInfo);
+ completeData.Close();
+ callInfoData.SerialiseL(completeData);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo,KErrNone,completeData,0);
+ User::WaitForRequest(mockLtsyStatus);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ TName callName3(lineName);
+ callName3.Append('3');
+ ASSERT_TRUE(0 == callName.Compare(callName3));
+
+
+ CleanupStack::PopAndDestroy(4, this);
+
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNCA-00012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RLine::NotifyCallAdded for fax lines
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RLine::NotifyCallAdded for fax lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallAdded00012L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TTimeIntervalSeconds time;
+
+ RCall call;
+
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ TName tmpname;
+ RCall tmpcall;
+
+ TRequestStatus mockLtsyStatus;
+
+ TName callName;
+ line.NotifyCallAdded(requestStatus, callName);
+
+ line.NotifyCallAddedCancel();
+
+ OpenNewCallLC(tmpcall, line, &tmpname);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNCA-00014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RLine::NotifyCallAdded for fax lines
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RLine::NotifyCallAdded for fax lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallAdded00014L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyFaxLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+ //----------------------------------------
+
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+
+ TName callName;
+ TName callName2;
+
+ line.NotifyCallAdded(requestStatus, callName);
+ line2.NotifyCallAdded(requestStatus2, callName2);
+
+ RCall call;
+ TName tmpname;
+
+ OpenNewCallLC(call, line, &tmpname);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(0 == callName.Compare(tmpname));
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE(0 == callName2.Compare(tmpname));
+
+ CleanupStack::PopAndDestroy(7, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNIC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::NotifyIncomingCall for voice lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::NotifyIncomingCall for voice lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyIncomingCall0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestNotify;
+
+ TRequestStatus mockLtsyStatus;
+
+ line.NotifyIncomingCall(requestNotify, incomingCallName);
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iService = RMobilePhone::EVoiceService;
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::EVoiceService, mobileCallInfo);
+ completeData.Close();
+ mockCallData1.SerialiseL(completeData);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ _LIT(KName, "Voice11");
+
+ User::WaitForRequest(requestNotify);
+ ASSERT_EQUALS(KErrNone, requestNotify.Int());
+ ASSERT_TRUE(0 == incomingCallName.Compare(KName));
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNIC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RLine::NotifyIncomingCall for voice lines
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RLine::NotifyIncomingCall for voice lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyIncomingCall0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestNotify;
+
+ TRequestStatus mockLtsyStatus;
+
+ line.NotifyIncomingCall(requestNotify, incomingCallName);
+
+ line.CancelAsyncRequest(EEtelLineNotifyIncomingCall);
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iService = RMobilePhone::EVoiceService;
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::EVoiceService, mobileCallInfo);
+ completeData.Close();
+ mockCallData1.SerialiseL(completeData);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestNotify);
+ ASSERT_EQUALS(KErrCancel, requestNotify.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNIC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RLine::NotifyIncomingCall for voice lines
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RLine::NotifyIncomingCall for voice lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyIncomingCall0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyVoice1LineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+
+
+ TInt callId = 1;
+ TInt callId2= 2;
+
+ TName incomingCallName;
+ TName incomingCallName2;
+
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+ TRequestStatus requestNotify;
+
+ TRequestStatus mockLtsyStatus;
+
+ line.NotifyIncomingCall(requestStatus, incomingCallName);
+ line2.NotifyIncomingCall(requestStatus2, incomingCallName2);
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iService = RMobilePhone::EVoiceService;
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::EVoiceService, mobileCallInfo);
+ mockCallData1.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId2, RMobilePhone::EVoiceService, mobileCallInfo);
+ data.Close();
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ _LIT(KName, "Voice11");
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(0 == incomingCallName.Compare(KName));
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE(0 == incomingCallName2.Compare(KName));
+
+ CleanupStack::PopAndDestroy(6, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNIC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::NotifyIncomingCall for data lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::NotifyIncomingCall for data lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyIncomingCall0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestNotify;
+
+ TRequestStatus mockLtsyStatus;
+
+ line.NotifyIncomingCall(requestNotify, incomingCallName);
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iService = RMobilePhone::ECircuitDataService;
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::ECircuitDataService, mobileCallInfo);
+ completeData.Close();
+ mockCallData1.SerialiseL(completeData);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ _LIT(KName, "Data1");
+
+ User::WaitForRequest(requestNotify);
+ ASSERT_EQUALS(KErrNone, requestNotify.Int());
+ ASSERT_TRUE(0 == incomingCallName.Compare(KName));
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNIC-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RLine::NotifyIncomingCall for data lines
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RLine::NotifyIncomingCall for data lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyIncomingCall0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestNotify;
+
+ TRequestStatus mockLtsyStatus;
+
+ line.NotifyIncomingCall(requestNotify, incomingCallName);
+
+ line.CancelAsyncRequest(EEtelLineNotifyIncomingCall);
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iService = RMobilePhone::ECircuitDataService;
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::ECircuitDataService, mobileCallInfo);
+ completeData.Close();
+ mockCallData1.SerialiseL(completeData);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestNotify);
+ ASSERT_EQUALS(KErrCancel, requestNotify.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNIC-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RLine::NotifyIncomingCall for data lines
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RLine::NotifyIncomingCall for data lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyIncomingCall0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyDataLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+
+ TInt callId = 1;
+ TInt callId2= 2;
+
+ TName incomingCallName;
+ TName incomingCallName2;
+
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+ TRequestStatus requestNotify;
+
+ TRequestStatus mockLtsyStatus;
+
+ line.NotifyIncomingCall(requestStatus, incomingCallName);
+ line2.NotifyIncomingCall(requestStatus2, incomingCallName2);
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iService = RMobilePhone::ECircuitDataService;
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::ECircuitDataService, mobileCallInfo);
+ mockCallData1.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId2, RMobilePhone::ECircuitDataService, mobileCallInfo);
+ data.Close();
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ _LIT(KName, "Data1");
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(0 == incomingCallName.Compare(KName));
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE(0 == incomingCallName2.Compare(KName));
+
+ CleanupStack::PopAndDestroy(6, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNIC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::NotifyIncomingCall for fax lines
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::NotifyIncomingCall for fax lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyIncomingCall00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestNotify;
+
+ TRequestStatus mockLtsyStatus;
+
+ line.NotifyIncomingCall(requestNotify, incomingCallName);
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iService = RMobilePhone::EFaxService;
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::EFaxService, mobileCallInfo);
+ completeData.Close();
+ mockCallData1.SerialiseL(completeData);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ _LIT(KName, "Fax1");
+
+ User::WaitForRequest(requestNotify);
+ ASSERT_EQUALS(KErrNone, requestNotify.Int());
+ ASSERT_TRUE(0 == incomingCallName.Compare(KName));
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNIC-00012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RLine::NotifyIncomingCall for fax lines
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RLine::NotifyIncomingCall for fax lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyIncomingCall00012L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestNotify;
+
+ TRequestStatus mockLtsyStatus;
+
+ line.NotifyIncomingCall(requestNotify, incomingCallName);
+
+ line.CancelAsyncRequest(EEtelLineNotifyIncomingCall);
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iService = RMobilePhone::EFaxService;
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::EFaxService, mobileCallInfo);
+ completeData.Close();
+ mockCallData1.SerialiseL(completeData);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestNotify);
+ ASSERT_EQUALS(KErrCancel, requestNotify.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNIC-00014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RLine::NotifyIncomingCall for fax lines
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RLine::NotifyIncomingCall for fax lines
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyIncomingCall00014L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyFaxLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+ //----------------------------------------
+
+ TInt callId = 1;
+ TInt callId2= 2;
+
+ TName incomingCallName;
+ TName incomingCallName2;
+
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+ TRequestStatus requestNotify;
+
+ TRequestStatus mockLtsyStatus;
+
+ line.NotifyIncomingCall(requestStatus, incomingCallName);
+ line2.NotifyIncomingCall(requestStatus2, incomingCallName2);
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iService = RMobilePhone::EFaxService;
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::EFaxService, mobileCallInfo);
+ mockCallData1.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId2, RMobilePhone::EFaxService, mobileCallInfo);
+ data.Close();
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ _LIT(KName, "Fax1");
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(0 == incomingCallName.Compare(KName));
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE(0 == incomingCallName2.Compare(KName));
+
+
+ CleanupStack::PopAndDestroy(6, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCE-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyCallEvent for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyCallEvent for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallEvent0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallEvent ev;
+
+ //----------------------------------------
+ call.NotifyCallEvent(requestStatus, ev);
+
+ RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteTerminated);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::ERemoteTerminated, ev);
+
+ //----------------------------------------
+ ev1 = RMobileCall::ELocalHold;
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData4(callId, mobileService, ev1);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ //----------------------------------------
+
+ call.NotifyCallEvent(requestStatus, ev);
+
+ mobileCallStatus = RMobileCall::EStatusHold;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData5(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData5.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::ELocalHold, ev);
+
+ //----------------------------------------
+
+ call.NotifyCallEvent(requestStatus, ev);
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+
+ data.Close();
+ mockCallData5.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::ELocalResume, ev);
+
+ //----------------------------------------
+ // see CMmCallTsy::CompleteNotifyRemoteCallEvent in CMmCallTsy.cpp
+
+ mobileService = RMobilePhone::EVoiceService;
+
+ RArray<RMobileCall::TMobileCallEvent> arrayRemote;
+ CleanupClosePushL(arrayRemote);
+
+
+ // complete is called for these events from CMmCallTsy::CompleteNotifyRemoteCallEvent
+ arrayRemote.AppendL(RMobileCall::ERemoteHold);
+ arrayRemote.AppendL(RMobileCall::ERemoteResume);
+ arrayRemote.AppendL(RMobileCall::ERemoteTerminated);
+ arrayRemote.AppendL(RMobileCall::ERemoteConferenceCreate);
+ // and these are ingnored in CompleteNotifyRemoteCallEvent
+ arrayRemote.AppendL(RMobileCall::ELocalHold);
+ arrayRemote.AppendL(RMobileCall::ELocalResume);
+ arrayRemote.AppendL(RMobileCall::ELocalDeflectCall);
+ arrayRemote.AppendL(RMobileCall::ELocalTransfer);
+ arrayRemote.AppendL(RMobileCall::ERemoteTransferring);
+ arrayRemote.AppendL(RMobileCall::ERemoteTransferAlerting);
+ arrayRemote.AppendL(RMobileCall::ERemoteBarred);
+ arrayRemote.AppendL(RMobileCall::ERemoteForwarding);
+ arrayRemote.AppendL(RMobileCall::ERemoteWaiting);
+ arrayRemote.AppendL(RMobileCall::ELocalBarred);
+ arrayRemote.AppendL(static_cast<RMobileCall::TMobileCallEvent>(RMobileCall::ELocalBarred+1));
+
+ for (TInt i = 0; i < 4; i++)
+ {
+ RMobileCall::TMobileCallEvent evTemp(arrayRemote[i]);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallDataTemp(callId, mobileService, evTemp);
+ data.Close();
+ mockCallDataTemp.SerialiseL(data);
+
+ call.NotifyCallEvent(requestStatus, ev);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(evTemp, ev);
+ }
+
+ for (TInt i = 4; i < arrayRemote.Count(); i++)
+ {
+ RMobileCall::TMobileCallEvent evTemp(arrayRemote[i]);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallDataTemp(callId, mobileService, evTemp);
+ data.Close();
+ mockCallDataTemp.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ }
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCE-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyCallEvent for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyCallEvent for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallEvent0002L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+
+ RMobileCall::TMobileCallEvent ev;
+
+ call.NotifyCallEvent(requestStatus, ev);
+ call.CancelAsyncRequest(EMobileCallNotifyCallEvent);
+
+ RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteHold);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCE-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyCallEvent for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyCallEvent for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallEvent0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ TName lineName2(KMmTsyVoice1LineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+
+
+ RMobileCall call;
+ RMobileCall call2;
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+ RMobileCall::TMobileCallEvent ev;
+ RMobileCall::TMobileCallEvent ev2;
+
+ call.NotifyCallEvent(requestStatus, ev);
+ call2.NotifyCallEvent(requestStatus2, ev2);
+
+ RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteHold);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ RMobileCall::TMobileCallEvent ev11(RMobileCall::ERemoteTerminated);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData4(callId2, mobileService, ev11);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::ERemoteHold, ev);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_EQUALS(RMobileCall::ERemoteTerminated, ev2);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCE-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyCallEvent for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyCallEvent for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallEvent0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+ RMobileCall::TMobileCallEvent ev;
+
+ call.NotifyCallEvent(requestStatus, ev);
+
+ RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteTerminated);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::ERemoteTerminated, ev);
+
+ //----------------------------------------
+ ev1 = RMobileCall::ELocalHold;
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData4(callId, mobileService, ev1);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCE-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyCallEvent for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyCallEvent for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallEvent0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+ RMobileCall::TMobileCallEvent ev;
+
+ call.NotifyCallEvent(requestStatus, ev);
+ call.CancelAsyncRequest(EMobileCallNotifyCallEvent);
+
+ RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteHold);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCE-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyCallEvent for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyCallEvent for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallEvent0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyDataLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+ RMobileCall call;
+ RMobileCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+ RMobileCall::TMobileCallEvent ev;
+ RMobileCall::TMobileCallEvent ev2;
+
+ call.NotifyCallEvent(requestStatus, ev);
+ call2.NotifyCallEvent(requestStatus2, ev2);
+
+ RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteHold);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ RMobileCall::TMobileCallEvent ev11(RMobileCall::ERemoteTerminated);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData4(callId2, mobileService, ev11);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::ERemoteHold, ev);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_EQUALS(RMobileCall::ERemoteTerminated, ev2);
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCE-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyCallEvent for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyCallEvent for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallEvent00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RMobileCall call;
+
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+ RMobileCall::TMobileCallEvent ev;
+
+ call.NotifyCallEvent(requestStatus, ev);
+
+ RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteTerminated);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::ERemoteTerminated, ev);
+
+ //----------------------------------------
+ ev1 = RMobileCall::ELocalHold;
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData4(callId, mobileService, ev1);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCE-00012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyCallEvent for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyCallEvent for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallEvent00012L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+ RMobileCall::TMobileCallEvent ev;
+
+ call.NotifyCallEvent(requestStatus, ev);
+ call.CancelAsyncRequest(EMobileCallNotifyCallEvent);
+
+ RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteHold);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNCE-00014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyCallEvent for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyCallEvent for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyCallEvent00014L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyFaxLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+ RMobileCall call;
+ RMobileCall call2;
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+ RMobileCall::TMobileCallEvent ev;
+ RMobileCall::TMobileCallEvent ev2;
+
+ call.NotifyCallEvent(requestStatus, ev);
+ call2.NotifyCallEvent(requestStatus2, ev2);
+
+ RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteHold);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ RMobileCall::TMobileCallEvent ev11(RMobileCall::ERemoteTerminated);
+ TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData4(callId2, mobileService, ev11);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::ERemoteHold, ev);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_EQUALS(RMobileCall::ERemoteTerminated, ev2);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallCaps for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallCaps for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallCaps0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+ RMobileCall::TMobileCallCapsV1 caps;
+ RMobileCall::TMobileCallCapsV1Pckg capsPckg(caps);
+
+ TInt ret = call1.GetMobileCallCaps(capsPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE(0xFF == caps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsDial) == caps.iCallControlCaps);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+ //-------------------------------------------------------------------------
+
+ mobileCallStatus = RMobileCall::EStatusDisconnecting;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ ret = call.GetMobileCallCaps(capsPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE(0xFF == caps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsAnswer | RMobileCall::KCapsHangUp) == caps.iCallControlCaps);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCC-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallCaps with bad parameter data for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallCaps with bad parameter data for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallCaps0003L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+
+ OpenNewCallLC(call1, line, &name);
+
+ TInt8 badCaps;
+ TPckg<TInt8> badPckg(badCaps);
+
+ TInt ret = call1.GetMobileCallCaps(badPckg);
+ ASSERT_TRUE(KErrArgument == ret);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallCaps for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallCaps for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallCaps0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+
+ OpenNewCallLC(call1, line, &name);
+
+ RMobileCall::TMobileCallCapsV1 caps;
+ RMobileCall::TMobileCallCapsV1Pckg capsPckg(caps);
+
+ TInt ret = call1.GetMobileCallCaps(capsPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE(0xFF == caps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsData | RMobileCall::KCapsDial | RMobileCall::KCapsConnect) == caps.iCallControlCaps);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+ //-------------------------------------------------------------------------
+
+ mobileCallStatus = RMobileCall::EStatusDisconnecting;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ ret = call.GetMobileCallCaps(capsPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE(0xFF == caps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsData | RMobileCall::KCapsAnswer | RMobileCall::KCapsHangUp) == caps.iCallControlCaps);
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCC-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallCaps with bad parameter data for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallCaps with bad parameter data for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallCaps0008L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+
+ OpenNewCallLC(call1, line, &name);
+
+ TInt8 badCaps;
+ TPckg<TInt8> badPckg(badCaps);
+
+ TInt ret = call1.GetMobileCallCaps(badPckg);
+
+ ASSERT_TRUE(KErrArgument == ret);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallCaps for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallCaps for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallCaps00011L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+
+ OpenNewCallLC(call1, line, &name);
+
+ RMobileCall::TMobileCallCapsV1 caps;
+ RMobileCall::TMobileCallCapsV1Pckg capsPckg(caps);
+
+ TInt ret = call1.GetMobileCallCaps(capsPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE(0xFF == caps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsFax | RMobileCall::KCapsDial) == caps.iCallControlCaps);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //-------------------------------------------------------------------------
+
+ mobileCallStatus = RMobileCall::EStatusDisconnecting;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ ret = call.GetMobileCallCaps(capsPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_TRUE(0xFF == caps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsFax | RMobileCall::KCapsAnswer | RMobileCall::KCapsHangUp) == caps.iCallControlCaps);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCC-00013
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallCaps with bad parameter data for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallCaps with bad parameter data for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallCaps00013L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+ TInt8 badCaps;
+ TPckg<TInt8> badPckg(badCaps);
+
+ TInt ret = call1.GetMobileCallCaps(badPckg);
+
+ ASSERT_TRUE(KErrArgument == ret);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCI-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallInfo for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallInfo0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+ RMobileCall::TMobileCallInfoV1 info;
+ RMobileCall::TMobileCallInfoV1Pckg infoPckg(info);
+
+ _LIT(KEmpty, "");
+ const TDateTime KZeroTime(0,TMonth(0),0,0,0,0,0);
+
+ TInt ret = call1.GetMobileCallInfo(infoPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE((RMobileCall::KCallStartTime |
+ RMobileCall::KCallDuration |
+ RMobileCall::KCallId |
+ RMobileCall::KCallExitCode |
+ RMobileCall::KCallEmergency) == info.iValid);
+ ASSERT_TRUE(RMobileCall::EServiceUnspecified == info.iService);
+ ASSERT_TRUE(RMobileCall::EStatusIdle == info.iStatus);
+ ASSERT_TRUE(0 == info.iCallId);
+ ASSERT_TRUE(-1 == info.iExitCode);
+ ASSERT_TRUE(0 == info.iEmergency);
+ ASSERT_TRUE(0 == info.iForwarded);
+ ASSERT_TRUE(RMobilePhone::EPrivacyUnspecified == info.iPrivacy);
+ ASSERT_TRUE(RMobilePhone::EAlternatingModeUnspecified == info.iAlternatingCall);
+ ASSERT_TRUE(RMobileCall::ETchUnknown == info.iTch);
+ ASSERT_TRUE(RMobileCall::ERemoteIdentityUnknown == info.iRemoteParty.iRemoteIdStatus);
+ ASSERT_TRUE(RMobileCall::EDirectionUnknown == info.iRemoteParty.iDirection);
+ ASSERT_TRUE(0 == info.iRemoteParty.iCallingName.Compare(KEmpty));
+ ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTelNumber.Size());
+ ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTypeOfNumber);
+ ASSERT_TRUE(RMobilePhone::EUnknownNumber == info.iDialledParty.iTypeOfNumber);
+ ASSERT_TRUE(RMobilePhone::EUnknownNumberingPlan == info.iDialledParty.iNumberPlan);
+ ASSERT_TRUE(0 == info.iDialledParty.iTelNumber.Compare(KEmpty));
+ ASSERT_TRUE(0 == memcmp( &info.iStartTime, &KZeroTime, sizeof(KZeroTime)));
+ ASSERT_TRUE(0 == info.iCallName.Compare(name));
+ ASSERT_TRUE(0 == info.iLineName.Compare(lineName));
+
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData2.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ //-----------------------------------------------------------------------
+
+ ret = call.GetMobileCallInfo(infoPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE((RMobileCall::KCallStartTime |
+ RMobileCall::KCallDuration |
+ RMobileCall::KCallId |
+ RMobileCall::KCallExitCode |
+ RMobileCall::KCallEmergency) == info.iValid);
+ ASSERT_TRUE(RMobilePhone::EVoiceService == info.iService);
+ ASSERT_TRUE(RMobileCall::EStatusConnected == info.iStatus);
+ ASSERT_TRUE(1 == info.iCallId);
+ ASSERT_TRUE(0 == info.iExitCode);
+ ASSERT_TRUE(0 == info.iEmergency);
+ ASSERT_TRUE(0 == info.iForwarded);
+ ASSERT_TRUE(RMobilePhone::EPrivacyUnspecified == info.iPrivacy);
+ ASSERT_TRUE(RMobilePhone::EAlternatingModeUnspecified == info.iAlternatingCall);
+ ASSERT_TRUE(RMobileCall::ETchUnknown == info.iTch);
+ ASSERT_TRUE(RMobileCall::ERemoteIdentityUnknown == info.iRemoteParty.iRemoteIdStatus);
+ ASSERT_TRUE(RMobileCall::EMobileTerminated == info.iRemoteParty.iDirection);
+ ASSERT_TRUE(0 == info.iRemoteParty.iCallingName.Compare(KEmpty));
+ ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTelNumber.Size());
+ ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTypeOfNumber);
+ ASSERT_TRUE(RMobilePhone::EUnknownNumber == info.iDialledParty.iTypeOfNumber);
+ ASSERT_TRUE(RMobilePhone::EUnknownNumberingPlan == info.iDialledParty.iNumberPlan);
+ ASSERT_TRUE(0 == info.iDialledParty.iTelNumber.Compare(KEmpty));
+ ASSERT_TRUE(0 == memcmp( &info.iStartTime, &KZeroTime, sizeof(KZeroTime)));
+ ASSERT_TRUE(0 == info.iCallName.Compare(incomingCallName));
+ ASSERT_TRUE(0 == info.iLineName.Compare(lineName));
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCI-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo with bad parameter data for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallInfo with bad parameter data for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallInfo0003L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+ TInt8 badInfo;
+ TPckg<TInt8> badPckg(badInfo);
+
+ TInt ret = call1.GetMobileCallInfo(badPckg);
+
+ ASSERT_TRUE(KErrArgument == ret);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); //call1, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCI-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallInfo for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallInfo0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+ TBool activeCall = EFalse;
+
+ RMobileCall::TMobileCallInfoV1 info;
+ RMobileCall::TMobileCallInfoV1Pckg infoPckg(info);
+
+ const TDateTime KZeroTime(0,TMonth(0),0,0,0,0,0);
+
+ TInt ret = call1.GetMobileCallInfo(infoPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateMobileCallInfo(&infoPckg, name, lineName, activeCall);
+
+ // For TMobileCallInfoV3
+ RMobileCall::TMobileCallInfoV3 info3;
+ RMobileCall::TMobileCallInfoV3Pckg infoPckg3(info3);
+
+ ret = call1.GetMobileCallInfo(infoPckg3);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateMobileCallInfo(&infoPckg3,name, lineName, activeCall);
+
+ // For TMobileCallInfoV7
+ RMobileCall::TMobileCallInfoV7 info7;
+ RMobileCall::TMobileCallInfoV7Pckg infoPckg7(info7);
+
+ ret = call1.GetMobileCallInfo(infoPckg7);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateMobileCallInfo(&infoPckg7,name, lineName, activeCall);
+
+ //--- check after activating call -------------------------------------
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ activeCall = ETrue;
+
+ mobileCallStatus = RMobileCall::EStatusAnswering;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ //-----------------------------------------------------------------------
+
+ ret = call.GetMobileCallInfo(infoPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateMobileCallInfo(&infoPckg, name, lineName, activeCall, RMobileCall::EStatusAnswering);
+ ASSERT_TRUE(0 == info.iCallName.Compare(incomingCallName));
+
+ // For TMobileCallinfoV3
+ ret = call.GetMobileCallInfo(infoPckg3);
+ ASSERT_EQUALS(KErrNone, ret);
+ ValidateMobileCallInfo(&infoPckg3, name, lineName, activeCall, RMobileCall::EStatusAnswering);
+ ASSERT_TRUE(0 == info.iCallName.Compare(incomingCallName));
+
+ // For TMobileCallinfoV7
+ ret = call.GetMobileCallInfo(infoPckg7);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateMobileCallInfo(&infoPckg7, name, lineName, activeCall, RMobileCall::EStatusAnswering);
+ ASSERT_TRUE(0 == info.iCallName.Compare(incomingCallName));
+
+ // iStatus can be RMobileCall::EStatusAnswering or RMobileCall::EStatusConnected depending on the network answer.
+ ASSERT_TRUE(RMobileCall::EStatusAnswering == info3.iStatus);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCI-0006b
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo for data calls with MobileCallInfoV8. It is in connection to BA-CTSY-CALLI-CGMCI-0006.
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallInfo for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallInfo0006bL()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+ TBool activeCall = EFalse;
+
+ RMobileCall::TMobileCallInfoV8 info8;
+ RMobileCall::TMobileCallInfoV8Pckg infoPckg8(info8);
+
+ TInt ret = call1.GetMobileCallInfo(infoPckg8);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateMobileCallInfo(&infoPckg8,name, lineName, activeCall);
+
+ //--- check after activating call -------------------------------------
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ activeCall = ETrue;
+
+ //-----------------------------------------------------------------------
+
+ ret = call.GetMobileCallInfo(infoPckg8);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ValidateMobileCallInfo(&infoPckg8, name, lineName, activeCall);
+ ASSERT_TRUE(0 == info8.iCallName.Compare(incomingCallName));
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCI-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo with bad parameter data for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallInfo with bad parameter data for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallInfo0008L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+ TInt8 badInfo;
+ TPckg<TInt8> badPckg(badInfo);
+
+ TInt ret = call1.GetMobileCallInfo(badPckg);
+
+ ASSERT_TRUE(KErrArgument == ret);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // call1, line, this
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCI-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallInfo for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallInfo00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+ RMobileCall::TMobileCallInfoV1 info;
+ RMobileCall::TMobileCallInfoV1Pckg infoPckg(info);
+
+ _LIT(KEmpty, "");
+ const TDateTime KZeroTime(0,TMonth(0),0,0,0,0,0);
+
+ TInt ret = call1.GetMobileCallInfo(infoPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE((RMobileCall::KCallStartTime |
+ RMobileCall::KCallDuration |
+ RMobileCall::KCallId |
+ RMobileCall::KCallExitCode |
+ RMobileCall::KCallEmergency) == info.iValid);
+ ASSERT_TRUE(RMobileCall::EServiceUnspecified == info.iService);
+ ASSERT_TRUE(RMobileCall::EStatusIdle == info.iStatus);
+ ASSERT_TRUE(0 == info.iCallId);
+ ASSERT_TRUE(-1 == info.iExitCode);
+ ASSERT_TRUE(0 == info.iEmergency);
+ ASSERT_TRUE(0 == info.iForwarded);
+ ASSERT_TRUE(RMobilePhone::EPrivacyUnspecified == info.iPrivacy);
+ ASSERT_TRUE(RMobilePhone::EAlternatingModeUnspecified == info.iAlternatingCall);
+ ASSERT_TRUE(RMobileCall::ETchUnknown == info.iTch);
+ ASSERT_TRUE(RMobileCall::ERemoteIdentityUnknown == info.iRemoteParty.iRemoteIdStatus);
+ ASSERT_TRUE(RMobileCall::EDirectionUnknown == info.iRemoteParty.iDirection);
+ ASSERT_TRUE(0 == info.iRemoteParty.iCallingName.Compare(KEmpty));
+ ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTelNumber.Size());
+ ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTypeOfNumber);
+ ASSERT_TRUE(RMobilePhone::EUnknownNumber == info.iDialledParty.iTypeOfNumber);
+ ASSERT_TRUE(RMobilePhone::EUnknownNumberingPlan == info.iDialledParty.iNumberPlan);
+ ASSERT_TRUE(0 == info.iDialledParty.iTelNumber.Compare(KEmpty));
+ ASSERT_TRUE(0 == memcmp( &info.iStartTime, &KZeroTime, sizeof(KZeroTime)));
+ ASSERT_TRUE(0 == info.iCallName.Compare(name));
+ ASSERT_TRUE(0 == info.iLineName.Compare(lineName));
+
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //-----------------------------------------------------------------------
+
+ ret = call.GetMobileCallInfo(infoPckg);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ASSERT_TRUE((RMobileCall::KCallStartTime |
+ RMobileCall::KCallDuration |
+ RMobileCall::KCallId |
+ RMobileCall::KCallExitCode |
+ RMobileCall::KCallEmergency) == info.iValid);
+ ASSERT_TRUE(RMobilePhone::EFaxService == info.iService);
+ ASSERT_TRUE(RMobileCall::EStatusRinging == info.iStatus);
+ ASSERT_TRUE(1 == info.iCallId);
+ ASSERT_TRUE(-1 == info.iExitCode);
+ ASSERT_TRUE(0 == info.iEmergency);
+ ASSERT_TRUE(0 == info.iForwarded);
+ ASSERT_TRUE(RMobilePhone::EPrivacyUnspecified == info.iPrivacy);
+ ASSERT_TRUE(RMobilePhone::EAlternatingModeUnspecified == info.iAlternatingCall);
+ ASSERT_TRUE(RMobileCall::ETchUnknown == info.iTch);
+ ASSERT_TRUE(RMobileCall::ERemoteIdentityUnknown == info.iRemoteParty.iRemoteIdStatus);
+ ASSERT_TRUE(RMobileCall::EMobileTerminated == info.iRemoteParty.iDirection);
+ ASSERT_TRUE(0 == info.iRemoteParty.iCallingName.Compare(KEmpty));
+ ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTelNumber.Size());
+ ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTypeOfNumber);
+ ASSERT_TRUE(RMobilePhone::EUnknownNumber == info.iDialledParty.iTypeOfNumber);
+ ASSERT_TRUE(RMobilePhone::EUnknownNumberingPlan == info.iDialledParty.iNumberPlan);
+ ASSERT_TRUE(0 == info.iDialledParty.iTelNumber.Compare(KEmpty));
+ ASSERT_TRUE(0 == memcmp( &info.iStartTime, &KZeroTime, sizeof(KZeroTime)));
+ ASSERT_TRUE(0 == info.iCallName.Compare(incomingCallName));
+ ASSERT_TRUE(0 == info.iLineName.Compare(lineName));
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this);
+
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCI-00013
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo with bad parameter data for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallInfo with bad parameter data for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallInfo00013L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+ TInt8 badInfo;
+ TPckg<TInt8> badPckg(badInfo);
+
+ TInt ret = call1.GetMobileCallInfo(badPckg);
+
+ ASSERT_TRUE(KErrArgument == ret);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // call1, line, this
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCS-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallStatus for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallStatus for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallStatus0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+
+ RMobileCall::TMobileCallStatus statusToGet;
+
+ TInt ret = call1.GetMobileCallStatus(statusToGet);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ mobileCallStatus = RMobileCall::EStatusAnswering;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ ret = call.GetMobileCallStatus(statusToGet);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ //This iStatus can be RMobileCall::EStatusAnswering or RMobileCall::EStatusConnected depending on the network answer.
+ ASSERT_EQUALS(RMobileCall::EStatusAnswering, statusToGet);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCS-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallStatus for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallStatus for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallStatus0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+ RMobileCall::TMobileCallStatus statusToGet;
+
+ TInt ret = call1.GetMobileCallStatus(statusToGet);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet);
+
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ mobileCallStatus = RMobileCall::EStatusAnswering;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(callId, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ ret = call.GetMobileCallStatus(statusToGet);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ //This iStatus can be RMobileCall::EStatusAnswering or RMobileCall::EStatusConnected depending on the network answer.
+ ASSERT_EQUALS(RMobileCall::EStatusAnswering, statusToGet);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CGMCS-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallStatus for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileCallStatus for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetMobileCallStatus00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //--- check not active call -------------------------------------
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+
+ RMobileCall::TMobileCallStatus statusToGet;
+
+ TInt ret = call1.GetMobileCallStatus(statusToGet);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestNotify;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ ret = call.GetMobileCallStatus(statusToGet);
+ ASSERT_EQUALS(KErrNone, ret);
+ ASSERT_EQUALS(RMobileCall::EStatusRinging, statusToGet);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNATE-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyAudioToneEvent for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyAudioToneEvent for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyAudioToneEvent0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+ TRequestStatus requestStatus;
+ TInt8 tmp;
+ TPckg<TInt8> tmpPckg(tmp);
+
+ call1.NotifyAudioToneEvent(requestStatus, tmpPckg);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNATE-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyAudioToneEvent for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyAudioToneEvent for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyAudioToneEvent0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+ TRequestStatus requestStatus;
+ TInt8 tmp;
+ TPckg<TInt8> tmpPckg(tmp);
+
+ call1.NotifyAudioToneEvent(requestStatus, tmpPckg);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNATE-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyAudioToneEvent for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyAudioToneEvent for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyAudioToneEvent00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ RMobileCall call1;
+ TName name;
+ OpenNewCallLC(call1, line, &name);
+
+ TRequestStatus requestStatus;
+ TInt8 tmp;
+ TPckg<TInt8> tmpPckg(tmp);
+
+ call1.NotifyAudioToneEvent(requestStatus, tmpPckg);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallCapsChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileCallCapsChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ TRequestStatus notifyStatus;
+ RMobileCall::TMobileCallCapsV1 mcaps;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg(mcaps);
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusRinging;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsVoice |
+ RMobileCall::KCapsHangUp |
+ RMobileCall::KCapsAnswer |
+ RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);
+
+
+ //-----------------------
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusAnswering;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsHangUp) == mcaps.iCallControlCaps);
+
+ //-----------------------
+ // just to change back mobile caps
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsVoice |
+ RMobileCall::KCapsHangUp |
+ RMobileCall::KCapsAnswer |
+ RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);
+
+ //-----------------------
+
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusDisconnecting;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsVoice |
+ RMobileCall::KCapsHangUp |
+ RMobileCall::KCapsAnswer) == mcaps.iCallControlCaps);
+
+ //-----------------------
+ // just to change back mobile caps
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsVoice |
+ RMobileCall::KCapsHangUp |
+ RMobileCall::KCapsAnswer |
+ RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);
+
+ //-----------------------
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsVoice
+ | RMobileCall::KCapsHangUp
+ | RMobileCall::KCapsHold) == mcaps.iCallControlCaps);
+
+ //-----------------------
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusDisconnectingWithInband;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsHangUp) == mcaps.iCallControlCaps);
+
+ //-----------------------
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsDial) == mcaps.iCallControlCaps);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileCallCapsChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileCallCapsChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //---------------------------------------
+
+ TRequestStatus notifyStatus;
+ RMobileCall::TMobileCallCapsV1 mcaps;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg(mcaps);
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+ call.CancelAsyncRequest(EMobileCallNotifyMobileCallCapsChange);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrCancel, notifyStatus.Int());
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallCapsChange with bad parameter data for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileCallCapsChange with bad parameter data for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0003L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+ //---------------------------------------
+
+ TRequestStatus notifyStatus;
+ TBuf8<1> caps(KNullDesC8);
+
+ call.NotifyMobileCallCapsChange( notifyStatus, caps );
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_TRUE(KErrNone != notifyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileCallCapsChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileCallCapsChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyVoice1LineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+
+ RMobileCall call;
+ RMobileCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+
+ RMobileCall::TMobileCallCapsV1 mcaps;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg(mcaps);
+
+ RMobileCall::TMobileCallCapsV1 mcaps2;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg2(mcaps2);
+
+ call.NotifyMobileCallCapsChange( requestStatus, mcapsPckg);
+ call2.NotifyMobileCallCapsChange( requestStatus2, mcapsPckg2);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId2, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsDial) == mcaps.iCallControlCaps);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE(0xFF == mcaps2.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsDial) == mcaps2.iCallControlCaps);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(8, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallCapsChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileCallCapsChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ TRequestStatus notifyStatus;
+ RMobileCall::TMobileCallCapsV1 mcaps;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg(mcaps);
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusRinging;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsData |
+ RMobileCall::KCapsHangUp |
+ RMobileCall::KCapsAnswer |
+ RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);
+
+
+ //-----------------------
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusAnswering;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsData | RMobileCall::KCapsHangUp) == mcaps.iCallControlCaps);
+
+ //-----------------------
+ // just to change back mobile caps
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsData |
+ RMobileCall::KCapsHangUp |
+ RMobileCall::KCapsAnswer |
+ RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);
+
+ //-----------------------
+
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusDisconnecting;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsData |
+ RMobileCall::KCapsHangUp |
+ RMobileCall::KCapsAnswer) == mcaps.iCallControlCaps);
+
+ //-----------------------
+ // just to change back mobile caps
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsData |
+ RMobileCall::KCapsHangUp |
+ RMobileCall::KCapsAnswer |
+ RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);
+
+ //-----------------------
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsData
+ | RMobileCall::KCapsHangUp) == mcaps.iCallControlCaps);
+
+ //-----------------------
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsData |
+ RMobileCall::KCapsDial |
+ RMobileCall::KCapsConnect) == mcaps.iCallControlCaps);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileCallCapsChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileCallCapsChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //---------------------------------------
+
+ TRequestStatus notifyStatus;
+ RMobileCall::TMobileCallCapsV1 mcaps;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg(mcaps);
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+ call.CancelAsyncRequest(EMobileCallNotifyMobileCallCapsChange);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrCancel, notifyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallCapsChange with bad parameter data for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileCallCapsChange with bad parameter data for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0008L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+ //---------------------------------------
+
+ TRequestStatus notifyStatus;
+ TBuf8<1> caps(KNullDesC8);
+
+ call.NotifyMobileCallCapsChange( notifyStatus, caps );
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_TRUE(KErrNone != notifyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileCallCapsChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileCallCapsChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyDataLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+
+ RMobileCall call;
+ RMobileCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+
+
+ RMobileCall::TMobileCallCapsV1 mcaps;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg(mcaps);
+
+ RMobileCall::TMobileCallCapsV1 mcaps2;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg2(mcaps2);
+
+ call.NotifyMobileCallCapsChange( requestStatus, mcapsPckg);
+ call2.NotifyMobileCallCapsChange( requestStatus2, mcapsPckg2);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId2, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsData | RMobileCall::KCapsDial | RMobileCall::KCapsConnect) == mcaps.iCallControlCaps);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE(0xFF == mcaps2.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsData | RMobileCall::KCapsDial | RMobileCall::KCapsConnect) == mcaps2.iCallControlCaps);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(8, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallCapsChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileCallCapsChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ TRequestStatus notifyStatus;
+ RMobileCall::TMobileCallCapsV1 mcaps;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg(mcaps);
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusRinging;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsFax |
+ RMobileCall::KCapsHangUp |
+ RMobileCall::KCapsAnswer |
+ RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);
+
+
+ //-----------------------
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusAnswering;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsFax | RMobileCall::KCapsHangUp) == mcaps.iCallControlCaps);
+
+ //-----------------------
+ // just to change back mobile caps
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsFax |
+ RMobileCall::KCapsHangUp |
+ RMobileCall::KCapsAnswer |
+ RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);
+
+ //-----------------------
+
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusDisconnecting;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsFax |
+ RMobileCall::KCapsHangUp |
+ RMobileCall::KCapsAnswer) == mcaps.iCallControlCaps);
+
+ //-----------------------
+ // just to change back mobile caps
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsFax |
+ RMobileCall::KCapsHangUp |
+ RMobileCall::KCapsAnswer |
+ RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);
+
+ //-----------------------
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsFax
+ | RMobileCall::KCapsHangUp) == mcaps.iCallControlCaps);
+
+ //-----------------------
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrNone, notifyStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsFax |
+ RMobileCall::KCapsDial) == mcaps.iCallControlCaps);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-00012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileCallCapsChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileCallCapsChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange00012L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //---------------------------------------
+ TRequestStatus notifyStatus;
+ RMobileCall::TMobileCallCapsV1 mcaps;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg(mcaps);
+
+ call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
+ call.CancelAsyncRequest(EMobileCallNotifyMobileCallCapsChange);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_EQUALS(KErrCancel, notifyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-00013
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallCapsChange with bad parameter data for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileCallCapsChange with bad parameter data for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange00013L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //---------------------------------------
+ TRequestStatus notifyStatus;
+ TBuf8<1> caps(KNullDesC8);
+
+ call.NotifyMobileCallCapsChange( notifyStatus, caps);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(notifyStatus);
+ ASSERT_TRUE(KErrNone != notifyStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-00014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileCallCapsChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileCallCapsChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange00014L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyFaxLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+
+ RMobileCall call;
+ RMobileCall call2;
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallCapsV1 mcaps;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg(mcaps);
+
+ RMobileCall::TMobileCallCapsV1 mcaps2;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg2(mcaps2);
+
+ call.NotifyMobileCallCapsChange( requestStatus, mcapsPckg);
+ call2.NotifyMobileCallCapsChange( requestStatus2, mcapsPckg2);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId2, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsFax | RMobileCall::KCapsDial) == mcaps.iCallControlCaps);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_TRUE(0xFF == mcaps2.iCallEventCaps);
+ ASSERT_TRUE((RMobileCall::KCapsFax | RMobileCall::KCapsDial) == mcaps2.iCallControlCaps);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(8, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyRemotePartyInfoChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyRemotePartyInfoChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ //---------------------------------------
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 info;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
+
+ call.NotifyRemotePartyInfoChange(requestStatus, pckg);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ _LIT(KNum, "Num");
+ _LIT(KName, "Name");
+
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
+ callInfo.iRemoteParty.iCallingName = KName;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
+ mockCallData2.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);
+ ASSERT_EQUALS(RMobileCall::EMobileTerminated, info.iDirection);
+ ASSERT_TRUE(0 == info.iCallingName.Compare(KName));
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);
+ ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));
+
+ CloseIncomingCallL(call, callId, mobileService );
+
+ //---------------------------------------
+
+ RMobileCall call2;
+
+ TInt ret = OpenNewCall(line, call2, KMmTsyVoice1LineName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call2);
+
+ // now we're giving the call a concrete callId > 0 and getting a name
+ TName name;
+ line.NotifyCallAdded(requestStatus, name);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ callId = 2;
+ callInfo.iCallId = callId;
+ callInfo.iStatus = RMobileCall::EStatusConnecting;
+
+ data.Close();
+ mockCallData2.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ // now we have an opened call with known name and callId
+ RMobileCall call3;
+ ret = call3.OpenExistingCall(line, name);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call3);
+
+
+ call3.NotifyRemotePartyInfoChange(requestStatus, pckg);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);
+ ASSERT_EQUALS(RMobileCall::EMobileOriginated, info.iDirection);
+ ASSERT_TRUE(0 == info.iCallingName.Compare(KName));
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);
+ ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(6, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyRemotePartyInfoChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyRemotePartyInfoChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0002L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 info;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
+
+ call.NotifyRemotePartyInfoChange(requestStatus, pckg);
+ call.CancelAsyncRequest(EMobileCallNotifyRemotePartyInfoChange);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
+ mockCallData2.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0003
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyRemotePartyInfoChange with bad parameter data for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyRemotePartyInfoChange with bad parameter data for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0003L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ TInt8 badInfo;
+ TPckg<TInt8> pckg(badInfo);
+
+ call.NotifyRemotePartyInfoChange(requestStatus, pckg);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ _LIT(KNum, "Num");
+ _LIT(KName, "Name");
+
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
+ callInfo.iRemoteParty.iCallingName = KName;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
+ mockCallData2.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_TRUE(KErrArgument == requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); //data, line, call, this
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyRemotePartyInfoChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyRemotePartyInfoChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0004L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyVoice1LineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+ RMobileCall call;
+ RMobileCall call2;
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 info;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 info2;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg2(info2);
+
+ call.NotifyRemotePartyInfoChange(requestStatus, pckg);
+ call2.NotifyRemotePartyInfoChange(requestStatus2, pckg2);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ _LIT(KNum, "Num");
+ _LIT(KName, "Name");
+
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
+ callInfo.iRemoteParty.iCallingName = KName;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ _LIT(KNum2, "Num2");
+ _LIT(KName2, "Name2");
+
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentitySuppressed;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum2;
+ callInfo.iRemoteParty.iCallingName = KName2;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData3(callId2, mobileService, callInfo);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+
+ ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);
+ ASSERT_EQUALS(RMobileCall::EMobileTerminated, info.iDirection);
+ ASSERT_TRUE(0 == info.iCallingName.Compare(KName));
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);
+ ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));
+
+ ASSERT_EQUALS(RMobileCall::ERemoteIdentitySuppressed, info2.iRemoteIdStatus);
+ ASSERT_EQUALS(RMobileCall::EMobileTerminated, info2.iDirection);
+ ASSERT_TRUE(0 == info2.iCallingName.Compare(KName2));
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info2.iRemoteNumber.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info2.iRemoteNumber.iNumberPlan);
+ ASSERT_TRUE(0 == info2.iRemoteNumber.iTelNumber.Compare(KNum2));
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(8, this);
+
+ }
+
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyRemotePartyInfoChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyRemotePartyInfoChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 info;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
+
+ call.NotifyRemotePartyInfoChange(requestStatus, pckg);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ _LIT(KNum, "Num");
+ _LIT(KName, "Name");
+
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
+ callInfo.iRemoteParty.iCallingName = KName;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
+ mockCallData2.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);
+ ASSERT_EQUALS(RMobileCall::EMobileTerminated, info.iDirection);
+ ASSERT_TRUE(0 == info.iCallingName.Compare(KName));
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);
+ ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyRemotePartyInfoChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyRemotePartyInfoChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 info;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
+
+ call.NotifyRemotePartyInfoChange(requestStatus, pckg);
+ call.CancelAsyncRequest(EMobileCallNotifyRemotePartyInfoChange);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
+ mockCallData2.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyRemotePartyInfoChange with bad parameter data for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyRemotePartyInfoChange with bad parameter data for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0008L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ TInt8 badInfo;
+ TPckg<TInt8> pckg(badInfo);
+
+ call.NotifyRemotePartyInfoChange(requestStatus, pckg);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ _LIT(KNum, "Num");
+ _LIT(KName, "Name");
+
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
+ callInfo.iRemoteParty.iCallingName = KName;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
+ mockCallData2.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_TRUE(KErrArgument == requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyRemotePartyInfoChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyRemotePartyInfoChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyDataLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+
+ RMobileCall call;
+ RMobileCall call2;
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 info;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 info2;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg2(info2);
+
+ call.NotifyRemotePartyInfoChange(requestStatus, pckg);
+ call2.NotifyRemotePartyInfoChange(requestStatus2, pckg2);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ _LIT(KNum, "Num");
+ _LIT(KName, "Name");
+
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
+ callInfo.iRemoteParty.iCallingName = KName;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ _LIT(KNum2, "Num2");
+ _LIT(KName2, "Name2");
+
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentitySuppressed;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum2;
+ callInfo.iRemoteParty.iCallingName = KName2;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData3(callId2, mobileService, callInfo);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+
+ ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);
+ ASSERT_EQUALS(RMobileCall::EMobileTerminated, info.iDirection);
+ ASSERT_TRUE(0 == info.iCallingName.Compare(KName));
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);
+ ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));
+
+ ASSERT_EQUALS(RMobileCall::ERemoteIdentitySuppressed, info2.iRemoteIdStatus);
+ ASSERT_EQUALS(RMobileCall::EMobileTerminated, info2.iDirection);
+ ASSERT_TRUE(0 == info2.iCallingName.Compare(KName2));
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info2.iRemoteNumber.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info2.iRemoteNumber.iNumberPlan);
+ ASSERT_TRUE(0 == info2.iRemoteNumber.iTelNumber.Compare(KNum2));
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(8, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyRemotePartyInfoChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyRemotePartyInfoChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 info;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
+
+ call.NotifyRemotePartyInfoChange(requestStatus, pckg);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ _LIT(KNum, "Num");
+ _LIT(KName, "Name");
+
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
+ callInfo.iRemoteParty.iCallingName = KName;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
+ mockCallData2.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);
+ ASSERT_EQUALS(RMobileCall::EMobileTerminated, info.iDirection);
+ ASSERT_TRUE(0 == info.iCallingName.Compare(KName));
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);
+ ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-00012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyRemotePartyInfoChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyRemotePartyInfoChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange00012L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 info;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
+
+ call.NotifyRemotePartyInfoChange(requestStatus, pckg);
+ call.CancelAsyncRequest(EMobileCallNotifyRemotePartyInfoChange);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
+ mockCallData2.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-00013
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyRemotePartyInfoChange with bad parameter data for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyRemotePartyInfoChange with bad parameter data for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange00013L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ TInt8 badInfo;
+ TPckg<TInt8> pckg(badInfo);
+
+ call.NotifyRemotePartyInfoChange(requestStatus, pckg);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ _LIT(KNum, "Num");
+ _LIT(KName, "Name");
+
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
+ callInfo.iRemoteParty.iCallingName = KName;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
+ mockCallData2.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_TRUE(KErrArgument == requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-00014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyRemotePartyInfoChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyRemotePartyInfoChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange00014L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyFaxLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+
+ RMobileCall call;
+ RMobileCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+ //----------------------------------------
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 info;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 info2;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg2(info2);
+
+ call.NotifyRemotePartyInfoChange(requestStatus, pckg);
+ call2.NotifyRemotePartyInfoChange(requestStatus2, pckg2);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ _LIT(KNum, "Num");
+ _LIT(KName, "Name");
+
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
+ callInfo.iRemoteParty.iCallingName = KName;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
+ mockCallData2.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ _LIT(KNum2, "Num2");
+ _LIT(KName2, "Name2");
+
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentitySuppressed;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum2;
+ callInfo.iRemoteParty.iCallingName = KName2;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData3(callId2, mobileService, callInfo);
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+
+ ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);
+ ASSERT_EQUALS(RMobileCall::EMobileTerminated, info.iDirection);
+ ASSERT_TRUE(0 == info.iCallingName.Compare(KName));
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);
+ ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));
+
+ ASSERT_EQUALS(RMobileCall::ERemoteIdentitySuppressed, info2.iRemoteIdStatus);
+ ASSERT_EQUALS(RMobileCall::EMobileTerminated, info2.iDirection);
+ ASSERT_TRUE(0 == info2.iCallingName.Compare(KName2));
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info2.iRemoteNumber.iTypeOfNumber);
+ ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info2.iRemoteNumber.iNumberPlan);
+ ASSERT_TRUE(0 == info2.iRemoteNumber.iTelNumber.Compare(KNum2));
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(8, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallStatusChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileCallStatusChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallStatus statusToGet;
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusRinging, statusToGet);
+
+ //--------------------
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusDialling;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusDialling, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusConnecting;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusConnecting, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusAnswering;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusAnswering, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusConnected, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusDisconnecting;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusDisconnecting, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusDisconnectingWithInband;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusDisconnectingWithInband, statusToGet);
+
+ //-----------------------
+
+ // for other status values CompleteNotifyStatusChange() does not complete the notify request
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-0002
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileCallStatusChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileCallStatusChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange0002L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+
+ RMobileCall::TMobileCallStatus statusToGet;
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+ call.CancelAsyncRequest(EMobileCallNotifyMobileCallStatusChange);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileCallStatusChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileCallStatusChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange0004L()
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyVoice1LineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+ //----------------------------------------
+
+ RMobileCall call;
+ RMobileCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+
+ RMobileCall::TMobileCallStatus statusToGet;
+ RMobileCall::TMobileCallStatus statusToGet2;
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+ call2.NotifyMobileCallStatusChange(requestStatus2, statusToGet2);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId2, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusRinging, statusToGet);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet2);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallStatusChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileCallStatusChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallStatus statusToGet;
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusRinging, statusToGet);
+
+ //--------------------
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusDialling;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusDialling, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusConnecting;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusConnecting, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusAnswering;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusAnswering, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusConnected, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusDisconnecting;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusDisconnecting, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusDisconnectingWithInband;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusDisconnectingWithInband, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+
+ TUint32 duration = 4; // this is a dummy value, which will be ignored, when mocksy engine is doing the validation check
+ TMockLtsyData1<TUint32> ltsyData( duration );
+ data.Close();
+ ltsyData.SerialiseL(data);
+ // when the call state becomes idle, there is update LifeTime param into LTSY:
+ iMockLTSY.ExpectL(EMmTsyUpdateLifeTimeIPC, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet);
+
+ //-----------------------
+
+ // for other status values CompleteNotifyStatusChange() does not complete the notify request
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileCallStatusChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileCallStatusChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallStatus statusToGet;
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+ call.CancelAsyncRequest(EMobileCallNotifyMobileCallStatusChange);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileCallStatusChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileCallStatusChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyDataLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+ //----------------------------------------
+
+ RMobileCall call;
+ RMobileCall call2;
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+
+
+ RMobileCall::TMobileCallStatus statusToGet;
+ RMobileCall::TMobileCallStatus statusToGet2;
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+ call2.NotifyMobileCallStatusChange(requestStatus2, statusToGet2);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId2, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusRinging, statusToGet);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet2);
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(8, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallStatusChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileCallStatusChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallStatus statusToGet;
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusRinging;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusRinging, statusToGet);
+
+ //--------------------
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusDialling;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusDialling, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusConnecting;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusConnecting, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusAnswering;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusAnswering, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusConnected, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusDisconnecting;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusDisconnecting, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusDisconnectingWithInband;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusDisconnectingWithInband, statusToGet);
+
+ //-----------------------
+
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+ data.Close();
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ TUint32 duration = 4; // this is a dummy value, which will be ignored, when mocksy engine is doing the validation check
+ TMockLtsyData1<TUint32> ltsyData( duration );
+ data.Close();
+ ltsyData.SerialiseL(data);
+ // when the call state becomes idle, there is update LifeTime param into LTSY:
+ iMockLTSY.ExpectL(EMmTsyUpdateLifeTimeIPC, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet);
+
+ //-----------------------
+
+ // for other status values CompleteNotifyStatusChange() does not complete the notify request
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-00012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileCallStatusChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileCallStatusChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange00012L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ //----------------------------------------
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RMobileCall::TMobileCallStatus statusToGet;
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+ call.CancelAsyncRequest(EMobileCallNotifyMobileCallStatusChange);
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrCancel, requestStatus.Int());
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+ }
+
+
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-00014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileCallStatusChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileCallStatusChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange00014L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ // 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);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ TName lineName2(KMmTsyFaxLineName);
+ RLine line2;
+
+ OpenLineLC(line2, phone2, lineName2);
+
+ RMobileCall call;
+ RMobileCall call2;
+
+ TInt callId = 1;
+ TInt callId2 = 2;
+ TName incomingCallName;
+ TName incomingCallName2;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus requestStatus2;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2,
+ lineName2, callId2, mobileCallStatus, mobileService);
+
+
+ RMobileCall::TMobileCallStatus statusToGet;
+ RMobileCall::TMobileCallStatus statusToGet2;
+ call.NotifyMobileCallStatusChange(requestStatus, statusToGet);
+ call2.NotifyMobileCallStatusChange(requestStatus2, statusToGet2);
+
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
+ mockCallData3.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ mobileCallStatus = RMobileCall::EStatusIdle;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId2, mobileService, mobileCallStatus);
+ data.Close();
+ mockCallData4.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusConnected, statusToGet);
+
+ User::WaitForRequest(requestStatus2);
+ ASSERT_EQUALS(KErrNone, requestStatus2.Int());
+ ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet2);
+
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(8, this);
+ }
+
+
+void CCTsyCallInformationFU::AuxGetIncomingCallType0001L(const TDesC& aLineName, RMobilePhone::TMobileService aMobileService)
+ {
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+
+ OpenLineLC(line, iPhone, aLineName);
+
+ RMobileCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ aLineName, callId, mobileCallStatus, aMobileService);
+
+ //---------------------------------------
+ TRequestStatus notifyStatus;
+ RMobileCall::TMobileCallCapsV1 mcaps;
+ RMobileCall::TMobileCallCapsV1Pckg mcapsPckg(mcaps);
+
+ RMobilePhone::TMobilePhoneIncomingCallType type;
+ RMobileCall::TMobileDataCallParamsV1 callParams;
+ RMobileCall::TMobileDataCallParamsV1Pckg callParamsPckg(callParams);
+
+ iPhone.GetIncomingCallType(requestStatus, type, callParamsPckg);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this);
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-MGICT-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetIncomingCallType
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::GetIncomingCallType
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetIncomingCallType0001L()
+ {
+
+ AuxGetIncomingCallType0001L(KMmTsyVoice1LineName, RMobilePhone::EVoiceService);
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-MGICT-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetIncomingCallType
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::GetIncomingCallType
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetIncomingCallType0006L()
+ {
+
+ AuxGetIncomingCallType0001L(KMmTsyDataLineName, RMobilePhone::ECircuitDataService);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-MGICT-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetIncomingCallType
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::GetIncomingCallType
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestGetIncomingCallType00011L()
+ {
+
+ AuxGetIncomingCallType0001L(KMmTsyFaxLineName, RMobilePhone::EFaxService);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-MNICTC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifyIncomingCallTypeChange
+@SYMTestPriority High
+@SYMTestActions Invokes RMobilePhone::NotifyIncomingCallTypeChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyIncomingCallTypeChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ TRequestStatus requestStatus;
+
+ RMobilePhone::TMobilePhoneIncomingCallType type;
+ RMobileCall::TMobileDataCallParamsV1 callParams;
+ RMobileCall::TMobileDataCallParamsV1Pckg callParamsPckg(callParams);
+ iPhone.NotifyIncomingCallTypeChange(requestStatus, type, callParamsPckg);
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(1, this);
+ }
+
+
+
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNHCC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::NotifyHookChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::NotifyHookChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyLineHookChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyVoice1LineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
+
+ TRequestStatus notifyStatus;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RCall::THookStatus hookStatus;
+ line.NotifyHookChange(requestStatus, hookStatus);
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ // this test is written supposing that NotifyHookChange() is supported
+ // however RCall::NotifyHookChange returns KErrNotSupported
+ // because CTSY does NOT support this feature
+ // the rationale would be that NotifyStatusChange performs the same function
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNHCC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::NotifyHookChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::NotifyHookChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyLineHookChange0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyDataLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ TRequestStatus notifyStatus;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RCall::THookStatus hookStatus;
+ line.NotifyHookChange(requestStatus, hookStatus);
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ TMockLtsyCallData0 mockData01(callId, mobileService);
+ mockData01.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallAnswer, data);
+ iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
+ call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNone, requestStatus1.Int());
+
+ // this test is written supposing that NotifyHookChange() is supported
+ // however RCall::NotifyHookChange returns KErrNotSupported
+ // because CTSY does NOT support this feature
+ // the rationale would be that NotifyStatusChange performs the same function
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CALLI-LNHCC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RLine::NotifyHookChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RLine::NotifyHookChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyCallInformationFU::TestNotifyLineHookChange00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TName lineName(KMmTsyFaxLineName);
+ RLine line;
+
+ OpenLineLC(line, iPhone, lineName);
+
+ RCall call;
+ TInt callId = 1;
+ TName incomingCallName;
+ TRequestStatus requestStatus;
+ TRequestStatus requestStatus1;
+ TRequestStatus mockLtsyStatus;
+
+ RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+
+ TRequestStatus notifyStatus;
+
+ CreateAndOpenIncomingCalLC(line, call, incomingCallName,
+ lineName, callId, mobileCallStatus, mobileService);
+
+ RCall::THookStatus hookStatus;
+ line.NotifyHookChange(requestStatus, hookStatus);
+
+ RMobileCall::TMobileCallParamsV1 callParamsV1;
+ TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
+
+ call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
+ User::WaitForRequest(requestStatus1);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus1.Int());
+
+ // this test is written supposing that NotifyHookChange() is supported
+ // however RCall::NotifyHookChange returns KErrNotSupported
+ // because CTSY does NOT support this feature
+ // the rationale would be that NotifyStatusChange performs the same function
+
+ User::WaitForRequest(requestStatus);
+ ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this);
+
+
+ }
+
+
+
+
+
+// ExpectL and CompleteL must precede this function.
+void CCTsyCallInformationFU::CallGetMobileCallInfoL(TInt aCallId,
+ RMobilePhone::TMobileService aService,
+ const TDesC &aTelNumber)
+ {
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+
+ callInfo.iDialledParty.iTelNumber.Copy(aTelNumber);
+ callInfo.iService = aService;
+ callInfo.iEmergency = EFalse;
+ callInfo.iRemoteParty.iCallingName = KNullDesC;
+ callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityUnknown;
+ callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNullDesC;
+ callInfo.iRemoteParty.iRemoteNumber.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo.iRemoteParty.iRemoteNumber.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo.iForwarded = EFalse;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallRemoteParty;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> callInfoData(aCallId, aService, callInfo);
+ callInfoData.SerialiseL(data);
+
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+
+ CleanupStack::PopAndDestroy(1);
+ }
+
+
+void CCTsyCallInformationFU::OpenLineLC(RLine& aLine, RPhone& aPhone, const TDesC& aName)
+ {
+
+ TInt res = aLine.Open(aPhone, aName);
+ ASSERT_EQUALS(KErrNone, res);
+ CleanupClosePushL(aLine);
+ AssertMockLtsyStatusL();
+
+ }
+
+
+void CCTsyCallInformationFU::CreateAndOpenIncomingCalLC(RLine &aLine,
+ RCall &aCall,
+ TName& aCallName,
+ const TDesC& aLineName,
+ const TInt aCallId,
+ RMobileCall::TMobileCallStatus aMobileCallStatus,
+ RMobilePhone::TMobileService aMobileService
+ )
+ {
+
+ TInt ret = CreateIncomingCallL(aLine, aCallId, aLineName, aCallName,
+ aMobileService, aMobileCallStatus);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ ret = aCall.OpenExistingCall(aLine, aCallName);
+ ASSERT_EQUALS(KErrNone, ret);
+
+ CleanupClosePushL(aCall);
+ }
+
+
+void CCTsyCallInformationFU::OpenNewCallLC(RCall& aCall, RLine& aLine, TDes* aCallName)
+ {
+ TInt res;
+ if (aCallName)
+ {
+ res = aCall.OpenNewCall(aLine, *aCallName);
+ }
+ else
+ {
+ res = aCall.OpenNewCall(aLine);
+ }
+ ASSERT_EQUALS(KErrNone, res);
+ CleanupClosePushL(aCall);
+ AssertMockLtsyStatusL();
+ }
+void CCTsyCallInformationFU::ValidateMobileCallInfo(TDes8* aCallInfo, TName &aCallName, const TDesC& aLineName, TBool aCallFlagActive, RMobileCall::TMobileCallStatus aStatus)
+ {
+
+ _LIT(KEmpty, "");
+ const TDateTime KZeroTime(0,TMonth(0),0,0,0,0,0);
+
+ RMobilePhone::TMultimodeTypePckg* infoParamsPckg =
+ reinterpret_cast<RMobilePhone::TMultimodeTypePckg*>(
+ aCallInfo );
+ RMobilePhone::TMultimodeType& callInfo = ( *infoParamsPckg )();
+
+ // get extensionid
+ TInt extensionId( callInfo.ExtensionId() );
+
+ if ( (KETelExtMultimodeV1 == extensionId) ||
+ (KETelExtMultimodeV3 == extensionId) ||
+ (KEtelExtMultimodeV7 == extensionId) ||
+ (KEtelExtMultimodeV8 == extensionId) )
+ {
+
+ RMobileCall::TMobileCallInfoV1Pckg* paramsPckgV1 =
+ reinterpret_cast<RMobileCall::TMobileCallInfoV1Pckg*>(aCallInfo );
+ RMobileCall::TMobileCallInfoV1& info = ( *paramsPckgV1 )();
+
+ if(aCallFlagActive)
+ {
+ ASSERT_TRUE(RMobilePhone::ECircuitDataService == info.iService);
+ ASSERT_TRUE(1 == info.iCallId);
+ ASSERT_TRUE(0 == info.iExitCode);
+ ASSERT_TRUE(RMobileCall::EMobileTerminated == info.iRemoteParty.iDirection);
+ ASSERT_TRUE(aStatus == info.iStatus);
+ }
+ else
+ {
+ ASSERT_TRUE(RMobileCall::EServiceUnspecified == info.iService);
+ ASSERT_TRUE(0 == info.iCallId);
+ ASSERT_TRUE(-1 == info.iExitCode);
+ ASSERT_TRUE(RMobileCall::EDirectionUnknown == info.iRemoteParty.iDirection);
+ ASSERT_TRUE(RMobileCall::EStatusIdle == info.iStatus);
+ ASSERT_TRUE(0 == info.iCallName.Compare(aCallName));
+ }
+ ASSERT_TRUE((RMobileCall::KCallStartTime |
+ RMobileCall::KCallDuration |
+ RMobileCall::KCallId |
+ RMobileCall::KCallExitCode |
+ RMobileCall::KCallEmergency) == info.iValid);
+
+
+
+ ASSERT_TRUE(0 == info.iEmergency);
+ ASSERT_TRUE(0 == info.iForwarded);
+ ASSERT_TRUE(RMobilePhone::EPrivacyUnspecified == info.iPrivacy);
+ ASSERT_TRUE(RMobilePhone::EAlternatingModeUnspecified == info.iAlternatingCall);
+ ASSERT_TRUE(RMobileCall::ETchUnknown == info.iTch);
+ ASSERT_TRUE(RMobileCall::ERemoteIdentityUnknown == info.iRemoteParty.iRemoteIdStatus);
+ ASSERT_TRUE(0 == info.iRemoteParty.iCallingName.Compare(KEmpty));
+ ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTelNumber.Size());
+ ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTypeOfNumber);
+ ASSERT_TRUE(RMobilePhone::EUnknownNumber == info.iDialledParty.iTypeOfNumber);
+ ASSERT_TRUE(RMobilePhone::EUnknownNumberingPlan == info.iDialledParty.iNumberPlan);
+ ASSERT_TRUE(0 == info.iDialledParty.iTelNumber.Compare(KEmpty));
+ ASSERT_TRUE(0 == memcmp( &info.iStartTime, &KZeroTime, sizeof(KZeroTime)));
+ ASSERT_TRUE(0 == info.iLineName.Compare(aLineName));
+ }
+
+ if ( (KETelExtMultimodeV3 == extensionId) ||
+ (KEtelExtMultimodeV7 == extensionId) ||
+ (KEtelExtMultimodeV8 == extensionId) )
+ {
+
+ RMobileCall::TMobileCallInfoV3Pckg* paramsPckgV3 =
+ reinterpret_cast<RMobileCall::TMobileCallInfoV3Pckg*>(aCallInfo );
+ RMobileCall::TMobileCallInfoV3& info = ( *paramsPckgV3 )();
+
+ ASSERT_TRUE(RMobilePhone::ECipheringOff == info.iSecurity);
+ }
+
+ if ( (KEtelExtMultimodeV7 == extensionId) ||
+ (KEtelExtMultimodeV8 == extensionId) )
+ {
+
+ RMobileCall::TMobileCallInfoV7Pckg* paramsPckgV7 =
+ reinterpret_cast<RMobileCall::TMobileCallInfoV7Pckg*>(aCallInfo );
+ RMobileCall::TMobileCallInfoV7& info = ( *paramsPckgV7 )();
+
+ ASSERT_TRUE(RMobileCall::EOriginatorUnknown == info.iCallParamOrigin);
+ ASSERT_TRUE(RMobileCall::EIconQualifierNotSet == info.iIconId.iQualifier);
+ ASSERT_TRUE(0 == info.iIconId.iIdentifier);
+ ASSERT_TRUE(info.iAlphaId.Length() == 0);
+ ASSERT_TRUE(EFalse == info.iParamsCallControlModified);
+
+ }
+
+ if (KEtelExtMultimodeV8 == extensionId )
+ {
+
+ RMobileCall::TMobileCallInfoV8Pckg* paramsPckgV8 =
+ reinterpret_cast<RMobileCall::TMobileCallInfoV8Pckg*>(aCallInfo );
+ RMobileCall::TMobileCallInfoV8& info = ( *paramsPckgV8 )();
+
+ ASSERT_TRUE(0 == info.iSubAddress.Length());
+ ASSERT_TRUE(0 == info.iBearerCap1.Length());
+ ASSERT_TRUE(0 == info.iBearerCap2.Length());
+ ASSERT_EQUALS(RMobileCall::EBCAlternateMode,info.iBCRepeatIndicator);
+
+ }
+
+ }
+
+void CCTsyCallInformationFU::ValidateCallParams(const TDesC8* aCallParams, TBool aCallFlagActive)
+ {
+
+
+ //use base class to determine callparam version
+ RCall::TCallParamsPckg* callParamsPckg =
+ reinterpret_cast<RCall::TCallParamsPckg*>(const_cast<TDesC8*>( aCallParams ) );
+
+ RCall::TCallParams& callParams = ( *callParamsPckg )();
+
+ // get extensionid
+ TInt extensionId( callParams.ExtensionId() );
+ _LIT( KStringAlphaId, "Alpha Id" );
+
+ if ( (RMobileCall::KETelMobileCallParamsV1 == extensionId) ||
+ (RMobileCall::KETelMobileCallParamsV2 == extensionId) ||
+ (RMobileCall::KETelMobileCallParamsV7 == extensionId))
+ {
+
+ RMobileCall::TMobileCallParamsV1Pckg* paramsPckgV1 =
+ reinterpret_cast<RMobileCall::TMobileCallParamsV1Pckg*>(
+ const_cast<TDesC8*>( aCallParams ) );
+ RMobileCall::TMobileCallParamsV1& callParams1 = (*paramsPckgV1)();
+
+ if(aCallFlagActive)
+ {
+ ASSERT_EQUALS(RCall::EMonitorSpeakerControlAlwaysOff, callParams1.iSpeakerControl);
+ ASSERT_EQUALS(RCall::EMonitorSpeakerVolumeMedium, callParams1.iSpeakerVolume);
+ ASSERT_TRUE(2 == callParams1.iInterval);
+ ASSERT_EQUALS(RCall::EDialToneWait, callParams1.iWaitForDialTone);
+ ASSERT_EQUALS(RMobileCall::EIdRestrictDefault, callParams1.iIdRestrict);
+ ASSERT_TRUE(EFalse == callParams1.iCug.iExplicitInvoke);
+ ASSERT_TRUE(0 == callParams1.iCug.iCugIndex);
+ ASSERT_TRUE(EFalse == callParams1.iCug.iSuppressOA);
+ ASSERT_TRUE(EFalse == callParams1.iCug.iSuppressPrefCug);
+ ASSERT_TRUE(EFalse == callParams1.iAutoRedial);
+ }
+ else
+ {
+ ASSERT_EQUALS(RCall::EMonitorSpeakerControlOnUntilCarrier, callParams1.iSpeakerControl);
+ ASSERT_EQUALS(RCall::EMonitorSpeakerVolumeLow, callParams1.iSpeakerVolume);
+ ASSERT_TRUE(4 == callParams1.iInterval);
+ ASSERT_EQUALS(RCall::EDialToneWait, callParams1.iWaitForDialTone);
+ ASSERT_EQUALS(RMobileCall::EIdRestrictDefault, callParams1.iIdRestrict);
+ ASSERT_TRUE(EFalse == callParams1.iCug.iExplicitInvoke);
+ ASSERT_TRUE(0 == callParams1.iCug.iCugIndex);
+ ASSERT_TRUE(EFalse == callParams1.iCug.iSuppressOA);
+ ASSERT_TRUE(EFalse == callParams1.iCug.iSuppressPrefCug);
+ ASSERT_TRUE(EFalse == callParams1.iAutoRedial);
+ }
+
+ }
+
+ if ((RMobileCall::KETelMobileCallParamsV2 == extensionId) ||
+ (RMobileCall::KETelMobileCallParamsV7 == extensionId))
+ {
+ RMobileCall::TMobileCallParamsV2Pckg* paramsPckgV2 =
+ reinterpret_cast<RMobileCall::TMobileCallParamsV2Pckg*>(
+ const_cast<TDesC8*>( aCallParams ) );
+ RMobileCall::TMobileCallParamsV2& callParams2 = (*paramsPckgV2)();
+ if(aCallFlagActive)
+ {
+ ASSERT_EQUALS(RMobileCall::EMulticallNotSupported, callParams2.iBearerMode );
+ }
+ else
+ {
+ ASSERT_EQUALS(RMobileCall::EMulticallNotSupported, callParams2.iBearerMode );
+ }
+ }
+
+ if ((RMobileCall::KETelMobileCallParamsV7 == extensionId))
+ {
+ RMobileCall::TMobileCallParamsV7Pckg* paramsPckgV7 =
+ reinterpret_cast<RMobileCall::TMobileCallParamsV7Pckg*>(
+ const_cast<TDesC8*>( aCallParams ) );
+ RMobileCall::TMobileCallParamsV7& callParams7 = (*paramsPckgV7)();
+ if(aCallFlagActive)
+ {
+ ASSERT_EQUALS(RMobileCall::EOriginatorUnknown, callParams7.iCallParamOrigin);
+ ASSERT_TRUE(0 == callParams7.iSubAddress.Length());
+ ASSERT_TRUE(0 == callParams7.iBearerCap1.Length());
+ ASSERT_TRUE(0 == callParams7.iBearerCap2.Length());
+ ASSERT_EQUALS(RMobileCall::EBCAlternateMode,callParams7.iBCRepeatIndicator);
+ ASSERT_TRUE(RMobileCall::EIconQualifierNotSet == callParams7.iIconId.iQualifier);
+ ASSERT_TRUE(0 == callParams7.iIconId.iIdentifier);
+ ASSERT_TRUE(0 == callParams7.iAlphaId.Compare(KStringAlphaId));
+ }
+ else
+ {
+ ASSERT_EQUALS(RMobileCall::EOriginatorUnknown, callParams7.iCallParamOrigin);
+ ASSERT_TRUE(0 == callParams7.iSubAddress.Length());
+ ASSERT_TRUE(0 == callParams7.iBearerCap1.Length());
+ ASSERT_TRUE(0 == callParams7.iBearerCap2.Length());
+ ASSERT_EQUALS(RMobileCall::EBCAlternateMode,callParams7.iBCRepeatIndicator);
+ ASSERT_TRUE(RMobileCall::EIconQualifierNotSet == callParams7.iIconId.iQualifier);
+ ASSERT_TRUE(0 == callParams7.iIconId.iIdentifier);
+ ASSERT_TRUE(0 == callParams7.iAlphaId.Length());
+ }
+
+ }
+
+ }
+
+
+void CCTsyCallInformationFU::ValidateDataCallParams(const TDesC8* aCallParams, TBool aDataCallFlagActive)
+ {
+
+ //use base class to determine datacallparam version
+ RMobileCall::TMobileDataCallParamsV1Pckg* paramsPckgV1 =
+ reinterpret_cast<RMobileCall::TMobileDataCallParamsV1Pckg*>(
+ const_cast<TDesC8*>( aCallParams ) );
+
+ RMobileCall::TMobileDataCallParamsV1& dataParams = (*paramsPckgV1)();
+
+ // get extensionid
+ TInt extensionId( dataParams.ExtensionId() );
+ _LIT( KStringSubAddress, "An Unknown SubAddress");
+ _LIT( KStringAlphaId, "Alpha Id" );
+
+ if ( (RMobileCall::KETelMobileDataCallParamsV1 == extensionId) ||
+ (RMobileCall::KETelMobileDataCallParamsV2 == extensionId) ||
+ (RMobileCall::KETelMobileDataCallParamsV8 == extensionId))
+ {
+
+ if(aDataCallFlagActive)
+ {
+ ASSERT_EQUALS(RCall::EMonitorSpeakerControlAlwaysOff, dataParams.iSpeakerControl);
+ ASSERT_EQUALS(RCall::EMonitorSpeakerVolumeMedium, dataParams.iSpeakerVolume);
+ ASSERT_TRUE(2 == dataParams.iInterval);
+ ASSERT_EQUALS(RCall::EDialToneWait, dataParams.iWaitForDialTone);
+ ASSERT_EQUALS(RMobileCall::EIdRestrictDefault, dataParams.iIdRestrict);
+ ASSERT_TRUE(EFalse == dataParams.iCug.iExplicitInvoke);
+ ASSERT_TRUE(0xFFFF == dataParams.iCug.iCugIndex);
+ ASSERT_TRUE(EFalse == dataParams.iCug.iSuppressOA);
+ ASSERT_TRUE(EFalse == dataParams.iCug.iSuppressPrefCug);
+ ASSERT_TRUE(EFalse == dataParams.iAutoRedial);
+ ASSERT_EQUALS(RMobileCall::EServiceDataCircuitAsync, dataParams.iService);
+ ASSERT_EQUALS(RMobileCall::ESpeedUnspecified, dataParams.iSpeed);
+ ASSERT_EQUALS(RMobileCall::EProtocolUnspecified, dataParams.iProtocol);
+ ASSERT_EQUALS(RMobileCall::EQosTransparentPreferred, dataParams.iQoS);
+ ASSERT_EQUALS(RMobileCall::ERLPNotRequested, dataParams.iRLPVersion);
+ ASSERT_EQUALS(RMobileCall::EV42bisTxDirection, dataParams.iV42bisReq);
+ ASSERT_TRUE(0 == dataParams.iModemToMSWindowSize);
+ ASSERT_TRUE(0 == dataParams.iMSToModemWindowSize);
+ ASSERT_TRUE(0 == dataParams.iAckTimer);
+ ASSERT_TRUE(0 == dataParams.iRetransmissionAttempts);
+ ASSERT_TRUE(0 == dataParams.iResequencingPeriod);
+ ASSERT_TRUE(0 == dataParams.iV42bisCodewordsNum);
+ ASSERT_TRUE(0 == dataParams.iV42bisMaxStringLength);
+ ASSERT_TRUE(EFalse == dataParams.iUseEdge);
+ }
+ else
+ {
+ ASSERT_EQUALS(RCall::EMonitorSpeakerControlOnUntilCarrier, dataParams.iSpeakerControl);
+ ASSERT_EQUALS(RCall::EMonitorSpeakerVolumeLow, dataParams.iSpeakerVolume);
+ ASSERT_TRUE(4 == dataParams.iInterval);
+ ASSERT_EQUALS(RCall::EDialToneWait, dataParams.iWaitForDialTone);
+ ASSERT_EQUALS(RMobileCall::EIdRestrictDefault, dataParams.iIdRestrict);
+ ASSERT_TRUE(EFalse == dataParams.iCug.iExplicitInvoke);
+ ASSERT_TRUE(0 == dataParams.iCug.iCugIndex);
+ ASSERT_TRUE(EFalse == dataParams.iCug.iSuppressOA);
+ ASSERT_TRUE(EFalse == dataParams.iCug.iSuppressPrefCug);
+ ASSERT_TRUE(EFalse == dataParams.iAutoRedial);
+
+ ASSERT_EQUALS(RMobileCall::EServiceDataCircuitAsync, dataParams.iService);
+ ASSERT_EQUALS(RMobileCall::ESpeedUnspecified, dataParams.iSpeed);
+ ASSERT_EQUALS(RMobileCall::EProtocolUnspecified, dataParams.iProtocol);
+ ASSERT_EQUALS(RMobileCall::EQoSNonTransparent, dataParams.iQoS);
+ ASSERT_EQUALS(RMobileCall::ERLPNotRequested, dataParams.iRLPVersion);
+ ASSERT_EQUALS(RMobileCall::EV42bisNeitherDirection, dataParams.iV42bisReq);
+ ASSERT_TRUE(0 == dataParams.iModemToMSWindowSize);
+ ASSERT_TRUE(0 == dataParams.iMSToModemWindowSize);
+ ASSERT_TRUE(0 == dataParams.iAckTimer);
+ ASSERT_TRUE(0 == dataParams.iRetransmissionAttempts);
+ ASSERT_TRUE(0 == dataParams.iResequencingPeriod);
+ ASSERT_TRUE(0 == dataParams.iV42bisCodewordsNum);
+ ASSERT_TRUE(0 == dataParams.iV42bisMaxStringLength);
+ ASSERT_TRUE(EFalse == dataParams.iUseEdge);
+ }
+
+ }
+
+ if ((RMobileCall::KETelMobileDataCallParamsV2 == extensionId) ||
+ (RMobileCall::KETelMobileDataCallParamsV8 == extensionId))
+ {
+ RMobileCall::TMobileDataCallParamsV2Pckg* dataParamsPckgV2 =
+ reinterpret_cast<RMobileCall::TMobileDataCallParamsV2Pckg*>(
+ const_cast<TDesC8*>( aCallParams ) );
+ RMobileCall::TMobileDataCallParamsV2& dataCallParams2 = (*dataParamsPckgV2)();
+ if(aDataCallFlagActive)
+ {
+ ASSERT_EQUALS(RMobileCall::EMulticallShareBearer, dataCallParams2.iBearerMode );
+ }
+ else
+ {
+ ASSERT_EQUALS(RMobileCall::EMulticallNotSupported, dataCallParams2.iBearerMode );
+ }
+ }
+
+ if ((RMobileCall::KETelMobileDataCallParamsV8 == extensionId))
+ {
+ RMobileCall::TMobileDataCallParamsV8Pckg* dataParamsPckgV8 =
+ reinterpret_cast<RMobileCall::TMobileDataCallParamsV8Pckg*>(
+ const_cast<TDesC8*>( aCallParams ) );
+ RMobileCall::TMobileDataCallParamsV8& dataCallParams8 = (*dataParamsPckgV8)();
+
+ if(aDataCallFlagActive)
+ {
+ ASSERT_EQUALS(RMobileCall::EOriginatorSIM, dataCallParams8.iCallParamOrigin);
+ ASSERT_TRUE(0 == dataCallParams8.iSubAddress.Compare(KStringSubAddress));
+ ASSERT_TRUE(0 == dataCallParams8.iBearerCap1.Length());
+ ASSERT_TRUE(0 == dataCallParams8.iBearerCap2.Length());
+ ASSERT_EQUALS(RMobileCall::EBCAlternateMode,dataCallParams8.iBCRepeatIndicator);
+ ASSERT_TRUE(0 == dataCallParams8.iAlphaId.Compare(KStringAlphaId))
+ }
+ else
+ {
+ ASSERT_EQUALS(RMobileCall::EOriginatorUnknown, dataCallParams8.iCallParamOrigin);
+ ASSERT_TRUE(0 == dataCallParams8.iSubAddress.Length());
+ ASSERT_TRUE(0 == dataCallParams8.iBearerCap1.Length());
+ ASSERT_TRUE(0 == dataCallParams8.iBearerCap2.Length());
+ ASSERT_EQUALS(RMobileCall::EBCAlternateMode,dataCallParams8.iBCRepeatIndicator);
+ ASSERT_TRUE(0 == dataCallParams8.iAlphaId.Length())
+ }
+
+ }
+
+ }
+
+
+void CCTsyCallInformationFU::ValidateHscsdCallParams(const TDesC8* aCallParams, TBool aHscsdCallFlagActive)
+ {
+ //use base class to determine hscsdcallparam version
+ RMobileCall::TMobileHscsdCallParamsV1Pckg* paramsPckgV1 =
+ reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV1Pckg*>(
+ const_cast<TDesC8*>( aCallParams ) );
+
+ RMobileCall::TMobileHscsdCallParamsV1& hscsdParams = (*paramsPckgV1)();
+
+ // get extensionid
+ TInt extensionId( hscsdParams.ExtensionId() );
+ _LIT( KStringAlphaId, "Alpha Id" );
+ _LIT( KStringSubAddress, "An Unknown SubAddress");
+
+ if ( (RMobileCall::KETelMobileHscsdCallParamsV1 == extensionId) ||
+ (RMobileCall::KETelMobileHscsdCallParamsV2 == extensionId) ||
+ (RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId) ||
+ (RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId))
+ {
+
+ if(aHscsdCallFlagActive)
+ {
+ ASSERT_EQUALS(RCall::EMonitorSpeakerControlAlwaysOff, hscsdParams.iSpeakerControl);
+ ASSERT_EQUALS(RCall::EMonitorSpeakerVolumeMedium, hscsdParams.iSpeakerVolume);
+ ASSERT_TRUE(2 == hscsdParams.iInterval);
+ ASSERT_EQUALS(RCall::EDialToneWait, hscsdParams.iWaitForDialTone);
+ ASSERT_EQUALS(RMobileCall::EIdRestrictDefault, hscsdParams.iIdRestrict);
+ ASSERT_TRUE(EFalse == hscsdParams.iCug.iExplicitInvoke);
+ ASSERT_TRUE(0xFFFF == hscsdParams.iCug.iCugIndex);
+ ASSERT_TRUE(EFalse == hscsdParams.iCug.iSuppressOA);
+ ASSERT_TRUE(EFalse == hscsdParams.iCug.iSuppressPrefCug);
+ ASSERT_TRUE(EFalse == hscsdParams.iAutoRedial);
+ ASSERT_EQUALS(RMobileCall::EServiceDataCircuitAsync, hscsdParams.iService);
+ ASSERT_EQUALS(RMobileCall::ESpeedUnspecified, hscsdParams.iSpeed);
+ ASSERT_EQUALS(RMobileCall::EProtocolUnspecified, hscsdParams.iProtocol);
+ ASSERT_EQUALS(RMobileCall::EQosTransparentPreferred, hscsdParams.iQoS);
+ ASSERT_EQUALS(RMobileCall::ERLPNotRequested, hscsdParams.iRLPVersion);
+ ASSERT_EQUALS(RMobileCall::EV42bisTxDirection, hscsdParams.iV42bisReq);
+ ASSERT_TRUE(0 == hscsdParams.iModemToMSWindowSize);
+ ASSERT_TRUE(0 == hscsdParams.iMSToModemWindowSize);
+ ASSERT_TRUE(0 == hscsdParams.iAckTimer);
+ ASSERT_TRUE(0 == hscsdParams.iRetransmissionAttempts);
+ ASSERT_TRUE(0 == hscsdParams.iResequencingPeriod);
+ ASSERT_TRUE(0 == hscsdParams.iV42bisCodewordsNum);
+ ASSERT_TRUE(0 == hscsdParams.iV42bisMaxStringLength);
+ ASSERT_TRUE(EFalse == hscsdParams.iUseEdge);
+
+ ASSERT_TRUE(RMobileCall::EAiurBpsUnspecified == hscsdParams.iWantedAiur);
+ ASSERT_TRUE(RMobileCall::EAsymmetryNoPreference == hscsdParams.iAsymmetry);
+ ASSERT_TRUE(2 == hscsdParams.iWantedRxTimeSlots);
+ ASSERT_TRUE(3 == hscsdParams.iCodings);
+ ASSERT_TRUE(EFalse == hscsdParams.iUserInitUpgrade);
+
+ }
+ else
+ {
+ ASSERT_EQUALS(RCall::EMonitorSpeakerControlOnUntilCarrier, hscsdParams.iSpeakerControl);
+ ASSERT_EQUALS(RCall::EMonitorSpeakerVolumeLow, hscsdParams.iSpeakerVolume);
+ ASSERT_TRUE(4 == hscsdParams.iInterval);
+ ASSERT_EQUALS(RCall::EDialToneWait, hscsdParams.iWaitForDialTone);
+ ASSERT_EQUALS(RMobileCall::EIdRestrictDefault, hscsdParams.iIdRestrict);
+ ASSERT_TRUE(EFalse == hscsdParams.iCug.iExplicitInvoke);
+ ASSERT_TRUE(0 == hscsdParams.iCug.iCugIndex);
+ ASSERT_TRUE(EFalse == hscsdParams.iCug.iSuppressOA);
+ ASSERT_TRUE(EFalse == hscsdParams.iCug.iSuppressPrefCug);
+ ASSERT_TRUE(EFalse == hscsdParams.iAutoRedial);
+
+ ASSERT_EQUALS(RMobileCall::EServiceDataCircuitAsync, hscsdParams.iService);
+ ASSERT_EQUALS(RMobileCall::ESpeedUnspecified, hscsdParams.iSpeed);
+ ASSERT_EQUALS(RMobileCall::EProtocolUnspecified, hscsdParams.iProtocol);
+ ASSERT_EQUALS(RMobileCall::EQoSNonTransparent, hscsdParams.iQoS);
+ ASSERT_EQUALS(RMobileCall::ERLPNotRequested, hscsdParams.iRLPVersion);
+ ASSERT_EQUALS(RMobileCall::EV42bisNeitherDirection, hscsdParams.iV42bisReq);
+ ASSERT_TRUE(0 == hscsdParams.iModemToMSWindowSize);
+ ASSERT_TRUE(0 == hscsdParams.iMSToModemWindowSize);
+ ASSERT_TRUE(0 == hscsdParams.iAckTimer);
+ ASSERT_TRUE(0 == hscsdParams.iRetransmissionAttempts);
+ ASSERT_TRUE(0 == hscsdParams.iResequencingPeriod);
+ ASSERT_TRUE(0 == hscsdParams.iV42bisCodewordsNum);
+ ASSERT_TRUE(0 == hscsdParams.iV42bisMaxStringLength);
+ ASSERT_TRUE(EFalse == hscsdParams.iUseEdge);
+
+ ASSERT_TRUE(RMobileCall::EAiurBpsUnspecified == hscsdParams.iWantedAiur);
+ ASSERT_TRUE(RMobileCall::EAsymmetryNoPreference == hscsdParams.iAsymmetry);
+ ASSERT_TRUE(0 == hscsdParams.iWantedRxTimeSlots);
+ ASSERT_TRUE(0 == hscsdParams.iCodings);
+ ASSERT_TRUE(EFalse == hscsdParams.iUserInitUpgrade);
+ }
+
+ }
+
+ if ((RMobileCall::KETelMobileHscsdCallParamsV2 == extensionId) ||
+ (RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId) ||
+ (RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId))
+ {
+ RMobileCall::TMobileHscsdCallParamsV2Pckg* paramsPckgV2 =
+ reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV2Pckg*>(
+ const_cast<TDesC8*>( aCallParams ) );
+
+ RMobileCall::TMobileHscsdCallParamsV2& hscsdParams2 = (*paramsPckgV2)();
+
+ if(aHscsdCallFlagActive)
+ {
+ ASSERT_EQUALS(RMobileCall::EMulticallShareBearer, hscsdParams2.iBearerMode );
+ }
+ else
+ {
+ ASSERT_EQUALS(RMobileCall::EMulticallNotSupported, hscsdParams2.iBearerMode );
+ }
+ }
+
+ if ((RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId)||
+ (RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId))
+ {
+ RMobileCall::TMobileHscsdCallParamsV7Pckg* hscsdParamsPckgV7 =
+ reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV7Pckg*>(
+ const_cast<TDesC8*>( aCallParams ) );
+ RMobileCall::TMobileHscsdCallParamsV7& hscsdParams7 = (*hscsdParamsPckgV7)();
+
+ if(aHscsdCallFlagActive)
+ {
+ ASSERT_EQUALS(RMobileCall::EOriginatorSIM, hscsdParams7.iCallParamOrigin);
+ ASSERT_TRUE(RMobileCall::EIconQualifierNotSet == hscsdParams7.iIconId.iQualifier);
+ ASSERT_TRUE(0 == hscsdParams7.iIconId.iIdentifier);
+ ASSERT_TRUE(0 == hscsdParams7.iAlphaId.Compare(KStringAlphaId));
+ }
+ else
+ {
+ ASSERT_EQUALS(RMobileCall::EOriginatorUnknown, hscsdParams7.iCallParamOrigin);
+ ASSERT_TRUE(RMobileCall::EIconQualifierNotSet == hscsdParams7.iIconId.iQualifier);
+ ASSERT_TRUE(0 == hscsdParams7.iIconId.iIdentifier);
+ ASSERT_TRUE(0 == hscsdParams7.iAlphaId.Length());
+ }
+ }
+
+ if (RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId)
+ {
+ RMobileCall::TMobileHscsdCallParamsV8Pckg* hscsdParamsPckgV8 =
+ reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV8Pckg*>(
+ const_cast<TDesC8*>( aCallParams ) );
+ RMobileCall::TMobileHscsdCallParamsV8& hscsdParams8 = (*hscsdParamsPckgV8)();
+
+ if(aHscsdCallFlagActive)
+ {
+ ASSERT_TRUE(0 == hscsdParams8.iSubAddress.Compare(KStringSubAddress));
+ ASSERT_TRUE(0 == hscsdParams8.iBearerCap1.Length());
+ ASSERT_TRUE(0 == hscsdParams8.iBearerCap2.Length());
+ ASSERT_EQUALS(RMobileCall::EBCAlternateMode,hscsdParams8.iBCRepeatIndicator);
+ }
+ else
+ {
+ ASSERT_TRUE(0 == hscsdParams8.iSubAddress.Length());
+ ASSERT_TRUE(0 == hscsdParams8.iBearerCap1.Length());
+ ASSERT_TRUE(0 == hscsdParams8.iBearerCap2.Length());
+ ASSERT_EQUALS(RMobileCall::EBCAlternateMode,hscsdParams8.iBCRepeatIndicator);
+ }
+
+ }
+
+ }
+
+
+
+
+
+
+