// 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 CallControl in the Common TSY.

// 

//

/**

*/

#include "cctsycallcontrolfu.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 <etelmmerr.h>

#include "MmTsy_timeoutdefs.h"

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

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0008L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall00010L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCall00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0001bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006cL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006dL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006eL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006fL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006gL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006hL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0006iL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0008L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0009bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial0009cL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial00010L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDial00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00010L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00011bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00011cL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00012L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00014L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHangUp00015L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestHold0001aL);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSwap0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSwap0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSwap0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSwap0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSwap0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSwap00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestResume0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestResume0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestResume0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestResume0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestResume0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestResume00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDeflect0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDeflect0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDeflect0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTransfer00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateAllCalls0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateAllCalls0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateAllCalls0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestTerminateAllCalls0005L);	

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestSetIncomingCallType0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCallISV0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCallISV0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCallISV0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCallISV0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCallISV0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestAnswerIncomingCallISV00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDialISV0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDialISV0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDialISV00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDialCallControl0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDialCallControl0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestDialCallControl00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestEnumerateCall0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestEnumerateCall0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestEnumerateCall00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestNotifyHookChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestNotifyHookChange0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestNotifyHookChange00011L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestCompleteNotifyStatusChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyCallControlFU, TestUpdateLifeTime0001L);	

	END_SUITE;

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CTSY-CCON-CAIC-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RCall::AnswerIncomingCall for voice calls

@SYMTestPriority High

