// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// The TEFUnit test suite for CallControlControl in the Common TSY.

//

#include "cctsycallcontrolfu.h"

#include "isvao.h"

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <test/tmockltsydata.h>

#include <ctsy/ltsy/mltsydispatchcallcontrolinterface.h>

#include "testconstants.h"

#include "mockltsyindicatorids.h"

#include <sacls.h> // For phone power P&S key needed by Etel3rdParty testing

#include <e32property.h>

#include <ctsy/rmmcustomapi.h>

#include <centralrepository.h>

CTestSuite* CCTsyCallControlFU::CreateSuiteL(const TDesC& aName)

	{

	SUB_SUITE;

	// Add use-case tests

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0008L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0010L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0012L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0013L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0014L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0015L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0016L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0017L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0018L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0019L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0020L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0021L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0022L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0023L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0024L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUseCase0025L);

	// Add other unit tests

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0008L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0010L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0012L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0013L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0014L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0015L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0016L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0017L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0018L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0019L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0020L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUnit0021L);

	END_SUITE;

	}

//

// Use-case tests

//

/**

@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0001

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for mobile originated voice call accepted and hang up

@SYMTestPriority High

@SYMTestActions Make a voice call, receive status change notifications, hang up

@SYMTestExpectedResults Pass - Call reaches connected state and call is hung up

@SYMTestType CT

*/

void CCTsyCallControlFU::TestUseCase0001L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	TRequestStatus reqStatus;

	iMockLTSY.NotifyTerminated(reqStatus); 

	TInt callId = 1;

	RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	DriverDialCallL(callId, mobileService);

	TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up

	DriverHangUpCallL(callId, hangUpCause);

	// Client Side Test

	RMobileLine mobileLine;

	CleanupClosePushL(mobileLine);

	RMobileCall mobileCall;

	CleanupClosePushL(mobileCall);

	ClientDialCallL(mobileLine, mobileCall, mobileService);

	ClientHangUpCallL(mobileCall);

	mobileCall.Close();

	mobileLine.Close();

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrNone, reqStatus.Int());

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(3, this); //mobileCall, mobileLine, this

	} // CCTsyCallControlFU::TestUseCase0001L

/**

@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0002

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for failed dialling of a mobile originated call

@SYMTestPriority High

@SYMTestActions Dials a voice call, receives error from LTSY

@SYMTestExpectedResults Pass - Dial request fails

@SYMTestType CT

*/

void CCTsyCallControlFU::TestUseCase0002L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup, this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	TInt callId = 1;

	RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	DriverExpectDialCallRequestL(callId, mobileService, KErrGeneral);

	// Client Side Test

	RMobileLine mobileLine;

	CleanupClosePushL(mobileLine);

	RMobileCall mobileCall;

	CleanupClosePushL(mobileCall);

	ASSERT_EQUALS(KErrNone, OpenLineAndCallL(mobileLine, mobileCall, RMobilePhone::EVoiceService));

	RMobileCall::TMobileCallParamsV1 callParams;

	RMobileCall::TMobileCallParamsV1Pckg callParamsPckg(callParams);

	callParams.iAutoRedial = ETrue;

	callParams.iIdRestrict = RMobileCall::ESendMyId;

	TRequestStatus dialStatus;

	mobileCall.Dial(dialStatus, callParamsPckg, KPhoneNumber);

	User::WaitForRequest(dialStatus);

	ASSERT_EQUALS(KErrGeneral, dialStatus.Int());

	RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusUnknown;

	mobileCall.GetMobileCallStatus(callStatus);

	ASSERT_EQUALS(RMobileCall::EStatusIdle, callStatus);

	mobileCall.Close();

	mobileLine.Close();

	data.Close();

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(4, this); // mobileCall, mobileLine, data, this

	} // CCTsyCallControlFU::TestUseCase0002L

