// 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