@SYMTestActions Invokes RCall::AnswerIncomingCall for voice calls

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallControlFU::TestAnswerIncomingCall0001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

    RBuf8 expectData;

    CleanupClosePushL(expectData);

    RBuf8 completeData;

    CleanupClosePushL(completeData);

	RLine line;

	RCall call;

	CleanupClosePushL(call);

	TInt errorCode = KErrNone;

	TInt callId = 1;

	TName incomingCallName;

    TRequestStatus requestStatus;

    TRequestStatus requestNotify;

	// open new line and call for KMmTsyVoice1LineName

	errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName);

	ASSERT_EQUALS(KErrNone, errorCode);

    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;

    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

 	//-------------------------------------------------------------------------

	// TEST A: failure to dispatch request to LTSY

 	//-------------------------------------------------------------------------

 	//-------------------------------------------------------------------------

	// create new incoming call

	errorCode = CreateIncomingCallL(line, callId, incomingCallName, 

	                               mobileService, mobileCallStatus);	

	ASSERT_EQUALS(KErrNone, errorCode);

    errorCode = call.OpenExistingCall(line, incomingCallName);

    ASSERT_EQUALS(KErrNone, errorCode);

 	//-------------------------------------------------------------------------

    TMockLtsyCallData0 mockData0(callId, mobileService);

    expectData.Close();

    mockData0.SerialiseL(expectData);

    iMockLTSY.ExpectL(EEtelCallAnswer, expectData, KErrNotSupported);

	RMobileCall::TMobileCallParamsV1 callParamsV1;

	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);

    call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);

    User::WaitForRequest(requestStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

	// close incoming call

 	CloseIncomingCallL(call, callId, mobileService);

	//-------------------------------------------------------------------------

	// TEST B: failure on completion of pending request from LTSY->CTSY

 	//-------------------------------------------------------------------------

 	//-------------------------------------------------------------------------

	// create new incoming call

	errorCode = CreateIncomingCallL(line, callId, incomingCallName, 

	                               mobileService, mobileCallStatus);	

	ASSERT_EQUALS(KErrNone, errorCode);

    AssertMockLtsyStatusL();

    errorCode = call.OpenExistingCall(line, incomingCallName);

    ASSERT_EQUALS(KErrNone, errorCode);

    AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

    expectData.Close();

    mockData0.SerialiseL(expectData);

    iMockLTSY.ExpectL(EEtelCallAnswer, expectData);

    iMockLTSY.CompleteL(EEtelCallAnswer, KErrGeneral, expectData);

    call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);

    User::WaitForRequest(requestStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrGeneral, requestStatus.Int());

	// close incoming call

    CloseIncomingCallL(call, callId, mobileService);

 	//-------------------------------------------------------------------------

	// TEST C: Successful completion request of

	// RCall::AnswerIncomingCall when result is not cached.

 	//-------------------------------------------------------------------------

 	//-------------------------------------------------------------------------

	// create new incoming call

	errorCode = CreateIncomingCallL(line, callId, incomingCallName, 

	                               mobileService, mobileCallStatus);	

	ASSERT_EQUALS(KErrNone, errorCode);

    AssertMockLtsyStatusL();

    errorCode = call.OpenExistingCall(line, incomingCallName);

    ASSERT_EQUALS(KErrNone, errorCode);

    AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

    expectData.Close();

    mockData0.SerialiseL(expectData);

    iMockLTSY.ExpectL(EEtelCallAnswer, expectData);

    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData);

    call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);

    User::WaitForRequest(requestStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrNone, requestStatus.Int());

	// close incoming call

    CloseIncomingCallL(call, callId, mobileService);

 	//-------------------------------------------------------------------------

	// TEST E: Unsolicited completion of RCall::AnswerIncomingCall

	// from LTSY.

 	//-------------------------------------------------------------------------

    TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	expectData.Close();

    mockData0.SerialiseL(expectData);

	iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData);

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

 	//-------------------------------------------------------------------------

	// TEST : Call AnswerIncomingCall with null description

 	//-------------------------------------------------------------------------

 	//-------------------------------------------------------------------------

	// create new incoming call

	errorCode = CreateIncomingCallL(line, callId, incomingCallName,

	                               mobileService, mobileCallStatus);	

	ASSERT_EQUALS(KErrNone, errorCode);

    AssertMockLtsyStatusL();

    errorCode = call.OpenExistingCall(line, incomingCallName);

    ASSERT_EQUALS(KErrNone, errorCode);

    AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

    expectData.Close();

    mockData0.SerialiseL(expectData);

    iMockLTSY.ExpectL(EEtelCallAnswer, expectData);

    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData);

    TPtr8 null(NULL,0);

    call.AnswerIncomingCall(requestStatus, null);

    User::WaitForRequest(requestStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrNone, requestStatus.Int());

	// close incoming call

    CloseIncomingCallL(call, callId, mobileService);

 	//-------------------------------------------------------------------------

	// TEST : to increase CMmVoiceCallTsy::AnswerIncomingCall coverage

	// covers "if ( 0 < answerCallHandle )" condition

 	//-------------------------------------------------------------------------

	RCall call2;

	CleanupClosePushL(call2);

    TRequestStatus requestStatus2;

 	//-------------------------------------------------------------------------

	// create new incoming call

	errorCode = CreateIncomingCallL(line, callId, incomingCallName,

	                               mobileService, mobileCallStatus);	

	ASSERT_EQUALS(KErrNone, errorCode);

    AssertMockLtsyStatusL();

    errorCode = call.OpenExistingCall(line, incomingCallName);

    ASSERT_EQUALS(KErrNone, errorCode);

    AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

 	//-------------------------------------------------------------------------

    errorCode = call2.OpenExistingCall(line, incomingCallName);

    ASSERT_EQUALS(KErrNone, errorCode);

    AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

    expectData.Close();

    mockData0.SerialiseL(expectData);

    iMockLTSY.ExpectL(EEtelCallAnswer, expectData);

    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, expectData);

    call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);

    call2.AnswerIncomingCall(requestStatus2, mmParamsPckgV1);

    User::WaitForRequest(requestStatus);

    ASSERT_EQUALS(KErrNone, requestStatus.Int());

    User::WaitForRequest(requestStatus2);

    ASSERT_EQUALS(KErrServerBusy, requestStatus2.Int());

	call.Close();

	CloseIncomingCallL(call2, callId, mobileService);

	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

	// TEST : to increase CMmVoiceCallTsy::AnswerIncomingCall coverage

	// covers "else if( activeCall && 

	//                ( !( KETelExt3rdPartyV1 == activeCall->GetExtensionId() ) &&

	//                ( KETelExt3rdPartyV1 == extensionId ) ) )" condition

 	//-------------------------------------------------------------------------

	mobileCallStatus = RMobileCall::EStatusRinging;

	// create new incoming call1

	errorCode = CreateIncomingCallL(line, callId, incomingCallName,

	                               mobileService, mobileCallStatus);	

	ASSERT_EQUALS(KErrNone, errorCode);

	AssertMockLtsyStatusL();

	RMobileCall call1;

	CleanupClosePushL(call1);

    errorCode = call1.OpenExistingCall(line, incomingCallName);

    ASSERT_EQUALS(KErrNone, errorCode);

	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

 	TName incomingCallName2;

 	TInt callId2 = 2;

	mobileCallStatus = RMobileCall::EStatusConnected;

	// create new incoming call2

	errorCode = CreateIncomingCallL(line, callId2, incomingCallName2,

	                               mobileService, mobileCallStatus);	

	ASSERT_EQUALS(KErrNone, errorCode);

	AssertMockLtsyStatusL();

    errorCode = call2.OpenExistingCall(line, incomingCallName2);

    ASSERT_EQUALS(KErrNone, errorCode);

	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

	call2.AnswerIncomingCall(requestStatus2, mmParamsPckgV1);

	RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParams;

	TPckg<RMobileCall::TEtel3rdPartyMobileCallParamsV1> callParamsPckg(callParams);

	call1.AnswerIncomingCallISV(requestStatus, callParamsPckg);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrGsmNotAllowed, requestStatus.Int());

	User::WaitForRequest(requestStatus2);

	ASSERT_EQUALS(KErrNotSupported, requestStatus2.Int());

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(7, this); // expectData, completeData, call, line, call2

										  // this, call1 

	}