/**

@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0003

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for remote party rejecting a dialled call

@SYMTestPriority High

@SYMTestActions Dials a call, remote party rejects it, check call status and notifications are correct

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallControlFU::TestUseCase0003L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup, this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	TInt callId = 1;

	RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	DriverExpectDialCallRequestL(callId, mobileService, KErrNone);

	// Complete KLtsyDispatchCallControlNotifyCallStatusChangeApiId

	RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusDialling;

	TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(

			callId, RMobilePhone::EServiceUnspecified, callStatus);

    data.Close();

    mockCallData.SerialiseL(data);

    iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallStatusChangeIndId, KErrNone, data);

    // Complete events expected when remote party rejects call

    // Complete KLtsyDispatchCallControlNotifyCallStatusChangeApiId

    DriverCompleteSuccessfulHangUpNotificationsL(callId, EFalse, KErrGsmCCCallRejected, EFalse);

	// Client Side Test

    RMobileLine mobileLine;

	CleanupClosePushL(mobileLine);

	RMobileCall mobileCall;

	CleanupClosePushL(mobileCall);

	ASSERT_EQUALS(KErrNone, OpenLineAndCallL(mobileLine, mobileCall, RMobilePhone::EVoiceService));

	TRequestStatus notifyCallStatus;

	callStatus = RMobileCall::EStatusUnknown;

	mobileCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);

	RMobileCall::TMobileCallParamsV1 callParams;

	RMobileCall::TMobileCallParamsV1Pckg callParamsPckg(callParams);

	callParams.iAutoRedial = ETrue;

	callParams.iIdRestrict = RMobileCall::ESendMyId;

	TRequestStatus dialStatus;

	mobileCall.Dial(dialStatus, callParamsPckg, KPhoneNumber);

	User::WaitForRequest(dialStatus);

	ASSERT_EQUALS(KErrGsmCCCallRejected, dialStatus.Int());

	RArray<RMobileCall::TMobileCallStatus> expectedCallStatuses;

    CleanupClosePushL(expectedCallStatuses);

    expectedCallStatuses.AppendL(RMobileCall::EStatusDialling);

    expectedCallStatuses.AppendL(RMobileCall::EStatusDisconnecting);

    expectedCallStatuses.AppendL(RMobileCall::EStatusIdle);

    ClientWaitForCallStatusNotifications(mobileCall, notifyCallStatus, callStatus, expectedCallStatuses, KErrNone);

	callStatus = RMobileCall::EStatusUnknown;

	mobileCall.GetMobileCallStatus(callStatus);

	ASSERT_EQUALS(RMobileCall::EStatusIdle, callStatus);

	expectedCallStatuses.Close();

	mobileCall.Close();

	mobileLine.Close();

	data.Close();

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(5, this); // expectedCallStatuses, mobileCall, mobileLine, data, this

	} // CCTsyCallControlFU::TestUseCase0003L

/**

@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0004

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for remote party hang up without inband info

@SYMTestPriority High

@SYMTestActions Invokes dialling voice call, receive remote party hang up

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallControlFU::TestUseCase0004L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup, this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	TInt callId = 1;

	RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	DriverDialCallL(callId, mobileService);

    RMobileLine mobileLine;

	CleanupClosePushL(mobileLine);

	RMobileCall mobileCall;

	CleanupClosePushL(mobileCall);

	ClientDialCallL(mobileLine, mobileCall, mobileService);

	RMobileCall::TMobileCallEvent callEvent = RMobileCall::ERemoteTerminated;

	TMockLtsyCallData1<RMobileCall::TMobileCallEvent> callEventData(callId, mobileService, callEvent);

	callEventData.SerialiseL(data);

    iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyCallEventIndId, KErrNone, data);

    DriverCompleteSuccessfulHangUpNotificationsL(callId, EFalse, KErrGsmCCNormalCallClearing);

    TRequestStatus notifyCallEventStatus;

    RMobileCall::TMobileCallEvent receivedCallEvent;

    mobileCall.NotifyCallEvent(notifyCallEventStatus, receivedCallEvent);

	TRequestStatus notifyCallStatus;

	RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusUnknown;

	mobileCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);

	RArray<RMobileCall::TMobileCallStatus> expectedCallStatuses;

    CleanupClosePushL(expectedCallStatuses);

    expectedCallStatuses.AppendL(RMobileCall::EStatusDisconnecting);

    expectedCallStatuses.AppendL(RMobileCall::EStatusIdle);

    ClientWaitForCallStatusNotifications(mobileCall, notifyCallStatus, callStatus, expectedCallStatuses, KErrNone);

    User::WaitForRequest(notifyCallEventStatus);

    ASSERT_EQUALS(KErrNone, notifyCallEventStatus.Int());

    ASSERT_EQUALS(callEvent, receivedCallEvent);

    expectedCallStatuses.Close();

	mobileCall.Close();

	mobileLine.Close();

	data.Close();

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(5, this); // expectedCallStatuses, mobileCall, mobileLine, data, this

	} // CCTsyCallControlFU::TestUseCase0004L

/**

@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0005

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for remote party hang up with inband info

@SYMTestPriority High

@SYMTestActions Dial a voice call, remote party hangs up with inband info

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallControlFU::TestUseCase0005L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup, this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	TInt callId = 1;

	RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	DriverDialCallL(callId, mobileService);

    RMobileLine mobileLine;

	CleanupClosePushL(mobileLine);

	RMobileCall mobileCall;

	CleanupClosePushL(mobileCall);

	ClientDialCallL(mobileLine, mobileCall, mobileService);

	DriverCompleteSuccessfulHangUpNotificationsL(callId, ETrue, KErrGsmCCNormalCallClearing);

	TRequestStatus notifyCallStatus;

	RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusUnknown;

	mobileCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus);

	RArray<RMobileCall::TMobileCallStatus> expectedCallStatuses;

    CleanupClosePushL(expectedCallStatuses);

    expectedCallStatuses.AppendL(RMobileCall::EStatusDisconnectingWithInband);

    expectedCallStatuses.AppendL(RMobileCall::EStatusIdle);

    ClientWaitForCallStatusNotifications(mobileCall, notifyCallStatus, callStatus, expectedCallStatuses, KErrNone);

    expectedCallStatuses.Close();

	mobileCall.Close();

	mobileLine.Close();

	data.Close();

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(5, this); // expectedCallStatuses, mobileCall, mobileLine, data, this

	} // CCTsyCallControlFU::TestUseCase0005L

/**

@SYMTestCaseID BA-CTSYD-DIS-CALLCONTROL-UC0006

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for mobile originated data call

@SYMTestPriority High

@SYMTestActions Invokes Dials a data call, receives call status notifications, loan and recover the data port, hang up call.

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallControlFU::TestUseCase0006L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup, this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	TInt callId = 1;

	RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	DriverDialCallL(callId, mobileService);

	// KMockLtsyDispatchCallControlNotifyDataCallCapsChangeIndId

	RMobileCall::TMobileCallDataCapsV1 completeCallCaps;

	completeCallCaps.iSpeedCaps = RMobileCall::KCapsSpeed48000;

	completeCallCaps.iProtocolCaps = RMobileCall::KCapsProtocolV34;

	completeCallCaps.iServiceCaps = RMobileCall::KCapsPacketAccessSyncUDI;

	completeCallCaps.iQoSCaps = RMobileCall::KCapsTransparentPreferred;

	completeCallCaps.iHscsdSupport = ETrue;

	completeCallCaps.iMClass = 2;

	completeCallCaps.iMaxRxTimeSlots = 4;

	completeCallCaps.iMaxTxTimeSlots = 8;

	completeCallCaps.iTotalRxTxTimeSlots = 10;

	completeCallCaps.iCodingCaps = RMobileCall::KCapsAiurCoding96;

	completeCallCaps.iAsymmetryCaps = RMobileCall::KCapsAsymmetryDownlink;

	completeCallCaps.iUserInitUpgrade = ETrue;

	completeCallCaps.iRLPVersionCaps = RMobileCall::KCapsRLPSingleLinkVersion1;

	completeCallCaps.iV42bisCaps = RMobileCall::KCapsV42bisRxDirection;

	data.Close();

	TMockLtsyCallData1<RMobileCall::TMobileCallDataCapsV1>

		completeDataCapsData(callId, RMobilePhone::EServiceUnspecified, completeCallCaps);

	completeDataCapsData.SerialiseL(data);

	iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyDataCallCapsChangeIndId, KErrNone, data);

    _LIT(KDataPort, "DATAPORT::0");

    RCall::TCommPort commPort;

    commPort.iPort = KDataPort;

    data.Close();

    TMockLtsyData2<TInt,RCall::TCommPort> loanDataPortExpData(callId,commPort);

	loanDataPortExpData.SerialiseL(data);

    iMockLTSY.ExpectL(MLtsyDispatchCallControlLoanDataPort::KLtsyDispatchCallControlLoanDataPortApiId, data);

    iMockLTSY.ExpectL(MLtsyDispatchCallControlRecoverDataPort::KLtsyDispatchCallControlRecoverDataPortApiId, data);

	// MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId

	RMobileCall::TMobileHscsdCallParamsV8 hscsdParams;

	hscsdParams.iWantedAiur = RMobileCall::EAiurBps38400;

	hscsdParams.iWantedRxTimeSlots = 2;

	data.Close();

	TMockLtsyData2<TInt, RMobileCall::TMobileHscsdCallParamsV8> paramData(callId, hscsdParams);

	paramData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId, data);

    TMockLtsyData1<TInt> mockParamData(callId);

    data.Close();

    mockParamData.SerialiseL(data);

	iMockLTSY.CompleteL(MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId, KErrNone, data);

	// KMockLtsyDispatchCallControlNotifyHscsdInfoChangeIndId

    RMobileCall::TMobileCallHscsdInfoV8 hscsdInfo;

    hscsdInfo.iCodings = RMobileCall::ETchCoding320;

    hscsdInfo.iAiur = RMobileCall::EAiurBps38400;

    hscsdInfo.iRxTimeSlots = 2;

    hscsdInfo.iTxTimeSlots = 2;

    RMobileCall::TMobileCallDataCapsV1 completeCallCaps2 = completeCallCaps;

    completeCallCaps2.iHscsdSupport = ETrue;

    completeCallCaps2.iSpeedCaps = RMobileCall::KCapsSpeed57600;

    completeCallCaps2.iMaxRxTimeSlots = 3;

    completeCallCaps2.iMaxTxTimeSlots = 5;

    TMockLtsyCallData2<RMobileCall::TMobileCallHscsdInfoV8, RMobileCall::TMobileCallDataCapsV1>

    		hscsdData(1, RMobilePhone::ECircuitDataService, hscsdInfo, completeCallCaps2);

    data.Close();

    hscsdData.SerialiseL(data);

	iMockLTSY.CompleteL(KMockLtsyDispatchCallControlNotifyHscsdInfoChangeIndId, KErrNone, data);

	TInt hangUpCause = KErrGsmCCNormalCallClearing;

	DriverHangUpCallL(callId, hangUpCause);

	// Client Side Test

    RMobileLine mobileLine;

	CleanupClosePushL(mobileLine);

	RMobileCall mobileCall;

	CleanupClosePushL(mobileCall);

	ClientDialCallL(mobileLine, mobileCall, mobileService);

	RCall::TCommPort dataPort;

	TRequestStatus reqStatus;

	mobileCall.LoanDataPort(reqStatus, dataPort);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrNone, reqStatus.Int());

	ASSERT_EQUALS(0, dataPort.iPort.Compare(KDataPort()));

	TInt err = mobileCall.RecoverDataPort();

	ASSERT_EQUALS(KErrNone, err);

	RMobileCall::TMobileCallDataCapsV1 callCaps;

	RMobileCall::TMobileCallDataCapsV1Pckg callCapsPckg(callCaps);

	mobileCall.GetMobileDataCallCaps(callCapsPckg);

	ASSERT_TRUE(TComparator<RMobileCall::TMobileCallDataCapsV1>::IsEqual(completeCallCaps, callCaps));

	TRequestStatus hscsdInfoStatus;

	RMobileCall::TMobileCallHscsdInfoV8 hscsdInfo2;

	RMobileCall::TMobileCallHscsdInfoV8Pckg hscsdInfoPckg(hscsdInfo2);

	mobileCall.NotifyHscsdInfoChange(hscsdInfoStatus, hscsdInfoPckg);

	TRequestStatus dataCallCapsStatus;

	RMobileCall::TMobileCallDataCapsV1 dataCallCaps2;

	RMobileCall::TMobileCallDataCapsV1Pckg dataCallCapsPckg(dataCallCaps2);

	mobileCall.NotifyMobileDataCallCapsChange(dataCallCapsStatus, dataCallCapsPckg);

	TRequestStatus hscsdParamStatus;

	mobileCall.SetDynamicHscsdParams(hscsdParamStatus, hscsdParams.iWantedAiur, hscsdParams.iWantedRxTimeSlots);

	User::WaitForRequest(hscsdParamStatus);

	User::WaitForRequest(hscsdInfoStatus);

	ASSERT_EQUALS(KErrNone, hscsdInfoStatus.Int());

	ASSERT_EQUALS(hscsdInfo2.iAiur, hscsdInfo.iAiur);

	ASSERT_EQUALS(hscsdInfo2.iRxTimeSlots, hscsdInfo.iRxTimeSlots);

	ASSERT_EQUALS(hscsdInfo2.iTxTimeSlots, hscsdInfo.iTxTimeSlots);

	ASSERT_EQUALS(hscsdInfo2.iCodings, hscsdInfo.iCodings);

	User::WaitForRequest(dataCallCapsStatus);

	ASSERT_EQUALS(KErrNone, dataCallCapsStatus.Int());

	ASSERT_EQUALS(completeCallCaps2.iSpeedCaps, dataCallCaps2.iSpeedCaps);