--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/common_tsy/test/component/src/cctsydatacallcontrolfu.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,3475 @@
+// 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 DataCallControl in the Common TSY.
+//
+//
+
+/**
+ @file
+*/
+
+#include "cctsydatacallcontrolfu.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 "MmTsy_Csd_Defs.h"
+#include <featmgr/featurecontrol.h>
+#include <featureuids.h>
+
+CTestSuite* CCTsyDataCallControlFU::CreateSuiteL(const TDesC& aName)
+ {
+ SUB_SUITE;
+
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetBearerServiceInfo0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetBearerServiceInfo0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetBearerServiceInfo0011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0012L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0013L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestConnect0014L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetCurrentHscsdInfo0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetCurrentHscsdInfo0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetCurrentHscsdInfo0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetCurrentHscsdInfo0011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyVoiceFallback0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyVoiceFallback0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyVoiceFallback00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallCaps0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallCaps0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallCaps0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallCaps00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyHscsdInfoChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyHscsdInfoChange0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyHscsdInfoChange0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyHscsdInfoChange0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyHscsdInfoChange0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyHscsdInfoChange00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestSetDynamicHscsdParams0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestSetDynamicHscsdParams0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestSetDynamicHscsdParams0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestSetDynamicHscsdParams0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestSetDynamicHscsdParams00010L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestSetDynamicHscsdParams00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallRLPRange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallRLPRange0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestGetMobileDataCallRLPRange00011L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyMobileDataCallCapsChange0001L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyMobileDataCallCapsChange0006L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyMobileDataCallCapsChange0007L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyMobileDataCallCapsChange0008L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyMobileDataCallCapsChange0009L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyDataCallControlFU, TestNotifyMobileDataCallCapsChange00011L);
+
+ END_SUITE;
+ }
+
+
+//
+// Actual test cases
+//
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGBSI-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetBearerServiceInfo for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetBearerServiceInfo for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetBearerServiceInfo0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RCall::GetBearerServiceInfo is not supported for voice calls
+ //-------------------------------------------------------------------------
+
+ RCall call;
+ RLine line;
+ OpenLineLC(line, KMmTsyVoice1LineName);
+ OpenNewCallLC(line, call);
+ DialL(call, 1, RMobilePhone::EVoiceService);
+ RCall::TBearerService bearerService;
+ TInt res = call.GetBearerServiceInfo(bearerService);
+ ASSERT_EQUALS(KErrNotSupported, res)
+ AssertMockLtsyStatusL();
+
+ // same test for voice call from auxiliary voice line
+ RCall call2;
+ RLine line2;
+ OpenLineLC(line2, KMmTsyVoice2LineName);
+ OpenNewCallLC(line2, call2);
+ DialL(call2, 2, RMobilePhone::EAuxVoiceService);
+ res = call2.GetBearerServiceInfo(bearerService);
+ ASSERT_EQUALS(KErrNotSupported, res)
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(5, this); // call2, line2, call, line, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGBSI-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetBearerServiceInfo for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetBearerServiceInfo for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetBearerServiceInfo0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RLine line;
+ RCall call;
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // when call is not active
+ //-------------------------------------------------------------------------
+
+ RCall::TBearerService bearerService;
+ TInt res = call.GetBearerServiceInfo(bearerService);
+ ASSERT_EQUALS(KErrNotFound, res);
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RCall::GetBearerServiceInfo.
+ //-------------------------------------------------------------------------
+
+ DialL(call, 1, RMobilePhone::ECircuitDataService);
+ ChangeCallStatusL(1, RMobilePhone::ECircuitDataService, RMobileCall::EStatusConnected);
+
+ res = call.GetBearerServiceInfo(bearerService);
+ ASSERT_EQUALS(KErrNone, res)
+ ASSERT_EQUALS((TUint32) (RCall::KBearerCapsCompressionNone | RCall::KBearerCapsProtocolUnknown), bearerService.iBearerCaps)
+ ASSERT_EQUALS(RCall::EBearerDataUnknown, bearerService.iBearerSpeed)
+ AssertMockLtsyStatusL();
+
+ // change data in CTSY
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+ RCall::TBearerService changeBearerService;
+ changeBearerService.iBearerCaps = RCall::KBearerCapsProtocolALT_CELLULAR;
+ changeBearerService.iBearerSpeed = RCall::EBearerData57600;
+
+ TMockLtsyCallData1<RCall::TBearerService> mockBearerData(1, mobileService, changeBearerService);
+ data.Close();
+ mockBearerData.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelCallGetBearerServiceInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ // test again
+ res = call.GetBearerServiceInfo(bearerService);
+ ASSERT_EQUALS(KErrNone, res);
+ ASSERT_EQUALS((TUint32) (RCall::KBearerCapsProtocolALT_CELLULAR), bearerService.iBearerCaps)
+ ASSERT_EQUALS(RCall::EBearerData57600, bearerService.iBearerSpeed)
+ AssertMockLtsyStatusL();
+
+ ChangeCallStatusL(1, RMobilePhone::ECircuitDataService, RMobileCall::EStatusIdle, KErrGsmReleaseByUser);
+
+ CleanupStack::PopAndDestroy(4, this); // call, line, data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGBSI-0011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::GetBearerServiceInfo for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::GetBearerServiceInfo for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetBearerServiceInfo0011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RLine line;
+ RCall call;
+ OpenLineLC(line, KMmTsyFaxLineName);
+ OpenNewCallLC(line, call);
+
+ RCall::TBearerService bearerService;
+ TInt res = call.GetBearerServiceInfo(bearerService);
+ ASSERT_EQUALS(KErrNotFound, res);
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(&call);
+
+ TName name;
+ RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
+ CreateIncomingCallL(line, 1, KNullDesC, name, mobileService, RMobileCall::EStatusConnected);
+ res = call.OpenExistingCall(line, name);
+ ASSERT_EQUALS(KErrNone, res);
+ CleanupClosePushL(call);
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RCall::GetBearerServiceInfo.
+ //-------------------------------------------------------------------------
+
+ res = call.GetBearerServiceInfo(bearerService);
+ ASSERT_EQUALS(KErrNone, res)
+ ASSERT_EQUALS((TUint32) (RCall::KBearerCapsCompressionNone | RCall::KBearerCapsProtocolUnknown), bearerService.iBearerCaps)
+ ASSERT_EQUALS(RCall::EBearerDataUnknown, bearerService.iBearerSpeed)
+ AssertMockLtsyStatusL();
+
+ // change data in CTSY
+ RCall::TBearerService changeBearerService;
+ changeBearerService.iBearerCaps = RCall::KBearerCapsProtocolALT_CELLULAR;
+ changeBearerService.iBearerSpeed = RCall::EBearerData57600;
+
+ TMockLtsyCallData1<RCall::TBearerService> mockBearerData(1, mobileService, changeBearerService);
+ data.Close();
+ mockBearerData.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EEtelCallGetBearerServiceInfo, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+ AssertMockLtsyStatusL();
+
+ // test again
+ res = call.GetBearerServiceInfo(bearerService);
+ ASSERT_EQUALS(KErrNone, res);
+ ASSERT_EQUALS((TUint32) (RCall::KBearerCapsProtocolALT_CELLULAR), bearerService.iBearerCaps)
+ ASSERT_EQUALS(RCall::EBearerData57600, bearerService.iBearerSpeed)
+ AssertMockLtsyStatusL();
+
+ // Fax call is not in idle state while closing the call object.
+ // Therefore CTSY sends HangUp request to LTSY.
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ TInt hangUpCause = KErrGsmReleaseByUser;
+ TBool autoStChangeDisable = EFalse;
+ TMockLtsyCallData2<TInt, TBool> mockData2(1, RMobilePhone::EFaxService, hangUpCause, autoStChangeDisable);
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData);
+
+ TMockLtsyCallData0 mockData0(1, RMobilePhone::EFaxService);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData);
+
+ call.Close();
+ User::WaitForRequest(mockLtsyStatus);
+ CleanupStack::Pop(&call);
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // when call is not active
+ //-------------------------------------------------------------------------
+
+ OpenNewCallLC(line, call);
+
+ res = call.GetBearerServiceInfo(bearerService);
+ ASSERT_EQUALS(KErrNotFound, res);
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(6, this); // data, expectData, completeData, call, line, this
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::Connect for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::Connect for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestConnect0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RCall call;
+ OpenLineLC(line, KMmTsyVoice1LineName);
+ OpenNewCallLC(line, call);
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RCall::Connect is not supported for voice calls
+ //-------------------------------------------------------------------------
+
+ // synchronous version
+ TInt res = call.Connect();
+ ASSERT_EQUALS(KErrNotSupported, res)
+
+ // synchronous version with parameters
+ RCall::TCallParams callParams;
+ RCall::TCallParamsPckg callParamsPckg(callParams);
+ res = call.Connect(callParamsPckg);
+ ASSERT_EQUALS(KErrNotSupported, res)
+
+ // asynchronous version
+ TRequestStatus reqStatus;
+ call.Connect(reqStatus);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ // asynchronous version with parameters
+ call.Connect(reqStatus, callParamsPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(2); // call, line
+
+ // same test for voice call from auxiliary voice line
+ OpenLineLC(line, KMmTsyVoice2LineName);
+ OpenNewCallLC(line, call);
+
+ // synchronous version
+ res = call.Connect();
+ ASSERT_EQUALS(KErrNotSupported, res)
+
+ // synchronous version with parameters
+ res = call.Connect(callParamsPckg);
+ ASSERT_EQUALS(KErrNotSupported, res)
+
+ // asynchronous version
+ call.Connect(reqStatus);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ // asynchronous version with parameters
+ call.Connect(reqStatus, callParamsPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::Connect for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::Connect for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestConnect0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RCall call;
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RCall::Connect.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus reqStatus;
+
+ // synchronous version with no parameters
+ TInt res = call.Connect();
+ ASSERT_EQUALS(KErrNone, res)
+
+ // synchronous version with RCall::TCallParams parameter
+ RCall::TCallParams callParams;
+ callParams.iSpeakerControl = RMobileCall::EMonitorSpeakerControlAlwaysOff;
+ callParams.iSpeakerVolume = RMobileCall::EMonitorSpeakerVolumeOff;
+ callParams.iInterval = 0;
+ callParams.iWaitForDialTone = RMobileCall::EDialToneNoWait;
+ RCall::TCallParamsPckg callParamsPckg(callParams);
+ res = call.Connect(callParamsPckg);
+ ASSERT_EQUALS(KErrNone, res)
+
+ // synchronous version with RMobileCall::TMobileCallParamsV1Pckg parameter
+ RMobileCall::TMobileCallParamsV1 mobileCallParams;
+ mobileCallParams.iSpeakerControl = RMobileCall::EMonitorSpeakerControlAlwaysOn;
+ mobileCallParams.iSpeakerVolume = RMobileCall::EMonitorSpeakerVolumeMedium;
+ mobileCallParams.iInterval = 0;
+ mobileCallParams.iWaitForDialTone = RMobileCall::EDialToneNoWait;
+ mobileCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ mobileCallParams.iCug.iExplicitInvoke = EFalse;
+ mobileCallParams.iCug.iCugIndex = -1;
+ mobileCallParams.iCug.iSuppressOA = EFalse;
+ mobileCallParams.iCug.iSuppressPrefCug = EFalse;
+ mobileCallParams.iAutoRedial = EFalse;
+ RMobileCall::TMobileCallParamsV1Pckg mobileCallParamsPckg(mobileCallParams);
+
+ res = call.Connect(mobileCallParamsPckg);
+ ASSERT_EQUALS(KErrNone, res)
+
+ // synchronous version with RMobileCall::TMobileDataCallParamsV1Pckg parameter
+ RMobileCall::TMobileDataCallParamsV1 dataCallParams;
+ dataCallParams.iSpeakerControl = RMobileCall::EMonitorSpeakerControlAlwaysOn;
+ dataCallParams.iSpeakerVolume = RMobileCall::EMonitorSpeakerVolumeMedium;
+ dataCallParams.iInterval = 0;
+ dataCallParams.iWaitForDialTone = RMobileCall::EDialToneNoWait;
+ dataCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ dataCallParams.iCug.iExplicitInvoke = EFalse;
+ dataCallParams.iCug.iCugIndex = -1;
+ dataCallParams.iCug.iSuppressOA = EFalse;
+ dataCallParams.iCug.iSuppressPrefCug = EFalse;
+ dataCallParams.iAutoRedial = EFalse;
+ dataCallParams.iService = RMobileCall::EServiceDataCircuitAsync;
+ dataCallParams.iSpeed = RMobileCall::ESpeedAutobauding;
+ dataCallParams.iProtocol = RMobileCall::EProtocolV32;
+ dataCallParams.iQoS = RMobileCall::EQoSTransparent;
+ dataCallParams.iRLPVersion = RMobileCall::ERLPNotRequested;
+ dataCallParams.iModemToMSWindowSize = 100;
+ dataCallParams.iMSToModemWindowSize = 100;
+ dataCallParams.iAckTimer = 100;
+ dataCallParams.iRetransmissionAttempts = 3;
+ dataCallParams.iResequencingPeriod = 100;
+ dataCallParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ dataCallParams.iV42bisCodewordsNum = 2;
+ dataCallParams.iV42bisMaxStringLength = 64;
+ dataCallParams.iUseEdge = EFalse;
+ RMobileCall::TMobileDataCallParamsV1Pckg dataCallParamsPckg(dataCallParams);
+
+ res = call.Connect(dataCallParamsPckg);
+ ASSERT_EQUALS(KErrNone, res)
+
+ // asynchronous version with RMobileCall::TMobileHscsdCallParamsV1 parameter
+ RMobileCall::TMobileHscsdCallParamsV1 hscsdCallParams;
+ RMobileCall::TMobileHscsdCallParamsV1Pckg hscsdCallParamsPckg(hscsdCallParams);
+
+ hscsdCallParams.iService = RMobileCall::EServiceDataCircuitAsync;
+ hscsdCallParams.iSpeed = RMobileCall::ESpeedAutobauding;
+ hscsdCallParams.iProtocol = RMobileCall::EProtocolV32;
+ hscsdCallParams.iQoS = RMobileCall::EQoSTransparent;
+ hscsdCallParams.iRLPVersion = RMobileCall::ERLPNotRequested;
+ hscsdCallParams.iModemToMSWindowSize = 100;
+ hscsdCallParams.iMSToModemWindowSize = 100;
+ hscsdCallParams.iAckTimer = 100;
+ hscsdCallParams.iRetransmissionAttempts = 3;
+ hscsdCallParams.iResequencingPeriod = 100;
+ hscsdCallParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ hscsdCallParams.iV42bisCodewordsNum = 2;
+ hscsdCallParams.iV42bisMaxStringLength = 64;
+ hscsdCallParams.iUseEdge = EFalse;
+ hscsdCallParams.iWantedAiur = RMobileCall::EAiurBps19200;
+ hscsdCallParams.iWantedRxTimeSlots = 2;
+ hscsdCallParams.iMaxTimeSlots = 3;
+ hscsdCallParams.iCodings = RMobileCall::KCapsAiurCoding96;
+ hscsdCallParams.iAsymmetry = RMobileCall::EAsymmetryDownlink;
+ hscsdCallParams.iUserInitUpgrade = ETrue;
+
+
+ call.Connect(reqStatus, hscsdCallParamsPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+
+ //-------------------------------------------------------------------------
+ // Test: Test passing RMobileCall::TMobileDataCallParamsV2 to
+ // RCall::Connect
+ //-------------------------------------------------------------------------
+
+ RMobileCall::TMobileDataCallParamsV2 callParams2;
+ RMobileCall::TMobileDataCallParamsV2Pckg callParamsPckg2(callParams2);
+
+ callParams2.iService = RMobileCall::EServiceDataCircuitAsync;
+ callParams2.iSpeed = RMobileCall::ESpeedAutobauding;
+ callParams2.iProtocol = RMobileCall::EProtocolV32;
+ callParams2.iQoS = RMobileCall::EQoSTransparent;
+ callParams2.iRLPVersion = RMobileCall::ERLPNotRequested;
+ callParams2.iModemToMSWindowSize = 100;
+ callParams2.iMSToModemWindowSize = 100;
+ callParams2.iAckTimer = 100;
+ callParams2.iRetransmissionAttempts = 3;
+ callParams2.iResequencingPeriod = 100;
+ callParams2.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ callParams2.iV42bisCodewordsNum = 2;
+ callParams2.iV42bisMaxStringLength = 64;
+ callParams2.iUseEdge = EFalse;
+ callParams2.iBearerMode = RMobileCall::EMulticallNotSupported;
+
+ call.Connect(reqStatus, callParamsPckg2);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ //-------------------------------------------------------------------------
+ // Test: Test passing RMobileCall::TMobileDataCallParamsV8 to
+ // RCall::Connect
+ //-------------------------------------------------------------------------
+
+ RMobileCall::TMobileDataCallParamsV8 callParams8;
+ RMobileCall::TMobileDataCallParamsV8Pckg callParamsPckg8(callParams8);
+
+ callParams8.iService = RMobileCall::EServiceDataCircuitAsync;
+ callParams8.iSpeed = RMobileCall::ESpeedAutobauding;
+ callParams8.iProtocol = RMobileCall::EProtocolV32;
+ callParams8.iQoS = RMobileCall::EQoSTransparent;
+ callParams8.iRLPVersion = RMobileCall::ERLPNotRequested;
+ callParams8.iModemToMSWindowSize = 100;
+ callParams8.iMSToModemWindowSize = 100;
+ callParams8.iAckTimer = 100;
+ callParams8.iRetransmissionAttempts = 3;
+ callParams8.iResequencingPeriod = 100;
+ callParams8.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ callParams8.iV42bisCodewordsNum = 2;
+ callParams8.iV42bisMaxStringLength = 64;
+ callParams8.iUseEdge = EFalse;
+
+ callParams8.iBearerMode = RMobileCall::EMulticallNotSupported;
+ callParams8.iCallParamOrigin = RMobileCall::EOriginatorUnknown ;
+ callParams8.iSubAddress.Zero() ;
+ callParams8.iBearerCap1.Zero();
+ callParams8.iBearerCap2.Zero();
+ callParams8.iBCRepeatIndicator = RMobileCall::EBCServiceChangeAndFallbackMode ;
+ callParams8.iAlphaId.Copy(_L("Alpha Id"));
+
+ call.Connect(reqStatus, callParamsPckg8);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ //-------------------------------------------------------------------------
+ // Test: Test passing RMobileCall::TMobileHscsdCallParamsV2 to
+ // RCall::Connect
+ //-------------------------------------------------------------------------
+
+ RMobileCall::TMobileHscsdCallParamsV2 hscsdCallParams2;
+ RMobileCall::TMobileHscsdCallParamsV2Pckg hscsdCallParamsPckg2(hscsdCallParams2);
+
+ hscsdCallParams2.iService = RMobileCall::EServiceDataCircuitAsync;
+ hscsdCallParams2.iSpeed = RMobileCall::ESpeedAutobauding;
+ hscsdCallParams2.iProtocol = RMobileCall::EProtocolV32;
+ hscsdCallParams2.iQoS = RMobileCall::EQoSTransparent;
+ hscsdCallParams2.iRLPVersion = RMobileCall::ERLPNotRequested;
+ hscsdCallParams2.iModemToMSWindowSize = 100;
+ hscsdCallParams2.iMSToModemWindowSize = 100;
+ hscsdCallParams2.iAckTimer = 100;
+ hscsdCallParams2.iRetransmissionAttempts = 3;
+ hscsdCallParams2.iResequencingPeriod = 100;
+ hscsdCallParams2.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ hscsdCallParams2.iV42bisCodewordsNum = 2;
+ hscsdCallParams2.iV42bisMaxStringLength = 64;
+ hscsdCallParams2.iUseEdge = EFalse;
+ hscsdCallParams2.iWantedRxTimeSlots = 3;
+
+ hscsdCallParams2.iBearerMode = RMobileCall::EMulticallNotSupported;
+
+ call.Connect(reqStatus, hscsdCallParamsPckg2);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ //-------------------------------------------------------------------------
+ // Test: Test passing RMobileCall::TMobileHscsdCallParamsV7 to
+ // RCall::Connect
+ //-------------------------------------------------------------------------
+
+ RMobileCall::TMobileHscsdCallParamsV7 hscsdCallParams7;
+ RMobileCall::TMobileHscsdCallParamsV7Pckg hscsdCallParamsPckg7(hscsdCallParams7);
+
+ hscsdCallParams7.iService = RMobileCall::EServiceDataCircuitAsync;
+ hscsdCallParams7.iSpeed = RMobileCall::ESpeedAutobauding;
+ hscsdCallParams7.iProtocol = RMobileCall::EProtocolV32;
+ hscsdCallParams7.iQoS = RMobileCall::EQoSTransparent;
+ hscsdCallParams7.iRLPVersion = RMobileCall::ERLPNotRequested;
+ hscsdCallParams7.iModemToMSWindowSize = 100;
+ hscsdCallParams7.iMSToModemWindowSize = 100;
+ hscsdCallParams7.iAckTimer = 100;
+ hscsdCallParams7.iRetransmissionAttempts = 3;
+ hscsdCallParams7.iResequencingPeriod = 100;
+ hscsdCallParams7.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ hscsdCallParams7.iV42bisCodewordsNum = 2;
+ hscsdCallParams7.iV42bisMaxStringLength = 64;
+ hscsdCallParams7.iUseEdge = EFalse;
+ hscsdCallParams7.iWantedRxTimeSlots = 3;
+
+ hscsdCallParams7.iBearerMode = RMobileCall::EMulticallNotSupported;
+ hscsdCallParams7.iCallParamOrigin = RMobileCall::EOriginatorUnknown;
+ hscsdCallParams7.iIconId.iQualifier = RMobileCall::ENoIconId;
+ hscsdCallParams7.iIconId.iIdentifier = 2;
+ hscsdCallParams7.iAlphaId.Zero();
+
+ call.Connect(reqStatus, hscsdCallParamsPckg7);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ //-------------------------------------------------------------------------
+ // Test: Test passing RMobileCall::TMobileHscsdCallParamsV8 to
+ // RCall::Connect
+ //-------------------------------------------------------------------------
+
+ RMobileCall::TMobileHscsdCallParamsV8 hscsdCallParams8;
+ RMobileCall::TMobileHscsdCallParamsV8Pckg hscsdCallParamsPckg8(hscsdCallParams8);
+
+ hscsdCallParams8.iService = RMobileCall::EServiceDataCircuitAsync;
+ hscsdCallParams8.iSpeed = RMobileCall::ESpeedAutobauding;
+ hscsdCallParams8.iProtocol = RMobileCall::EProtocolV32;
+ hscsdCallParams8.iQoS = RMobileCall::EQoSTransparent;
+ hscsdCallParams8.iRLPVersion = RMobileCall::ERLPNotRequested;
+ hscsdCallParams8.iModemToMSWindowSize = 100;
+ hscsdCallParams8.iMSToModemWindowSize = 100;
+ hscsdCallParams8.iAckTimer = 100;
+ hscsdCallParams8.iRetransmissionAttempts = 3;
+ hscsdCallParams8.iResequencingPeriod = 100;
+ hscsdCallParams8.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ hscsdCallParams8.iV42bisCodewordsNum = 2;
+ hscsdCallParams8.iV42bisMaxStringLength = 64;
+ hscsdCallParams8.iUseEdge = EFalse;
+ hscsdCallParams8.iWantedRxTimeSlots = 3;
+
+ hscsdCallParams8.iBearerMode = RMobileCall::EMulticallNotSupported;
+ hscsdCallParams8.iCallParamOrigin = RMobileCall::EOriginatorUnknown;
+ hscsdCallParams8.iIconId.iQualifier = RMobileCall::ENoIconId;
+ hscsdCallParams8.iIconId.iIdentifier = 2;
+ hscsdCallParams8.iAlphaId.Zero();
+
+ hscsdCallParams8.iSubAddress.Zero();
+ hscsdCallParams8.iBearerCap1.Zero();
+ hscsdCallParams8.iBearerCap2.Zero();
+ hscsdCallParams8.iBCRepeatIndicator = RMobileCall::EBCServiceChangeAndFallbackMode ;
+
+ call.Connect(reqStatus, hscsdCallParamsPckg8);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CC-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::Connect for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RCall::Connect for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestConnect0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RCall call;
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RCall::Connect (Not Supported)
+ //-------------------------------------------------------------------------
+
+ RMobileCall::TMobileCallParamsV1 mobileCallParams;
+ mobileCallParams.iSpeakerControl = RMobileCall::EMonitorSpeakerControlAlwaysOn;
+ mobileCallParams.iSpeakerVolume = RMobileCall::EMonitorSpeakerVolumeMedium;
+ mobileCallParams.iInterval = 0;
+ mobileCallParams.iWaitForDialTone = RMobileCall::EDialToneNoWait;
+ mobileCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ mobileCallParams.iCug.iExplicitInvoke = EFalse;
+ mobileCallParams.iCug.iCugIndex = -1;
+ mobileCallParams.iCug.iSuppressOA = EFalse;
+ mobileCallParams.iCug.iSuppressPrefCug = EFalse;
+ mobileCallParams.iAutoRedial = EFalse;
+ RMobileCall::TMobileCallParamsV1Pckg mobileCallParamsPckg(mobileCallParams);
+
+ TRequestStatus reqStatus;
+ call.Connect(reqStatus, mobileCallParamsPckg);
+
+ // Cancels connecting of a (data) call.
+ call.ConnectCancel();
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CC-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::Connect with bad parameter data for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::Connect with bad parameter data for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestConnect0008L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RCall call;
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+
+ //-------------------------------------------------------------------------
+ // Test B: Test passing wrong descriptor size to parameter in
+ // RCall::Connect
+ //-------------------------------------------------------------------------
+
+ _LIT8(KOneCharDesc,"1");
+ TBuf8<1> buf(KOneCharDesc);
+ TInt res = call.Connect(buf);
+ // Passing a small buffer to function does cause an error.
+ ASSERT_EQUALS(KErrArgument, res)
+
+ TRequestStatus reqStatus;
+ call.Connect(reqStatus, buf);
+ User::WaitForRequest(reqStatus);
+ // Passing a small buffer to function does cause an error.
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int())
+
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CC-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::Connect for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RCall::Connect for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestConnect0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RCall call;
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+
+ RLine line2;
+ RCall call2;
+ OpenLineLC(line2, KMmTsyDataLineName);
+ OpenNewCallLC(line2, call2);
+
+ TRequestStatus reqStatus;
+ TRequestStatus reqStatus2;
+
+ RMobileCall::TMobileDataCallParamsV1 callParams;
+ callParams.iService = RMobileCall::EServiceDataCircuitAsync;
+ callParams.iSpeed = RMobileCall::ESpeedAutobauding;
+ callParams.iProtocol = RMobileCall::EProtocolV32;
+ callParams.iQoS = RMobileCall::EQoSTransparent;
+ callParams.iRLPVersion = RMobileCall::ERLPNotRequested;
+ callParams.iModemToMSWindowSize = 100;
+ callParams.iMSToModemWindowSize = 100;
+ callParams.iAckTimer = 100;
+ callParams.iRetransmissionAttempts = 3;
+ callParams.iResequencingPeriod = 100;
+ callParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ callParams.iV42bisCodewordsNum = 2;
+ callParams.iV42bisMaxStringLength = 64;
+ callParams.iUseEdge = EFalse;
+
+ RMobileCall::TMobileDataCallParamsV1Pckg callParamsPckg(callParams);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RCall::Connect
+ //-------------------------------------------------------------------------
+
+ call.Connect(reqStatus, callParamsPckg);
+ call2.Connect(reqStatus2, callParamsPckg);
+
+ User::WaitForRequest(reqStatus);
+ User::WaitForRequest(reqStatus2);
+
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int())
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(5, this); // call2, line2, call, line, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CC-0011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::Connect for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::Connect for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestConnect0011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RCall call;
+ OpenLineLC(line, KMmTsyFaxLineName);
+ OpenNewCallLC(line, call);
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RCall::Connect.
+ //-------------------------------------------------------------------------
+
+ // synchronous version
+ TInt res = call.Connect();
+
+ // RCall::Connect() without call parameters is not supported by CTSY.
+ // Because of this it is completed with KErrArgument.
+ ASSERT_EQUALS(KErrArgument, res)
+
+ // asynchronous version
+ TRequestStatus reqStatus;
+ call.Connect(reqStatus);
+ User::WaitForRequest(reqStatus);
+
+ // RCall::Connect() without call parameters is not supported by CTSY.
+ // Because of this it is completed with KErrArgument.
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int())
+
+ // synchronous version with RMobileCall::TMobileDataCallParamsV1Pckg parameter
+ RMobileCall::TMobileDataCallParamsV1 callParams;
+ callParams.iService = RMobileCall::EServiceDataCircuitAsync;
+ callParams.iSpeed = RMobileCall::ESpeedAutobauding;
+ callParams.iProtocol = RMobileCall::EProtocolV32;
+ callParams.iQoS = RMobileCall::EQoSTransparent;
+ callParams.iRLPVersion = RMobileCall::ERLPNotRequested;
+ callParams.iModemToMSWindowSize = 100;
+ callParams.iMSToModemWindowSize = 100;
+ callParams.iAckTimer = 100;
+ callParams.iRetransmissionAttempts = 3;
+ callParams.iResequencingPeriod = 100;
+ callParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ callParams.iV42bisCodewordsNum = 2;
+ callParams.iV42bisMaxStringLength = 64;
+ callParams.iUseEdge = EFalse;
+ RMobileCall::TMobileDataCallParamsV1Pckg callParamsPckg(callParams);
+
+ res = call.Connect(callParamsPckg);
+ ASSERT_EQUALS(KErrNone, res)
+
+ // asynchronous version with RMobileCall::TMobileHscsdCallParamsV1Pckg parameter
+ RMobileCall::TMobileHscsdCallParamsV1 hscsdCallParams;
+ hscsdCallParams.iService = RMobileCall::EServiceDataCircuitAsync;
+ hscsdCallParams.iSpeed = RMobileCall::ESpeedAutobauding;
+ hscsdCallParams.iProtocol = RMobileCall::EProtocolV32;
+ hscsdCallParams.iQoS = RMobileCall::EQoSTransparent;
+ hscsdCallParams.iRLPVersion = RMobileCall::ERLPNotRequested;
+ hscsdCallParams.iModemToMSWindowSize = 100;
+ hscsdCallParams.iMSToModemWindowSize = 100;
+ hscsdCallParams.iAckTimer = 100;
+ hscsdCallParams.iRetransmissionAttempts = 3;
+ hscsdCallParams.iResequencingPeriod = 100;
+ hscsdCallParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ hscsdCallParams.iV42bisCodewordsNum = 2;
+ hscsdCallParams.iV42bisMaxStringLength = 64;
+ hscsdCallParams.iUseEdge = EFalse;
+ hscsdCallParams.iWantedAiur = RMobileCall::EAiurBps19200;
+ hscsdCallParams.iWantedRxTimeSlots = 2;
+ hscsdCallParams.iMaxTimeSlots = 3;
+ hscsdCallParams.iCodings = RMobileCall::KCapsAiurCoding96;
+ hscsdCallParams.iAsymmetry = RMobileCall::EAsymmetryDownlink;
+ hscsdCallParams.iUserInitUpgrade = ETrue;
+ RMobileCall::TMobileHscsdCallParamsV1Pckg hscsdCallParamsPckg(hscsdCallParams);
+
+ call.Connect(reqStatus, hscsdCallParamsPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ //------------------------------------------------------------
+ // TMobileDataCallParamsV2
+ RMobileCall::TMobileDataCallParamsV2 dataCallParams2;
+ dataCallParams2.iService = RMobileCall::EServiceDataCircuitAsync;
+ dataCallParams2.iSpeed = RMobileCall::ESpeedAutobauding;
+ dataCallParams2.iProtocol = RMobileCall::EProtocolV32;
+ dataCallParams2.iQoS = RMobileCall::EQoSTransparent;
+ dataCallParams2.iRLPVersion = RMobileCall::ERLPNotRequested;
+ dataCallParams2.iModemToMSWindowSize = 100;
+ dataCallParams2.iMSToModemWindowSize = 100;
+ dataCallParams2.iAckTimer = 100;
+ dataCallParams2.iRetransmissionAttempts = 3;
+ dataCallParams2.iResequencingPeriod = 100;
+ dataCallParams2.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ dataCallParams2.iV42bisCodewordsNum = 2;
+ dataCallParams2.iV42bisMaxStringLength = 64;
+ dataCallParams2.iUseEdge = EFalse;
+ dataCallParams2.iBearerMode = RMobileCall::EMulticallShareBearer;
+ RMobileCall::TMobileDataCallParamsV2Pckg dataCallParamsPckg2(dataCallParams2);
+
+ res = call.Connect(dataCallParamsPckg2);
+ ASSERT_EQUALS(KErrNone, res)
+
+ //------------------------------------------------------------
+ // TMobileDataCallParamsV8
+
+ RMobileCall::TMobileDataCallParamsV8 dataCallParams8;
+ dataCallParams8.iService = RMobileCall::EServiceDataCircuitAsync;
+ dataCallParams8.iSpeed = RMobileCall::ESpeedAutobauding;
+ dataCallParams8.iProtocol = RMobileCall::EProtocolV32;
+ dataCallParams8.iQoS = RMobileCall::EQoSTransparent;
+ dataCallParams8.iRLPVersion = RMobileCall::ERLPNotRequested;
+ dataCallParams8.iModemToMSWindowSize = 100;
+ dataCallParams8.iMSToModemWindowSize = 100;
+ dataCallParams8.iAckTimer = 100;
+ dataCallParams8.iRetransmissionAttempts = 3;
+ dataCallParams8.iResequencingPeriod = 100;
+ dataCallParams8.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ dataCallParams8.iV42bisCodewordsNum = 2;
+ dataCallParams8.iV42bisMaxStringLength = 64;
+ dataCallParams8.iUseEdge = EFalse;
+ dataCallParams8.iBearerMode = RMobileCall::EMulticallShareBearer;
+ RMobileCall::TMobileDataCallParamsV8Pckg dataCallParamsPckg8(dataCallParams8);
+
+ res = call.Connect(dataCallParamsPckg8);
+ ASSERT_EQUALS(KErrNone, res)
+
+ //------------------------------------------------------------
+ // TMobileHscsdCallParamsV2
+
+ RMobileCall::TMobileHscsdCallParamsV2 hscsdCallParams2;
+ hscsdCallParams2.iService = RMobileCall::EServiceDataCircuitAsync;
+ hscsdCallParams2.iSpeed = RMobileCall::ESpeedAutobauding;
+ hscsdCallParams2.iProtocol = RMobileCall::EProtocolV32;
+ hscsdCallParams2.iQoS = RMobileCall::EQoSTransparent;
+ hscsdCallParams2.iRLPVersion = RMobileCall::ERLPNotRequested;
+ hscsdCallParams2.iModemToMSWindowSize = 100;
+ hscsdCallParams2.iMSToModemWindowSize = 100;
+ hscsdCallParams2.iAckTimer = 100;
+ hscsdCallParams2.iRetransmissionAttempts = 3;
+ hscsdCallParams2.iResequencingPeriod = 100;
+ hscsdCallParams2.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ hscsdCallParams2.iV42bisCodewordsNum = 2;
+ hscsdCallParams2.iV42bisMaxStringLength = 64;
+ hscsdCallParams2.iUseEdge = EFalse;
+ hscsdCallParams2.iWantedAiur = RMobileCall::EAiurBps19200;
+ hscsdCallParams2.iWantedRxTimeSlots = 2;
+ hscsdCallParams2.iMaxTimeSlots = 3;
+ hscsdCallParams2.iCodings = RMobileCall::KCapsAiurCoding96;
+ hscsdCallParams2.iAsymmetry = RMobileCall::EAsymmetryDownlink;
+ hscsdCallParams2.iUserInitUpgrade = ETrue;
+ RMobileCall::TMobileHscsdCallParamsV2Pckg hscsdCallParamsPckg2(hscsdCallParams2);
+
+ call.Connect(reqStatus, hscsdCallParamsPckg2);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ //------------------------------------------------------------
+ // TMobileHscsdCallParamsV2
+
+ RMobileCall::TMobileHscsdCallParamsV7 hscsdCallParams7;
+ hscsdCallParams7.iService = RMobileCall::EServiceDataCircuitAsync;
+ hscsdCallParams7.iSpeed = RMobileCall::ESpeedAutobauding;
+ hscsdCallParams7.iProtocol = RMobileCall::EProtocolV32;
+ hscsdCallParams7.iQoS = RMobileCall::EQoSTransparent;
+ hscsdCallParams7.iRLPVersion = RMobileCall::ERLPNotRequested;
+ hscsdCallParams7.iModemToMSWindowSize = 100;
+ hscsdCallParams7.iMSToModemWindowSize = 100;
+ hscsdCallParams7.iAckTimer = 100;
+ hscsdCallParams7.iRetransmissionAttempts = 3;
+ hscsdCallParams7.iResequencingPeriod = 100;
+ hscsdCallParams7.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ hscsdCallParams7.iV42bisCodewordsNum = 2;
+ hscsdCallParams7.iV42bisMaxStringLength = 64;
+ hscsdCallParams7.iUseEdge = EFalse;
+ hscsdCallParams7.iWantedAiur = RMobileCall::EAiurBps19200;
+ hscsdCallParams7.iWantedRxTimeSlots = 2;
+ hscsdCallParams7.iMaxTimeSlots = 3;
+ hscsdCallParams7.iCodings = RMobileCall::KCapsAiurCoding96;
+ hscsdCallParams7.iAsymmetry = RMobileCall::EAsymmetryDownlink;
+ hscsdCallParams7.iUserInitUpgrade = ETrue;
+ RMobileCall::TMobileHscsdCallParamsV7Pckg hscsdCallParamsPckg7(hscsdCallParams7);
+
+ call.Connect(reqStatus, hscsdCallParamsPckg7);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ //------------------------------------------------------------
+ // TMobileHscsdCallParamsV8
+
+ RMobileCall::TMobileHscsdCallParamsV8 hscsdCallParams8;
+ hscsdCallParams8.iService = RMobileCall::EServiceDataCircuitAsync;
+ hscsdCallParams8.iSpeed = RMobileCall::ESpeedAutobauding;
+ hscsdCallParams8.iProtocol = RMobileCall::EProtocolV32;
+ hscsdCallParams8.iQoS = RMobileCall::EQoSTransparent;
+ hscsdCallParams8.iRLPVersion = RMobileCall::ERLPNotRequested;
+ hscsdCallParams8.iModemToMSWindowSize = 100;
+ hscsdCallParams8.iMSToModemWindowSize = 100;
+ hscsdCallParams8.iAckTimer = 100;
+ hscsdCallParams8.iRetransmissionAttempts = 3;
+ hscsdCallParams8.iResequencingPeriod = 100;
+ hscsdCallParams8.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ hscsdCallParams8.iV42bisCodewordsNum = 2;
+ hscsdCallParams8.iV42bisMaxStringLength = 64;
+ hscsdCallParams8.iUseEdge = EFalse;
+ hscsdCallParams8.iWantedAiur = RMobileCall::EAiurBps19200;
+ hscsdCallParams8.iWantedRxTimeSlots = 2;
+ hscsdCallParams8.iMaxTimeSlots = 3;
+ hscsdCallParams8.iCodings = RMobileCall::KCapsAiurCoding96;
+ hscsdCallParams8.iAsymmetry = RMobileCall::EAsymmetryDownlink;
+ hscsdCallParams8.iUserInitUpgrade = ETrue;
+ RMobileCall::TMobileHscsdCallParamsV8Pckg hscsdCallParamsPckg8(hscsdCallParams8);
+
+ call.Connect(reqStatus, hscsdCallParamsPckg8);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CC-0012
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::Connect for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RCall::Connect for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestConnect0012L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RCall call;
+ OpenLineLC(line, KMmTsyFaxLineName);
+ OpenNewCallLC(line, call);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RCall::Connect (Not Supported)
+ //-------------------------------------------------------------------------
+
+ RMobileCall::TMobileDataCallParamsV1 callParams;
+ callParams.iService = RMobileCall::EServiceDataCircuitAsync;
+ callParams.iSpeed = RMobileCall::ESpeedAutobauding;
+ callParams.iProtocol = RMobileCall::EProtocolV32;
+ callParams.iQoS = RMobileCall::EQoSTransparent;
+ callParams.iRLPVersion = RMobileCall::ERLPNotRequested;
+ callParams.iModemToMSWindowSize = 100;
+ callParams.iMSToModemWindowSize = 100;
+ callParams.iAckTimer = 100;
+ callParams.iRetransmissionAttempts = 3;
+ callParams.iResequencingPeriod = 100;
+ callParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ callParams.iV42bisCodewordsNum = 2;
+ callParams.iV42bisMaxStringLength = 64;
+ callParams.iUseEdge = EFalse;
+ RMobileCall::TMobileDataCallParamsV1Pckg callParamsPckg(callParams);
+
+ TRequestStatus reqStatus;
+ call.Connect(reqStatus, callParamsPckg);
+
+ // Cancels connecting of a (data) call (Not Supported).
+ call.ConnectCancel();
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CC-0013
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RCall::Connect with bad parameter data for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RCall::Connect with bad parameter data for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestConnect0013L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RCall call;
+ OpenLineLC(line, KMmTsyFaxLineName);
+ OpenNewCallLC(line, call);
+
+ //-------------------------------------------------------------------------
+ // Test B: Test passing wrong descriptor size to parameter in
+ // RCall::Connect
+ //-------------------------------------------------------------------------
+
+ TBuf8<1> buf(KNullDesC8);
+ TInt res = call.Connect(buf);
+ // Passing a small buffer to function doesn't cause an error.
+ ASSERT_EQUALS(KErrArgument, res)
+
+ TRequestStatus reqStatus;
+ call.Connect(reqStatus, buf);
+ User::WaitForRequest(reqStatus);
+ // Passing a small buffer to function doesn't cause an error.
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CC-0014
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::Connect for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RCall::Connect for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestConnect0014L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RCall call;
+ OpenLineLC(line, KMmTsyFaxLineName);
+ OpenNewCallLC(line, call);
+
+ RLine line2;
+ RCall call2;
+ OpenLineLC(line2, KMmTsyFaxLineName);
+ OpenNewCallLC(line2, call2);
+
+ TRequestStatus reqStatus;
+ TRequestStatus reqStatus2;
+
+ RMobileCall::TMobileDataCallParamsV1 callParams;
+ callParams.iService = RMobileCall::EServiceDataCircuitAsync;
+ callParams.iSpeed = RMobileCall::ESpeedAutobauding;
+ callParams.iProtocol = RMobileCall::EProtocolV32;
+ callParams.iQoS = RMobileCall::EQoSTransparent;
+ callParams.iRLPVersion = RMobileCall::ERLPNotRequested;
+ callParams.iModemToMSWindowSize = 100;
+ callParams.iMSToModemWindowSize = 100;
+ callParams.iAckTimer = 100;
+ callParams.iRetransmissionAttempts = 3;
+ callParams.iResequencingPeriod = 100;
+ callParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
+ callParams.iV42bisCodewordsNum = 2;
+ callParams.iV42bisMaxStringLength = 64;
+ callParams.iUseEdge = EFalse;
+ RMobileCall::TMobileDataCallParamsV1Pckg callParamsPckg(callParams);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RCall::Connect
+ //-------------------------------------------------------------------------
+
+ call.Connect(reqStatus, callParamsPckg);
+ call2.Connect(reqStatus2, callParamsPckg);
+
+ User::WaitForRequest(reqStatus);
+ User::WaitForRequest(reqStatus2);
+
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int())
+
+ CleanupStack::PopAndDestroy(5, this); // call2, line2, call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGCHI-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetCurrentHscsdInfo for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetCurrentHscsdInfo for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetCurrentHscsdInfo0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ RMobileCall::TMobileCallHscsdInfoV1 info;
+ RMobileCall::TMobileCallHscsdInfoV1Pckg infoPckg(info);
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::GetCurrentHscsdInfo is not supported for voice calls
+ //-------------------------------------------------------------------------
+
+ OpenLineLC(line, KMmTsyVoice1LineName);
+ OpenNewCallLC(line, call);
+
+ TInt res = call.GetCurrentHscsdInfo(infoPckg);
+ ASSERT_EQUALS(KErrNotSupported, res)
+
+ CleanupStack::PopAndDestroy(2); // call, line
+
+ // same test for voice call from auxiliary voice line
+ OpenLineLC(line, KMmTsyVoice2LineName);
+ OpenNewCallLC(line, call);
+
+ res = call.GetCurrentHscsdInfo(infoPckg);
+ ASSERT_EQUALS(KErrNotSupported, res)
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGCHI-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetCurrentHscsdInfo for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetCurrentHscsdInfo for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetCurrentHscsdInfo0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RLine line;
+ RMobileCall call;
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // when dial request is pending
+ //-------------------------------------------------------------------------
+
+ // create dial request
+ RMobileCall::TMobileCallParamsV1 callParams;
+ callParams.iInterval = 4;
+ callParams.iCug.iCugIndex = 0xFFFF;
+
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ _LIT(KPhoneNumber, "101632960000");
+ callInfo.iDialledParty.iTelNumber.Copy(KPhoneNumber);
+ callInfo.iService = RMobilePhone::ECircuitDataService;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV8>
+ expDialData(0, RMobilePhone::ECircuitDataService, callParams, callInfo);
+
+ data.Close();
+ expDialData.SerialiseL(data);
+ iMockLTSY.ExpectL(EEtelCallDial, data);
+ TRequestStatus requestStatus;
+ TPckg<RMobileCall::TMobileCallParamsV1> callParamsPckg(callParams);
+ call.Dial(requestStatus, callParamsPckg, KPhoneNumber);
+
+ // test
+ RMobileCall::TMobileCallHscsdInfoV8 resInfo;
+ RMobileCall::TMobileCallHscsdInfoV8Pckg resInfoPckg(resInfo);
+ TInt res = call.GetCurrentHscsdInfo(resInfoPckg);
+ ASSERT_EQUALS(KErrEtelCallNotActive, res);
+ ASSERT_EQUALS(RMobileCall::EAiurBpsUnspecified, resInfo.iAiur);
+ ASSERT_EQUALS(0, resInfo.iRxTimeSlots);
+ ASSERT_EQUALS(0, resInfo.iTxTimeSlots);
+ ASSERT_EQUALS(RMobileCall::ETchCodingUnspecified, resInfo.iCodings);
+ ASSERT_TRUE(0 == resInfo.iAlphaId.Length());
+ ASSERT_TRUE(0 == resInfo.iSubAddress.Length());
+ AssertMockLtsyStatusL();
+
+ // complete dial request
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ CallGetMobileCallInfoL(1, RMobilePhone::ECircuitDataService, KPhoneNumber);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ TMockLtsyCallData0 completeDialData(1, RMobilePhone::ECircuitDataService);
+ data.Close();
+ completeDialData.SerialiseL(data);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ User::WaitForRequest(requestStatus); // dial request completed
+ ASSERT_EQUALS(KErrNone, requestStatus.Int());
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(&call);
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // when info is not ready
+ //-------------------------------------------------------------------------
+
+ OpenNewCallLC(line, call);
+ DialL(call, 1, RMobilePhone::ECircuitDataService);
+
+ res = call.GetCurrentHscsdInfo(resInfoPckg);
+ ASSERT_EQUALS(KErrNotReady, res)
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileCall::GetCurrentHscsdInfo.
+ //-------------------------------------------------------------------------
+
+ RMobileCall::TMobileCallHscsdInfoV8 hscsdInfo;
+
+ hscsdInfo.iAiur = RMobileCall::EAiurBps38400;
+ hscsdInfo.iRxTimeSlots = 2;
+ hscsdInfo.iTxTimeSlots = 2;
+ hscsdInfo.iCodings = RMobileCall::ETchCoding320;
+ hscsdInfo.iAlphaId.Copy(_L("Alpha Id"));
+ hscsdInfo.iSubAddress.Copy(_L("An unknown SubAddress"));
+ hscsdInfo.iCallParamOrigin = RMobileCall::EOriginatorSIM ;
+
+ RMobileCall::TMobileCallDataCapsV1 dataCallCaps;
+ dataCallCaps.iAsymmetryCaps = RMobileCall::KCapsAsymmetryNoPreference;
+ dataCallCaps.iUserInitUpgrade = EFalse;
+ dataCallCaps.iCodingCaps = RMobileCall::KCapsAiurCoding144;
+ dataCallCaps.iRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion1;
+ dataCallCaps.iHscsdSupport = ETrue;
+ dataCallCaps.iMaxRxTimeSlots = 2;
+ dataCallCaps.iSpeedCaps = RMobileCall::KCapsSpeed14400;
+ dataCallCaps.iMaxTxTimeSlots = 2;
+ dataCallCaps.iProtocolCaps = RMobileCall::KCapsProtocolV32 | RMobileCall::KCapsPstnMultimedia;
+ dataCallCaps.iQoSCaps = RMobileCall::KCapsTransparentPreferred;
+ dataCallCaps.iServiceCaps = RMobileCall::KCapsDataCircuitAsynchronousRDI;
+ dataCallCaps.iMClass = 1;
+ dataCallCaps.iTotalRxTxTimeSlots = 4;
+ dataCallCaps.iV42bisCaps = RMobileCall::KCapsV42bisBothDirections;
+
+ TMockLtsyCallData2<RMobileCall::TMobileCallHscsdInfoV8, RMobileCall::TMobileCallDataCapsV1> hscsdData(1, RMobilePhone::ECircuitDataService, hscsdInfo, dataCallCaps);
+ data.Close();
+ hscsdData.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyHscsdInfoChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ RMobileCall::TMobileCallHscsdInfoV8 resInfo8;
+ RMobileCall::TMobileCallHscsdInfoV8Pckg resInfoPckg8(resInfo8);
+ res = call.GetCurrentHscsdInfo(resInfoPckg8);
+ ASSERT_EQUALS(KErrNone, res);
+ ASSERT_EQUALS(hscsdInfo.iAiur, resInfo8.iAiur);
+ ASSERT_EQUALS(hscsdInfo.iRxTimeSlots, resInfo8.iRxTimeSlots);
+ ASSERT_EQUALS(hscsdInfo.iTxTimeSlots, resInfo8.iTxTimeSlots);
+ ASSERT_EQUALS(hscsdInfo.iCodings, resInfo8.iCodings);
+ ASSERT_EQUALS(hscsdInfo.iCallParamOrigin, resInfo8.iCallParamOrigin);
+ ASSERT_EQUALS(hscsdInfo.iAlphaId, resInfo8.iAlphaId);
+ ASSERT_EQUALS(hscsdInfo.iSubAddress, resInfo8.iSubAddress);
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // when Hscsd is not supported
+ //-------------------------------------------------------------------------
+
+ // prepare CTSY (make Hscsd unsupported)
+ dataCallCaps.iHscsdSupport = EFalse;
+ data.Close();
+ hscsdData.SerialiseL(data);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyHscsdInfoChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ // test
+ res = call.GetCurrentHscsdInfo(resInfoPckg);
+ ASSERT_EQUALS(KErrEtelCallNotActive, res);
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this); // call, line, data, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGCHI-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetCurrentHscsdInfo with bad parameter data for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetCurrentHscsdInfo with bad parameter data for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetCurrentHscsdInfo0008L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RLine line;
+ RMobileCall call;
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+ DialL(call, 1, RMobilePhone::ECircuitDataService);
+
+ // prepare CTSY (make info ready)
+ RMobileCall::TMobileCallHscsdInfoV1 hscsdInfo;
+ hscsdInfo.iAiur = RMobileCall::EAiurBps38400;
+ hscsdInfo.iRxTimeSlots = 2;
+ hscsdInfo.iTxTimeSlots = 2;
+ hscsdInfo.iCodings = RMobileCall::ETchCoding320;
+
+ RMobileCall::TMobileCallDataCapsV1 dataCallCaps;
+ dataCallCaps.iAsymmetryCaps = RMobileCall::KCapsAsymmetryNoPreference;
+ dataCallCaps.iUserInitUpgrade = EFalse;
+ dataCallCaps.iCodingCaps = RMobileCall::KCapsAiurCoding144;
+ dataCallCaps.iRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion1;
+ dataCallCaps.iHscsdSupport = ETrue;
+ dataCallCaps.iMaxRxTimeSlots = 2;
+ dataCallCaps.iSpeedCaps = RMobileCall::KCapsSpeed14400;
+ dataCallCaps.iMaxTxTimeSlots = 2;
+ dataCallCaps.iProtocolCaps = RMobileCall::KCapsProtocolV32 | RMobileCall::KCapsPstnMultimedia;
+ dataCallCaps.iQoSCaps = RMobileCall::KCapsTransparentPreferred;
+ dataCallCaps.iServiceCaps = RMobileCall::KCapsDataCircuitAsynchronousRDI;
+ dataCallCaps.iMClass = 1;
+ dataCallCaps.iTotalRxTxTimeSlots = 4;
+ dataCallCaps.iV42bisCaps = RMobileCall::KCapsV42bisBothDirections;
+
+ TMockLtsyCallData2<RMobileCall::TMobileCallHscsdInfoV1, RMobileCall::TMobileCallDataCapsV1> hscsdData(1, RMobilePhone::ECircuitDataService, hscsdInfo, dataCallCaps);
+ data.Close();
+ hscsdData.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyHscsdInfoChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ //-------------------------------------------------------------------------
+ // Test B: Test passing wrong descriptor size to parameter in
+ // RMobileCall::GetCurrentHscsdInfo
+ //-------------------------------------------------------------------------
+
+ TBuf8<1> info(KNullDesC8);
+ TInt res = call.GetCurrentHscsdInfo(info);
+
+ ASSERT_EQUALS(KErrArgument, res)
+
+ CleanupStack::PopAndDestroy(4, this); // call, line, data, this
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGCHI-0011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetCurrentHscsdInfo for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetCurrentHscsdInfo for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetCurrentHscsdInfo0011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::GetCurrentHscsdInfo is not supported for fax calls
+ //-------------------------------------------------------------------------
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyFaxLineName);
+ OpenNewCallLC(line, call);
+
+ RMobileCall::TMobileCallHscsdInfoV1 info;
+ RMobileCall::TMobileCallHscsdInfoV1Pckg infoPckg(info);
+
+ TInt res = call.GetCurrentHscsdInfo(infoPckg);
+ ASSERT_EQUALS(KErrNotSupported, res)
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNVF-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyVoiceFallback for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyVoiceFallback for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyVoiceFallback0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::NotifyVoiceFallback is not supported
+ //-------------------------------------------------------------------------
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyVoice1LineName);
+ OpenNewCallLC(line, call);
+ DialL(call, 1, RMobilePhone::EVoiceService);
+
+ TRequestStatus reqStatus;
+ TName name;
+ call.NotifyVoiceFallback(reqStatus, name);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ // same test for voice call from auxiliary voice line
+ RLine line2;
+ RMobileCall call2;
+
+ OpenLineLC(line2, KMmTsyVoice2LineName);
+ OpenNewCallLC(line2, call2);
+ DialL(call2, 2, RMobilePhone::EAuxVoiceService);
+
+ call2.NotifyVoiceFallback(reqStatus, name);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(5, this); // call2, line2, call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNVF-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyVoiceFallback for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyVoiceFallback for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyVoiceFallback0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::NotifyVoiceFallback is not supported
+ //-------------------------------------------------------------------------
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+ DialL(call, 1, RMobilePhone::ECircuitDataService);
+
+ TRequestStatus reqStatus;
+ TName name;
+ call.NotifyVoiceFallback(reqStatus, name);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNVF-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyVoiceFallback for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyVoiceFallback for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyVoiceFallback00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::NotifyVoiceFallback is not supported
+ //-------------------------------------------------------------------------
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyFaxLineName);
+
+ TName name;
+ CreateIncomingCallL(line, 1, KNullDesC, name, RMobilePhone::EFaxService, RMobileCall::EStatusConnected);
+ TInt res = call.OpenExistingCall(line, name);
+ ASSERT_EQUALS(KErrNone, res);
+ CleanupClosePushL(call);
+
+ TRequestStatus reqStatus;
+ call.NotifyVoiceFallback(reqStatus, name);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGMDCC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileDataCallCaps for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileDataCallCaps for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetMobileDataCallCaps0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::GetMobileDataCallCaps is not supported for voice calls
+ //-------------------------------------------------------------------------
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyVoice1LineName);
+ OpenNewCallLC(line, call);
+
+ RMobileCall::TMobileCallDataCapsV1 dataCallCaps;
+ RMobileCall::TMobileCallDataCapsV1Pckg dataCallCapsPckg(dataCallCaps);
+
+ TInt res = call.GetMobileDataCallCaps(dataCallCapsPckg);
+ ASSERT_EQUALS(KErrNotSupported, res)
+ AssertMockLtsyStatusL();
+
+ // same test for voice call from auxiliary voice line
+ RLine line2;
+ RMobileCall call2;
+
+ OpenLineLC(line2, KMmTsyVoice2LineName);
+ OpenNewCallLC(line2, call2);
+
+ res = call2.GetMobileDataCallCaps(dataCallCapsPckg);
+ ASSERT_EQUALS(KErrNotSupported, res)
+
+ CleanupStack::PopAndDestroy(5, this); // call2, line2, call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGMDCC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileDataCallCaps for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileDataCallCaps for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetMobileDataCallCaps0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileCall::GetMobileDataCallCaps.
+ //-------------------------------------------------------------------------
+
+ RMobileCall::TMobileCallDataCapsV1 dataCallCaps;
+ RMobileCall::TMobileCallDataCapsV1Pckg dataCallCapsPckg(dataCallCaps);
+ TInt res = call.GetMobileDataCallCaps(dataCallCapsPckg);
+ ASSERT_EQUALS(KErrNone, res)
+
+ // check results
+ TBool usingFeatureManager(EFalse);
+ RFeatureControl featureControl;
+ CleanupClosePushL(featureControl);
+ res = featureControl.Open();
+ if ( KErrNone == res )
+ {
+ usingFeatureManager = ETrue;
+ }
+ // additional flags for videotelephony
+ if ( (usingFeatureManager) && (featureControl.FeatureSupported(NFeature::KCsVideoTelephony) == KFeatureSupported) )
+ {
+ ASSERT_EQUALS((TUint32)(KMultimodeTsyDataSpeedCaps | KMultimodeTsyDataSpeedCapsVT), dataCallCaps.iSpeedCaps)
+ ASSERT_EQUALS((TUint32)(KMultimodeTsyDataProtocolCaps | KMultimodeTsyDataProtocolCapsVT), dataCallCaps.iProtocolCaps)
+ ASSERT_EQUALS((TUint32)(KMultimodeTsyDataServiceCaps | KMultimodeTsyDataServiceCapsVT), dataCallCaps.iServiceCaps)
+ }
+ else
+ {
+ ASSERT_EQUALS((TUint32)KMultimodeTsyDataSpeedCaps, dataCallCaps.iSpeedCaps)
+ ASSERT_EQUALS((TUint32)KMultimodeTsyDataProtocolCaps, dataCallCaps.iProtocolCaps)
+ ASSERT_EQUALS((TUint32)KMultimodeTsyDataServiceCaps, dataCallCaps.iServiceCaps)
+ }
+ ASSERT_EQUALS((TUint32)KMultimodeTsyDataQoSCaps, dataCallCaps.iQoSCaps)
+ ASSERT_EQUALS((TBool)KMultimodeTsyDataHscsdSupport, dataCallCaps.iHscsdSupport)
+ ASSERT_EQUALS((TInt)KMultimodeTsyDataMClassDefValue, dataCallCaps.iMClass)
+ ASSERT_EQUALS((TInt)KMultimodeTsyDataMaxRxTSDefValue, dataCallCaps.iMaxRxTimeSlots)
+ ASSERT_EQUALS((TInt)KMultimodeTsyDataMaxTxTSDefValue, dataCallCaps.iMaxTxTimeSlots)
+ ASSERT_EQUALS((TInt)KMultimodeTsyDataTotalRxTxTSDefValue, dataCallCaps.iTotalRxTxTimeSlots)
+ ASSERT_EQUALS((TUint32)KMultimodeTsyDataTchCodingsCaps, dataCallCaps.iCodingCaps)
+ ASSERT_EQUALS((TUint32)KMultimodeTsyDataAsymmetryCaps, dataCallCaps.iAsymmetryCaps)
+ ASSERT_EQUALS((TBool)KMultimodeTsyDataUserInitUpgrade, dataCallCaps.iUserInitUpgrade)
+ ASSERT_EQUALS((TUint32)KMultimodeTsyDataRLPVersionCaps, dataCallCaps.iRLPVersionCaps)
+ ASSERT_EQUALS((TUint32)KMultimodeTsyDataV42bisCaps, dataCallCaps.iV42bisCaps)
+ CleanupStack::PopAndDestroy(&featureControl);
+ AssertMockLtsyStatusL();
+
+ // change data in CTSY
+
+ //This is needed for assign a callId to Call for setting new callDataCaps values.
+
+ DialL(call, 1, RMobilePhone::ECircuitDataService);
+
+ RMobileCall::TMobileCallDataCapsV1 newCaps;
+ newCaps.iAsymmetryCaps = RMobileCall::KCapsAsymmetryNoPreference;
+ newCaps.iUserInitUpgrade = EFalse;
+ newCaps.iCodingCaps = RMobileCall::KCapsAiurCoding144;
+ newCaps.iRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion1;
+ newCaps.iHscsdSupport = ETrue;
+ newCaps.iMaxRxTimeSlots = 2;
+ newCaps.iSpeedCaps = RMobileCall::KCapsSpeed14400;
+ newCaps.iMaxTxTimeSlots = 2;
+ newCaps.iProtocolCaps = RMobileCall::KCapsProtocolV32 | RMobileCall::KCapsPstnMultimedia;
+ newCaps.iQoSCaps = RMobileCall::KCapsTransparentPreferred;
+ newCaps.iServiceCaps = RMobileCall::KCapsDataCircuitAsynchronousRDI;
+ newCaps.iMClass = 1;
+ newCaps.iTotalRxTxTimeSlots = 4;
+ newCaps.iV42bisCaps = RMobileCall::KCapsV42bisBothDirections;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+ TMockLtsyCallData1<RMobileCall::TMobileCallDataCapsV1> newCapsData(1, mobileService, newCaps);
+ newCapsData.SerialiseL(data);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileDataCallCapsChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ // test again
+ res = call.GetMobileDataCallCaps(dataCallCapsPckg);
+ ASSERT_EQUALS(KErrNone, res)
+
+ ASSERT_EQUALS(newCaps.iSpeedCaps, dataCallCaps.iSpeedCaps)
+ ASSERT_EQUALS(newCaps.iProtocolCaps, dataCallCaps.iProtocolCaps)
+ ASSERT_EQUALS(newCaps.iServiceCaps, dataCallCaps.iServiceCaps)
+ ASSERT_EQUALS(newCaps.iQoSCaps, dataCallCaps.iQoSCaps)
+ ASSERT_EQUALS(newCaps.iHscsdSupport, dataCallCaps.iHscsdSupport)
+ ASSERT_EQUALS(newCaps.iMClass, dataCallCaps.iMClass)
+ ASSERT_EQUALS(newCaps.iMaxRxTimeSlots, dataCallCaps.iMaxRxTimeSlots)
+ ASSERT_EQUALS(newCaps.iMaxTxTimeSlots, dataCallCaps.iMaxTxTimeSlots)
+ ASSERT_EQUALS(newCaps.iTotalRxTxTimeSlots, dataCallCaps.iTotalRxTxTimeSlots)
+ ASSERT_EQUALS(newCaps.iCodingCaps, dataCallCaps.iCodingCaps)
+ ASSERT_EQUALS(newCaps.iAsymmetryCaps, dataCallCaps.iAsymmetryCaps)
+ ASSERT_EQUALS(newCaps.iUserInitUpgrade, dataCallCaps.iUserInitUpgrade)
+ ASSERT_EQUALS(newCaps.iRLPVersionCaps, dataCallCaps.iRLPVersionCaps)
+ ASSERT_EQUALS(newCaps.iV42bisCaps, dataCallCaps.iV42bisCaps)
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this); // call, line, data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGMDCC-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileDataCallCaps with bad parameter data for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileDataCallCaps with bad parameter data for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetMobileDataCallCaps0008L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+
+ //-------------------------------------------------------------------------
+ // Test B: Test passing wrong descriptor size to parameter in
+ // RMobileCall::GetMobileDataCallCaps
+ //-------------------------------------------------------------------------
+
+ TBuf8<1> caps(KNullDesC8);
+ TInt res = call.GetMobileDataCallCaps(caps);
+ ASSERT_EQUALS(KErrArgument, res);
+
+ //-------------------------------------------------------------------------
+ // Test B: Test passing wrong parameter to
+ // RMobileCall::GetMobileDataCallCaps method
+ //-------------------------------------------------------------------------
+
+ const TInt bufSize = sizeof ( RMobileCall::TMobileCallDataCapsV1 );
+ TBuf8<bufSize> caps2;
+ caps2.FillZ(); //Fill buffer with zeros
+ res = call.GetMobileDataCallCaps(caps2);
+ ASSERT_EQUALS(KErrArgument, res);
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGMDCC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileDataCallCaps for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileDataCallCaps for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetMobileDataCallCaps00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyFaxLineName);
+ OpenNewCallLC(line, call);
+
+ RMobileCall::TMobileCallDataCapsV1 dataCallCaps;
+ RMobileCall::TMobileCallDataCapsV1Pckg dataCallCapsPckg(dataCallCaps);
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::GetMobileDataCallCaps is not supported for fax calls
+ //-------------------------------------------------------------------------
+
+ TInt res = call.GetMobileDataCallCaps(dataCallCapsPckg);
+ ASSERT_EQUALS(KErrNotSupported, res)
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNHIC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyHscsdInfoChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyHscsdInfoChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyHscsdInfoChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::NotifyHscsdInfoChange is not supported for voice calls
+ //-------------------------------------------------------------------------
+
+ OpenLineLC(line, KMmTsyVoice1LineName);
+ OpenNewCallLC(line, call);
+
+ TRequestStatus reqStatus;
+ RMobileCall::TMobileCallHscsdInfoV1 info;
+ RMobileCall::TMobileCallHscsdInfoV1Pckg infoPckg(info);
+ call.NotifyHscsdInfoChange(reqStatus, infoPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(2); // call, line
+
+ // same test for voice call from auxiliary voice line
+ OpenLineLC(line, KMmTsyVoice2LineName);
+ OpenNewCallLC(line, call);
+
+ call.NotifyHscsdInfoChange(reqStatus, infoPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNHIC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyHscsdInfoChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyHscsdInfoChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyHscsdInfoChange0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+ DialL(call, 1, RMobilePhone::ECircuitDataService);
+
+ TRequestStatus reqStatus;
+
+ RMobileCall::TMobileCallHscsdInfoV1 info;
+ RMobileCall::TMobileCallHscsdInfoV1Pckg infoPckg(info);
+
+ RMobileCall::TMobileCallHscsdInfoV1 hscsdInfo;
+ RMobileCall::TMobileCallDataCapsV1 dataCallCaps;
+
+ hscsdInfo.iAiur = RMobileCall::EAiurBps38400;
+ hscsdInfo.iRxTimeSlots = 2;
+ hscsdInfo.iTxTimeSlots = 2;
+ hscsdInfo.iCodings = RMobileCall::ETchCoding320;
+
+ dataCallCaps.iAsymmetryCaps = RMobileCall::KCapsAsymmetryNoPreference;
+ dataCallCaps.iUserInitUpgrade = EFalse;
+ dataCallCaps.iCodingCaps = RMobileCall::KCapsAiurCoding144;
+ dataCallCaps.iRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion1;
+ dataCallCaps.iHscsdSupport = ETrue; // should be ETrue
+ dataCallCaps.iMaxRxTimeSlots = 2;
+ dataCallCaps.iSpeedCaps = RMobileCall::KCapsSpeed14400;
+ dataCallCaps.iMaxTxTimeSlots = 2;
+ dataCallCaps.iProtocolCaps = RMobileCall::KCapsProtocolV32 | RMobileCall::KCapsPstnMultimedia;
+ dataCallCaps.iQoSCaps = RMobileCall::KCapsTransparentPreferred;
+ dataCallCaps.iServiceCaps = RMobileCall::KCapsDataCircuitAsynchronousRDI;
+ dataCallCaps.iMClass = 1;
+ dataCallCaps.iTotalRxTxTimeSlots = 4;
+ dataCallCaps.iV42bisCaps = RMobileCall::KCapsV42bisBothDirections;
+
+ TMockLtsyCallData2<RMobileCall::TMobileCallHscsdInfoV1, RMobileCall::TMobileCallDataCapsV1> hscsdData(1, RMobilePhone::ECircuitDataService, hscsdInfo, dataCallCaps);
+ data.Close();
+ hscsdData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileCall::NotifyHscsdInfoChange.
+ //-------------------------------------------------------------------------
+
+ call.NotifyHscsdInfoChange(reqStatus, infoPckg);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyHscsdInfoChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ ASSERT_EQUALS(hscsdInfo.iAiur, info.iAiur)
+ ASSERT_EQUALS(hscsdInfo.iRxTimeSlots, info.iRxTimeSlots)
+ ASSERT_EQUALS(hscsdInfo.iTxTimeSlots, info.iTxTimeSlots)
+ ASSERT_EQUALS(hscsdInfo.iCodings, info.iCodings)
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileCall::NotifyHscsdInfoChange
+ // from LTSY.
+ //-------------------------------------------------------------------------
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyHscsdInfoChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(4, this); // call, line, data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNHIC-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyHscsdInfoChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyHscsdInfoChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyHscsdInfoChange0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+ DialL(call, 1, RMobilePhone::ECircuitDataService);
+
+ TRequestStatus reqStatus;
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileCall::NotifyHscsdInfoChange
+ //-------------------------------------------------------------------------
+
+ RMobileCall::TMobileCallHscsdInfoV1 info;
+ RMobileCall::TMobileCallHscsdInfoV1Pckg infoPckg(info);
+ call.NotifyHscsdInfoChange(reqStatus, infoPckg);
+
+ call.CancelAsyncRequest(EMobileCallNotifyHscsdInfoChange);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrCancel, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(4, this); // call, line, data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNHIC-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyHscsdInfoChange with bad parameter data for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyHscsdInfoChange with bad parameter data for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyHscsdInfoChange0008L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+ DialL(call, 1, RMobilePhone::ECircuitDataService);
+
+ TRequestStatus reqStatus;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+
+ RMobileCall::TMobileCallHscsdInfoV1 hscsdInfo;
+ hscsdInfo.iAiur = RMobileCall::EAiurBps38400;
+ hscsdInfo.iRxTimeSlots = 2;
+ hscsdInfo.iTxTimeSlots = 2;
+ hscsdInfo.iCodings = RMobileCall::ETchCoding320;
+
+ RMobileCall::TMobileCallDataCapsV1 dataCallCaps;
+ dataCallCaps.iAsymmetryCaps = RMobileCall::KCapsAsymmetryNoPreference;
+ dataCallCaps.iUserInitUpgrade = EFalse;
+ dataCallCaps.iCodingCaps = RMobileCall::KCapsAiurCoding144;
+ dataCallCaps.iRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion1;
+ dataCallCaps.iHscsdSupport = ETrue; // should be ETrue
+ dataCallCaps.iMaxRxTimeSlots = 2;
+ dataCallCaps.iSpeedCaps = RMobileCall::KCapsSpeed14400;
+ dataCallCaps.iMaxTxTimeSlots = 2;
+ dataCallCaps.iProtocolCaps = RMobileCall::KCapsProtocolV32 | RMobileCall::KCapsPstnMultimedia;
+ dataCallCaps.iQoSCaps = RMobileCall::KCapsTransparentPreferred;
+ dataCallCaps.iServiceCaps = RMobileCall::KCapsDataCircuitAsynchronousRDI;
+ dataCallCaps.iMClass = 1;
+ dataCallCaps.iTotalRxTxTimeSlots = 4;
+ dataCallCaps.iV42bisCaps = RMobileCall::KCapsV42bisBothDirections;
+
+ TMockLtsyCallData2<RMobileCall::TMobileCallHscsdInfoV1, RMobileCall::TMobileCallDataCapsV1> hscsdData(1, mobileService, hscsdInfo, dataCallCaps);
+ data.Close();
+ hscsdData.SerialiseL(data);
+
+ //-------------------------------------------------------------------------
+ // Test B: Test passing wrong descriptor size to parameter in
+ // RMobileCall::NotifyHscsdInfoChange
+ //-------------------------------------------------------------------------
+
+ TBuf8<1> smallBuf(KNullDesC8);
+ call.NotifyHscsdInfoChange(reqStatus, smallBuf);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyHscsdInfoChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ User::WaitForRequest(reqStatus);
+
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+
+ CleanupStack::PopAndDestroy(4, this); // call, line, data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNHIC-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyHscsdInfoChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyHscsdInfoChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyHscsdInfoChange0009L()
+ {
+
+ 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);
+
+ // prepare first call
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ TName callName;
+ ret = call.OpenNewCall(line, callName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call);
+ DialL(call, 1, RMobilePhone::ECircuitDataService);
+
+ RMobileCall::TMobileCallHscsdInfoV1 info;
+ RMobileCall::TMobileCallHscsdInfoV1Pckg infoPckg(info);
+
+ TRequestStatus reqStatus;
+
+ // prepare second call
+ RLine line2;
+ RMobileCall call2;
+
+ TInt errorCode = line2.Open(phone2, KMmTsyDataLineName);
+ ASSERT_EQUALS(KErrNone, errorCode)
+ CleanupClosePushL(line2);
+
+ OpenNewCallLC(line2, call2);
+ DialL(call2, 2, RMobilePhone::ECircuitDataService);
+
+ RMobileCall::TMobileCallHscsdInfoV1 info2;
+ RMobileCall::TMobileCallHscsdInfoV1Pckg infoPckg2(info2);
+
+ TRequestStatus reqStatus2;
+
+ // prepare third call
+ RMobileCall call3;
+ ret = call3.OpenExistingCall(line, callName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call3);
+
+ RMobileCall::TMobileCallHscsdInfoV1 info3;
+ RMobileCall::TMobileCallHscsdInfoV1Pckg infoPckg3(info3);
+
+ TRequestStatus reqStatus3;
+
+ // prepare ltsy data
+ RMobileCall::TMobileCallHscsdInfoV1 hscsdInfo;
+ hscsdInfo.iAiur = RMobileCall::EAiurBps38400;
+ hscsdInfo.iRxTimeSlots = 2;
+ hscsdInfo.iTxTimeSlots = 2;
+ hscsdInfo.iCodings = RMobileCall::ETchCoding320;
+
+ RMobileCall::TMobileCallHscsdInfoV1 hscsdInfo2;
+ hscsdInfo2.iAiur = RMobileCall::EAiurBps43200;
+ hscsdInfo2.iRxTimeSlots = 4;
+ hscsdInfo2.iTxTimeSlots = 4;
+ hscsdInfo2.iCodings = RMobileCall::ETchCoding432;
+
+ RMobileCall::TMobileCallDataCapsV1 dataCallCaps;
+ dataCallCaps.iAsymmetryCaps = RMobileCall::KCapsAsymmetryNoPreference;
+ dataCallCaps.iUserInitUpgrade = EFalse;
+ dataCallCaps.iCodingCaps = RMobileCall::KCapsAiurCoding144;
+ dataCallCaps.iRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion1;
+ dataCallCaps.iHscsdSupport = ETrue; // should be ETrue
+ dataCallCaps.iMaxRxTimeSlots = 2;
+ dataCallCaps.iSpeedCaps = RMobileCall::KCapsSpeed14400;
+ dataCallCaps.iMaxTxTimeSlots = 2;
+ dataCallCaps.iProtocolCaps = RMobileCall::KCapsProtocolV32 | RMobileCall::KCapsPstnMultimedia;
+ dataCallCaps.iQoSCaps = RMobileCall::KCapsTransparentPreferred;
+ dataCallCaps.iServiceCaps = RMobileCall::KCapsDataCircuitAsynchronousRDI;
+ dataCallCaps.iMClass = 1;
+ dataCallCaps.iTotalRxTxTimeSlots = 4;
+ dataCallCaps.iV42bisCaps = RMobileCall::KCapsV42bisBothDirections;
+
+ RMobileCall::TMobileCallDataCapsV1 dataCallCaps2;
+ dataCallCaps2.iAsymmetryCaps = RMobileCall::KCapsAsymmetryDownlink;
+ dataCallCaps2.iUserInitUpgrade = ETrue;
+ dataCallCaps2.iCodingCaps = RMobileCall::KCapsAiurCoding96;
+ dataCallCaps2.iRLPVersionCaps = RMobileCall::KCapsRLPMultiLinkVersion2;
+ dataCallCaps2.iHscsdSupport = ETrue; // should be ETrue
+ dataCallCaps2.iMaxRxTimeSlots = 4;
+ dataCallCaps2.iSpeedCaps = RMobileCall::KCapsSpeed28800;
+ dataCallCaps2.iMaxTxTimeSlots = 4;
+ dataCallCaps2.iProtocolCaps = RMobileCall::KCapsProtocolV34 | RMobileCall::KCapsIsdnMultimedia;
+ dataCallCaps2.iQoSCaps = RMobileCall::KCapsTransparent;
+ dataCallCaps2.iServiceCaps = RMobileCall::KCapsDataCircuitSynchronous;
+ dataCallCaps2.iMClass = 2;
+ dataCallCaps2.iTotalRxTxTimeSlots = 6;
+ dataCallCaps2.iV42bisCaps = RMobileCall::KCapsV42bisRxDirection;
+
+ TMockLtsyCallData2<RMobileCall::TMobileCallHscsdInfoV1, RMobileCall::TMobileCallDataCapsV1> hscsdData(1, RMobilePhone::ECircuitDataService, hscsdInfo, dataCallCaps);
+ TMockLtsyCallData2<RMobileCall::TMobileCallHscsdInfoV1, RMobileCall::TMobileCallDataCapsV1> hscsdData2(2, RMobilePhone::ECircuitDataService, hscsdInfo2, dataCallCaps2);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobileCall::NotifyHscsdInfoChange
+ //-------------------------------------------------------------------------
+
+ call.NotifyHscsdInfoChange(reqStatus, infoPckg);
+ call2.NotifyHscsdInfoChange(reqStatus2, infoPckg2);
+ call3.NotifyHscsdInfoChange(reqStatus3, infoPckg3);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ data.Close();
+ hscsdData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallNotifyHscsdInfoChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ data.Close();
+ hscsdData2.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallNotifyHscsdInfoChange, KErrNone, data);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ ASSERT_EQUALS(hscsdInfo.iAiur, info.iAiur)
+ ASSERT_EQUALS(hscsdInfo.iRxTimeSlots, info.iRxTimeSlots)
+ ASSERT_EQUALS(hscsdInfo.iTxTimeSlots, info.iTxTimeSlots)
+ ASSERT_EQUALS(hscsdInfo.iCodings, info.iCodings)
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int())
+ ASSERT_EQUALS(hscsdInfo2.iAiur, info2.iAiur)
+ ASSERT_EQUALS(hscsdInfo2.iRxTimeSlots, info2.iRxTimeSlots)
+ ASSERT_EQUALS(hscsdInfo2.iTxTimeSlots, info2.iTxTimeSlots)
+ ASSERT_EQUALS(hscsdInfo2.iCodings, info2.iCodings)
+
+ User::WaitForRequest(reqStatus3);
+ ASSERT_EQUALS(KErrNone, reqStatus3.Int())
+ // same data as for 1st call because 3rd call object
+ // is opened from existing call
+ ASSERT_EQUALS(hscsdInfo.iAiur, info3.iAiur)
+ ASSERT_EQUALS(hscsdInfo.iRxTimeSlots, info3.iRxTimeSlots)
+ ASSERT_EQUALS(hscsdInfo.iTxTimeSlots, info3.iTxTimeSlots)
+ ASSERT_EQUALS(hscsdInfo.iCodings, info3.iCodings)
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(9, this); // call3, call2, line2, call, line, phone2, telServer2, data, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNHIC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyHscsdInfoChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyHscsdInfoChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyHscsdInfoChange00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyFaxLineName);
+ OpenNewCallLC(line, call);
+
+ TRequestStatus reqStatus;
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::NotifyHscsdInfoChange is not supported for fax calls
+ //-------------------------------------------------------------------------
+
+ RMobileCall::TMobileCallHscsdInfoV1 info;
+ RMobileCall::TMobileCallHscsdInfoV1Pckg infoPckg(info);
+
+ call.NotifyHscsdInfoChange(reqStatus, infoPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CSDHP-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::SetDynamicHscsdParams for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::SetDynamicHscsdParams for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestSetDynamicHscsdParams0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::SetDynamicHscsdParams is not supported for voice calls
+ //-------------------------------------------------------------------------
+
+ OpenLineLC(line, KMmTsyVoice1LineName);
+ OpenNewCallLC(line, call);
+
+ TRequestStatus reqStatus;
+ call.SetDynamicHscsdParams(reqStatus, RMobileCall::EAiurBps38400, 2);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(2); // call, line
+
+ // same test for voice call from auxiliary voice line
+ OpenLineLC(line, KMmTsyVoice2LineName);
+ OpenNewCallLC(line, call);
+
+ call.SetDynamicHscsdParams(reqStatus, RMobileCall::EAiurBps38400, 2);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CSDHP-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::SetDynamicHscsdParams for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::SetDynamicHscsdParams for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestSetDynamicHscsdParams0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 expData;
+ CleanupClosePushL(expData);
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ const TInt KCallId = 1;
+ OpenNewCallLC(line, call);
+ DialL(call, KCallId, RMobilePhone::ECircuitDataService);
+
+ TRequestStatus reqStatus;
+
+ RMobileCall::TMobileHscsdCallParamsV8 hscsdParams;
+ hscsdParams.iWantedAiur = RMobileCall::EAiurBps38400;
+ hscsdParams.iWantedRxTimeSlots = 2;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+ TMockLtsyCallData1<RMobileCall::TMobileHscsdCallParamsV1>
+ expLtsyData(KCallId, mobileService, hscsdParams);
+ expLtsyData.SerialiseL(expData);
+
+ TMockLtsyCallData0 completeLtsyData(KCallId, mobileService);
+ completeLtsyData.SerialiseL(completeData);
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileCallSetDynamicHscsdParams, expData, KErrNotSupported);
+
+ call.SetDynamicHscsdParams(reqStatus, hscsdParams.iWantedAiur, hscsdParams.iWantedRxTimeSlots);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotFound, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST B: failure on completion of pending request from LTSY->CTSY
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileCallSetDynamicHscsdParams, expData, KErrNone);
+ iMockLTSY.CompleteL(EMobileCallSetDynamicHscsdParams, KErrGeneral, completeData);
+
+ call.SetDynamicHscsdParams(reqStatus, hscsdParams.iWantedAiur, hscsdParams.iWantedRxTimeSlots);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrGeneral, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileCall::SetDynamicHscsdParams.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileCallSetDynamicHscsdParams, expData, KErrNone);
+ iMockLTSY.CompleteL(EMobileCallSetDynamicHscsdParams, KErrNone, completeData);
+
+ call.SetDynamicHscsdParams(reqStatus, hscsdParams.iWantedAiur, hscsdParams.iWantedRxTimeSlots);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileCall::SetDynamicHscsdParams
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallSetDynamicHscsdParams, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(5, this); // call, line, completeData, expData, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CSDHP-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::SetDynamicHscsdParams for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::SetDynamicHscsdParams for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestSetDynamicHscsdParams0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 expData;
+ CleanupClosePushL(expData);
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ const TInt KCallId = 1;
+ OpenNewCallLC(line, call);
+ DialL(call, KCallId, RMobilePhone::ECircuitDataService);
+
+ TRequestStatus reqStatus;
+
+ RMobileCall::TMobileHscsdCallParamsV8 hscsdParams;
+ hscsdParams.iWantedAiur = RMobileCall::EAiurBps38400;
+ hscsdParams.iWantedRxTimeSlots = 2;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+ TMockLtsyCallData1<RMobileCall::TMobileHscsdCallParamsV1>
+ expLtsyData(KCallId, mobileService, hscsdParams);
+ expLtsyData.SerialiseL(expData);
+
+ TMockLtsyCallData0 completeLtsyData(KCallId, mobileService);
+ completeLtsyData.SerialiseL(completeData);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileCall::SetDynamicHscsdParams
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileCallSetDynamicHscsdParams, expData, KErrNone);
+ iMockLTSY.CompleteL(EMobileCallSetDynamicHscsdParams, KErrNone, completeData);
+
+ call.SetDynamicHscsdParams(reqStatus, hscsdParams.iWantedAiur, hscsdParams.iWantedRxTimeSlots);
+
+ call.CancelAsyncRequest(EMobileCallSetDynamicHscsdParams);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(5, this); // call, line, completeData, expData, this
+
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CSDHP-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::SetDynamicHscsdParams for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::SetDynamicHscsdParams for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestSetDynamicHscsdParams0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 expData;
+ CleanupClosePushL(expData);
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ const TInt KCallId = 1;
+ TName callName;
+ TInt ret = call.OpenNewCall(line, callName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call);
+ DialL(call, KCallId, RMobilePhone::ECircuitDataService);
+
+ TRequestStatus reqStatus;
+
+ RMobileCall::TMobileHscsdCallParamsV8 hscsdParams;
+ hscsdParams.iWantedAiur = RMobileCall::EAiurBps38400;
+ hscsdParams.iWantedRxTimeSlots = 2;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+ TMockLtsyCallData1<RMobileCall::TMobileHscsdCallParamsV1>
+ expLtsyData(KCallId, mobileService, hscsdParams);
+ expLtsyData.SerialiseL(expData);
+
+ TMockLtsyCallData0 completeLtsyData(KCallId, mobileService);
+ completeLtsyData.SerialiseL(completeData);
+
+ // Open second client
+ RTelServer telServer2;
+ ret = telServer2.Connect();
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(telServer2);
+
+ RMobilePhone phone2;
+ ret = phone2.Open(telServer2, KMmTsyPhoneName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(phone2);
+
+ RBuf8 expData2;
+ CleanupClosePushL(expData2);
+ RBuf8 completeData2;
+ CleanupClosePushL(completeData2);
+
+ RLine line2;
+ RMobileCall call2;
+
+ const TInt KCallId2 = 2;
+
+ ret = line2.Open(phone2, KMmTsyDataLineName);
+ ASSERT_EQUALS(KErrNone, ret)
+ CleanupClosePushL(line2);
+
+ OpenNewCallLC(line2, call2);
+ DialL(call2, KCallId2, RMobilePhone::ECircuitDataService);
+
+ TRequestStatus reqStatus2;
+
+ RMobileCall::TMobileHscsdCallParamsV8 hscsdParams2;
+ hscsdParams2.iWantedAiur = RMobileCall::EAiurBps43200;
+ hscsdParams2.iWantedRxTimeSlots = 3;
+
+ TMockLtsyCallData1<RMobileCall::TMobileHscsdCallParamsV1>
+ expLtsyData2(KCallId2, mobileService, hscsdParams2);
+ expLtsyData2.SerialiseL(expData2);
+
+ TMockLtsyCallData0 completeLtsyData2(KCallId2, mobileService);
+ completeLtsyData2.SerialiseL(completeData2);
+
+ // Open third call
+ RBuf8 expData3;
+ CleanupClosePushL(expData3);
+
+ RMobileCall call3;
+ ret = call3.OpenExistingCall(line2, callName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call3);
+
+ TRequestStatus reqStatus3;
+
+ RMobileCall::TMobileHscsdCallParamsV8 hscsdParams3;
+ hscsdParams3.iWantedAiur = RMobileCall::EAiurBps57600;
+ hscsdParams3.iWantedRxTimeSlots = 4;
+
+ TMockLtsyCallData1<RMobileCall::TMobileHscsdCallParamsV1>
+ expLtsyData3(KCallId, mobileService, hscsdParams3);
+ expLtsyData3.SerialiseL(expData3);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobileCall::SetDynamicHscsdParams
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileCallSetDynamicHscsdParams, expData, KErrNone);
+ iMockLTSY.CompleteL(EMobileCallSetDynamicHscsdParams, KErrNone, completeData);
+ call.SetDynamicHscsdParams(reqStatus, hscsdParams.iWantedAiur, hscsdParams.iWantedRxTimeSlots);
+
+ iMockLTSY.ExpectL(EMobileCallSetDynamicHscsdParams, expData2, KErrNone);
+ iMockLTSY.CompleteL(EMobileCallSetDynamicHscsdParams, KErrNone, completeData2);
+ call2.SetDynamicHscsdParams(reqStatus2, hscsdParams2.iWantedAiur, hscsdParams2.iWantedRxTimeSlots);
+
+ iMockLTSY.ExpectL(EMobileCallSetDynamicHscsdParams, expData3, KErrNone);
+ iMockLTSY.CompleteL(EMobileCallSetDynamicHscsdParams, KErrNone, completeData);
+ call3.SetDynamicHscsdParams(reqStatus3, hscsdParams3.iWantedAiur, hscsdParams3.iWantedRxTimeSlots);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int())
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int())
+
+ User::WaitForRequest(reqStatus3);
+ ASSERT_EQUALS(KErrNone, reqStatus3.Int())
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(8); // call3, expData3, call2, line2, completeData2, expData2, phone2, telServer2
+ CleanupStack::PopAndDestroy(5, this); // call, line, completeData, expData, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CSDHP-00010
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::SetDynamicHscsdParams with timeout for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::SetDynamicHscsdParams and tests for timeout for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestSetDynamicHscsdParams00010L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 expData;
+ CleanupClosePushL(expData);
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ const TInt KCallId = 1;
+ OpenNewCallLC(line, call);
+ DialL(call, KCallId, RMobilePhone::ECircuitDataService);
+
+ TRequestStatus reqStatus;
+
+ RMobileCall::TMobileHscsdCallParamsV1 hscsdParams;
+ hscsdParams.iWantedAiur = RMobileCall::EAiurBps38400;
+ hscsdParams.iWantedRxTimeSlots = 2;
+
+ RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
+ TMockLtsyCallData1<RMobileCall::TMobileHscsdCallParamsV1>
+ expLtsyData(KCallId, mobileService, hscsdParams);
+ expLtsyData.SerialiseL(expData);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test timeout of RMobileCall::SetDynamicHscsdParams
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.ExpectL(EMobileCallSetDynamicHscsdParams, expData, KErrNone);
+ call.SetDynamicHscsdParams(reqStatus, hscsdParams.iWantedAiur, hscsdParams.iWantedRxTimeSlots);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrTimedOut, reqStatus.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this); // call, line, expData, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CSDHP-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::SetDynamicHscsdParams for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::SetDynamicHscsdParams for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestSetDynamicHscsdParams00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyFaxLineName);
+ OpenNewCallLC(line, call);
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::SetDynamicHscsdParams is not supported for fax calls
+ //-------------------------------------------------------------------------
+
+ TRequestStatus reqStatus;
+ call.SetDynamicHscsdParams(reqStatus, RMobileCall::EAiurBps38400, 2);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGMDCRR-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileDataCallRLPRange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileDataCallRLPRange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetMobileDataCallRLPRange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::GetMobileDataCallRLPRange is not supported
+ //-------------------------------------------------------------------------
+
+ OpenLineLC(line, KMmTsyVoice1LineName);
+ OpenNewCallLC(line, call);
+
+ TRequestStatus reqStatus;
+ RMobileCall::TMobileDataRLPRangesV1 ranges;
+ RMobileCall::TMobileDataRLPRangesV1Pckg rangesPckg(ranges);
+ call.GetMobileDataCallRLPRange(reqStatus, 0, rangesPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(2); // call, line
+
+ // same test for voice call from auxiliary voice line
+ OpenLineLC(line, KMmTsyVoice2LineName);
+ OpenNewCallLC(line, call);
+
+ call.GetMobileDataCallRLPRange(reqStatus, 0, rangesPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGMDCRR-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileDataCallRLPRange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileDataCallRLPRange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetMobileDataCallRLPRange0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ OpenNewCallLC(line, call);
+
+ TRequestStatus reqStatus;
+ RMobileCall::TMobileDataRLPRangesV1 ranges;
+ RMobileCall::TMobileDataRLPRangesV1Pckg rangesPckg(ranges);
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::GetMobileDataCallRLPRange is not supported
+ //-------------------------------------------------------------------------
+
+ call.GetMobileDataCallRLPRange(reqStatus, 0, rangesPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CGMDCRR-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileDataCallRLPRange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::GetMobileDataCallRLPRange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestGetMobileDataCallRLPRange00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyFaxLineName);
+ OpenNewCallLC(line, call);
+
+ TRequestStatus reqStatus;
+ RMobileCall::TMobileDataRLPRangesV1 ranges;
+ RMobileCall::TMobileDataRLPRangesV1Pckg rangesPckg(ranges);
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::GetMobileDataCallRLPRange is not supported
+ //-------------------------------------------------------------------------
+
+ call.GetMobileDataCallRLPRange(reqStatus, 0, rangesPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNMDCCC-0001
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileDataCallCapsChange for voice calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileDataCallCapsChange for voice calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyMobileDataCallCapsChange0001L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::NotifyMobileDataCallCapsChange is not supported for voice calls
+ //-------------------------------------------------------------------------
+
+ OpenLineLC(line, KMmTsyVoice1LineName);
+ OpenNewCallLC(line, call);
+
+ TRequestStatus reqStatus;
+ RMobileCall::TMobileCallDataCapsV1 callCaps;
+ RMobileCall::TMobileCallDataCapsV1Pckg callCapsPckg(callCaps);
+ call.NotifyMobileDataCallCapsChange(reqStatus, callCapsPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(2); // call, line
+
+ // same test for voice call from auxiliary voice line
+ OpenLineLC(line, KMmTsyVoice2LineName);
+ OpenNewCallLC(line, call);
+
+ call.NotifyMobileDataCallCapsChange(reqStatus, callCapsPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNMDCCC-0006
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileDataCallCapsChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileDataCallCapsChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyMobileDataCallCapsChange0006L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ const TInt KCallId = 1;
+ OpenNewCallLC(line, call);
+ DialL(call, KCallId, RMobilePhone::ECircuitDataService);
+
+ RMobileCall::TMobileCallDataCapsV1 completeCallCaps;
+ completeCallCaps.iSpeedCaps = RMobileCall::KCapsSpeed48000;
+ completeCallCaps.iProtocolCaps = RMobileCall::KCapsProtocolV34;
+ completeCallCaps.iServiceCaps = RMobileCall::KCapsPacketAccessSyncUDI;
+ completeCallCaps.iQoSCaps = RMobileCall::KCapsTransparentPreferred;
+ completeCallCaps.iHscsdSupport = ETrue;
+ completeCallCaps.iMClass = 2;
+ completeCallCaps.iMaxRxTimeSlots = 4;
+ completeCallCaps.iMaxTxTimeSlots = 8;
+ completeCallCaps.iTotalRxTxTimeSlots = 10;
+ completeCallCaps.iCodingCaps = RMobileCall::KCapsAiurCoding96;
+ completeCallCaps.iAsymmetryCaps = RMobileCall::KCapsAsymmetryDownlink;
+ completeCallCaps.iUserInitUpgrade = ETrue;
+ completeCallCaps.iRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion1;
+ completeCallCaps.iV42bisCaps = RMobileCall::KCapsV42bisRxDirection;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallDataCapsV1>
+ completeLtsyData(KCallId, RMobilePhone::ECircuitDataService, completeCallCaps);
+ completeLtsyData.SerialiseL(completeData);
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // RMobileCall::NotifyMobileDataCallCapsChange when result is not cached.
+ //-------------------------------------------------------------------------
+
+ TRequestStatus reqStatus;
+ RMobileCall::TMobileCallDataCapsV1 callCaps;
+ RMobileCall::TMobileCallDataCapsV1Pckg callCapsPckg(callCaps);
+ call.NotifyMobileDataCallCapsChange(reqStatus, callCapsPckg);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileDataCallCapsChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ ASSERT_TRUE(TComparator<RMobileCall::TMobileCallDataCapsV1>::IsEqual(completeCallCaps, callCaps));
+
+ AssertMockLtsyStatusL();
+
+ //-------------------------------------------------------------------------
+ // TEST E: Unsolicited completion of RMobileCall::NotifyMobileDataCallCapsChange
+ // from LTSY.
+ //-------------------------------------------------------------------------
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileDataCallCapsChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(4, this); // call, line, completeData, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNMDCCC-0007
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileDataCallCapsChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileDataCallCapsChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyMobileDataCallCapsChange0007L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ const TInt KCallId = 1;
+ OpenNewCallLC(line, call);
+ DialL(call, KCallId, RMobilePhone::ECircuitDataService);
+
+ //-------------------------------------------------------------------------
+ // Test cancelling of RMobileCall::NotifyMobileDataCallCapsChange
+ //-------------------------------------------------------------------------
+
+ TRequestStatus reqStatus;
+ RMobileCall::TMobileCallDataCapsV1 callCaps;
+ RMobileCall::TMobileCallDataCapsV1Pckg callCapsPckg(callCaps);
+ call.NotifyMobileDataCallCapsChange(reqStatus, callCapsPckg);
+
+ call.CancelAsyncRequest(EMobileCallNotifyMobileDataCallCapsChange);
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrCancel, reqStatus.Int());
+
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy(3, this); // line, call, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNMDCCC-0008
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileDataCallCapsChange with bad parameter data for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileDataCallCapsChange with bad parameter data for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyMobileDataCallCapsChange0008L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ const TInt KCallId = 1;
+ OpenNewCallLC(line, call);
+ DialL(call, KCallId, RMobilePhone::ECircuitDataService);
+
+ RMobileCall::TMobileCallDataCapsV1 completeCallCaps;
+ completeCallCaps.iSpeedCaps = RMobileCall::KCapsSpeed48000;
+ completeCallCaps.iProtocolCaps = RMobileCall::KCapsProtocolV34;
+ completeCallCaps.iServiceCaps = RMobileCall::KCapsPacketAccessSyncUDI;
+ completeCallCaps.iQoSCaps = RMobileCall::KCapsTransparentPreferred;
+ completeCallCaps.iHscsdSupport = ETrue;
+ completeCallCaps.iMClass = 2;
+ completeCallCaps.iMaxRxTimeSlots = 4;
+ completeCallCaps.iMaxTxTimeSlots = 8;
+ completeCallCaps.iTotalRxTxTimeSlots = 10;
+ completeCallCaps.iCodingCaps = RMobileCall::KCapsAiurCoding96;
+ completeCallCaps.iAsymmetryCaps = RMobileCall::KCapsAsymmetryDownlink;
+ completeCallCaps.iUserInitUpgrade = ETrue;
+ completeCallCaps.iRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion1;
+ completeCallCaps.iV42bisCaps = RMobileCall::KCapsV42bisRxDirection;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallDataCapsV1>
+ completeLtsyData(KCallId, RMobilePhone::ECircuitDataService, completeCallCaps);
+ completeLtsyData.SerialiseL(completeData);
+
+ //-------------------------------------------------------------------------
+ // Test B: Test passing wrong descriptor size to parameter in
+ // RMobileCall::NotifyMobileDataCallCapsChange
+ //-------------------------------------------------------------------------
+
+ TRequestStatus reqStatus;
+ TBuf8<1> wrongCallCaps(KNullDesC8);
+ call.NotifyMobileDataCallCapsChange(reqStatus, wrongCallCaps);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileDataCallCapsChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+
+ //-------------------------------------------------------------------------
+ // Test B: Test passing wrong parameter to
+ // RMobileCall::NotifyMobileDataCallCapsChange method
+ //-------------------------------------------------------------------------
+
+ const TInt bufSize = sizeof ( RMobileCall::TMobileCallDataCapsV1 );
+ TBuf8<bufSize> wrongCallCaps2;
+ wrongCallCaps2.FillZ(); // Fill buffer with zero
+ call.NotifyMobileDataCallCapsChange(reqStatus, wrongCallCaps2);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileDataCallCapsChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrArgument, reqStatus.Int());
+
+ CleanupStack::PopAndDestroy(4, this); // call, line, completeData, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNMDCCC-0009
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileDataCallCapsChange for data calls
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileDataCallCapsChange for data calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyMobileDataCallCapsChange0009L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyDataLineName);
+ const TInt KCallId = 1;
+ TName callName;
+ TInt ret = call.OpenNewCall(line, callName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call);
+ DialL(call, KCallId, RMobilePhone::ECircuitDataService);
+
+ RMobileCall::TMobileCallDataCapsV1 completeCallCaps;
+ completeCallCaps.iSpeedCaps = RMobileCall::KCapsSpeed48000;
+ completeCallCaps.iProtocolCaps = RMobileCall::KCapsProtocolV34;
+ completeCallCaps.iServiceCaps = RMobileCall::KCapsPacketAccessSyncUDI;
+ completeCallCaps.iQoSCaps = RMobileCall::KCapsTransparentPreferred;
+ completeCallCaps.iHscsdSupport = ETrue;
+ completeCallCaps.iMClass = 2;
+ completeCallCaps.iMaxRxTimeSlots = 4;
+ completeCallCaps.iMaxTxTimeSlots = 8;
+ completeCallCaps.iTotalRxTxTimeSlots = 10;
+ completeCallCaps.iCodingCaps = RMobileCall::KCapsAiurCoding96;
+ completeCallCaps.iAsymmetryCaps = RMobileCall::KCapsAsymmetryDownlink;
+ completeCallCaps.iUserInitUpgrade = ETrue;
+ completeCallCaps.iRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion1;
+ completeCallCaps.iV42bisCaps = RMobileCall::KCapsV42bisRxDirection;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallDataCapsV1>
+ completeLtsyData(KCallId, RMobilePhone::ECircuitDataService, completeCallCaps);
+ completeLtsyData.SerialiseL(completeData);
+
+ // Open second client
+ 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;
+ RMobileCall call2;
+
+ const TInt KCallId2 = 2;
+
+ ret = line2.Open(phone2, KMmTsyDataLineName);
+ ASSERT_EQUALS(KErrNone, ret)
+ CleanupClosePushL(line2);
+
+ OpenNewCallLC(line2, call2);
+ DialL(call2, KCallId2, RMobilePhone::ECircuitDataService);
+
+ RBuf8 completeData2;
+ CleanupClosePushL(completeData2);
+
+ RMobileCall::TMobileCallDataCapsV1 completeCallCaps2;
+ completeCallCaps2.iSpeedCaps = RMobileCall::KCapsSpeed56000;
+ completeCallCaps2.iProtocolCaps = RMobileCall::KCapsProtocolV32;
+ completeCallCaps2.iServiceCaps = RMobileCall::KCapsPacketAccessSyncRDI;
+ completeCallCaps2.iQoSCaps = RMobileCall::KCapsTransparent;
+ completeCallCaps2.iHscsdSupport = EFalse;
+ completeCallCaps2.iMClass = 1;
+ completeCallCaps2.iMaxRxTimeSlots = 2;
+ completeCallCaps2.iMaxTxTimeSlots = 4;
+ completeCallCaps2.iTotalRxTxTimeSlots = 6;
+ completeCallCaps2.iCodingCaps = RMobileCall::KCapsAiurCoding144;
+ completeCallCaps2.iAsymmetryCaps = RMobileCall::KCapsAsymmetryUplink;
+ completeCallCaps2.iUserInitUpgrade = EFalse;
+ completeCallCaps2.iRLPVersionCaps = RMobileCall::KCapsRLPMultiLinkVersion2;
+ completeCallCaps2.iV42bisCaps = RMobileCall::KCapsV42bisBothDirections;
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallDataCapsV1>
+ completeLtsyData2(KCallId2, RMobilePhone::ECircuitDataService, completeCallCaps2);
+ completeLtsyData2.SerialiseL(completeData2);
+
+ // open third call
+ RMobileCall call3;
+ ret = call3.OpenExistingCall(line2, callName);
+ ASSERT_EQUALS(KErrNone, ret);
+ CleanupClosePushL(call3);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting RMobileCall::NotifyMobileDataCallCapsChange
+ //-------------------------------------------------------------------------
+
+ TRequestStatus reqStatus;
+ RMobileCall::TMobileCallDataCapsV1 callCaps;
+ RMobileCall::TMobileCallDataCapsV1Pckg callCapsPckg(callCaps);
+ call.NotifyMobileDataCallCapsChange(reqStatus, callCapsPckg);
+
+ TRequestStatus reqStatus2;
+ RMobileCall::TMobileCallDataCapsV1 callCaps2;
+ RMobileCall::TMobileCallDataCapsV1Pckg callCapsPckg2(callCaps2);
+ call2.NotifyMobileDataCallCapsChange(reqStatus2, callCapsPckg2);
+
+ TRequestStatus reqStatus3;
+ RMobileCall::TMobileCallDataCapsV1 callCaps3;
+ RMobileCall::TMobileCallDataCapsV1Pckg callCapsPckg3(callCaps3);
+ call3.NotifyMobileDataCallCapsChange(reqStatus3, callCapsPckg3);
+
+ TRequestStatus mockLtsyStatus;
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileDataCallCapsChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileDataCallCapsChange, KErrNone, completeData2);
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int())
+
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNone, reqStatus.Int());
+ ASSERT_TRUE(TComparator<RMobileCall::TMobileCallDataCapsV1>::IsEqual(completeCallCaps, callCaps));
+
+ User::WaitForRequest(reqStatus2);
+ ASSERT_EQUALS(KErrNone, reqStatus2.Int());
+ ASSERT_TRUE(TComparator<RMobileCall::TMobileCallDataCapsV1>::IsEqual(completeCallCaps2, callCaps2));
+
+ User::WaitForRequest(reqStatus3);
+ ASSERT_EQUALS(KErrNone, reqStatus3.Int());
+ ASSERT_TRUE(TComparator<RMobileCall::TMobileCallDataCapsV1>::IsEqual(completeCallCaps, callCaps3));
+
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy(10, this); // call3, completeData2, call2, line2, phone2, telServer2, call, line, completeData, this
+
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-DATC-CNMDCCC-00011
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileDataCallCapsChange for fax calls
+@SYMTestPriority High
+@SYMTestActions Invokes RMobileCall::NotifyMobileDataCallCapsChange for fax calls
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+*/
+void CCTsyDataCallControlFU::TestNotifyMobileDataCallCapsChange00011L()
+ {
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RLine line;
+ RMobileCall call;
+
+ OpenLineLC(line, KMmTsyFaxLineName);
+ OpenNewCallLC(line, call);
+
+ TRequestStatus reqStatus;
+ RMobileCall::TMobileCallDataCapsV1 callCaps;
+ RMobileCall::TMobileCallDataCapsV1Pckg callCapsPckg(callCaps);
+
+ //-------------------------------------------------------------------------
+ // TEST: failure to dispatch request to CTSY
+ // because RMobileCall::NotifyMobileDataCallCapsChange is not supported for fax calls
+ //-------------------------------------------------------------------------
+
+ call.NotifyMobileDataCallCapsChange(reqStatus, callCapsPckg);
+ User::WaitForRequest(reqStatus);
+ ASSERT_EQUALS(KErrNotSupported, reqStatus.Int())
+
+ CleanupStack::PopAndDestroy(3, this); // call, line, this
+
+ }
+
+