/**

@SYMTestCaseID BA-CTSY-CCON-CAIC-0002

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::AnswerIncomingCall for voice calls

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RCall::AnswerIncomingCall for voice calls

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallControlFU::TestAnswerIncomingCall0002L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 expectData;

	CleanupClosePushL(expectData);

	RLine line;

	RCall call;

	CleanupClosePushL(call);

	TInt errorCode = KErrNone;

	TInt callId = 1;

	TName incomingCallName;

    TRequestStatus requestStatus;

	TRequestStatus mockLtsyStatus;

    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;

    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

 	//-------------------------------------------------------------------------

	// Test cancelling of RCall::AnswerIncomingCall

 	//-------------------------------------------------------------------------

	// open new line for KMmTsyVoice1LineName

	errorCode = OpenNewLineLC(iPhone, line, KMmTsyVoice1LineName);

	ASSERT_EQUALS(KErrNone, errorCode);

 	//-------------------------------------------------------------------------

	// create new incoming call

	errorCode = CreateIncomingCallL(line, callId, incomingCallName,

	                               mobileService, mobileCallStatus);	

	ASSERT_EQUALS(KErrNone, errorCode);

	AssertMockLtsyStatusL();

    errorCode = call.OpenExistingCall(line, incomingCallName);

    ASSERT_EQUALS(KErrNone, errorCode);

	AssertMockLtsyStatusL();

 	//-------------------------------------------------------------------------

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

    TMockLtsyCallData0 mockData0(callId, mobileService);

    expectData.Close();

    mockData0.SerialiseL(expectData);

    iMockLTSY.ExpectL(EEtelCallAnswer, expectData);

    iMockLTSY.CompleteL(EEtelCallAnswer, KErrCancel, expectData);

	RMobileCall::TMobileCallParamsV1 callParamsV1;

	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);

    call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);

	TInt hangUpCause = KErrGsmBusyUserRequest;

	TBool autoStChangeDisable = ETrue;

    TMockLtsyCallData2<TInt, TBool> mockData2(callId, mobileService, 

                                             hangUpCause, 

                                             autoStChangeDisable);

    expectData.Close();                                             

    mockData2.SerialiseL(expectData);

    iMockLTSY.ExpectL(EEtelCallHangUp, expectData);

    call.CancelAsyncRequest(EEtelCallAnswer);

    User::WaitForRequest(requestStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

	User::WaitForRequest(mockLtsyStatus);

	CleanupStack::PopAndDestroy(4); // this, expectData, call, line

	}

/**

@SYMTestCaseID BA-CTSY-CCON-CAIC-0004

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::AnswerIncomingCall for voice calls

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to RCall::AnswerIncomingCall for voice calls

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyCallControlFU::TestAnswerIncomingCall0004L()