// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// The TEFUnit test suite for CallInformation in the Common TSY.
// 
//

/**
 @file 
*/

#include "cctsycallinformationfu.h"
#include <etel.h>
#include <etelmm.h>
#include <et_clsvr.h>
#include <ctsy/mmtsy_names.h>
#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
#include "tmockltsydata.h"
#include <ctsy/serviceapi/gsmerror.h>
#include <sys/unistd.h>


CTestSuite* CCTsyCallInformationFU::CreateSuiteL(const TDesC& aName)
	{
	SUB_SUITE;
	
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams0006bL);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams0006cL);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams0008L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallParams00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallDuration0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallDuration0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallDuration00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetOwnershipStatus0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetOwnershipStatus0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetOwnershipStatus00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCaps0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCaps0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCaps00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetInfo0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetInfo0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetInfo00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetStatus0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetStatus0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetStatus00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallInfo0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallInfo0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallInfo0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallInfo0008L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallInfo00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetCallInfo00013L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestEnumerateCall0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestEnumerateCall0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestEnumerateCall00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange0004L);	
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange0007L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange00012L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCapsChange00014L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyHookChange0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyHookChange0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyHookChange00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange0007L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange00012L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyStatusChange00014L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange0007L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange00012L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallDurationChange00014L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded0007L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded00012L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallAdded00014L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall0007L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall00012L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCall00014L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent0007L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent00012L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyCallEvent00014L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallCaps0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallCaps0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallCaps0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallCaps0008L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallCaps00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallCaps00013L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo0006bL);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo0008L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallInfo00013L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallStatus0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallStatus0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetMobileCallStatus00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyAudioToneEvent0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyAudioToneEvent0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyAudioToneEvent00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0007L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0008L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange00012L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange00013L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallCapsChange00014L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0003L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0007L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0008L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange00012L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange00013L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyRemotePartyInfoChange00014L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange0002L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange0004L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange0007L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange0009L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange00012L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyMobileCallStatusChange00014L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetIncomingCallType0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetIncomingCallType0006L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestGetIncomingCallType00011L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyIncomingCallTypeChange0001L);
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyLineHookChange0001L);	
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyLineHookChange0006L);	
	ADD_TEST_STEP_ISO_CPP(CCTsyCallInformationFU, TestNotifyLineHookChange00011L);	

	END_SUITE;
	}


//
// Actual test cases
//


/**
@SYMTestCaseID BA-CTSY-CALLI-CGCP-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCallParams for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallParams0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);
    TBool activeCallFlag = EFalse;
    //----------------------------------------

    RMobileCall::TMobileCallParamsV1 callParams1;
    RMobileCall::TMobileCallParamsV1Pckg paramPckg1(callParams1);
    
    TInt ret = call.GetCallParams(paramPckg1);
    ASSERT_EQUALS(KErrNone, ret);

    ValidateCallParams(&paramPckg1, activeCallFlag);
    
    //----------------------------------------
    RMobileCall::TMobileCallParamsV2 callParams2;
    RMobileCall::TMobileCallParamsV2Pckg paramPckg2(callParams2);

    ret = call.GetCallParams(paramPckg2);
    ASSERT_EQUALS(KErrNone, ret);

    ValidateCallParams(&paramPckg2, activeCallFlag);
    
  	
	//----------------------------------------
    RMobileCall::TMobileCallParamsV7 callParams7;
    RMobileCall::TMobileCallParamsV7Pckg paramPckg7(callParams7);

    ret = call.GetCallParams(paramPckg7);

    ValidateCallParams(&paramPckg7, activeCallFlag);
    
    AssertMockLtsyStatusL();
	
	//-- now create incoming call and get params when dialing, just to show that they are changed 
	
    RBuf8 completeData;
    CleanupClosePushL(completeData);
	
	RCall call2;	
	TInt callId = 1;
	TName incomingCallName;

    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
	
	CreateAndOpenIncomingCalLC(line, call2, incomingCallName, 
		lineName, callId, RMobileCall::EStatusIdle, mobileService);
	
    TRequestStatus requestStatus;
			
 	//-- dial -----------------------------------------------------------------------

    _LIT(KNum, "23467");
    RCall::TTelNumberC num(KNum);
    
    // TMobileCallParamsV1 params for Dial
	RMobileCall::TMobileCallParamsV1 params;
	RMobileCall::TMobileCallParamsV1Pckg paramsPckg(params);
    params.iInterval = 2;
    params.iCug.iCugIndex = 0;
    params.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
    params.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
    params.iWaitForDialTone = RCall::EDialToneWait;
    
   	RMobileCall::TMobileCallInfoV8 callInfo;
	callInfo.iDialledParty.iTelNumber.Copy(KNum);
	callInfo.iRemoteParty.iDirection = RMobileCall::EDirectionUnknown;
	callInfo.iService = mobileService;
	callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
	callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
	
	// Dialing and Verfication of params for TMobileCallParamsV1
	TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV8> 
		dialData(-1, mobileService, params, callInfo);
	completeData.Close();
	dialData.SerialiseL(completeData);
	iMockLTSY.ExpectL(EEtelCallDial,completeData);    
	
    call2.Dial(requestStatus, paramsPckg, callInfo.iDialledParty.iTelNumber);
    TMockLtsyCallData0 dialCompleteData(0,mobileService);
	completeData.Close();
	dialCompleteData.SerialiseL(completeData);
	iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData,0);	
	
    User::WaitForRequest(requestStatus);
    AssertMockLtsyStatusL(); 
       
    RMobileCall::TMobileCallParamsV1 recParams;
    RMobileCall::TMobileCallParamsV1Pckg recParamsPckg(recParams);
    ret = call2.GetCallParams(recParamsPckg);
    ASSERT_EQUALS(KErrNone, ret);
    activeCallFlag = ETrue;
    
    ValidateCallParams(&recParamsPckg, activeCallFlag);

    // TMobileCallParamsV2 params for Dial
   	RMobileCall::TMobileCallParamsV2 params2;
   	RMobileCall::TMobileCallParamsV2Pckg paramsPckg2(params2);
    params2.iInterval = 2;
    params2.iCug.iCugIndex = 0;
    params2.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
    params2.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
    params2.iWaitForDialTone = RCall::EDialToneWait;
    params2.iBearerMode = RMobileCall::EMulticallNotSupported;
       
    // Dialing and Verfication of params for TMobileCallParamsV2
    TMockLtsyCallData2<RMobileCall::TMobileCallParamsV2, RMobileCall::TMobileCallInfoV8> 
		dialData2(-1, mobileService, params2, callInfo);
	completeData.Close();
	dialData2.SerialiseL(completeData);
	iMockLTSY.ExpectL(EEtelCallDial,completeData);    
	
    call2.Dial(requestStatus, paramsPckg2, callInfo.iDialledParty.iTelNumber);
    completeData.Close();
	dialCompleteData.SerialiseL(completeData);
	iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData,0);	
		
    User::WaitForRequest(requestStatus);
    AssertMockLtsyStatusL();
    
    RMobileCall::TMobileCallParamsV2 recParams2;
    RMobileCall::TMobileCallParamsV2Pckg recParamsPckg2(recParams2);
    
    ret = call2.GetCallParams(recParamsPckg2);
    ASSERT_EQUALS(KErrNone, ret);

    ValidateCallParams(&recParamsPckg2, activeCallFlag);

    // TMobileCallParamsV7 params for Dial
	RMobileCall::TMobileCallParamsV7 params7;
	RMobileCall::TMobileCallParamsV7Pckg paramsPckg7(params7);
	params7.iInterval = 2;
	params7.iCug.iCugIndex = 0;
	params7.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
	params7.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
	params7.iWaitForDialTone = RCall::EDialToneWait;
	params7.iBearerMode = RMobileCall::EMulticallNotSupported;
	params7.iAlphaId.Copy(_L("Alpha Id"));
    
    // Dialing and Verfication of params for TMobileCallParamsV7
    TMockLtsyCallData2<RMobileCall::TMobileCallParamsV7, RMobileCall::TMobileCallInfoV8> 
		dialData7(-1, mobileService, params7, callInfo);
	completeData.Close();
	dialData7.SerialiseL(completeData);
	iMockLTSY.ExpectL(EEtelCallDial,completeData);    
	
    call2.Dial(requestStatus, paramsPckg7, callInfo.iDialledParty.iTelNumber);
    completeData.Close();
	dialCompleteData.SerialiseL(completeData);
	iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData,0);	
		
    User::WaitForRequest(requestStatus);
    AssertMockLtsyStatusL();
    RMobileCall::TMobileCallParamsV7 recParams7;
    RMobileCall::TMobileCallParamsV7Pckg recParamsPckg7(recParams7);
    ret = call2.GetCallParams(recParamsPckg7);
    ASSERT_EQUALS(KErrNone, ret);

    ValidateCallParams(&recParamsPckg7, activeCallFlag);

    CleanupStack::PopAndDestroy(5, this); 

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGCP-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams with bad parameter data for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCallParams with bad parameter data for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallParams0003L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);  
    
    TInt8 callParams;    // bad param
    TPckg<TInt8> paramPckg(callParams);
        
    TInt ret = call.GetCallParams(paramPckg);
    ASSERT_EQUALS(KErrArgument, ret);
    
    RCall::TCallParams callParams2;
    RCall::TCallParamsPckg paramPckg2(callParams2);
  
    ret = call.GetCallParams(paramPckg2);
    ASSERT_EQUALS(KErrArgument, ret);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 
	}

/**
@SYMTestCaseID BA-CTSY-CALLI-CGCP-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams for data calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCallParams for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallParams0006L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
       
	OpenLineLC(line, iPhone, lineName);
	
    
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);
   
   
    //- using different types of params struct---------------------------------------
    
    RMobileCall::TMobileCallParamsV1 callParams1;
    RMobileCall::TMobileCallParamsV1Pckg paramPckg1(callParams1);
    TBool activeCallFlag = EFalse; 
    TInt ret = call.GetCallParams(paramPckg1);
    ASSERT_EQUALS(KErrNone, ret);

    ValidateCallParams(&paramPckg1, activeCallFlag);
         
    //----------------------------------------
    RMobileCall::TMobileCallParamsV2 callParams2;
    RMobileCall::TMobileCallParamsV2Pckg paramPckg2(callParams2);
    ret = call.GetCallParams(paramPckg2);
    ASSERT_EQUALS(KErrNone, ret);

    ValidateCallParams(&paramPckg2, activeCallFlag);
      
    //---------------------------------------------
    RMobileCall::TMobileCallParamsV7 callParams7;
    RMobileCall::TMobileCallParamsV7Pckg paramPckg7(callParams7);

    ret = call.GetCallParams(paramPckg7);
    ASSERT_EQUALS(KErrNone, ret);
    ValidateCallParams(&paramPckg7, activeCallFlag);
    //-- data param --------------------------------------
    RMobileCall::TMobileDataCallParamsV1 dataCallParams1;
    RMobileCall::TMobileDataCallParamsV1Pckg dataCallParamPckg1(dataCallParams1);
    
    ret = call.GetCallParams(dataCallParamPckg1);
    ASSERT_EQUALS(KErrNone, ret);
    
    ValidateDataCallParams(&dataCallParamPckg1, activeCallFlag);
    
    //--------------------------------------------------
    RMobileCall::TMobileDataCallParamsV2 dataCallParams2;
    RMobileCall::TMobileDataCallParamsV2Pckg dataCallParamPckg2(dataCallParams2);
    
    ret = call.GetCallParams(dataCallParamPckg2);
    ASSERT_EQUALS(KErrNone, ret);
    
    ValidateDataCallParams(&dataCallParamPckg2, activeCallFlag);
    
    //------------------------------------------------------
    RMobileCall::TMobileDataCallParamsV8 dataCallParams8;
    RMobileCall::TMobileDataCallParamsV8Pckg dataCallParamPckg8(dataCallParams8);
    
    ret = call.GetCallParams(dataCallParamPckg8);
    ASSERT_EQUALS(KErrNone, ret);
    ValidateDataCallParams(&dataCallParamPckg8, activeCallFlag);

 	//-- Dial -----------------------------------------------------------------------

    TRequestStatus requestStatus;			    
    _LIT(KNum, "23467");
    RCall::TTelNumberC num(KNum);
    
    RBuf8 completeData;
    CleanupClosePushL(completeData);
		
	TInt callId = 1;
	RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
   
    
    RMobileCall::TMobileDataCallParamsV1 recDataCallParams1;
    RMobileCall::TMobileDataCallParamsV1Pckg recDataCallParamPckg1(recDataCallParams1);
        
    // TMobileDataCallParamsV1 params for Dial
    dataCallParams1.iInterval = 2;
    dataCallParams1.iCug.iCugIndex = 0xFFFF;
    dataCallParams1.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
    dataCallParams1.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
    dataCallParams1.iWaitForDialTone = RCall::EDialToneWait;
    dataCallParams1.iQoS = RMobileCall::EQosTransparentPreferred;
    dataCallParams1.iV42bisReq = RMobileCall::EV42bisTxDirection;
    
    RMobileCall::TMobileCallInfoV8 callInfo;
	callInfo.iDialledParty.iTelNumber.Copy(KNum);
	callInfo.iService = mobileService;
	callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
	callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;

	TMockLtsyCallData2<RMobileCall::TMobileDataCallParamsV1, RMobileCall::TMobileCallInfoV8> 
		dialDataCall(0, mobileService, dataCallParams1, callInfo);
	completeData.Close();
	dialDataCall.SerialiseL(completeData);
	iMockLTSY.ExpectL(EEtelCallDial,completeData);    
	
	CallGetMobileCallInfoL(callId, mobileService, callInfo.iDialledParty.iTelNumber);
	
	TMockLtsyCallData0 dialCompleteData(callId,mobileService);
   	completeData.Close();
   	dialCompleteData.SerialiseL(completeData);
   	iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData);
	
    call.Dial(requestStatus, dataCallParamPckg1, callInfo.iDialledParty.iTelNumber);
	
    CompleteDialStatusNotificationsL(call, callId, mobileService );
	
    User::WaitForRequest(requestStatus);
   	AssertMockLtsyStatusL(); 
    
    ret = call.GetCallParams(recDataCallParamPckg1);
    ASSERT_EQUALS(KErrNone, ret);
	activeCallFlag = ETrue;
    ValidateDataCallParams(&recDataCallParamPckg1, activeCallFlag);
  
    CompleteCallDisconnectNotificationsL(callId, mobileService);
    
    call.Close();
    //------------------------------------------------------------------------    
   
    RMobileCall::TMobileDataCallParamsV2 recDataCallParams2;
    RMobileCall::TMobileDataCallParamsV2Pckg recDataCallParamPckg2(recDataCallParams2);
      
    // TMobileDataCallParamsV2 params for Dial
    dataCallParams2.iInterval = 2;
    dataCallParams2.iCug.iCugIndex = 0xFFFF;
    dataCallParams2.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
    dataCallParams2.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
    dataCallParams2.iWaitForDialTone = RCall::EDialToneWait;
    dataCallParams2.iQoS = RMobileCall::EQosTransparentPreferred;
    dataCallParams2.iV42bisReq = RMobileCall::EV42bisTxDirection;
    dataCallParams2.iBearerMode = RMobileCall::EMulticallShareBearer;
       
    // open new call
  	CleanupClosePushL(call);
  	TInt errorCode = call.OpenNewCall(line, name);
    ASSERT_EQUALS(KErrNone, errorCode);

    TMockLtsyCallData2<RMobileCall::TMobileDataCallParamsV2, RMobileCall::TMobileCallInfoV8> 
		dialDataCall2(0, mobileService, dataCallParams2, callInfo);
	completeData.Close();
	dialDataCall2.SerialiseL(completeData);
	iMockLTSY.ExpectL(EEtelCallDial,completeData);    
	
	CallGetMobileCallInfoL(callId, mobileService, callInfo.iDialledParty.iTelNumber);
	
	completeData.Close();
   	dialCompleteData.SerialiseL(completeData);
   	iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData);
		
	call.Dial(requestStatus, dataCallParamPckg2, callInfo.iDialledParty.iTelNumber);
	
	CompleteDialStatusNotificationsL(call, callId, mobileService );
	
   	User::WaitForRequest(requestStatus);
   	AssertMockLtsyStatusL();
    
   	ret = call.GetCallParams(recDataCallParamPckg2);
    ASSERT_EQUALS(KErrNone, ret);
    ValidateDataCallParams(&recDataCallParamPckg2, activeCallFlag);
    
    CompleteCallDisconnectNotificationsL(callId, mobileService);
    call.Close();
    
    //--------------------------------------------------------------------
    
    RMobileCall::TMobileDataCallParamsV8 recDataCallParams8;
    RMobileCall::TMobileDataCallParamsV8Pckg recDataCallParamPckg8(recDataCallParams8);
        
    RMobileCall::TMobileCallInfoV8 callInformation;
    callInformation.iDialledParty.iTelNumber.Copy(KNum);
    callInformation.iService = mobileService;
    callInformation.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
    callInformation.iAlphaId.Copy(_L("Alpha Id"));
    callInformation.iValid |= RMobileCall::KCallAlphaId;
    callInformation.iCallParamOrigin = RMobileCall::EOriginatorSIM;
    callInformation.iValid |= RMobileCall::KCallParamOrigin;
   
     
    // TMobileDataCallParamsV8 params for Dial
    dataCallParams8.iInterval = 2;
    dataCallParams8.iCug.iCugIndex = 0xFFFF;
    dataCallParams8.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
    dataCallParams8.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
    dataCallParams8.iWaitForDialTone = RCall::EDialToneWait;
    dataCallParams8.iQoS = RMobileCall::EQosTransparentPreferred;
    dataCallParams8.iV42bisReq = RMobileCall::EV42bisTxDirection;
    dataCallParams8.iBearerMode = RMobileCall::EMulticallShareBearer;
    dataCallParams8.iSubAddress.Copy(_L("An Unknown SubAddress"));
    dataCallParams8.iCallParamOrigin = RMobileCall::EOriginatorSIM;
    dataCallParams8.iAlphaId.Copy(_L("Alpha Id"));

    // open new call
   	CleanupClosePushL(call);
   	errorCode = call.OpenNewCall(line, name);
    ASSERT_EQUALS(KErrNone, errorCode);
    
    TMockLtsyCallData2<RMobileCall::TMobileDataCallParamsV8, RMobileCall::TMobileCallInfoV8> 
		dialDataCall8(0, mobileService, dataCallParams8, callInformation);
	completeData.Close();
	dialDataCall8.SerialiseL(completeData);
	iMockLTSY.ExpectL(EEtelCallDial,completeData);    
	
	CallGetMobileCallInfoL(callId, mobileService,  callInformation.iDialledParty.iTelNumber);
	
	completeData.Close();
	dialCompleteData.SerialiseL(completeData);
	iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
	
	call.Dial(requestStatus, dataCallParamPckg8,  callInformation.iDialledParty.iTelNumber);
	
	CompleteDialStatusNotificationsL(call, callId, mobileService );
	
	User::WaitForRequest(requestStatus);
   	AssertMockLtsyStatusL(); 
        	
    ret = call.GetCallParams(recDataCallParamPckg8);
    ASSERT_EQUALS(KErrNone, ret);
    ValidateDataCallParams(&recDataCallParamPckg8, activeCallFlag);
    
    CompleteCallDisconnectNotificationsL(callId, mobileService);
    
    call.Close();
   
    CleanupStack::PopAndDestroy(6, this); 

    }


/**
@SYMTestCaseID BA-CTSY-CALLI-CGCP-0006b
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams for data calls with HscsdCallParams. It is in connection to BA-CTSY-CALLI-CGCP-0006
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCallParams for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallParams0006bL()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
       
	OpenLineLC(line, iPhone, lineName);
	
    
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);
   
   
    //- using different types of params struct---------------------------------------
    TBool activeCallFlag = EFalse;

		    
    //-- Hscsd param --------------------------------------    
    RMobileCall::TMobileHscsdCallParamsV1 hscsdCallParams1;
    RMobileCall::TMobileHscsdCallParamsV1Pckg hscsdCallParamPckg1(hscsdCallParams1);
    TInt ret = call.GetCallParams(hscsdCallParamPckg1);
    ASSERT_EQUALS(KErrNone, ret);
    
    ValidateHscsdCallParams(&hscsdCallParamPckg1, activeCallFlag);
    //----------------------------------------
    
    RMobileCall::TMobileHscsdCallParamsV2 hscsdCallParams2;
    RMobileCall::TMobileHscsdCallParamsV2Pckg hscsdCallParamPckg2(hscsdCallParams2);

    ret = call.GetCallParams(hscsdCallParamPckg2);
    ASSERT_EQUALS(KErrNone, ret);
    
    ValidateHscsdCallParams(&hscsdCallParamPckg2, activeCallFlag);
    
    //----------------------------------------
        
    RMobileCall::TMobileHscsdCallParamsV7 hscsdCallParams7;
    RMobileCall::TMobileHscsdCallParamsV7Pckg hscsdCallParamPckg7(hscsdCallParams7);

    ret = call.GetCallParams(hscsdCallParamPckg7);
    ASSERT_EQUALS(KErrNone, ret);
    
    ValidateHscsdCallParams(&hscsdCallParamPckg7, activeCallFlag);
    
    call.Close();
    //-- Dial -----------------------------------------------------------------------

    TRequestStatus requestStatus;			    
    _LIT(KNum, "23467");
    RCall::TTelNumberC num(KNum);
    
    RBuf8 completeData;
    CleanupClosePushL(completeData);
		
	TInt callId = 1;
	RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
   
    RMobileCall::TMobileHscsdCallParamsV1 recHscsdCallParams1;
    RMobileCall::TMobileHscsdCallParamsV1Pckg recHscsdCallParamPckg1(recHscsdCallParams1);

    // TMobileHscsdCallParamsV1 params for Dial
    hscsdCallParams1.iInterval = 2;
    hscsdCallParams1.iCug.iCugIndex = 0xFFFF;
    hscsdCallParams1.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
    hscsdCallParams1.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
    hscsdCallParams1.iWaitForDialTone = RCall::EDialToneWait;
    hscsdCallParams1.iQoS = RMobileCall::EQosTransparentPreferred;
    hscsdCallParams1.iV42bisReq = RMobileCall::EV42bisTxDirection;
    hscsdCallParams1.iWantedRxTimeSlots = 2; 
    hscsdCallParams1.iCodings = 3;
    
    RMobileCall::TMobileCallInfoV8 callInfo;
   	callInfo.iDialledParty.iTelNumber.Copy(KNum);
   	callInfo.iService = mobileService;
   	callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
   	callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
    
    // open new call
   	CleanupClosePushL(call);
   	TInt errorCode = call.OpenNewCall(line, name);
    ASSERT_EQUALS(KErrNone, errorCode);

    TMockLtsyCallData2<RMobileCall::TMobileHscsdCallParamsV1, RMobileCall::TMobileCallInfoV8> 
		dialHscsdCall(0, mobileService, hscsdCallParams1, callInfo);
	completeData.Close();
	dialHscsdCall.SerialiseL(completeData);
	iMockLTSY.ExpectL(EEtelCallDial,completeData);    
	
	CallGetMobileCallInfoL(callId, mobileService, callInfo.iDialledParty.iTelNumber);
	
	TMockLtsyCallData0 dialCompleteData(callId,mobileService);
	completeData.Close();
   	dialCompleteData.SerialiseL(completeData);
   	iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData);
	
	call.Dial(requestStatus, hscsdCallParamPckg1, callInfo.iDialledParty.iTelNumber);
    
	CompleteDialStatusNotificationsL(call, callId, mobileService );
	 
   	User::WaitForRequest(requestStatus);
    AssertMockLtsyStatusL();  
        
    ret = call.GetCallParams(recHscsdCallParamPckg1);
    ASSERT_EQUALS(KErrNone, ret);
    activeCallFlag = ETrue;
    ValidateHscsdCallParams(&recHscsdCallParamPckg1, activeCallFlag);
    
    CompleteCallDisconnectNotificationsL(callId, mobileService);
   
    call.Close();
    //-----------------------------------------------------------
    
    RMobileCall::TMobileHscsdCallParamsV2 recHscsdCallParams2;
    RMobileCall::TMobileHscsdCallParamsV2Pckg recHscsdCallParamPckg2(recHscsdCallParams2);
    
    // TMobileHscsdCallParamsV2 params for Dial
    hscsdCallParams2.iInterval = 2;
    hscsdCallParams2.iCug.iCugIndex = 0xFFFF;
    hscsdCallParams2.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
    hscsdCallParams2.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
    hscsdCallParams2.iWaitForDialTone = RCall::EDialToneWait;
    hscsdCallParams2.iQoS = RMobileCall::EQosTransparentPreferred;
    hscsdCallParams2.iV42bisReq = RMobileCall::EV42bisTxDirection;
    hscsdCallParams2.iWantedRxTimeSlots = 2; 
    hscsdCallParams2.iCodings = 3;
    hscsdCallParams2.iBearerMode = RMobileCall::EMulticallShareBearer;
    
    // open new call
   	CleanupClosePushL(call);
   	errorCode = call.OpenNewCall(line, name);
    ASSERT_EQUALS(KErrNone, errorCode);
    
    TMockLtsyCallData2<RMobileCall::TMobileHscsdCallParamsV2, RMobileCall::TMobileCallInfoV8> 
		dialHscsdCall2(0, mobileService, hscsdCallParams2, callInfo);
	completeData.Close();
	dialHscsdCall2.SerialiseL(completeData);
	iMockLTSY.ExpectL(EEtelCallDial,completeData);    
	
	CallGetMobileCallInfoL(callId, mobileService, callInfo.iDialledParty.iTelNumber);
	
	completeData.Close();
   	dialCompleteData.SerialiseL(completeData);
   	iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData);	
	
	call.Dial(requestStatus, hscsdCallParamPckg2, callInfo.iDialledParty.iTelNumber);
    
	CompleteDialStatusNotificationsL(call, callId, mobileService );
    		
    User::WaitForRequest(requestStatus);
    AssertMockLtsyStatusL();  
    
    ret = call.GetCallParams(recHscsdCallParamPckg2);
    ASSERT_EQUALS(KErrNone, ret);
    ValidateHscsdCallParams(&recHscsdCallParamPckg2, activeCallFlag);
    
    CompleteCallDisconnectNotificationsL(callId, mobileService);
    
    call.Close();
    //---------------------------------------------------------------
 
    RMobileCall::TMobileHscsdCallParamsV7 recHscsdCallParams7;
    RMobileCall::TMobileHscsdCallParamsV7Pckg recHscsdCallParamPckg7(recHscsdCallParams7);
    
    // TMobileHscsdCallParamsV7 params for Dial
    hscsdCallParams7.iInterval = 2;
    hscsdCallParams7.iCug.iCugIndex = 0xFFFF;
    hscsdCallParams7.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
    hscsdCallParams7.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
    hscsdCallParams7.iWaitForDialTone = RCall::EDialToneWait;
    hscsdCallParams7.iQoS = RMobileCall::EQosTransparentPreferred;
    hscsdCallParams7.iV42bisReq = RMobileCall::EV42bisTxDirection;
    hscsdCallParams7.iWantedRxTimeSlots = 2; 
    hscsdCallParams7.iCodings = 3;
    hscsdCallParams7.iBearerMode = RMobileCall::EMulticallShareBearer;
    hscsdCallParams7.iAlphaId.Copy(_L("Alpha Id"));
    hscsdCallParams7.iCallParamOrigin = RMobileCall::EOriginatorSIM;
    
    RMobileCall::TMobileCallInfoV8 callInformation;
    callInformation.iDialledParty.iTelNumber.Copy(KNum);
    callInformation.iService = mobileService;
    callInformation.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
    callInformation.iAlphaId.Copy(_L("Alpha Id"));
    callInformation.iValid |= RMobileCall::KCallAlphaId;
    callInformation.iCallParamOrigin = RMobileCall::EOriginatorSIM;
    callInformation.iValid |= RMobileCall::KCallParamOrigin;
    
    // open new call
   	CleanupClosePushL(call);
   	errorCode = call.OpenNewCall(line, name);
    ASSERT_EQUALS(KErrNone, errorCode);
    
    TMockLtsyCallData2<RMobileCall::TMobileHscsdCallParamsV7, RMobileCall::TMobileCallInfoV8> 
		dialHscsdCall7(0, mobileService, hscsdCallParams7, callInformation);
	completeData.Close();
	dialHscsdCall7.SerialiseL(completeData);
	iMockLTSY.ExpectL(EEtelCallDial,completeData);    
	
	CallGetMobileCallInfoL(callId, mobileService, callInfo.iDialledParty.iTelNumber);
	
	completeData.Close();
   	dialCompleteData.SerialiseL(completeData);
   	iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData);	
	
	call.Dial(requestStatus, hscsdCallParamPckg7, callInfo.iDialledParty.iTelNumber);
        
	CompleteDialStatusNotificationsL(call, callId, mobileService );
    		
    User::WaitForRequest(requestStatus);
    AssertMockLtsyStatusL();  
        
    ret = call.GetCallParams(recHscsdCallParamPckg7);
    ASSERT_EQUALS(KErrNone, ret);
    ValidateHscsdCallParams(&recHscsdCallParamPckg7, activeCallFlag);
    
    CompleteCallDisconnectNotificationsL(callId, mobileService);
    call.Close();
   
    CleanupStack::PopAndDestroy(7, this); 

    }

/**
@SYMTestCaseID BA-CTSY-CALLI-CGCP-0006c
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams for data calls with HscsdCallParamsV8. It is in connection to BA-CTSY-CALLI-CGCP-0006b 
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCallParams for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallParams0006cL()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
       
	OpenLineLC(line, iPhone, lineName);
	
    
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);
   
   
    //- using different types of params struct---------------------------------------
    TBool activeCallFlag = EFalse;
        
    RMobileCall::TMobileHscsdCallParamsV8 hscsdCallParams8;
    RMobileCall::TMobileHscsdCallParamsV8Pckg hscsdCallParamPckg8(hscsdCallParams8);

    TInt ret = call.GetCallParams(hscsdCallParamPckg8);
    ASSERT_EQUALS(KErrNone, ret);
    
    ValidateHscsdCallParams(&hscsdCallParamPckg8, activeCallFlag);
    
    call.Close();
    //-- Dial -----------------------------------------------------------------------

    TRequestStatus requestStatus;			    
    _LIT(KNum, "23467");
    RCall::TTelNumberC num(KNum);
    
    RBuf8 completeData;
    CleanupClosePushL(completeData);
		
	TInt callId = 1;
	RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
   
    // TMobileHscsdCallParamsV8 params for Dial
    hscsdCallParams8.iInterval = 2;
    hscsdCallParams8.iCug.iCugIndex = 0xFFFF;
    hscsdCallParams8.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
    hscsdCallParams8.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
    hscsdCallParams8.iWaitForDialTone = RCall::EDialToneWait;
    hscsdCallParams8.iQoS = RMobileCall::EQosTransparentPreferred;
    hscsdCallParams8.iV42bisReq = RMobileCall::EV42bisTxDirection;
    hscsdCallParams8.iWantedRxTimeSlots = 2; 
    hscsdCallParams8.iCodings = 3;
    hscsdCallParams8.iBearerMode = RMobileCall::EMulticallShareBearer;
    hscsdCallParams8.iAlphaId.Copy(_L("Alpha Id"));
    hscsdCallParams8.iSubAddress.Copy(_L("An Unknown SubAddress"));
    hscsdCallParams8.iCallParamOrigin = RMobileCall::EOriginatorSIM;
    
    RMobileCall::TMobileCallInfoV8 callInformation;
    callInformation.iDialledParty.iTelNumber.Copy(KNum);
    callInformation.iService = mobileService;
    callInformation.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
    callInformation.iAlphaId.Copy(_L("Alpha Id"));
    callInformation.iValid |= RMobileCall::KCallAlphaId;
    callInformation.iCallParamOrigin = RMobileCall::EOriginatorSIM;
    callInformation.iValid |= RMobileCall::KCallParamOrigin;
    
    RMobileCall::TMobileHscsdCallParamsV8 recHscsdCallParams8;
    RMobileCall::TMobileHscsdCallParamsV8Pckg recHscsdCallParamPckg8(recHscsdCallParams8);
   
    // open new call
   	CleanupClosePushL(call);
   	TInt errorCode = call.OpenNewCall(line, name);
    ASSERT_EQUALS(KErrNone, errorCode);
    
    TMockLtsyCallData2<RMobileCall::TMobileHscsdCallParamsV8, RMobileCall::TMobileCallInfoV8> 
		dialHscsdCall8(0, mobileService, hscsdCallParams8, callInformation);
	completeData.Close();
	dialHscsdCall8.SerialiseL(completeData);
	iMockLTSY.ExpectL(EEtelCallDial,completeData);    
	
	CallGetMobileCallInfoL(callId, mobileService, callInformation.iDialledParty.iTelNumber);
	
	TMockLtsyCallData0 dialCompleteData(callId,mobileService);
	completeData.Close();
   	dialCompleteData.SerialiseL(completeData);
   	iMockLTSY.CompleteL(EEtelCallDial,KErrNone,completeData);	
	
	call.Dial(requestStatus, hscsdCallParamPckg8, callInformation.iDialledParty.iTelNumber);
      
	CompleteDialStatusNotificationsL(call, callId, mobileService );
   	    		
    User::WaitForRequest(requestStatus);
    AssertMockLtsyStatusL();  
    
    ret = call.GetCallParams(recHscsdCallParamPckg8);
    ASSERT_EQUALS(KErrNone, ret);
    activeCallFlag = ETrue;
    ValidateHscsdCallParams(&recHscsdCallParamPckg8, activeCallFlag);
    
    CompleteCallDisconnectNotificationsL(callId, mobileService);
    call.Close();
   
    CleanupStack::PopAndDestroy(5, this); 

    }


/**
@SYMTestCaseID BA-CTSY-CALLI-CGCP-0008
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams with bad parameters data for data calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCallParams with bad parameters for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallParams0008L()
	{
	
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
       
	OpenLineLC(line, iPhone, lineName);
	
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);
	   
	//-------------------------------------------------------------------------
	// Test B: Test passing wrong descriptor size to parameter in
	// RCall::GetCallParams
 	//-------------------------------------------------------------------------

	TBuf8<1> buf(KNullDesC8);
	TInt ret = call.GetCallParams(buf);
	// Passing a small buffer to function doesn't cause an error.
	ASSERT_EQUALS(KErrArgument, ret)
	
	RCall::TCallParams callParams;
    RCall::TCallParamsPckg paramPckg(callParams);
       
    ret = call.GetCallParams(paramPckg);
   	ASSERT_EQUALS(KErrArgument, ret)

	CleanupStack::PopAndDestroy(3, this); // call, line, this
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CGCP-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCallParams for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCallParams for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallParams00011L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);

   
    TBool activeCallFlag = EFalse;  
    //----------------------------------------
    
    RMobileCall::TMobileCallParamsV1 callParams1;
    RMobileCall::TMobileCallParamsV1Pckg paramPckg1(callParams1);
   
    TInt ret = call.GetCallParams(paramPckg1);
    ASSERT_EQUALS(KErrNone, ret);

    ValidateCallParams(&paramPckg1, activeCallFlag);
        
    //----------------------------------------
    RMobileCall::TMobileCallParamsV2 callParams2;
    RMobileCall::TMobileCallParamsV2Pckg paramPckg2(callParams2);

    ret = call.GetCallParams(paramPckg2);
    ASSERT_EQUALS(KErrNone, ret);

    ValidateCallParams(&paramPckg2, activeCallFlag);
     
    //---------------------------------------------
    RMobileCall::TMobileCallParamsV7 callParams7;
    RMobileCall::TMobileCallParamsV7Pckg paramPckg7(callParams7);

    ret = call.GetCallParams(paramPckg7);

    ValidateCallParams(&paramPckg7, activeCallFlag);

 	//--  now GetCallParams for an incoming dialing call -----

    RBuf8 completeData;
    CleanupClosePushL(completeData);
	
	RCall call2;	
	TInt callId = 1;
	TName incomingCallName;

    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
	
	CreateAndOpenIncomingCalLC(line, call2, incomingCallName, 
		lineName, callId, RMobileCall::EStatusIdle, mobileService);
	
 	//---  Dial ---------------------------------------------
    TRequestStatus requestStatus;   

    _LIT(KNum, "23467");
    RCall::TTelNumberC num(KNum);
    
    
    // TMobileCallParamsV1 params for Dial
   	RMobileCall::TMobileCallParamsV1 params;
   	RMobileCall::TMobileCallParamsV1Pckg paramsPckg(params);
    params.iInterval = 2;
    params.iCug.iCugIndex = 0xFFFF;
    params.iSpeakerControl = RCall::EMonitorSpeakerControlAlwaysOff;
    params.iSpeakerVolume = RCall::EMonitorSpeakerVolumeMedium;
    params.iWaitForDialTone = RCall::EDialToneWait;
   
  	RMobileCall::TMobileCallInfoV8 callInfo;
  	callInfo.iDialledParty.iTelNumber.Copy(KNum);
  	callInfo.iRemoteParty.iDirection = RMobileCall::EDirectionUnknown;
  	callInfo.iService = mobileService;
  	callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
  	callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;

   	call2.Dial(requestStatus, paramsPckg, callInfo.iDialledParty.iTelNumber);
  	User::WaitForRequest(requestStatus);
  	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
   	
   	CleanupStack::PopAndDestroy(5, this); 
	}



void CCTsyCallInformationFU::AuxGetCallDuration0001L(const TDesC& aLineName, RMobilePhone::TMobileService aMobileService)
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RLine line;
    
	OpenLineLC(line, iPhone, aLineName);
	
    TName name;
    RCall call1;
    
    OpenNewCallLC(call1, line, &name);

    //---  check not active call -------------------------------------
    const TTimeIntervalSeconds KZeroTime(0);
    
    TTimeIntervalSeconds time;
    TInt ret = call1.GetCallDuration(time);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_EQUALS(KZeroTime, time);
    
    //--- try to make duration not zero ---------------------------------------
			
	RCall call;	
	TInt callId = 1;
	TName incomingCallName;

    RMobilePhone::TMobileService mobileService = aMobileService;
	
	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		aLineName, callId, RMobileCall::EStatusAnswering, mobileService);	
    
 	//-------------------------------------------------------------------------
    RBuf8 completeData;
    CleanupClosePushL(completeData);

    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusConnected;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    completeData.Close();
    mockCallData2.SerialiseL(completeData);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
 	//-------------------------------------------------------------------------

	// this is to allow duration > 0
    sleep(2);

    ret = call.GetCallDuration(time);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE(KZeroTime != time);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(5, this);
	
	}

/**
@SYMTestCaseID BA-CTSY-CALLI-CGCD-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCallDuration for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCallDuration for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallDuration0001L()
	{

	AuxGetCallDuration0001L(KMmTsyVoice1LineName, RMobilePhone::EVoiceService);
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CGCD-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCallDuration for data calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCallDuration for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallDuration0006L()
	{

	AuxGetCallDuration0001L(KMmTsyDataLineName, RMobilePhone::ECircuitDataService);
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGCD-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCallDuration for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCallDuration for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallDuration00011L()
	{

	AuxGetCallDuration0001L(KMmTsyFaxLineName, RMobilePhone::EFaxService);

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CGOS-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetOwnershipStatus for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetOwnershipStatus for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetOwnershipStatus0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;

	OpenLineLC(line, iPhone, lineName);
    
	RCall call;
	TInt callId = 1;
	TName incomingCallName;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);

	
    RCall::TOwnershipStatus ownershipStatus;
    
	// Ownership is not supported for voice calls, so we just check for UnOwned
    TInt ret = call.GetOwnershipStatus(ownershipStatus);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_EQUALS(RCall::EOwnershipUnowned, ownershipStatus);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this);
	
	}



void CCTsyCallInformationFU::AuxGetOwnershipStatus0001L(const TDesC& aLineName, RMobilePhone::TMobileService aMobileService)
	{
	
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RLine line;

	OpenLineLC(line, iPhone, aLineName);
    
	RCall call;
	TInt callId = 1;
	TName incomingCallName;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		aLineName, callId, RMobileCall::EStatusRinging, aMobileService);

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

    RCall::TOwnershipStatus ownershipStatus;
    	
	// UnOwned
    TInt ret = call.GetOwnershipStatus(ownershipStatus);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_EQUALS(RCall::EOwnershipUnowned, ownershipStatus);

	TRequestStatus requestStatus1;
	
	RMobileCall::TMobileCallParamsV1 callParams;
	RMobileCall::TMobileCallParamsV1Pckg callParamsPckg(callParams);
    call.Connect(requestStatus1,callParamsPckg);
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());
	
	// EOwnershipOwnedByThisClient
    ret = call.GetOwnershipStatus(ownershipStatus);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_EQUALS(RCall::EOwnershipOwnedByThisClient, ownershipStatus);
	 
	 
    //- now set ownership to EOwnershipOwnedByAnotherClient -------------------	
	
	RTelServer telServer2;
	ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2, KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

	RLine line2;

	OpenLineLC(line2, phone2, aLineName);

	RCall call2;
	
	// open existing call to send take ownership request
	ret = call2.OpenExistingCall(line2, incomingCallName);
	ASSERT_EQUALS(KErrNone, ret)
	CleanupClosePushL(call2);

	TRequestStatus reqStatus;
	call2.AcquireOwnership(reqStatus);

	// TransferOwnership to call2
	ret = call.TransferOwnership();
	ASSERT_EQUALS(KErrNone, ret)
	AssertMockLtsyStatusL();

	User::WaitForRequest(reqStatus);
	ASSERT_EQUALS(KErrNone, reqStatus.Int())
	AssertMockLtsyStatusL();

	//EOwnershipOwnedByAnotherClient
    ret = call.GetOwnershipStatus(ownershipStatus);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_EQUALS(RCall::EOwnershipOwnedByAnotherClient, ownershipStatus);


    //-now set ownership to EOwnershipThisIsPriorityClient -------------------	

	// There must be "etel_KPriorityClientSid <SID>" in epoc.ini (emulator)
	// or "patchdata etel.dll@KPriorityClientSid <SID>" in etel.iby (ROM)
	// If this test fails, ensure that the lines:
	// etel_KPriorityClientSid 0x101F777C
    // etel_KSatEngineSid 0x101F777C
	// are present in \epoc32\data\epoc.ini

   	ret  = iTelServer.SetPriorityClientV2();
	ASSERT_EQUALS(KErrNone, ret);

    ret = call.GetOwnershipStatus(ownershipStatus);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_EQUALS(RCall::EOwnershipThisIsPriorityClient, ownershipStatus);
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(7, this); 
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CGOS-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetOwnershipStatus for data calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetOwnershipStatus for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetOwnershipStatus0006L()
	{

	AuxGetOwnershipStatus0001L(KMmTsyDataLineName, RMobilePhone::ECircuitDataService);

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGOS-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetOwnershipStatus for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetOwnershipStatus for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetOwnershipStatus00011L()
	{
	
	AuxGetOwnershipStatus0001L(KMmTsyFaxLineName, RMobilePhone::EFaxService);

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CGC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCaps for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCaps for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCaps0001L()
	{
	
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);

	// get caps of a just created call	
	RCall::TCaps caps;
	TInt ret = call.GetCaps(caps);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsDial) == caps.iFlags);
    
	CleanupStack::PopAndDestroy(1);

	// now get caps of an incoming call to ensure that they are changed
	
	TInt callId = 1;
	TName incomingCallName;
			
	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);

	
	ret = call.GetCaps(caps);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsAnswer) == caps.iFlags);
	
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this);
	}

/**
@SYMTestCaseID BA-CTSY-CALLI-CGC-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCaps for data calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCaps for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCaps0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);

	// get caps of a just created call	
	
	RCall::TCaps caps;
	TInt ret = call.GetCaps(caps);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE((RCall::KCapsData | RCall::KCapsDial | RCall::KCapsConnect) == caps.iFlags);
    
	CleanupStack::PopAndDestroy(1);

	
	// now get caps of an incoming call to ensure that they are changed
	
	TInt callId = 1;
	TName incomingCallName;
			
	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::ECircuitDataService);
	
	ret = call.GetCaps(caps);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE((RCall::KCapsData | RCall::KCapsAnswer | RCall::KCapsHangUp) == caps.iFlags);
	
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this);
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGC-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetCaps for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetCaps for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCaps00011L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);

	// get caps of a just created call	
	
	RCall::TCaps caps;
	TInt ret = call.GetCaps(caps);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE((RCall::KCapsConnect | RCall::KCapsFax) == caps.iFlags);
    
	CleanupStack::PopAndDestroy(1);

	// now get caps of an incoming call to ensure that they are changed
	
	TInt callId = 1;
	TName incomingCallName;
			
	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EFaxService);
	
	ret = call.GetCaps(caps);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE((RCall::KCapsFax | RCall::KCapsAnswer | RCall::KCapsConnect) == caps.iFlags);
	    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this);
	}



void CCTsyCallInformationFU::AuxGetInfo0001L(const TDesC& aLineName, RMobilePhone::TMobileService aMobileService)
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(aLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);
	
	// get call info for a just created call
	RCall::TCallInfo info;
	TInt ret = call.GetInfo(info);
    ASSERT_EQUALS(KErrNone, ret);
       
    ASSERT_TRUE(0 == info.iLineName.Compare(lineName));
    ASSERT_TRUE(0 == info.iCallName.Compare(name));
    ASSERT_TRUE(RCall::EHookStatusUnknown == info.iHookStatus);
    ASSERT_TRUE(RCall::EStatusIdle == info.iStatus);
    ASSERT_TRUE(0 == info.iDuration.Int());
	CleanupStack::PopAndDestroy(1);

	AssertMockLtsyStatusL();
	
	// now get call info for an incoming call
	TInt callId = 1;
	TName incomingCallName;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, aMobileService);
	
	ret = call.GetInfo(info);
    ASSERT_EQUALS(KErrNone, ret);

    ASSERT_TRUE(0 == info.iLineName.Compare(lineName));
    ASSERT_TRUE(0 == info.iCallName.Compare(incomingCallName));
    ASSERT_TRUE(RCall::EHookStatusUnknown == info.iHookStatus);
    ASSERT_TRUE(RCall::EStatusRinging == info.iStatus);
    ASSERT_TRUE(0 == info.iDuration.Int());
	
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this);

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CGI-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetInfo for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetInfo for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetInfo0001L()
	{
	
	AuxGetInfo0001L(KMmTsyVoice1LineName, RMobilePhone::EVoiceService);
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGI-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetInfo for data calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetInfo for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetInfo0006L()
	{
	
	AuxGetInfo0001L(KMmTsyDataLineName, RMobilePhone::ECircuitDataService);
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGI-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetInfo for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetInfo for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetInfo00011L()
	{

	AuxGetInfo0001L(KMmTsyFaxLineName, RMobilePhone::EFaxService);

	}


void CCTsyCallInformationFU::AuxGetStatus0001L(const TDesC& aLineName, RMobilePhone::TMobileService aMobileService)
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(aLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);
	
	// get call status for a just created call
	RCall::TStatus status;
	TInt ret = call.GetStatus(status);
    ASSERT_EQUALS(KErrNone, ret);
    
    ASSERT_EQUALS(RCall::EStatusIdle, status);

	CleanupStack::PopAndDestroy(1);

	AssertMockLtsyStatusL();
	
	// now get call info for an incoming call
	TInt callId = 1;
	TName incomingCallName;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, aMobileService);
	
	ret = call.GetStatus(status);
    ASSERT_EQUALS(KErrNone, ret);
    
    ASSERT_EQUALS(RCall::EStatusRinging, status);
	
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this);

	}
/**
@SYMTestCaseID BA-CTSY-CALLI-CGS-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetStatus for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetStatus for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetStatus0001L()
	{

	AuxGetStatus0001L(KMmTsyVoice1LineName, RMobilePhone::EVoiceService);

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGS-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetStatus for data calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetStatus for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetStatus0006L()
	{

	AuxGetInfo0001L(KMmTsyDataLineName, RMobilePhone::ECircuitDataService);

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGS-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::GetStatus for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::GetStatus for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetStatus00011L()
	{

	AuxGetInfo0001L(KMmTsyFaxLineName, RMobilePhone::EFaxService);

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LGCI-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::GetCallInfo for voice lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::GetCallInfo for voice lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallInfo0001L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name); 
	
	// get call info for a just created call
	RLine::TCallInfo callInfo;
    TInt ret = line.GetCallInfo( 0, callInfo);

    ASSERT_EQUALS(KErrNone, ret);

    ASSERT_TRUE(0 == callInfo.iCallName.Compare(name));
    ASSERT_EQUALS(RCall::EStatusIdle, callInfo.iStatus);
    ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsDial) == callInfo.iCallCapsFlags);
     
    
	//-- get call info for an incoming call ---------------------	
	RCall call1;
	TInt callId = 1;
	TName incomingCallName;

	CreateAndOpenIncomingCalLC(line, call1, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);

    ret = line.GetCallInfo( 1, callInfo);

    ASSERT_EQUALS(KErrNone, ret);

    ASSERT_TRUE(0 == callInfo.iCallName.Compare(incomingCallName));
    ASSERT_EQUALS(RCall::EStatusRinging, callInfo.iStatus);
    ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsAnswer) == callInfo.iCallCapsFlags);	
	   
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	}


void CCTsyCallInformationFU::AuxGetCallInfo0003L(const TDesC& aLineName)
	{
	
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RLine line;
    
	OpenLineLC(line, iPhone, aLineName);
	
	// try get info when there is no calls
	RLine::TCallInfo callInfo;
    TInt ret = line.GetCallInfo( 0, callInfo);

    ASSERT_EQUALS(KErrNotFound, ret);

    //----------------------------------------
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name); 

	// try to get info of a call with negative Id	
    ret = line.GetCallInfo( -1, callInfo);

    ASSERT_EQUALS(KErrNotFound, ret);
    
	//----------------------------------------	
	// try to get info of a call a too big Id	
    ret = line.GetCallInfo( 3, callInfo);

    ASSERT_EQUALS(KErrNotFound, ret);
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this);

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LGCI-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::GetCallInfo with bad parameter data for voice lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::GetCallInfo with bad parameter data for voice lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallInfo0003L()
	{

	AuxGetCallInfo0003L(KMmTsyVoice1LineName);
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LGCI-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::GetCallInfo for data lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::GetCallInfo for data lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallInfo0006L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name); 
	
	// get call info for a just created call
	RLine::TCallInfo callInfo;
    TInt ret = line.GetCallInfo( 0, callInfo);

    ASSERT_EQUALS(KErrNone, ret);

    ASSERT_TRUE(0 == callInfo.iCallName.Compare(name));
    ASSERT_EQUALS(RCall::EStatusIdle, callInfo.iStatus);
    ASSERT_TRUE((RCall::KCapsData | RCall::KCapsDial | RCall::KCapsConnect) == callInfo.iCallCapsFlags);
     
    
	//-- get call info for an incoming call ---------------------	
	RCall call1;
	TInt callId = 1;
	TName incomingCallName;

	CreateAndOpenIncomingCalLC(line, call1, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::ECircuitDataService);

    ret = line.GetCallInfo( 1, callInfo);

    ASSERT_EQUALS(KErrNone, ret);

    ASSERT_TRUE(0 == callInfo.iCallName.Compare(incomingCallName));
    ASSERT_EQUALS(RCall::EStatusRinging, callInfo.iStatus);
    ASSERT_TRUE((RCall::KCapsData | RCall::KCapsAnswer | RCall::KCapsHangUp) == callInfo.iCallCapsFlags);	
	   
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LGCI-0008
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::GetCallInfo with bad parameter data for data lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::GetCallInfo with bad parameter data for data lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallInfo0008L()
	{
	
	AuxGetCallInfo0003L(KMmTsyDataLineName);

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LGCI-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::GetCallInfo for fax lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::GetCallInfo for fax lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallInfo00011L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name); 
	
	// get call info for a just created call
	RLine::TCallInfo callInfo;
    TInt ret = line.GetCallInfo( 0, callInfo);

    ASSERT_EQUALS(KErrNone, ret);

    ASSERT_TRUE(0 == callInfo.iCallName.Compare(name));
    ASSERT_EQUALS(RCall::EStatusIdle, callInfo.iStatus);
    ASSERT_TRUE((RCall::KCapsFax | RCall::KCapsConnect) == callInfo.iCallCapsFlags);
     
    
	//-- get call info for an incoming call ---------------------	
	RCall call1;
	TInt callId = 1;
	TName incomingCallName;

	CreateAndOpenIncomingCalLC(line, call1, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EFaxService);

    ret = line.GetCallInfo( 1, callInfo);

    ASSERT_EQUALS(KErrNone, ret);

    ASSERT_TRUE(0 == callInfo.iCallName.Compare(incomingCallName));
    ASSERT_EQUALS(RCall::EStatusRinging, callInfo.iStatus);
    ASSERT_TRUE((RCall::KCapsFax | RCall::KCapsAnswer | RCall::KCapsConnect) == callInfo.iCallCapsFlags);	
	   
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LGCI-00013
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::GetCallInfo with bad parameter data for fax lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::GetCallInfo with bad parameter data for fax lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetCallInfo00013L()
	{

	AuxGetCallInfo0003L(KMmTsyFaxLineName);

	}


void CCTsyCallInformationFU::AuxEnumerateCall0001L(const TDesC& aLineName, RMobilePhone::TMobileService aMobileService)
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RLine line;
    
	OpenLineLC(line, iPhone, aLineName);
	
	// enumerate when there is no calls
	TInt numCalls;
	TInt ret = line.EnumerateCall(numCalls);
    ASSERT_EQUALS(KErrNone, ret);
    
    ASSERT_TRUE(0 == numCalls);

    
    TName name;
    RCall call;
    
    OpenNewCallLC(call, line, &name);
	
	// get number of calls when we have one call 
	ret = line.EnumerateCall(numCalls);
    ASSERT_EQUALS(KErrNone, ret);
    
    ASSERT_TRUE(1 == numCalls);
    
	
	RCall call1;	
	TInt callId = 1;
	TName incomingCallName;

	CreateAndOpenIncomingCalLC(line, call1, incomingCallName, 
		aLineName, callId, RMobileCall::EStatusRinging, aMobileService);	
		
	// check if the number of calls incremented correctly
	ret = line.EnumerateCall(numCalls);
    ASSERT_EQUALS(KErrNone, ret);
    
    ASSERT_TRUE(2 == numCalls);
	
    call.Close();
    
	// check if the number of calls decremented correctly
	ret = line.EnumerateCall(numCalls);
    ASSERT_EQUALS(KErrNone, ret);
    
    ASSERT_TRUE(1 == numCalls);
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LEC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::EnumerateCall for voice lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::EnumerateCall for voice lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestEnumerateCall0001L()
	{

	AuxEnumerateCall0001L(KMmTsyVoice1LineName, RMobilePhone::EVoiceService);
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LEC-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::EnumerateCall for data lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::EnumerateCall for data lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestEnumerateCall0006L()
	{

	AuxEnumerateCall0001L(KMmTsyDataLineName, RMobilePhone::ECircuitDataService);

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LEC-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::EnumerateCall for fax lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::EnumerateCall for fax lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestEnumerateCall00011L()
	{
    
	AuxEnumerateCall0001L(KMmTsyFaxLineName, RMobilePhone::EFaxService);

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNCC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::NotifyCapsChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::NotifyCapsChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCapsChange0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
	RCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus mockLtsyStatus;

			
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, mobileService);
	    
    TRequestStatus notifyStatus;
    RCall::TCaps caps;

	// test C1, completed from AnswerIncomingCall() ---------------------------------	    

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

    call.NotifyCapsChange( notifyStatus, caps);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsHangUp) == caps.iFlags);

    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

	AssertMockLtsyStatusL();

	// test C2, completed from HangUp()  ---------------------------------	   

	TInt hangUpCause = KErrGsmBusyUserRequest;
	TBool autoStChangeDisable = ETrue;
    TMockLtsyCallData2<TInt, TBool> mockData2x(callId, mobileService, 
                                             hangUpCause, 
                                             autoStChangeDisable);
    data.Close();
    mockData2x.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallHangUp, data);
    
    call.NotifyCapsChange( notifyStatus, caps);

    call.HangUp(requestStatus1);

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE((RCall::KCapsVoice) == caps.iFlags);

	// test C3, completed from CompleteHangUp()  ---------------------------------	   
	
    TMockLtsyCallData0 mockData2(callId, mobileService);
    data.Close();
    mockData2.SerialiseL(data);
    iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, data);

    call.NotifyCapsChange( notifyStatus, caps);

    User::WaitForRequest(requestStatus1);

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsDial) == caps.iFlags);
    
    
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusIdle;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    

	// test C4 ---------------------------------	
   
      
    call.NotifyCapsChange( notifyStatus, caps);
        
    _LIT(KNum, "23467");
    RCall::TTelNumberC num(KNum);
    
	RMobileCall::TMobileCallParamsV7 callParams;
	RMobileCall::TMobileCallParamsV7Pckg callParamsPckg(callParams);
    callParams.iInterval = 0;
    callParams.iCug.iCugIndex = 0xFFFF;
    callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
    callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
    callParams.iWaitForDialTone = RCall::EDialToneWait;
    
	RMobileCall::TMobileCallInfoV8 callInfo;
	
	callInfo.iDialledParty.iTelNumber.Copy(KNum);
	callInfo.iRemoteParty.iDirection = RMobileCall::EDirectionUnknown;
	callInfo.iService = mobileService;
	callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
	
	TMockLtsyCallData2<RMobileCall::TMobileCallParamsV7, RMobileCall::TMobileCallInfoV8> 
		dialData(-1, mobileService, callParams, callInfo);
	data.Close();
	dialData.SerialiseL(data);
	iMockLTSY.ExpectL(EEtelCallDial,data);    
	
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = _L("");
	
	call.Dial(requestStatus,callParamsPckg, callInfo.iDialledParty.iTelNumber);

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsHangUp) == caps.iFlags);
    
	// complete Dial
	TMockLtsyCallData0 dialCompleteData(0,mobileService);
	data.Close();
	dialCompleteData.SerialiseL(data);
	iMockLTSY.CompleteL(EEtelCallDial,KErrNone,data,0);	
	       
    User::WaitForRequest(requestStatus);

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(4, this);
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCC-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyCapsChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RCall::NotifyCapsChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCapsChange0002L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	
	TInt callId = 1;
	TName incomingCallName;
	RCall call;
	
	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EVoiceService);
	    
    TRequestStatus notifyStatus;
    RCall::TCaps caps;
    
    call.NotifyCapsChange( notifyStatus, caps);

    call.NotifyCapsChangeCancel();

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrCancel, notifyStatus.Int());
	       
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this);
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNCC-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyCapsChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RCall::NotifyCapsChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCapsChange0004L()
	{
					
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyVoice1LineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    
	RCall call;
	RCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName, 
		lineName2, callId2, RMobileCall::EStatusRinging, mobileService);

    //----------------------------------------
    RCall::TCaps caps;
    RCall::TCaps caps2;
	    
    call.NotifyCapsChange( requestStatus, caps);
    
    //----------------------------------------
	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

    //----------------------------------------
    TMockLtsyCallData0 mockData02(callId2, mobileService);
    data.Close();
    mockData02.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call2.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

    call2.NotifyCapsChange( requestStatus2, caps2);

	TInt hangUpCause = KErrGsmBusyUserRequest;
	TBool autoStChangeDisable = ETrue;
    TMockLtsyCallData2<TInt, TBool> mockData2x(callId2, mobileService, 
                                             hangUpCause, 
                                             autoStChangeDisable);
    data.Close();
    mockData2x.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallHangUp, data);
    

    TMockLtsyCallData0 mockData2(callId2, mobileService);
    data.Close();
    mockData2.SerialiseL(data);
    iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, data);
    call2.HangUp();


    User::WaitForRequest(requestStatus);
    User::WaitForRequest(requestStatus2);
    
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    
    ASSERT_TRUE((RCall::KCapsVoice | RCall::KCapsHangUp) == caps.iFlags);
    ASSERT_TRUE((RCall::KCapsVoice) == caps2.iFlags);

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(8, this);
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCC-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::NotifyCapsChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::NotifyCapsChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCapsChange0006L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus mockLtsyStatus;
			
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, mobileService);

	    
	//---------------------------------------------------------------------
	//Test C1, completed from AnswerIncomingCall()
	//---------------------------------------------------------------------
    TRequestStatus notifyStatus;
    RCall::TCaps caps;
    
    call.NotifyCapsChange( notifyStatus, caps);

	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE((RCall::KCapsData | RCall::KCapsHangUp) == caps.iFlags);

    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

    AssertMockLtsyStatusL();  

	//Test C2, completed from HangUp()

	TInt hangUpCause = KErrGsmBusyUserRequest;
	TBool autoStChangeDisable = EFalse;
    TMockLtsyCallData2<TInt, TBool> mockData2x(callId, mobileService, 
                                             hangUpCause, 
                                             autoStChangeDisable);
    data.Close();
    mockData2x.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallHangUp, data);
   
    call.NotifyCapsChange( notifyStatus, caps);
    
    call.HangUp(requestStatus1);    

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE((RCall::KCapsData) == caps.iFlags);
    
	//Test C3, completed from CompleteHangUp()

    TMockLtsyCallData0 mockData2(callId, mobileService);
    data.Close();
    mockData2.SerialiseL(data);
    iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, data);

    call.NotifyCapsChange( notifyStatus, caps);

    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE((RCall::KCapsData | RCall::KCapsConnect | RCall::KCapsDial) == caps.iFlags);
    
    //---------------------------------	
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusIdle;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


	//---------------------------------------------------------------------
	//Test C4, completed from Dial()
	//---------------------------------------------------------------------
    call.NotifyCapsChange( notifyStatus, caps);
        
    _LIT(KNum, "23467");
    RCall::TTelNumberC num(KNum);
    
	RMobileCall::TMobileDataCallParamsV1 dataCallParams;
	RMobileCall::TMobileDataCallParamsV1Pckg dataCallParamsPckg(dataCallParams);
	dataCallParams.iInterval = 0;
	dataCallParams.iCug.iCugIndex = 0xFFFF;
	dataCallParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
	dataCallParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
	dataCallParams.iWaitForDialTone = RCall::EDialToneWait;
    
	RMobileCall::TMobileCallInfoV8 callInfo;
	callInfo.iDialledParty.iTelNumber.Copy(KNum);
	callInfo.iRemoteParty.iDirection = RMobileCall::EMobileTerminated;
	callInfo.iService = mobileService;
	callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
		
	TMockLtsyCallData2<RMobileCall::TMobileDataCallParamsV1, RMobileCall::TMobileCallInfoV8> 
		dialData(-1, mobileService, dataCallParams, callInfo);
	data.Close();
	dialData.SerialiseL(data);
	iMockLTSY.ExpectL(EEtelCallDial,data);    
	
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = _L("");

    call.Dial(requestStatus, dataCallParamsPckg, callInfo.iDialledParty.iTelNumber);
    
    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE((RCall::KCapsData | RCall::KCapsHangUp) == caps.iFlags);

    TMockLtsyCallData0 dialCompleteData(0,mobileService);
	data.Close();
	dialCompleteData.SerialiseL(data);
	iMockLTSY.CompleteL(EEtelCallDial,KErrNone,data,0);	
       
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    AssertMockLtsyStatusL();
   
    
    //---------------------------------------------------------------------
	//Test C5, completed from LoanDataPort
	//---------------------------------------------------------------------
    caps.iFlags = 0;
    call.NotifyCapsChange( notifyStatus, caps);

	callId = -1;

    _LIT(KCom, "Com");    
	TFileName csy(KCom);
    TName portName(KCom);    
    RCall::TCommPort port;
    port.iCsy = csy;
    port.iPort = portName;            
    TMockLtsyCallData1<RCall::TCommPort> mockLoanData(callId, mobileService, port);
    data.Close();
    mockLoanData.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallLoanDataPort, data);    
    call.LoanDataPort(requestStatus1, port);    
    User::WaitForRequest(requestStatus1);   
     
    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());    
  	ASSERT_TRUE( (RCall::KCapsData | RCall::KCapsHangUp | RCall::KCapsRecoverDataPort) == caps.iFlags);
  
  	AssertMockLtsyStatusL();
  	 
  	// Recover Data Port
    iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data);    
    call.RecoverDataPort(); 
    //---------------------------------------    
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCC-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyCapsChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RCall::NotifyCapsChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCapsChange0007L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    

	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
			
	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::ECircuitDataService);
	    
    TRequestStatus notifyStatus;
    RCall::TCaps caps;
    
    call.NotifyCapsChange( notifyStatus, caps);

    call.NotifyCapsChangeCancel();

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrCancel, notifyStatus.Int());
	
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	}




/**
@SYMTestCaseID BA-CTSY-CALLI-CNCC-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyCapsChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RCall::NotifyCapsChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCapsChange0009L()
	{
					
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyDataLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    

	RCall call;
	RCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, RMobileCall::EStatusRinging, mobileService);

    //----------------------------------------
    RCall::TCaps caps;
    RCall::TCaps caps2;
	    
    call.NotifyCapsChange( requestStatus, caps);
    
    //----------------------------------------
	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

    //----------------------------------------
    TMockLtsyCallData0 mockData02(callId2, mobileService);
    data.Close();
    mockData02.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call2.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

    call2.NotifyCapsChange( requestStatus2, caps2);

	TInt hangUpCause = KErrGsmBusyUserRequest;
	TBool autoStChangeDisable = EFalse;
    TMockLtsyCallData2<TInt, TBool> mockData2x(callId2, mobileService, 
                                             hangUpCause, 
                                             autoStChangeDisable);
    data.Close();
    mockData2x.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallHangUp, data);
    

    TMockLtsyCallData0 mockData2(callId2, mobileService);
    data.Close();
    mockData2.SerialiseL(data);
    iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, data);
    call2.HangUp();


    User::WaitForRequest(requestStatus);
    User::WaitForRequest(requestStatus2);
    
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    
    ASSERT_TRUE((RCall::KCapsData | RCall::KCapsHangUp) == caps.iFlags);
    ASSERT_TRUE((RCall::KCapsData) == caps2.iFlags);

	CleanupStack::PopAndDestroy(8, this);
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCC-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::NotifyCapsChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::NotifyCapsChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCapsChange00011L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
			
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, mobileService);
	    
    //---------------------------------------

    TRequestStatus notifyStatus;
    RCall::TCaps caps;

    call.NotifyCapsChange( requestStatus, caps);

    _LIT(KCom, "Com");
    
	TFileName csy(KCom);
    TName portName(KCom);    
    RCall::TCommPort port;
    port.iCsy = csy;
    port.iPort = portName;
        
    TMockLtsyCallData1<RCall::TCommPort> mockData01(callId, mobileService, port);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallLoanDataPort, data);
    
    call.LoanDataPort(requestStatus1, port);       

    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    ASSERT_TRUE( (RCall::KCapsData | 
        RCall::KCapsFax |
            RCall::KCapsConnect |
                RCall::KCapsHangUp |
                    RCall::KCapsAnswer |
                        RCall::KCapsRecoverDataPort) == caps.iFlags);
    //---------------------------------------

	AssertMockLtsyStatusL();
    
	TInt hangUpCause = KErrGsmBusyUserRequest;
	TBool autoStChangeDisable = EFalse;
    TMockLtsyCallData2<TInt, TBool> mockData2x(callId, mobileService, 
                                             hangUpCause, 
                                             autoStChangeDisable);
    data.Close();
    mockData2x.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallHangUp, data);
    
	// test C2, completed from HangUp()
    call.NotifyCapsChange( requestStatus, caps);

    call.HangUp(requestStatus1);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE((RCall::KCapsData | 
        RCall::KCapsFax |
            RCall::KCapsConnect |
                    RCall::KCapsAnswer) == caps.iFlags);



	// test C3, completed from CompleteHangUp()

    TMockLtsyCallData0 mockData2(callId, mobileService);
    data.Close();
    mockData2.SerialiseL(data);
    iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, data);

    call.NotifyCapsChange( requestStatus, caps);

    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE((RCall::KCapsData | 
        RCall::KCapsFax |
            RCall::KCapsConnect |
                    RCall::KCapsDial) == caps.iFlags);
    
    
    //-- loaned port has to be recovered --------
    TMockLtsyCallData1<RCall::TCommPort> mockData01x(callId, mobileService, port);
    data.Close();
    mockData01x.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data);

    call.RecoverDataPort();       
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCC-00012
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyCapsChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RCall::NotifyCapsChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCapsChange00012L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
			
	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, RMobilePhone::EFaxService);
	    
    TRequestStatus notifyStatus;
    RCall::TCaps caps;
    
    call.NotifyCapsChange( notifyStatus, caps);

    call.NotifyCapsChangeCancel();

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrCancel, notifyStatus.Int());
	
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNCC-00014
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyCapsChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RCall::NotifyCapsChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCapsChange00014L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyFaxLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);  

	RCall call;
	RCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
			
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, mobileService);
	
    //----------------------------------------
    // create new incoming call
        
	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, RMobileCall::EStatusRinging, mobileService);
	
    //----------------------------------------
    RCall::TCaps caps;
    RCall::TCaps caps2;
	    
   _LIT(KCom, "Com");
    
	TFileName csy(KCom);
    TName portName(KCom);    
    RCall::TCommPort port;
    port.iCsy = csy;
    port.iPort = portName;
        
    TMockLtsyCallData1<RCall::TCommPort> mockData01(callId, mobileService, port);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallLoanDataPort, data);

    call.LoanDataPort(requestStatus1, port);       

    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());
    AssertMockLtsyStatusL(); 
    //---------------------------------------
    
    call.NotifyCapsChange( requestStatus, caps);
    call2.NotifyCapsChange( requestStatus2, caps2);

    TMockLtsyCallData1<RCall::TCommPort> mockData02(callId2, mobileService, port);
    data.Close();
    mockData02.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallLoanDataPort, data);
    
    call2.LoanDataPort(requestStatus1, port);       

    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());
    AssertMockLtsyStatusL(); 
    //---------------------------------------
    
    TInt hangUpCause = KErrGsmBusyUserRequest;
    TBool autoStChangeDisable = EFalse;
    TMockLtsyCallData2<TInt, TBool> mockData2x(callId, mobileService, 
                                                 hangUpCause, 
                                                 autoStChangeDisable);
    data.Close();
    mockData2x.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallHangUp, data);
        
    TMockLtsyCallData0 mockData2(callId, mobileService);
    data.Close();
    mockData2.SerialiseL(data);
    iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, data);
    call.HangUp();

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE((RCall::KCapsData | 
        RCall::KCapsFax |
            RCall::KCapsConnect |
                    RCall::KCapsAnswer) == caps.iFlags);


    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE((RCall::KCapsData | 
        RCall::KCapsFax |
            RCall::KCapsConnect |
                    RCall::KCapsAnswer |
                    	RCall::KCapsHangUp |
                    		RCall::KCapsRecoverDataPort) == caps2.iFlags);
    AssertMockLtsyStatusL();
    //---------------------------------------    

    TMockLtsyCallData1<RCall::TCommPort> mockData03(callId, mobileService, port);
    data.Close();
    mockData03.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data);

    call.RecoverDataPort();       
    AssertMockLtsyStatusL();
    
    TMockLtsyCallData1<RCall::TCommPort> mockData04(callId2, mobileService, port);
    data.Close();
    mockData04.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallRecoverDataPort, data);
    
    call2.RecoverDataPort();       
    AssertMockLtsyStatusL();
    
	CleanupStack::PopAndDestroy(8, this);

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNHCC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::NotifyHookChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::NotifyHookChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyHookChange0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

	RCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
			
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, mobileService);
	
	
    TRequestStatus notifyStatus;
	RCall::THookStatus hookStatus;
	
	call.NotifyHookChange(requestStatus, hookStatus); 
	    
	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

	// this test is written supposing that NotifyHookChange() is supported
    // however RCall::NotifyHookChange returns KErrNotSupported
    // because CTSY does NOT support this feature
    // the rationale would be that NotifyStatusChange performs the same function

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

	AssertMockLtsyStatusL();
    
	CleanupStack::PopAndDestroy(4, this);
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNHCC-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::NotifyHookChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::NotifyHookChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyHookChange0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

	RCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
			
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, mobileService);

	
    TRequestStatus notifyStatus;
	RCall::THookStatus hookStatus;
	call.NotifyHookChange(requestStatus, hookStatus); 
	    
	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

	// this test is written supposing that NotifyHookChange() is supported
    // however RCall::NotifyHookChange returns KErrNotSupported
    // because CTSY does NOT support this feature
    // the rationale would be that NotifyStatusChange performs the same function

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

	AssertMockLtsyStatusL();
    
	CleanupStack::PopAndDestroy(4, this);
		
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNHCC-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::NotifyHookChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::NotifyHookChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyHookChange00011L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

	RCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
			
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, RMobileCall::EStatusRinging, mobileService);
	
    TRequestStatus notifyStatus;
	RCall::THookStatus hookStatus;
	call.NotifyHookChange(requestStatus, hookStatus); 
	
	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNotSupported, requestStatus1.Int());
    
	// this test is written supposing that NotifyHookChange() is supported
    // however RCall::NotifyHookChange returns KErrNotSupported
    // because CTSY does NOT support this feature
    // the rationale would be that NotifyStatusChange performs the same function

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

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

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNSC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::NotifyStatusChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::NotifyStatusChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyStatusChange0001L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    //-- test cases for different status values----------------------------------------------

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    
    RCall::TStatus statusToGet;
    call.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusRinging, statusToGet);

    //--------------------------------------------------    
    mobileCallStatus = RMobileCall::EStatusDialling; 
    data.Close();
    mockCallData3.SerialiseL(data);

    call.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusDialling, statusToGet);

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

    mobileCallStatus = RMobileCall::EStatusAnswering; 
    data.Close();
    mockCallData3.SerialiseL(data);

    call.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusAnswering, statusToGet);

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

    mobileCallStatus = RMobileCall::EStatusConnecting; 
    data.Close();
    mockCallData3.SerialiseL(data);

    call.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusConnecting, statusToGet);

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

    mobileCallStatus = RMobileCall::EStatusConnected; 
    data.Close();
    mockCallData3.SerialiseL(data);

    call.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusConnected, statusToGet);

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

    mobileCallStatus = RMobileCall::EStatusDisconnecting; 
    data.Close();
    mockCallData3.SerialiseL(data);

    call.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(RCall::EStatusHangingUp == statusToGet);

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

    mobileCallStatus = RMobileCall::EStatusDisconnectingWithInband; 
    data.Close();
    mockCallData3.SerialiseL(data);

    call.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(RCall::EStatusHangingUp == statusToGet);

	
    // for other status values the CompleteNotifyStatusChange() does not complete request
            	    

 	//- making status Idle + emergencyCalled ----------------------------------------
    mobileCallStatus = RMobileCall::EStatusIdle; 
    data.Close();
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
  
    TUint32 duration = 4; // this dummy param will be ignored by mocksy engine validation check	
    TMockLtsyData1<TUint32> ltsyData( duration );
    data.Close();
    ltsyData.SerialiseL(data);
    // when the call state becomes idle, there is update LifeTime param into LTSY:	
    iMockLTSY.ExpectL(EMmTsyUpdateLifeTimeIPC, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    // make this for callId > 0
	line.NotifyIncomingCall(requestStatus, incomingCallName);

    RMobileCall::TMobileCallInfoV1 mobileCallInfo;
    mobileCallInfo.iService = mobileService;
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> idleCallData(callId, mobileService, mobileCallInfo);
    data.Close();
    idleCallData.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    CleanupStack::PopAndDestroy(&call);
    //---------------------------------------------------------

    RMobileCall emerCall;

    TInt ret = emerCall.OpenExistingCall(line, incomingCallName);
    ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(emerCall);

	iMockLTSY.NotifyTerminated(mockLtsyStatus);
	TRfStateInfo rfInfo = ERfsStateInfoNormal;
	TMockLtsyData1<TRfStateInfo> mockData1(rfInfo);
	
    data.Close();
    mockData1.SerialiseL(data);
    
	iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, data);
	User::WaitForRequest(mockLtsyStatus);
	AssertMockLtsyStatusL();
	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
	

	RMobileENStore::TEmergencyNumber number(_L("911"));
	TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData(number);
	data.Close();
	numberLtsyData.SerialiseL(data);
	iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

    emerCall.DialEmergencyCall(requestStatus, number);
    
    mobileCallStatus = RMobileCall::EStatusIdle;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockEmCallData(callId, mobileService, mobileCallStatus);
    data.Close();
    mockEmCallData.SerialiseL(data);

    TRequestStatus requestStatus2;
    emerCall.NotifyStatusChange(requestStatus2, statusToGet); 

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> emerCallData(callId, mobileService, mobileCallStatus);
    data.Close();
    emerCallData.SerialiseL(data);
    
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGsmReleaseByUser, data);
    User::WaitForRequest(mockLtsyStatus);
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrGsmReleaseByUser, requestStatus.Int());
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_EQUALS(RCall::EStatusIdle, statusToGet);

    AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(&emerCall);

	//-- for checking branches with ghost calls, EStatusRinging --------------------------------------------
	callId = 2;
	mobileCallStatus = RMobileCall::EStatusRinging;    
	
    mobileCallInfo.iCallId = callId;
    mobileCallInfo.iService = mobileService;
    mobileCallInfo.iStatus = RMobileCall::EStatusDialling;     
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, mobileService, mobileCallInfo);
    data.Close();
    mockCallData1.SerialiseL(data);  

	line.NotifyCallAdded(requestStatus, incomingCallName);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);

    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());	
    
    //-------------------------------------------------------------------------------------------------
       
	RMobileCall call2;
    ret = call2.OpenExistingCall(line, incomingCallName);
    ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(call2);    
	   
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData4.SerialiseL(data);
       
    RMobileCall::TMobileCallStatus mStatusToGet;
    TRequestStatus mRequestStatus;
    
    call2.NotifyMobileCallStatusChange(mRequestStatus, mStatusToGet); 
    call2.NotifyStatusChange(requestStatus, statusToGet); 
    
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusDialling, statusToGet);

    User::WaitForRequest(mRequestStatus);

    CloseCallL(call2, callId, mobileService);
    AssertMockLtsyStatusL();
    CleanupStack::PopAndDestroy(&call2);


	//-- EStatusIdle --------------------------------------------
	callId = 3;
	mobileCallStatus = RMobileCall::EStatusRinging;    
	
    mobileCallInfo.iCallId = callId;
    mobileCallInfo.iService = mobileService;
    mobileCallInfo.iStatus = RMobileCall::EStatusDialling;  
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData5(callId, mobileService, mobileCallInfo);
    data.Close();
    mockCallData5.SerialiseL(data);  

	line.NotifyCallAdded(requestStatus, incomingCallName);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);

    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
	

    RMobileCall call3;
    ret = call3.OpenExistingCall(line, incomingCallName);
    ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(call3);

    mobileCallStatus = RMobileCall::EStatusIdle;    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData6(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData6.SerialiseL(data);
        
    call3.NotifyMobileCallStatusChange(mRequestStatus, mStatusToGet); 
    call3.NotifyStatusChange(requestStatus, statusToGet); 
    
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusIdle, statusToGet);

    User::WaitForRequest(mRequestStatus);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(&call3);
    
    //-- EStatusDisconnecting ---------------------------------------------

	callId = 4;
	mobileCallStatus = RMobileCall::EStatusRinging;    
	
    mobileCallInfo.iCallId = callId;
    mobileCallInfo.iService = mobileService;
    mobileCallInfo.iStatus = RMobileCall::EStatusDialling;  
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData7(callId, mobileService, mobileCallInfo);
    data.Close();
    mockCallData7.SerialiseL(data);  

	line.NotifyCallAdded(requestStatus, incomingCallName);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    RMobileCall call4;
    ret = call4.OpenExistingCall(line, incomingCallName);
    ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(call4);

    mobileCallStatus = RMobileCall::EStatusDisconnecting;    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData8(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData8.SerialiseL(data);
        
    call4.NotifyStatusChange(requestStatus, statusToGet); 
    call4.NotifyMobileCallStatusChange(mRequestStatus, mStatusToGet); 
    
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusHangingUp, statusToGet);

    User::WaitForRequest(mRequestStatus);

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(4, this);	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNSC-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyStatusChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RCall::NotifyStatusChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyStatusChange0002L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    RCall::TStatus statusToGet;
    call.NotifyStatusChange(requestStatus, statusToGet); 
    
    call.NotifyStatusChangeCancel();

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNSC-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyStatusChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RCall::NotifyStatusChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyStatusChange0004L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyVoice1LineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);    
	
	RCall call;
	RCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
    
	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);

    RCall::TStatus statusToGet;
    RCall::TStatus statusToGet2;
    call.NotifyStatusChange(requestStatus, statusToGet); 
    call2.NotifyStatusChange(requestStatus2, statusToGet2); 

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    mobileCallStatus = RMobileCall::EStatusIdle;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId2, mobileService, mobileCallStatus);
    data.Close();
    mockCallData4.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusRinging, statusToGet);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_EQUALS(RCall::EStatusIdle, statusToGet2);

	CleanupStack::PopAndDestroy(8, this);
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNSC-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::NotifyStatusChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::NotifyStatusChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyStatusChange0006L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);
	
	RBuf8 expectData;
	CleanupClosePushL(expectData);
	
    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
    
    RCall::TStatus statusToGet;
    call.NotifyStatusChange(requestStatus, statusToGet); 

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusRinging, statusToGet);

    //-- test cases for different status values----------------------------------------------
	mobileCallStatus = RMobileCall::EStatusConnecting;
    data.Close();
    mockCallData3.SerialiseL(data);
	    
    call.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusConnecting, statusToGet);
	    
	mobileCallStatus = RMobileCall::EStatusDialling;
    data.Close();
    mockCallData3.SerialiseL(data);

    call.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusDialling, statusToGet);

	RArray<RMobileCall::TMobileCallStatus> arrayStatus;
	CleanupClosePushL(arrayStatus);
	
	arrayStatus.AppendL(RMobileCall::EStatusUnknown);
	arrayStatus.AppendL(RMobileCall::EStatusReconnectPending);
	arrayStatus.AppendL(RMobileCall::EStatusWaitingAlternatingCallSwitch);
	arrayStatus.AppendL(RMobileCall::EStatusTransferring);
	arrayStatus.AppendL(RMobileCall::EStatusTransferAlerting);
	arrayStatus.AppendL(static_cast<RMobileCall::TMobileCallStatus>(RMobileCall::EStatusTransferAlerting+1));

	for (TInt i = 0; i < arrayStatus.Count(); i++)
		{
		mobileCallStatus = arrayStatus[i];
	    data.Close();
	    mockCallData3.SerialiseL(data);
	    
	    iMockLTSY.NotifyTerminated(mockLtsyStatus);
	    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
	    User::WaitForRequest(mockLtsyStatus);
	    AssertMockLtsyStatusL();
	    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
		}

 	//- making status Idle + KErrNone != aResult ----------------------------------------
	mobileCallStatus = RMobileCall::EStatusIdle;
    data.Close();
    mockCallData3.SerialiseL(data);
	    
    call.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGeneral, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusIdle, statusToGet);
    
 	//- making status Idle + KErrNone != KErrGsmReleaseByUser ----------------------------

    // make this for callId > 0
	line.NotifyIncomingCall(requestStatus, incomingCallName);

	RMobileCall::TMobileCallInfoV1 mobileCallInfo;
    mobileCallInfo.iService = mobileService;
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> idleCallData4(callId, mobileService, mobileCallInfo);
    data.Close();
    idleCallData4.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    RMobileCall em_call;
    TInt ret = em_call.OpenExistingCall(line, incomingCallName);
    ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(em_call);

	mobileCallStatus = RMobileCall::EStatusIdle;
    data.Close();
    mockCallData3.SerialiseL(data);

    em_call.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGsmReleaseByUser, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusIdle, statusToGet);

	//-- for checking branches with ghost calls, EStatusRinging --------------------------------------------
	callId = 2;
	mobileCallStatus = RMobileCall::EStatusRinging;    
	
    mobileCallInfo.iCallId = callId;
    mobileCallInfo.iService = mobileService;
    mobileCallInfo.iStatus = RMobileCall::EStatusDialling;  
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, mobileService, mobileCallInfo);
    data.Close();
    mockCallData1.SerialiseL(data);  

	line.NotifyCallAdded(requestStatus, incomingCallName);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
	
	RMobileCall call3;
    ret = call3.OpenExistingCall(line, incomingCallName);
    ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(call3);
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData4.SerialiseL(data);
    
    RMobileCall::TMobileCallStatus mStatusToGet;
    TRequestStatus mRequestStatus;
    
    call3.NotifyMobileCallStatusChange(mRequestStatus, mStatusToGet); 
    call3.NotifyStatusChange(requestStatus, statusToGet); 
    
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusDialling, statusToGet);

    User::WaitForRequest(mRequestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(8, this); 	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNSC-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyStatusChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RCall::NotifyStatusChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyStatusChange0007L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    RCall::TStatus statusToGet;
    call.NotifyStatusChange(requestStatus, statusToGet); 
    
    call.NotifyStatusChangeCancel();

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	
	}





/**
@SYMTestCaseID BA-CTSY-CALLI-CNSC-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyStatusChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RCall::NotifyStatusChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyStatusChange0009L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyDataLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    
	RCall call;
	RCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);


    RCall::TStatus statusToGet;
    RCall::TStatus statusToGet2;
    call.NotifyStatusChange(requestStatus, statusToGet); 
    call2.NotifyStatusChange(requestStatus2, statusToGet2); 

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    mobileCallStatus = RMobileCall::EStatusIdle;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId2, mobileService, mobileCallStatus);
    data.Close();
    mockCallData4.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusRinging, statusToGet);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_EQUALS(RCall::EStatusIdle, statusToGet2);


	CleanupStack::PopAndDestroy(8, this); 
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNSC-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::NotifyStatusChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::NotifyStatusChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyStatusChange00011L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    RCall::TStatus statusToGet;
    call.NotifyStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusIdle;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusIdle, statusToGet);


	//-- for checking branches with ghost calls, EStatusRinging --------------------------------------------	
	callId = 1;
	mobileCallStatus = RMobileCall::EStatusRinging;    
	
	RMobileCall::TMobileCallInfoV1 mobileCallInfo;
    mobileCallInfo.iCallId = callId;
    mobileCallInfo.iService = mobileService;
    mobileCallInfo.iStatus = RMobileCall::EStatusDialling;  
    
   	TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, mobileService, mobileCallInfo);
    data.Close();
    mockCallData1.SerialiseL(data);  

	line.NotifyCallAdded(requestStatus, incomingCallName);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
	
	RMobileCall call2;
    TInt ret = call2.OpenExistingCall(line, incomingCallName);
    ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(call2);
	
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData4.SerialiseL(data);
    
    RMobileCall::TMobileCallStatus mStatusToGet;
    TRequestStatus mRequestStatus;
    
    call2.NotifyMobileCallStatusChange(mRequestStatus, mStatusToGet); 
    call2.NotifyStatusChange(requestStatus, statusToGet); 
    
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusDialling, statusToGet);

    User::WaitForRequest(mRequestStatus);
    AssertMockLtsyStatusL();
    
	RArray<RMobileCall::TMobileCallStatus> arrayStatus;
	CleanupClosePushL(arrayStatus);
	
	arrayStatus.AppendL(RMobileCall::EStatusUnknown);
	arrayStatus.AppendL(RMobileCall::EStatusReconnectPending);
	arrayStatus.AppendL(RMobileCall::EStatusWaitingAlternatingCallSwitch);
	arrayStatus.AppendL(RMobileCall::EStatusTransferring);
	arrayStatus.AppendL(RMobileCall::EStatusTransferAlerting);
	arrayStatus.AppendL(RMobileCall::EStatusDisconnectingWithInband);
	arrayStatus.AppendL(RMobileCall::EStatusConnecting);
	arrayStatus.AppendL(static_cast<RMobileCall::TMobileCallStatus>(RMobileCall::EStatusTransferAlerting+1));

	for (TInt i = 0; i < arrayStatus.Count(); i++)
		{
		mobileCallStatus = arrayStatus[i];
	    data.Close();
	    mockCallData3.SerialiseL(data);
	    
	    iMockLTSY.NotifyTerminated(mockLtsyStatus);
	    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
	    User::WaitForRequest(mockLtsyStatus);
	    AssertMockLtsyStatusL();
	    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
		}
    
 	//- making status Idle + aResult  == KErrGsmReleaseByUser ----------------------------
	mobileCallStatus = RMobileCall::EStatusIdle;
    data.Close();
    mockCallData3.SerialiseL(data);

    call2.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrGsmReleaseByUser, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
 	//- making status Idle + aResult != KErrGsmReleaseByUser + aResult != KErrGsmBusyUserRequest  	
    call2.Close();
    
	callId = 2;
	mobileCallStatus = RMobileCall::EStatusRinging;    
	
    mobileCallInfo.iCallId = callId;
    mobileCallInfo.iService = mobileService;
    mobileCallInfo.iStatus = RMobileCall::EStatusDialling;  
    
	line.NotifyCallAdded(requestStatus, incomingCallName);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    data.Close();
    mockCallData1.SerialiseL(data);  
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
	
    ret = call2.OpenExistingCall(line, incomingCallName);
    ASSERT_EQUALS(KErrNone, ret);
    
	mobileCallStatus = RMobileCall::EStatusIdle;
    data.Close();
    mockCallData3.SerialiseL(data);

    call2.NotifyStatusChange(requestStatus, statusToGet); 

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNotSupported, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(6, this); 
	

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNSC-00012
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyStatusChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RCall::NotifyStatusChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyStatusChange00012L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);


    RCall::TStatus statusToGet;
    call.NotifyStatusChange(requestStatus, statusToGet); 
    
    call.NotifyStatusChangeCancel();

    mobileCallStatus = RMobileCall::EStatusIdle;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());	
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNSC-00014
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyStatusChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RCall::NotifyStatusChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyStatusChange00014L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyFaxLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
	
	        
	RCall call;
	RCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);

    RCall::TStatus statusToGet;
    RCall::TStatus statusToGet2;
    call.NotifyStatusChange(requestStatus, statusToGet); 
    call2.NotifyStatusChange(requestStatus2, statusToGet2); 

    mobileCallStatus = RMobileCall::EStatusConnected;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    mobileCallStatus = RMobileCall::EStatusIdle;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId2, mobileService, mobileCallStatus);
    data.Close();
    mockCallData4.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RCall::EStatusConnected, statusToGet);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_EQUALS(RCall::EStatusIdle, statusToGet2);

	CleanupStack::PopAndDestroy(8, this);
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::NotifyCallDurationChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::NotifyCallDurationChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallDurationChange0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
  
    TTimeIntervalSeconds time;
    
	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    call.NotifyCallDurationChange(requestStatus, time);


    mobileCallStatus = RMobileCall::EStatusConnected;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    completeData.Close();
    mockCallData2.SerialiseL(completeData);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
 	//-------------------------------------------------------------------------

    const TTimeIntervalSeconds KZeroTime(0);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(KZeroTime != time);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyCallDurationChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RCall::NotifyCallDurationChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallDurationChange0002L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	  
    TTimeIntervalSeconds time;
    
	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);


    call.NotifyCallDurationChange(requestStatus, time);

    call.NotifyCallDurationChangeCancel();

    mobileCallStatus = RMobileCall::EStatusConnected;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    completeData.Close();
    mockCallData2.SerialiseL(completeData);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyCallDurationChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RCall::NotifyCallDurationChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallDurationChange0004L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyVoice1LineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
       
	RCall call;
	RCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);

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

    mobileCallStatus = RMobileCall::EStatusConnected;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId2, mobileService, mobileCallStatus);
    data.Close();
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
 	//-------------------------------------------------------------------------
    TTimeIntervalSeconds time;
    TTimeIntervalSeconds time2;
	    
    call.NotifyCallDurationChange(requestStatus, time);
    call2.NotifyCallDurationChange(requestStatus2, time2);
 	

    const TTimeIntervalSeconds KZeroTime(0);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(KZeroTime != time);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE(KZeroTime != time2);

	CleanupStack::PopAndDestroy(8, this);
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::NotifyCallDurationChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::NotifyCallDurationChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallDurationChange0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

  
    TTimeIntervalSeconds time;
    
	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
 	//-------------------------------------------------------------------------

    call.NotifyCallDurationChange(requestStatus, time);


    mobileCallStatus = RMobileCall::EStatusConnected;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    completeData.Close();
    mockCallData2.SerialiseL(completeData);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
 	//-------------------------------------------------------------------------

    const TTimeIntervalSeconds KZeroTime(0);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(KZeroTime != time);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyCallDurationChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RCall::NotifyCallDurationChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallDurationChange0007L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

  
    TTimeIntervalSeconds time;
    
	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
 	//-------------------------------------------------------------------------

    call.NotifyCallDurationChange(requestStatus, time);

    call.NotifyCallDurationChangeCancel();

    mobileCallStatus = RMobileCall::EStatusConnected;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    completeData.Close();
    mockCallData2.SerialiseL(completeData);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
 	//-------------------------------------------------------------------------

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

	AssertMockLtsyStatusL();
	
	// Stop the timer by calling NotifyCallDurationChangeCancel and then check that the last call duration returned is accurate.
	call.NotifyCallDurationChange(requestStatus, time);
	sleep(1);
	call.NotifyCallDurationChangeCancel();
	User::WaitForRequest(requestStatus);
	TInt ret = call.GetCallDuration(time);
	ASSERT_EQUALS(KErrNone, ret);
	const TTimeIntervalSeconds KZeroTime(0);
	ASSERT_TRUE(KZeroTime != time);
			
	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(4, this);
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyCallDurationChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RCall::NotifyCallDurationChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallDurationChange0009L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyDataLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    
	RCall call;
	RCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
    
	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);
    //----------------------------------------    

    mobileCallStatus = RMobileCall::EStatusConnected;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId2, mobileService, mobileCallStatus);
    data.Close();
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
 	//-------------------------------------------------------------------------
    TTimeIntervalSeconds time;
    TTimeIntervalSeconds time2;
	    
    call.NotifyCallDurationChange(requestStatus, time);
    call2.NotifyCallDurationChange(requestStatus2, time2);
 	

    const TTimeIntervalSeconds KZeroTime(0);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(KZeroTime != time);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE(KZeroTime != time2);

	CleanupStack::PopAndDestroy(8, this);
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RCall::NotifyCallDurationChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RCall::NotifyCallDurationChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallDurationChange00011L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
  
    TTimeIntervalSeconds time;
    
	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
 	//-------------------------------------------------------------------------

    call.NotifyCallDurationChange(requestStatus, time);


    mobileCallStatus = RMobileCall::EStatusConnected;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    completeData.Close();
    mockCallData2.SerialiseL(completeData);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
 	//-------------------------------------------------------------------------

    const TTimeIntervalSeconds KZeroTime(0);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(KZeroTime != time);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-00012
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RCall::NotifyCallDurationChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RCall::NotifyCallDurationChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallDurationChange00012L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

  
    TTimeIntervalSeconds time;
    
	RCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
 	//-------------------------------------------------------------------------

    call.NotifyCallDurationChange(requestStatus, time);

    call.NotifyCallDurationChangeCancel();

    mobileCallStatus = RMobileCall::EStatusConnected;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    completeData.Close();
    mockCallData2.SerialiseL(completeData);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
 	//-------------------------------------------------------------------------

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNCDCC-00014
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RCall::NotifyCallDurationChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RCall::NotifyCallDurationChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallDurationChange00014L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyFaxLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    
	RCall call;
	RCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);

    mobileCallStatus = RMobileCall::EStatusConnected;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId2, mobileService, mobileCallStatus);
    data.Close();
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
 	//-------------------------------------------------------------------------
    TTimeIntervalSeconds time;
    TTimeIntervalSeconds time2;
	    
    call.NotifyCallDurationChange(requestStatus, time);
    call2.NotifyCallDurationChange(requestStatus2, time2);
 	

    const TTimeIntervalSeconds KZeroTime(0);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(KZeroTime != time);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE(KZeroTime != time2);

	CleanupStack::PopAndDestroy(8, this);
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LNCA-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::NotifyCallAdded for voice lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::NotifyCallAdded for voice lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallAdded0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);  
	
    TTimeIntervalSeconds time;
    
	RCall call;
	
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			

    TName tmpname;
	RCall tmpcall;

    TRequestStatus mockLtsyStatus;

    // test C1, complete called from CMmVoiceLineTsy::OpenNewObjectL()
	TName callName;
	line.NotifyCallAdded(requestStatus, callName);

   	OpenNewCallLC(tmpcall, line, &tmpname);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(0 == callName.Compare(tmpname));


	//test C2, complete called from CMmLineTsy::CompleteNotifyAddBypassingCall()
	line.NotifyCallAdded(requestStatus, callName);
	
	TInt callId = 1;
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;
	   
	RMobileCall::TMobileCallInfoV1 callInfo;
	
	callInfo.iStatus = RMobileCall::EStatusDialling;
	callInfo.iService = mobileService; 
		
	TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> callInfoData(callId, mobileService, callInfo);
	completeData.Close();
	callInfoData.SerialiseL(completeData);	

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
	iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo,KErrNone,completeData,0);
    User::WaitForRequest(mockLtsyStatus);
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    TName callName3(lineName);
    callName3.Append('3');
    ASSERT_TRUE(0 == callName.Compare(callName3));
    
 	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LNCA-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RLine::NotifyCallAdded for voice lines
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RLine::NotifyCallAdded for voice lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallAdded0002L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
  
    TTimeIntervalSeconds time;
    
	RCall call;
	
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    TName tmpname;
	RCall tmpcall;

    TRequestStatus mockLtsyStatus;

	TName callName;
	line.NotifyCallAdded(requestStatus, callName);
	
	line.NotifyCallAddedCancel();

   	OpenNewCallLC(tmpcall, line, &tmpname);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

 	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LNCA-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RLine::NotifyCallAdded for voice lines
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RLine::NotifyCallAdded for voice lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallAdded0004L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyVoice1LineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    //----------------------------------------
    
    TRequestStatus requestStatus;
    TRequestStatus requestStatus2;

	TName callName;
	TName callName2;
	
	line.NotifyCallAdded(requestStatus, callName);
	line2.NotifyCallAdded(requestStatus2, callName2);

 	RCall call;
    TName tmpname;
	
   	OpenNewCallLC(call, line, &tmpname);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(0 == callName.Compare(tmpname));

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE(0 == callName2.Compare(tmpname));
    

	CleanupStack::PopAndDestroy(6, this); 
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LNCA-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::NotifyCallAdded for data lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::NotifyCallAdded for data lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallAdded0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	  
    TTimeIntervalSeconds time;
    
	RCall call;
	
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			

    TName tmpname;
	RCall tmpcall;

    TRequestStatus mockLtsyStatus;

    // test C1, complete called from CMmDataLineTsy::OpenNewObjectL()
	TName callName;
	line.NotifyCallAdded(requestStatus, callName);

   	OpenNewCallLC(call, line, &tmpname);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(0 == callName.Compare(tmpname));

	//test C2, complete called from CMmLineTsy::CompleteNotifyAddBypassingCall()
	line.NotifyCallAdded(requestStatus, callName);
	
	TInt callId = 1;
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
	   
	RMobileCall::TMobileCallInfoV1 callInfo;
	
	callInfo.iStatus = RMobileCall::EStatusDialling;
	callInfo.iService = mobileService; 
		
	TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> callInfoData(callId, mobileService, callInfo);
	completeData.Close();
	callInfoData.SerialiseL(completeData);	

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
	iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo,KErrNone,completeData,0);
    User::WaitForRequest(mockLtsyStatus);
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    TName callName3(lineName);
    callName3.Append('3');
    ASSERT_TRUE(0 == callName.Compare(callName3));

 	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 	
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LNCA-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RLine::NotifyCallAdded for data lines
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RLine::NotifyCallAdded for data lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallAdded0007L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
  
    TTimeIntervalSeconds time;
    
	RCall call;
	
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    TName tmpname;
	RCall tmpcall;

	TName callName;
	line.NotifyCallAdded(requestStatus, callName);
	
	line.NotifyCallAddedCancel();

   	OpenNewCallLC(tmpcall, line, &tmpname);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

 	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LNCA-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RLine::NotifyCallAdded for data lines
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RLine::NotifyCallAdded for data lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallAdded0009L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyDataLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    //----------------------------------------
    
    TRequestStatus requestStatus;
    TRequestStatus requestStatus2;

	TName callName;
	TName callName2;
	
	line.NotifyCallAdded(requestStatus, callName);
	line2.NotifyCallAdded(requestStatus2, callName2);

 	RCall call;
    TName tmpname;
	
   	OpenNewCallLC(call, line, &tmpname);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(0 == callName.Compare(tmpname));

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE(0 == callName2.Compare(tmpname));    

	CleanupStack::PopAndDestroy(7, this); 

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LNCA-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::NotifyCallAdded for fax lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::NotifyCallAdded for fax lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallAdded00011L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
  
    TTimeIntervalSeconds time;
    
	RCall call;
	
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    TName tmpname;
	RCall tmpcall;

    TRequestStatus mockLtsyStatus;

    // test C1, complete called from CMmFaxLineTsy::OpenNewObjectL()
	TName callName;
	line.NotifyCallAdded(requestStatus, callName);

   	OpenNewCallLC(tmpcall, line, &tmpname);
   	
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(0 == callName.Compare(tmpname));

 	AssertMockLtsyStatusL();
 	
	//test C2, complete called from CMmLineTsy::CompleteNotifyAddBypassingCall()
	line.NotifyCallAdded(requestStatus, callName);
	
	TInt callId = 1;
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;
	   
	RMobileCall::TMobileCallInfoV1 callInfo;
	
	callInfo.iStatus = RMobileCall::EStatusDialling;
	callInfo.iService = mobileService; 
		
	TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> callInfoData(callId, mobileService, callInfo);
	completeData.Close();
	callInfoData.SerialiseL(completeData);	

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
	iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo,KErrNone,completeData,0);
    User::WaitForRequest(mockLtsyStatus);
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    TName callName3(lineName);
    callName3.Append('3');
    ASSERT_TRUE(0 == callName.Compare(callName3));
 	
 	
	CleanupStack::PopAndDestroy(4, this); 
	
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LNCA-00012
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RLine::NotifyCallAdded for fax lines
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RLine::NotifyCallAdded for fax lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallAdded00012L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
  
    TTimeIntervalSeconds time;
    
	RCall call;
	
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    TName tmpname;
	RCall tmpcall;

    TRequestStatus mockLtsyStatus;

	TName callName;
	line.NotifyCallAdded(requestStatus, callName);
	
	line.NotifyCallAddedCancel();

   	OpenNewCallLC(tmpcall, line, &tmpname);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

 	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this);
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LNCA-00014
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RLine::NotifyCallAdded for fax lines
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RLine::NotifyCallAdded for fax lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallAdded00014L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyFaxLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    //----------------------------------------
    
    TRequestStatus requestStatus;
    TRequestStatus requestStatus2;

	TName callName;
	TName callName2;
	
	line.NotifyCallAdded(requestStatus, callName);
	line2.NotifyCallAdded(requestStatus2, callName2);

 	RCall call;
    TName tmpname;
	
   	OpenNewCallLC(call, line, &tmpname);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(0 == callName.Compare(tmpname));

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE(0 == callName2.Compare(tmpname));
    
	CleanupStack::PopAndDestroy(7, this); 

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LNIC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::NotifyIncomingCall for voice lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::NotifyIncomingCall for voice lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyIncomingCall0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestNotify;
			
    TRequestStatus mockLtsyStatus;

	line.NotifyIncomingCall(requestNotify, incomingCallName);
	
    RMobileCall::TMobileCallInfoV1 mobileCallInfo;
    mobileCallInfo.iService = RMobilePhone::EVoiceService;
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::EVoiceService, mobileCallInfo);
    completeData.Close();
    mockCallData1.SerialiseL(completeData);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    _LIT(KName, "Voice11");

    User::WaitForRequest(requestNotify);
    ASSERT_EQUALS(KErrNone, requestNotify.Int());
    ASSERT_TRUE(0 == incomingCallName.Compare(KName));

 	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LNIC-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RLine::NotifyIncomingCall for voice lines
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RLine::NotifyIncomingCall for voice lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyIncomingCall0002L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestNotify;
			
    TRequestStatus mockLtsyStatus;

	line.NotifyIncomingCall(requestNotify, incomingCallName);

	line.CancelAsyncRequest(EEtelLineNotifyIncomingCall);
	
    RMobileCall::TMobileCallInfoV1 mobileCallInfo;
    mobileCallInfo.iService = RMobilePhone::EVoiceService;
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::EVoiceService, mobileCallInfo);
    completeData.Close();
    mockCallData1.SerialiseL(completeData);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestNotify);
    ASSERT_EQUALS(KErrCancel, requestNotify.Int());

 	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 	
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LNIC-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RLine::NotifyIncomingCall for voice lines
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RLine::NotifyIncomingCall for voice lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyIncomingCall0004L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyVoice1LineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);


      
	TInt callId = 1;
	TInt callId2= 2;
	
	TName incomingCallName;
	TName incomingCallName2;
	
    TRequestStatus requestStatus;
    TRequestStatus requestStatus2;
    TRequestStatus requestNotify;
			
    TRequestStatus mockLtsyStatus;

	line.NotifyIncomingCall(requestStatus, incomingCallName);
	line2.NotifyIncomingCall(requestStatus2, incomingCallName2);
	
    RMobileCall::TMobileCallInfoV1 mobileCallInfo;
    mobileCallInfo.iService = RMobilePhone::EVoiceService;
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::EVoiceService, mobileCallInfo);
    mockCallData1.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId2, RMobilePhone::EVoiceService, mobileCallInfo);
    data.Close();
    mockCallData2.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    _LIT(KName, "Voice11");

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(0 == incomingCallName.Compare(KName));

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE(0 == incomingCallName2.Compare(KName));    
    
	CleanupStack::PopAndDestroy(6, this); 

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LNIC-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::NotifyIncomingCall for data lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::NotifyIncomingCall for data lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyIncomingCall0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
	    
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestNotify;
			
    TRequestStatus mockLtsyStatus;

	line.NotifyIncomingCall(requestNotify, incomingCallName);
	
    RMobileCall::TMobileCallInfoV1 mobileCallInfo;
    mobileCallInfo.iService = RMobilePhone::ECircuitDataService;
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::ECircuitDataService, mobileCallInfo);
    completeData.Close();
    mockCallData1.SerialiseL(completeData);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    _LIT(KName, "Data1");

    User::WaitForRequest(requestNotify);
    ASSERT_EQUALS(KErrNone, requestNotify.Int());
    ASSERT_TRUE(0 == incomingCallName.Compare(KName));

 	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LNIC-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RLine::NotifyIncomingCall for data lines
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RLine::NotifyIncomingCall for data lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyIncomingCall0007L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestNotify;
			
    TRequestStatus mockLtsyStatus;

	line.NotifyIncomingCall(requestNotify, incomingCallName);

	line.CancelAsyncRequest(EEtelLineNotifyIncomingCall);
	
    RMobileCall::TMobileCallInfoV1 mobileCallInfo;
    mobileCallInfo.iService = RMobilePhone::ECircuitDataService;
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::ECircuitDataService, mobileCallInfo);
    completeData.Close();
    mockCallData1.SerialiseL(completeData);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestNotify);
    ASSERT_EQUALS(KErrCancel, requestNotify.Int());

 	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 		
	
	}




/**
@SYMTestCaseID BA-CTSY-CALLI-LNIC-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RLine::NotifyIncomingCall for data lines
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RLine::NotifyIncomingCall for data lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyIncomingCall0009L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	
    TName lineName2(KMmTsyDataLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
	
	    
	TInt callId = 1;
	TInt callId2= 2;
	
	TName incomingCallName;
	TName incomingCallName2;
	
    TRequestStatus requestStatus;
    TRequestStatus requestStatus2;
    TRequestStatus requestNotify;
			
    TRequestStatus mockLtsyStatus;

	line.NotifyIncomingCall(requestStatus, incomingCallName);
	line2.NotifyIncomingCall(requestStatus2, incomingCallName2);
	
    RMobileCall::TMobileCallInfoV1 mobileCallInfo;
    mobileCallInfo.iService = RMobilePhone::ECircuitDataService;
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::ECircuitDataService, mobileCallInfo);
    mockCallData1.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId2, RMobilePhone::ECircuitDataService, mobileCallInfo);
    data.Close();
    mockCallData2.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    _LIT(KName, "Data1");

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(0 == incomingCallName.Compare(KName));

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE(0 == incomingCallName2.Compare(KName));    
    
	CleanupStack::PopAndDestroy(6, this); 

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-LNIC-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::NotifyIncomingCall for fax lines
@SYMTestPriority High
@SYMTestActions Invokes RLine::NotifyIncomingCall for fax lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyIncomingCall00011L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestNotify;
			
    TRequestStatus mockLtsyStatus;

	line.NotifyIncomingCall(requestNotify, incomingCallName);
	
    RMobileCall::TMobileCallInfoV1 mobileCallInfo;
    mobileCallInfo.iService = RMobilePhone::EFaxService;
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::EFaxService, mobileCallInfo);
    completeData.Close();
    mockCallData1.SerialiseL(completeData);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    _LIT(KName, "Fax1");

    User::WaitForRequest(requestNotify);
    ASSERT_EQUALS(KErrNone, requestNotify.Int());
    ASSERT_TRUE(0 == incomingCallName.Compare(KName));

 	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LNIC-00012
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RLine::NotifyIncomingCall for fax lines
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RLine::NotifyIncomingCall for fax lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyIncomingCall00012L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestNotify;
			
    TRequestStatus mockLtsyStatus;

	line.NotifyIncomingCall(requestNotify, incomingCallName);

	line.CancelAsyncRequest(EEtelLineNotifyIncomingCall);
	
    RMobileCall::TMobileCallInfoV1 mobileCallInfo;
    mobileCallInfo.iService = RMobilePhone::EFaxService;
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::EFaxService, mobileCallInfo);
    completeData.Close();
    mockCallData1.SerialiseL(completeData);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestNotify);
    ASSERT_EQUALS(KErrCancel, requestNotify.Int());

 	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 	
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LNIC-00014
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RLine::NotifyIncomingCall for fax lines
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RLine::NotifyIncomingCall for fax lines
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyIncomingCall00014L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyFaxLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    //----------------------------------------
    
	TInt callId = 1;
	TInt callId2= 2;
	
	TName incomingCallName;
	TName incomingCallName2;
	
    TRequestStatus requestStatus;
    TRequestStatus requestStatus2;
    TRequestStatus requestNotify;
			
    TRequestStatus mockLtsyStatus;

	line.NotifyIncomingCall(requestStatus, incomingCallName);
	line2.NotifyIncomingCall(requestStatus2, incomingCallName2);
	
    RMobileCall::TMobileCallInfoV1 mobileCallInfo;
    mobileCallInfo.iService = RMobilePhone::EFaxService;
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, RMobilePhone::EFaxService, mobileCallInfo);
    mockCallData1.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId2, RMobilePhone::EFaxService, mobileCallInfo);
    data.Close();
    mockCallData2.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    _LIT(KName, "Fax1");

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(0 == incomingCallName.Compare(KName));

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE(0 == incomingCallName2.Compare(KName));
  
    
	CleanupStack::PopAndDestroy(6, this); 

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCE-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyCallEvent for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyCallEvent for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallEvent0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
	    
    //----------------------------------------
	RMobileCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    RMobileCall::TMobileCallEvent ev;

    //----------------------------------------
    call.NotifyCallEvent(requestStatus, ev);

    RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteTerminated);
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::ERemoteTerminated, ev);
    
    //----------------------------------------
    ev1 = RMobileCall::ELocalHold;
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData4(callId, mobileService, ev1);
    data.Close();
    mockCallData4.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

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

    call.NotifyCallEvent(requestStatus, ev);
    
    mobileCallStatus = RMobileCall::EStatusHold;

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData5(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData5.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::ELocalHold, ev);

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

    call.NotifyCallEvent(requestStatus, ev);
    
    mobileCallStatus = RMobileCall::EStatusConnected;

    data.Close();
    mockCallData5.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::ELocalResume, ev);
	
    //----------------------------------------
    // see CMmCallTsy::CompleteNotifyRemoteCallEvent in CMmCallTsy.cpp

	mobileService = RMobilePhone::EVoiceService;
	
	RArray<RMobileCall::TMobileCallEvent> arrayRemote;
	CleanupClosePushL(arrayRemote);

	
	// complete is called for these events from CMmCallTsy::CompleteNotifyRemoteCallEvent
	arrayRemote.AppendL(RMobileCall::ERemoteHold);
	arrayRemote.AppendL(RMobileCall::ERemoteResume);
	arrayRemote.AppendL(RMobileCall::ERemoteTerminated);
	arrayRemote.AppendL(RMobileCall::ERemoteConferenceCreate);
	// and these are ingnored in CompleteNotifyRemoteCallEvent
	arrayRemote.AppendL(RMobileCall::ELocalHold);
	arrayRemote.AppendL(RMobileCall::ELocalResume);
	arrayRemote.AppendL(RMobileCall::ELocalDeflectCall);
	arrayRemote.AppendL(RMobileCall::ELocalTransfer);
	arrayRemote.AppendL(RMobileCall::ERemoteTransferring);
	arrayRemote.AppendL(RMobileCall::ERemoteTransferAlerting);
	arrayRemote.AppendL(RMobileCall::ERemoteBarred);
	arrayRemote.AppendL(RMobileCall::ERemoteForwarding);
	arrayRemote.AppendL(RMobileCall::ERemoteWaiting);
	arrayRemote.AppendL(RMobileCall::ELocalBarred);
	arrayRemote.AppendL(static_cast<RMobileCall::TMobileCallEvent>(RMobileCall::ELocalBarred+1));

	for (TInt i = 0; i < 4; i++)
		{
	    RMobileCall::TMobileCallEvent evTemp(arrayRemote[i]);
	    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallDataTemp(callId, mobileService, evTemp);
	    data.Close();
	    mockCallDataTemp.SerialiseL(data);

	    call.NotifyCallEvent(requestStatus, ev);

	    iMockLTSY.NotifyTerminated(mockLtsyStatus);
	    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
	    User::WaitForRequest(mockLtsyStatus);
	    AssertMockLtsyStatusL();
	    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

	    User::WaitForRequest(requestStatus);
	    ASSERT_EQUALS(KErrNone, requestStatus.Int());
	    ASSERT_EQUALS(evTemp, ev);
		}
		
	for (TInt i = 4; i < arrayRemote.Count(); i++)
		{
	    RMobileCall::TMobileCallEvent evTemp(arrayRemote[i]);
	    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallDataTemp(callId, mobileService, evTemp);
	    data.Close();
	    mockCallDataTemp.SerialiseL(data);

	    iMockLTSY.NotifyTerminated(mockLtsyStatus);
	    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
	    User::WaitForRequest(mockLtsyStatus);
	    AssertMockLtsyStatusL();
	    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
		}

    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(5, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCE-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyCallEvent for voice calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileCall::NotifyCallEvent for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallEvent0002L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    //----------------------------------------
    
    RMobileCall::TMobileCallEvent ev;

    call.NotifyCallEvent(requestStatus, ev);
    call.CancelAsyncRequest(EMobileCallNotifyCallEvent);

    RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteHold);
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());
        
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCE-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyCallEvent for voice calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyCallEvent for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallEvent0004L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);


    TName lineName2(KMmTsyVoice1LineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);

    
    
	RMobileCall call;
	RMobileCall call2;
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);	

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);
			
    //----------------------------------------    
    RMobileCall::TMobileCallEvent ev;
    RMobileCall::TMobileCallEvent ev2;

    call.NotifyCallEvent(requestStatus, ev);
    call2.NotifyCallEvent(requestStatus2, ev2);

    RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteHold);
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    RMobileCall::TMobileCallEvent ev11(RMobileCall::ERemoteTerminated);
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData4(callId2, mobileService, ev11);
    data.Close();
    mockCallData4.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::ERemoteHold, ev);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_EQUALS(RMobileCall::ERemoteTerminated, ev2);
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(8, this); 
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCE-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyCallEvent for data calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyCallEvent for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallEvent0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    //----------------------------------------
    RMobileCall::TMobileCallEvent ev;

    call.NotifyCallEvent(requestStatus, ev);

    RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteTerminated);
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::ERemoteTerminated, ev);
    
    //----------------------------------------
    ev1 = RMobileCall::ELocalHold;
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData4(callId, mobileService, ev1);
    data.Close();
    mockCallData4.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCE-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyCallEvent for data calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileCall::NotifyCallEvent for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallEvent0007L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    //----------------------------------------
    RMobileCall::TMobileCallEvent ev;

    call.NotifyCallEvent(requestStatus, ev);
    call.CancelAsyncRequest(EMobileCallNotifyCallEvent);

    RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteHold);
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());
       
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
		
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNCE-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyCallEvent for data calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyCallEvent for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallEvent0009L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyDataLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    
	RMobileCall call;
	RMobileCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);
	
    //----------------------------------------    
    RMobileCall::TMobileCallEvent ev;
    RMobileCall::TMobileCallEvent ev2;

    call.NotifyCallEvent(requestStatus, ev);
    call2.NotifyCallEvent(requestStatus2, ev2);

    RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteHold);
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    RMobileCall::TMobileCallEvent ev11(RMobileCall::ERemoteTerminated);
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData4(callId2, mobileService, ev11);
    data.Close();
    mockCallData4.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::ERemoteHold, ev);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_EQUALS(RMobileCall::ERemoteTerminated, ev2);    


	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(8, this); 
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNCE-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyCallEvent for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyCallEvent for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallEvent00011L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RMobileCall call;
	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    //----------------------------------------
    RMobileCall::TMobileCallEvent ev;

    call.NotifyCallEvent(requestStatus, ev);

    RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteTerminated);
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::ERemoteTerminated, ev);
    
    //----------------------------------------
    ev1 = RMobileCall::ELocalHold;
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData4(callId, mobileService, ev1);
    data.Close();
    mockCallData4.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCE-00012
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyCallEvent for fax calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileCall::NotifyCallEvent for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallEvent00012L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

	RMobileCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    //----------------------------------------
    RMobileCall::TMobileCallEvent ev;

    call.NotifyCallEvent(requestStatus, ev);
    call.CancelAsyncRequest(EMobileCallNotifyCallEvent);

    RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteHold);
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNCE-00014
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyCallEvent for fax calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyCallEvent for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyCallEvent00014L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyFaxLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    
	RMobileCall call;
	RMobileCall call2;	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);
	
    //----------------------------------------    
    RMobileCall::TMobileCallEvent ev;
    RMobileCall::TMobileCallEvent ev2;

    call.NotifyCallEvent(requestStatus, ev);
    call2.NotifyCallEvent(requestStatus2, ev2);

    RMobileCall::TMobileCallEvent ev1(RMobileCall::ERemoteHold);
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData3(callId, mobileService, ev1);
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    RMobileCall::TMobileCallEvent ev11(RMobileCall::ERemoteTerminated);
    TMockLtsyCallData1<RMobileCall::TMobileCallEvent> mockCallData4(callId2, mobileService, ev11);
    data.Close();
    mockCallData4.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyCallEvent, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::ERemoteHold, ev);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_EQUALS(RMobileCall::ERemoteTerminated, ev2);
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(8, this);
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallCaps for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallCaps for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallCaps0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);


    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
    OpenNewCallLC(call1, line, &name);
    
    RMobileCall::TMobileCallCapsV1 caps;
    RMobileCall::TMobileCallCapsV1Pckg capsPckg(caps);
    
    TInt ret = call1.GetMobileCallCaps(capsPckg);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE(0xFF == caps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsDial) == caps.iCallControlCaps);
    
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
 	//-------------------------------------------------------------------------

    mobileCallStatus = RMobileCall::EStatusDisconnecting;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    completeData.Close();
    mockCallData2.SerialiseL(completeData);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    ret = call.GetMobileCallCaps(capsPckg);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE(0xFF == caps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsAnswer |  RMobileCall::KCapsHangUp) == caps.iCallControlCaps);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(5, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCC-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallCaps with bad parameter data for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallCaps with bad parameter data for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallCaps0003L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;

   	OpenNewCallLC(call1, line, &name);
    
    TInt8 badCaps;
    TPckg<TInt8> badPckg(badCaps);
    
    TInt ret = call1.GetMobileCallCaps(badPckg);        
    ASSERT_TRUE(KErrArgument == ret);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCC-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallCaps for data calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallCaps for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallCaps0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);


    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
    
   	OpenNewCallLC(call1, line, &name);
    
    RMobileCall::TMobileCallCapsV1 caps;
    RMobileCall::TMobileCallCapsV1Pckg capsPckg(caps);
    
    TInt ret = call1.GetMobileCallCaps(capsPckg);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE(0xFF == caps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsData | RMobileCall::KCapsDial | RMobileCall::KCapsConnect) == caps.iCallControlCaps);
    
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
 	//-------------------------------------------------------------------------

    mobileCallStatus = RMobileCall::EStatusDisconnecting;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    completeData.Close();
    mockCallData2.SerialiseL(completeData);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    ret = call.GetMobileCallCaps(capsPckg);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE(0xFF == caps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsData | RMobileCall::KCapsAnswer |  RMobileCall::KCapsHangUp) == caps.iCallControlCaps);


	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(5, this); 
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCC-0008
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallCaps with bad parameter data for data calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallCaps with bad parameter data for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallCaps0008L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
    
   	OpenNewCallLC(call1, line, &name);
    
    TInt8 badCaps;
    TPckg<TInt8> badPckg(badCaps);
    
    TInt ret = call1.GetMobileCallCaps(badPckg);
    
    ASSERT_TRUE(KErrArgument == ret);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 

	}




/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCC-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallCaps for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallCaps for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallCaps00011L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 completeData;
    CleanupClosePushL(completeData);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    //---  check not active call -------------------------------------
    RMobileCall call1;
	TName name;
    
   	OpenNewCallLC(call1, line, &name);
    
    RMobileCall::TMobileCallCapsV1 caps;
    RMobileCall::TMobileCallCapsV1Pckg capsPckg(caps);
    
    TInt ret = call1.GetMobileCallCaps(capsPckg);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE(0xFF == caps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsFax | RMobileCall::KCapsDial) == caps.iCallControlCaps);
    
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

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

    mobileCallStatus = RMobileCall::EStatusDisconnecting;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    completeData.Close();
    mockCallData2.SerialiseL(completeData);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    ret = call.GetMobileCallCaps(capsPckg);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_TRUE(0xFF == caps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsFax  | RMobileCall::KCapsAnswer |  RMobileCall::KCapsHangUp) == caps.iCallControlCaps);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(5, this); 
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCC-00013
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallCaps with bad parameter data for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallCaps with bad parameter data for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallCaps00013L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    
    TInt8 badCaps;
    TPckg<TInt8> badPckg(badCaps);
    
    TInt ret = call1.GetMobileCallCaps(badPckg);
    
    ASSERT_TRUE(KErrArgument == ret);
        
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCI-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallInfo for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallInfo0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 data;
    CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    
    RMobileCall::TMobileCallInfoV1 info;
    RMobileCall::TMobileCallInfoV1Pckg  infoPckg(info);

    _LIT(KEmpty, "");
    const TDateTime KZeroTime(0,TMonth(0),0,0,0,0,0);
    
    TInt ret = call1.GetMobileCallInfo(infoPckg);
    ASSERT_EQUALS(KErrNone, ret);
    
    ASSERT_TRUE((RMobileCall::KCallStartTime | 
        RMobileCall::KCallDuration | 
            RMobileCall::KCallId | 
                RMobileCall::KCallExitCode | 
                    RMobileCall::KCallEmergency) == info.iValid);
    ASSERT_TRUE(RMobileCall::EServiceUnspecified == info.iService);
    ASSERT_TRUE(RMobileCall::EStatusIdle == info.iStatus);
    ASSERT_TRUE(0 == info.iCallId);
    ASSERT_TRUE(-1 == info.iExitCode);
    ASSERT_TRUE(0 == info.iEmergency);
    ASSERT_TRUE(0 == info.iForwarded);
    ASSERT_TRUE(RMobilePhone::EPrivacyUnspecified == info.iPrivacy);     
    ASSERT_TRUE(RMobilePhone::EAlternatingModeUnspecified == info.iAlternatingCall);
    ASSERT_TRUE(RMobileCall::ETchUnknown == info.iTch);
    ASSERT_TRUE(RMobileCall::ERemoteIdentityUnknown == info.iRemoteParty.iRemoteIdStatus);
    ASSERT_TRUE(RMobileCall::EDirectionUnknown == info.iRemoteParty.iDirection);
    ASSERT_TRUE(0 == info.iRemoteParty.iCallingName.Compare(KEmpty));
    ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTelNumber.Size());
    ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTypeOfNumber);
    ASSERT_TRUE(RMobilePhone::EUnknownNumber == info.iDialledParty.iTypeOfNumber);
    ASSERT_TRUE(RMobilePhone::EUnknownNumberingPlan == info.iDialledParty.iNumberPlan);
    ASSERT_TRUE(0 == info.iDialledParty.iTelNumber.Compare(KEmpty));
    ASSERT_TRUE(0 == memcmp( &info.iStartTime, &KZeroTime, sizeof(KZeroTime)));
    ASSERT_TRUE(0 == info.iCallName.Compare(name));
    ASSERT_TRUE(0 == info.iLineName.Compare(lineName));

    
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());

	
    mobileCallStatus = RMobileCall::EStatusConnected;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData2.SerialiseL(data);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
	
 	//-----------------------------------------------------------------------

    ret = call.GetMobileCallInfo(infoPckg);
    ASSERT_EQUALS(KErrNone, ret);

    ASSERT_TRUE((RMobileCall::KCallStartTime | 
        RMobileCall::KCallDuration | 
            RMobileCall::KCallId | 
                RMobileCall::KCallExitCode | 
                    RMobileCall::KCallEmergency) == info.iValid);
    ASSERT_TRUE(RMobilePhone::EVoiceService == info.iService);
    ASSERT_TRUE(RMobileCall::EStatusConnected == info.iStatus);
    ASSERT_TRUE(1 == info.iCallId);
    ASSERT_TRUE(0 == info.iExitCode);
    ASSERT_TRUE(0 == info.iEmergency);
    ASSERT_TRUE(0 == info.iForwarded);
    ASSERT_TRUE(RMobilePhone::EPrivacyUnspecified == info.iPrivacy);     
    ASSERT_TRUE(RMobilePhone::EAlternatingModeUnspecified == info.iAlternatingCall);
    ASSERT_TRUE(RMobileCall::ETchUnknown == info.iTch);
    ASSERT_TRUE(RMobileCall::ERemoteIdentityUnknown == info.iRemoteParty.iRemoteIdStatus);
    ASSERT_TRUE(RMobileCall::EMobileTerminated == info.iRemoteParty.iDirection);
    ASSERT_TRUE(0 == info.iRemoteParty.iCallingName.Compare(KEmpty));
    ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTelNumber.Size());
    ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTypeOfNumber);
    ASSERT_TRUE(RMobilePhone::EUnknownNumber == info.iDialledParty.iTypeOfNumber);
    ASSERT_TRUE(RMobilePhone::EUnknownNumberingPlan == info.iDialledParty.iNumberPlan);
    ASSERT_TRUE(0 == info.iDialledParty.iTelNumber.Compare(KEmpty));
    ASSERT_TRUE(0 == memcmp( &info.iStartTime, &KZeroTime, sizeof(KZeroTime)));
    ASSERT_TRUE(0 == info.iCallName.Compare(incomingCallName));
    ASSERT_TRUE(0 == info.iLineName.Compare(lineName));
	
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(5, this); 
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCI-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo with bad parameter data for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallInfo with bad parameter data for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallInfo0003L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    
    TInt8 badInfo;
    TPckg<TInt8> badPckg(badInfo);
    
    TInt ret = call1.GetMobileCallInfo(badPckg);
    
    ASSERT_TRUE(KErrArgument == ret);        

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this);   //call1, line, this 

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCI-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo for data calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallInfo for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallInfo0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 data;
    CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    TBool activeCall = EFalse;
   	
    RMobileCall::TMobileCallInfoV1 info;
    RMobileCall::TMobileCallInfoV1Pckg infoPckg(info);

    const TDateTime KZeroTime(0,TMonth(0),0,0,0,0,0);
    
    TInt ret = call1.GetMobileCallInfo(infoPckg);
    ASSERT_EQUALS(KErrNone, ret);
     
    ValidateMobileCallInfo(&infoPckg, name, lineName, activeCall);
   
    // For TMobileCallInfoV3
    RMobileCall::TMobileCallInfoV3 info3;
    RMobileCall::TMobileCallInfoV3Pckg  infoPckg3(info3);

    ret = call1.GetMobileCallInfo(infoPckg3);
    ASSERT_EQUALS(KErrNone, ret);
 
    ValidateMobileCallInfo(&infoPckg3,name, lineName, activeCall);
    
    // For TMobileCallInfoV7
    RMobileCall::TMobileCallInfoV7 info7;
    RMobileCall::TMobileCallInfoV7Pckg  infoPckg7(info7);

    ret = call1.GetMobileCallInfo(infoPckg7);
    ASSERT_EQUALS(KErrNone, ret);
 
    ValidateMobileCallInfo(&infoPckg7,name, lineName, activeCall);
      
    //---  check after activating call -------------------------------------
    
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    activeCall = ETrue;
    
    mobileCallStatus = RMobileCall::EStatusAnswering;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData.SerialiseL(data);

    TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

 	//-----------------------------------------------------------------------
     
    ret = call.GetMobileCallInfo(infoPckg);
    ASSERT_EQUALS(KErrNone, ret);

    ValidateMobileCallInfo(&infoPckg, name, lineName, activeCall, RMobileCall::EStatusAnswering);
    ASSERT_TRUE(0 == info.iCallName.Compare(incomingCallName));
    
    // For TMobileCallinfoV3
    ret = call.GetMobileCallInfo(infoPckg3);
    ASSERT_EQUALS(KErrNone, ret);
    ValidateMobileCallInfo(&infoPckg3, name, lineName, activeCall, RMobileCall::EStatusAnswering);
    ASSERT_TRUE(0 == info.iCallName.Compare(incomingCallName));
    
    // For TMobileCallinfoV7
    ret = call.GetMobileCallInfo(infoPckg7);
    ASSERT_EQUALS(KErrNone, ret);

    ValidateMobileCallInfo(&infoPckg7, name, lineName, activeCall, RMobileCall::EStatusAnswering);
    ASSERT_TRUE(0 == info.iCallName.Compare(incomingCallName));
    
    // iStatus can be RMobileCall::EStatusAnswering or RMobileCall::EStatusConnected depending on the network answer.
    ASSERT_TRUE(RMobileCall::EStatusAnswering == info3.iStatus);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(5, this); 
		
	}

/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCI-0006b
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo for data calls with MobileCallInfoV8. It is in connection to BA-CTSY-CALLI-CGMCI-0006.
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallInfo for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallInfo0006bL()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 data;
    CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    TBool activeCall = EFalse;
   	
    RMobileCall::TMobileCallInfoV8 info8;
    RMobileCall::TMobileCallInfoV8Pckg  infoPckg8(info8);
   
    TInt ret = call1.GetMobileCallInfo(infoPckg8);
    ASSERT_EQUALS(KErrNone, ret);
 
    ValidateMobileCallInfo(&infoPckg8,name, lineName, activeCall);

    //---  check after activating call -------------------------------------
    
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;
       
	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    activeCall = ETrue;

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

    ret = call.GetMobileCallInfo(infoPckg8);
    ASSERT_EQUALS(KErrNone, ret);

    ValidateMobileCallInfo(&infoPckg8, name, lineName, activeCall);
    ASSERT_TRUE(0 == info8.iCallName.Compare(incomingCallName));
                 
   	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(5, this); 
		
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCI-0008
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo with bad parameter data for data calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallInfo with bad parameter data for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallInfo0008L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    
    TInt8 badInfo;
    TPckg<TInt8> badPckg(badInfo);
    
    TInt ret = call1.GetMobileCallInfo(badPckg);
    
    ASSERT_TRUE(KErrArgument == ret);
        
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this);   // call1, line, this

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCI-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallInfo for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallInfo00011L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 data;
    CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    
    RMobileCall::TMobileCallInfoV1 info;
    RMobileCall::TMobileCallInfoV1Pckg  infoPckg(info);

    _LIT(KEmpty, "");
    const TDateTime KZeroTime(0,TMonth(0),0,0,0,0,0);
    
    TInt ret = call1.GetMobileCallInfo(infoPckg);
    ASSERT_EQUALS(KErrNone, ret);
    
    ASSERT_TRUE((RMobileCall::KCallStartTime | 
        RMobileCall::KCallDuration | 
            RMobileCall::KCallId | 
                RMobileCall::KCallExitCode | 
                    RMobileCall::KCallEmergency) == info.iValid);
    ASSERT_TRUE(RMobileCall::EServiceUnspecified == info.iService);
    ASSERT_TRUE(RMobileCall::EStatusIdle == info.iStatus);
    ASSERT_TRUE(0 == info.iCallId);
    ASSERT_TRUE(-1 == info.iExitCode);
    ASSERT_TRUE(0 == info.iEmergency);
    ASSERT_TRUE(0 == info.iForwarded);
    ASSERT_TRUE(RMobilePhone::EPrivacyUnspecified == info.iPrivacy);     
    ASSERT_TRUE(RMobilePhone::EAlternatingModeUnspecified == info.iAlternatingCall);
    ASSERT_TRUE(RMobileCall::ETchUnknown == info.iTch);
    ASSERT_TRUE(RMobileCall::ERemoteIdentityUnknown == info.iRemoteParty.iRemoteIdStatus);
    ASSERT_TRUE(RMobileCall::EDirectionUnknown == info.iRemoteParty.iDirection);
    ASSERT_TRUE(0 == info.iRemoteParty.iCallingName.Compare(KEmpty));
    ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTelNumber.Size());
    ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTypeOfNumber);
    ASSERT_TRUE(RMobilePhone::EUnknownNumber == info.iDialledParty.iTypeOfNumber);
    ASSERT_TRUE(RMobilePhone::EUnknownNumberingPlan == info.iDialledParty.iNumberPlan);
    ASSERT_TRUE(0 == info.iDialledParty.iTelNumber.Compare(KEmpty));
    ASSERT_TRUE(0 == memcmp( &info.iStartTime, &KZeroTime, sizeof(KZeroTime)));
    ASSERT_TRUE(0 == info.iCallName.Compare(name));
    ASSERT_TRUE(0 == info.iLineName.Compare(lineName));

    
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

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

    ret = call.GetMobileCallInfo(infoPckg);
    ASSERT_EQUALS(KErrNone, ret);

    ASSERT_TRUE((RMobileCall::KCallStartTime | 
        RMobileCall::KCallDuration | 
            RMobileCall::KCallId | 
                RMobileCall::KCallExitCode | 
                    RMobileCall::KCallEmergency) == info.iValid);
    ASSERT_TRUE(RMobilePhone::EFaxService == info.iService);
    ASSERT_TRUE(RMobileCall::EStatusRinging == info.iStatus);
    ASSERT_TRUE(1 == info.iCallId);
    ASSERT_TRUE(-1 == info.iExitCode);
    ASSERT_TRUE(0 == info.iEmergency);
    ASSERT_TRUE(0 == info.iForwarded);
    ASSERT_TRUE(RMobilePhone::EPrivacyUnspecified == info.iPrivacy);     
    ASSERT_TRUE(RMobilePhone::EAlternatingModeUnspecified == info.iAlternatingCall);
    ASSERT_TRUE(RMobileCall::ETchUnknown == info.iTch);
    ASSERT_TRUE(RMobileCall::ERemoteIdentityUnknown == info.iRemoteParty.iRemoteIdStatus);
    ASSERT_TRUE(RMobileCall::EMobileTerminated == info.iRemoteParty.iDirection);
    ASSERT_TRUE(0 == info.iRemoteParty.iCallingName.Compare(KEmpty));
    ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTelNumber.Size());
    ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTypeOfNumber);
    ASSERT_TRUE(RMobilePhone::EUnknownNumber == info.iDialledParty.iTypeOfNumber);
    ASSERT_TRUE(RMobilePhone::EUnknownNumberingPlan == info.iDialledParty.iNumberPlan);
    ASSERT_TRUE(0 == info.iDialledParty.iTelNumber.Compare(KEmpty));
    ASSERT_TRUE(0 == memcmp( &info.iStartTime, &KZeroTime, sizeof(KZeroTime)));
    ASSERT_TRUE(0 == info.iCallName.Compare(incomingCallName));
    ASSERT_TRUE(0 == info.iLineName.Compare(lineName));
	
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(5, this); 
	
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCI-00013
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallInfo with bad parameter data for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallInfo with bad parameter data for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallInfo00013L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    
    TInt8 badInfo;
    TPckg<TInt8> badPckg(badInfo);
    
    TInt ret = call1.GetMobileCallInfo(badPckg);
    
    ASSERT_TRUE(KErrArgument == ret);
        
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this);   // call1, line, this
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCS-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallStatus for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallStatus for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallStatus0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 data;
    CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    

    RMobileCall::TMobileCallStatus statusToGet;
    
    TInt ret = call1.GetMobileCallStatus(statusToGet);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet);
    
    RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    mobileCallStatus = RMobileCall::EStatusAnswering;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData.SerialiseL(data);

    TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    ret = call.GetMobileCallStatus(statusToGet);
    ASSERT_EQUALS(KErrNone, ret);

	//This iStatus can be RMobileCall::EStatusAnswering or RMobileCall::EStatusConnected depending on the network answer.
	ASSERT_EQUALS(RMobileCall::EStatusAnswering, statusToGet);
	
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(5, this); 
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCS-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallStatus for data calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallStatus for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallStatus0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RBuf8 data;
    CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);

    RMobileCall::TMobileCallStatus statusToGet;
    
    TInt ret = call1.GetMobileCallStatus(statusToGet);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet);
    
    
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call.AnswerIncomingCall(requestStatus, mmParamsPckgV1);
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
	
    mobileCallStatus = RMobileCall::EStatusAnswering;
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(callId, mobileService, mobileCallStatus);
    data.Close();
    mockCallData.SerialiseL(data);

    TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
    
    ret = call.GetMobileCallStatus(statusToGet);
    ASSERT_EQUALS(KErrNone, ret);

    //This iStatus can be RMobileCall::EStatusAnswering or RMobileCall::EStatusConnected depending on the network answer.	
	ASSERT_EQUALS(RMobileCall::EStatusAnswering, statusToGet);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(5, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CGMCS-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::GetMobileCallStatus for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::GetMobileCallStatus for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetMobileCallStatus00011L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    //---  check not active call -------------------------------------
    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    

    RMobileCall::TMobileCallStatus statusToGet;
    
    TInt ret = call1.GetMobileCallStatus(statusToGet);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet);
        
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestNotify;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    ret = call.GetMobileCallStatus(statusToGet);
    ASSERT_EQUALS(KErrNone, ret);
    ASSERT_EQUALS(RMobileCall::EStatusRinging, statusToGet);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNATE-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyAudioToneEvent for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyAudioToneEvent for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyAudioToneEvent0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);


    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    
    TRequestStatus requestStatus;
    TInt8 tmp;
    TPckg<TInt8> tmpPckg(tmp);
    
	call1.NotifyAudioToneEvent(requestStatus, tmpPckg);
	
	User::WaitForRequest(requestStatus);
	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNATE-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyAudioToneEvent for data calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyAudioToneEvent for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyAudioToneEvent0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);


    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    
    TRequestStatus requestStatus;
    TInt8 tmp;
    TPckg<TInt8> tmpPckg(tmp);
    
	call1.NotifyAudioToneEvent(requestStatus, tmpPckg);
	
	User::WaitForRequest(requestStatus);
	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNATE-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyAudioToneEvent for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyAudioToneEvent for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyAudioToneEvent00011L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);


    RMobileCall call1;
    TName name;
   	OpenNewCallLC(call1, line, &name);
    
    TRequestStatus requestStatus;
    TInt8 tmp;
    TPckg<TInt8> tmpPckg(tmp);
    
	call1.NotifyAudioToneEvent(requestStatus, tmpPckg);
	
	User::WaitForRequest(requestStatus);
	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallCapsChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyMobileCallCapsChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    TRequestStatus notifyStatus;
    RMobileCall::TMobileCallCapsV1 mcaps;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg(mcaps);

    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

	mobileCallStatus = RMobileCall::EStatusRinging;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsVoice | 
    			  RMobileCall::KCapsHangUp | 
    			   RMobileCall::KCapsAnswer | 
    			    RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);


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

    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusAnswering;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsHangUp) == mcaps.iCallControlCaps);

	//-----------------------	
	// just to change back mobile caps
	
    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusRinging;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsVoice | 
    			  RMobileCall::KCapsHangUp | 
    			   RMobileCall::KCapsAnswer | 
    			    RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);

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


    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusDisconnecting;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsVoice | 
                   RMobileCall::KCapsHangUp | 
                     RMobileCall::KCapsAnswer) == mcaps.iCallControlCaps);

	//-----------------------	
	// just to change back mobile caps
	
    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusRinging;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsVoice | 
    			  RMobileCall::KCapsHangUp | 
    			   RMobileCall::KCapsAnswer | 
    			    RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);

	//-----------------------	
	
    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusConnected;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsVoice 
      | RMobileCall::KCapsHangUp
        | RMobileCall::KCapsHold) == mcaps.iCallControlCaps);

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

    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusDisconnectingWithInband;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsHangUp) == mcaps.iCallControlCaps);

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

    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusIdle;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsDial) == mcaps.iCallControlCaps);
	       	       
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
		
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileCallCapsChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileCallCapsChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0002L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

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

    TRequestStatus notifyStatus;
    RMobileCall::TMobileCallCapsV1 mcaps;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg(mcaps);
    
    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
    call.CancelAsyncRequest(EMobileCallNotifyMobileCallCapsChange);

    mobileCallStatus = RMobileCall::EStatusIdle;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
	    
    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrCancel, notifyStatus.Int());   

    
    AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 	
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallCapsChange with bad parameter data for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyMobileCallCapsChange with bad parameter data for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0003L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
    //---------------------------------------
    
    TRequestStatus notifyStatus;
    TBuf8<1> caps(KNullDesC8);
    
    call.NotifyMobileCallCapsChange( notifyStatus, caps );

    mobileCallStatus = RMobileCall::EStatusIdle;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
	    
    User::WaitForRequest(notifyStatus);
    ASSERT_TRUE(KErrNone != notifyStatus.Int());    
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 	

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileCallCapsChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileCallCapsChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0004L()
	{
					
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyVoice1LineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    
        
	RMobileCall call;
	RMobileCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);
		
    //----------------------------------------   

    RMobileCall::TMobileCallCapsV1 mcaps;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg(mcaps);

    RMobileCall::TMobileCallCapsV1 mcaps2;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg2(mcaps2);
    
    call.NotifyMobileCallCapsChange( requestStatus, mcapsPckg);
    call2.NotifyMobileCallCapsChange( requestStatus2, mcapsPckg2);

    mobileCallStatus = RMobileCall::EStatusIdle;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId2, mobileService, mobileCallStatus);
    data.Close();
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

	    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsDial) == mcaps.iCallControlCaps);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE(0xFF == mcaps2.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsVoice | RMobileCall::KCapsDial) == mcaps2.iCallControlCaps);	    
	
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(8, this); 

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallCapsChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyMobileCallCapsChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    TRequestStatus notifyStatus;
    RMobileCall::TMobileCallCapsV1 mcaps;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg(mcaps);

    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

	mobileCallStatus = RMobileCall::EStatusRinging;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsData | 
    			  RMobileCall::KCapsHangUp | 
    			   RMobileCall::KCapsAnswer | 
    			    RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);


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

    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusAnswering;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsData | RMobileCall::KCapsHangUp) == mcaps.iCallControlCaps);

	//-----------------------	
	// just to change back mobile caps
	
    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusRinging;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsData | 
    			  RMobileCall::KCapsHangUp | 
    			   RMobileCall::KCapsAnswer | 
    			    RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);

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


    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusDisconnecting;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsData | 
                   RMobileCall::KCapsHangUp | 
                     RMobileCall::KCapsAnswer) == mcaps.iCallControlCaps);

	//-----------------------	
	// just to change back mobile caps
	
    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusRinging;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsData | 
    			  RMobileCall::KCapsHangUp | 
    			   RMobileCall::KCapsAnswer | 
    			    RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);

	//-----------------------	
	
    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusConnected;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsData 
      | RMobileCall::KCapsHangUp) == mcaps.iCallControlCaps);

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

    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusIdle;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsData | 
                    RMobileCall::KCapsDial |
                       RMobileCall::KCapsConnect) == mcaps.iCallControlCaps);
	       	       
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
		
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileCallCapsChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileCallCapsChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0007L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

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

    TRequestStatus notifyStatus;
    RMobileCall::TMobileCallCapsV1 mcaps;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg(mcaps);
    
    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
    call.CancelAsyncRequest(EMobileCallNotifyMobileCallCapsChange);

    mobileCallStatus = RMobileCall::EStatusIdle;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
	    
    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrCancel, notifyStatus.Int());   
        
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);	
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0008
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallCapsChange with bad parameter data for data calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyMobileCallCapsChange with bad parameter data for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0008L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
    //---------------------------------------

    TRequestStatus notifyStatus;
    TBuf8<1> caps(KNullDesC8);
    
    call.NotifyMobileCallCapsChange( notifyStatus, caps );

    mobileCallStatus = RMobileCall::EStatusIdle;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
	    
    User::WaitForRequest(notifyStatus);
    ASSERT_TRUE(KErrNone != notifyStatus.Int());    
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileCallCapsChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileCallCapsChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange0009L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyDataLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);

    
	RMobileCall call;
	RMobileCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);

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

    RMobileCall::TMobileCallCapsV1 mcaps;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg(mcaps);

    RMobileCall::TMobileCallCapsV1 mcaps2;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg2(mcaps2);
    
    call.NotifyMobileCallCapsChange( requestStatus, mcapsPckg);
    call2.NotifyMobileCallCapsChange( requestStatus2, mcapsPckg2);

    mobileCallStatus = RMobileCall::EStatusIdle;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId2, mobileService, mobileCallStatus);
    data.Close();
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

	    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsData | RMobileCall::KCapsDial | RMobileCall::KCapsConnect) == mcaps.iCallControlCaps);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE(0xFF == mcaps2.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsData | RMobileCall::KCapsDial | RMobileCall::KCapsConnect) == mcaps2.iCallControlCaps);	    
	    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(8, this); 

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallCapsChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyMobileCallCapsChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange00011L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    TRequestStatus notifyStatus;
    RMobileCall::TMobileCallCapsV1 mcaps;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg(mcaps);

    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

	mobileCallStatus = RMobileCall::EStatusRinging;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsFax | 
    			  RMobileCall::KCapsHangUp | 
    			   RMobileCall::KCapsAnswer | 
    			    RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);


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

    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusAnswering;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsFax | RMobileCall::KCapsHangUp) == mcaps.iCallControlCaps);

	//-----------------------	
	// just to change back mobile caps
	
    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusRinging;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsFax | 
    			  RMobileCall::KCapsHangUp | 
    			   RMobileCall::KCapsAnswer | 
    			    RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);

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


    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusDisconnecting;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsFax | 
                   RMobileCall::KCapsHangUp | 
                     RMobileCall::KCapsAnswer) == mcaps.iCallControlCaps);

	//-----------------------	
	// just to change back mobile caps
	
    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusRinging;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsFax | 
    			  RMobileCall::KCapsHangUp | 
    			   RMobileCall::KCapsAnswer | 
    			    RMobileCall::KCapsDeflect) == mcaps.iCallControlCaps);

	//-----------------------	
	
    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusConnected;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsFax 
      | RMobileCall::KCapsHangUp) == mcaps.iCallControlCaps);

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

    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);

    mobileCallStatus = RMobileCall::EStatusIdle;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrNone, notifyStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsFax | 
                    RMobileCall::KCapsDial) == mcaps.iCallControlCaps);
	       	       
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
		
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-00012
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileCallCapsChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileCallCapsChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange00012L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    //---------------------------------------
    TRequestStatus notifyStatus;
    RMobileCall::TMobileCallCapsV1 mcaps;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg(mcaps);

    call.NotifyMobileCallCapsChange( notifyStatus, mcapsPckg);
    call.CancelAsyncRequest(EMobileCallNotifyMobileCallCapsChange);

    mobileCallStatus = RMobileCall::EStatusIdle;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
	    
    User::WaitForRequest(notifyStatus);
    ASSERT_EQUALS(KErrCancel, notifyStatus.Int());   
                
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-00013
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallCapsChange with bad parameter data for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyMobileCallCapsChange with bad parameter data for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange00013L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    //---------------------------------------
    TRequestStatus notifyStatus;
    TBuf8<1> caps(KNullDesC8);

    call.NotifyMobileCallCapsChange( notifyStatus, caps);

    mobileCallStatus = RMobileCall::EStatusIdle;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
	    
    User::WaitForRequest(notifyStatus);
    ASSERT_TRUE(KErrNone != notifyStatus.Int());    

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCCC-00014
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileCallCapsChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileCallCapsChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallCapsChange00014L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyFaxLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    
    
	RMobileCall call;
	RMobileCall call2;	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);
   
    RMobileCall::TMobileCallCapsV1 mcaps;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg(mcaps);

    RMobileCall::TMobileCallCapsV1 mcaps2;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg2(mcaps2);
    
    call.NotifyMobileCallCapsChange( requestStatus, mcapsPckg);
    call2.NotifyMobileCallCapsChange( requestStatus2, mcapsPckg2);

    mobileCallStatus = RMobileCall::EStatusIdle;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId2, mobileService, mobileCallStatus);
    data.Close();
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

	    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_TRUE(0xFF == mcaps.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsFax | RMobileCall::KCapsDial) == mcaps.iCallControlCaps);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_TRUE(0xFF == mcaps2.iCallEventCaps);
    ASSERT_TRUE((RMobileCall::KCapsFax | RMobileCall::KCapsDial) == mcaps2.iCallControlCaps);	    
	
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(8, this); 

	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyRemotePartyInfoChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyRemotePartyInfoChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RMobileCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    //---------------------------------------
	
    RMobileCall::TMobileCallRemotePartyInfoV1 info;
    RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
    
    call.NotifyRemotePartyInfoChange(requestStatus, pckg);

    RMobileCall::TMobileCallInfoV1 callInfo;
    
    _LIT(KNum, "Num");
    _LIT(KName, "Name");
    
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
	callInfo.iRemoteParty.iCallingName = KName;
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
    mockCallData2.SerialiseL(data);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);     
    ASSERT_EQUALS(RMobileCall::EMobileTerminated, info.iDirection);     
    ASSERT_TRUE(0 == info.iCallingName.Compare(KName));     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);     
    ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));     

    CloseIncomingCallL(call, callId, mobileService );
        
    //---------------------------------------

	RMobileCall call2;

	TInt ret = OpenNewCall(line, call2, KMmTsyVoice1LineName);
	ASSERT_EQUALS(KErrNone, ret);
    CleanupClosePushL(call2);

	// now we're giving the call a concrete callId > 0 and getting a name
	TName name;
	line.NotifyCallAdded(requestStatus, name);

	iMockLTSY.NotifyTerminated(mockLtsyStatus);
    callId = 2;
    callInfo.iCallId = callId;
    callInfo.iStatus = RMobileCall::EStatusConnecting;  
    
    data.Close();
    mockCallData2.SerialiseL(data);		
	iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
		
	User::WaitForRequest(mockLtsyStatus);
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());

	// now we have an opened call with known name and callId
	RMobileCall call3;
    ret = call3.OpenExistingCall(line, name);
    ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(call3);


    call3.NotifyRemotePartyInfoChange(requestStatus, pckg);

	iMockLTSY.NotifyTerminated(mockLtsyStatus);
	iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
	User::WaitForRequest(mockLtsyStatus);
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);     
    ASSERT_EQUALS(RMobileCall::EMobileOriginated, info.iDirection);     
    ASSERT_TRUE(0 == info.iCallingName.Compare(KName));     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);     
    ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));     
   
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(6, this);
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyRemotePartyInfoChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileCall::NotifyRemotePartyInfoChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0002L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RMobileCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    RMobileCall::TMobileCallRemotePartyInfoV1 info;
    RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
    
    call.NotifyRemotePartyInfoChange(requestStatus, pckg);
    call.CancelAsyncRequest(EMobileCallNotifyRemotePartyInfoChange);

    RMobileCall::TMobileCallInfoV1 callInfo;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
    mockCallData2.SerialiseL(data);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0003
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyRemotePartyInfoChange with bad parameter data for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyRemotePartyInfoChange with bad parameter data for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0003L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RMobileCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    TInt8 badInfo;
    TPckg<TInt8> pckg(badInfo);
    
    call.NotifyRemotePartyInfoChange(requestStatus, pckg);

    RMobileCall::TMobileCallInfoV1 callInfo;
    
    _LIT(KNum, "Num");
    _LIT(KName, "Name");
    
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
	callInfo.iRemoteParty.iCallingName = KName;
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
    mockCallData2.SerialiseL(data);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_TRUE(KErrArgument == requestStatus.Int());
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); //data, line, call, this
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyRemotePartyInfoChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyRemotePartyInfoChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0004L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyVoice1LineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    
	RMobileCall call;
	RMobileCall call2;
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);

    //----------------------------------------
    
    RMobileCall::TMobileCallRemotePartyInfoV1 info;
    RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);

    RMobileCall::TMobileCallRemotePartyInfoV1 info2;
    RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg2(info2);
    
    call.NotifyRemotePartyInfoChange(requestStatus, pckg);
    call2.NotifyRemotePartyInfoChange(requestStatus2, pckg2);

    RMobileCall::TMobileCallInfoV1 callInfo;
    
    _LIT(KNum, "Num");
    _LIT(KName, "Name");
    
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
	callInfo.iRemoteParty.iCallingName = KName;
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    _LIT(KNum2, "Num2");
    _LIT(KName2, "Name2");
    
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentitySuppressed;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum2;
	callInfo.iRemoteParty.iCallingName = KName2;
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData3(callId2, mobileService, callInfo);
    data.Close();
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    
    ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);     
    ASSERT_EQUALS(RMobileCall::EMobileTerminated, info.iDirection);     
    ASSERT_TRUE(0 == info.iCallingName.Compare(KName));     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);     
    ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));    

    ASSERT_EQUALS(RMobileCall::ERemoteIdentitySuppressed, info2.iRemoteIdStatus);     
    ASSERT_EQUALS(RMobileCall::EMobileTerminated, info2.iDirection);     
    ASSERT_TRUE(0 == info2.iCallingName.Compare(KName2));     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info2.iRemoteNumber.iTypeOfNumber);     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info2.iRemoteNumber.iNumberPlan);     
    ASSERT_TRUE(0 == info2.iRemoteNumber.iTelNumber.Compare(KNum2));    	    

	AssertMockLtsyStatusL();
    CleanupStack::PopAndDestroy(8, this); 

	}




/**
@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyRemotePartyInfoChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyRemotePartyInfoChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RMobileCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	
    RMobileCall::TMobileCallRemotePartyInfoV1 info;
    RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
    
    call.NotifyRemotePartyInfoChange(requestStatus, pckg);

    RMobileCall::TMobileCallInfoV1 callInfo;
    
    _LIT(KNum, "Num");
    _LIT(KName, "Name");
    
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
	callInfo.iRemoteParty.iCallingName = KName;
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
    mockCallData2.SerialiseL(data);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);     
    ASSERT_EQUALS(RMobileCall::EMobileTerminated, info.iDirection);     
    ASSERT_TRUE(0 == info.iCallingName.Compare(KName));     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);     
    ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));     

    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyRemotePartyInfoChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileCall::NotifyRemotePartyInfoChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0007L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    
	RMobileCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    RMobileCall::TMobileCallRemotePartyInfoV1 info;
    RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
    
    call.NotifyRemotePartyInfoChange(requestStatus, pckg);
    call.CancelAsyncRequest(EMobileCallNotifyRemotePartyInfoChange);

    RMobileCall::TMobileCallInfoV1 callInfo;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
    mockCallData2.SerialiseL(data);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());       
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0008
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyRemotePartyInfoChange with bad parameter data for data calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyRemotePartyInfoChange with bad parameter data for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0008L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RMobileCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    TInt8 badInfo;
    TPckg<TInt8> pckg(badInfo);
    
    call.NotifyRemotePartyInfoChange(requestStatus, pckg);

    RMobileCall::TMobileCallInfoV1 callInfo;
    
    _LIT(KNum, "Num");
    _LIT(KName, "Name");
    
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
	callInfo.iRemoteParty.iCallingName = KName;
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
    mockCallData2.SerialiseL(data);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_TRUE(KErrArgument == requestStatus.Int());
        
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyRemotePartyInfoChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyRemotePartyInfoChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange0009L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyDataLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    
    
	RMobileCall call;
	RMobileCall call2;	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);

    //----------------------------------------
    
    RMobileCall::TMobileCallRemotePartyInfoV1 info;
    RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);

    RMobileCall::TMobileCallRemotePartyInfoV1 info2;
    RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg2(info2);
    
    call.NotifyRemotePartyInfoChange(requestStatus, pckg);
    call2.NotifyRemotePartyInfoChange(requestStatus2, pckg2);

    RMobileCall::TMobileCallInfoV1 callInfo;
    
    _LIT(KNum, "Num");
    _LIT(KName, "Name");
    
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
	callInfo.iRemoteParty.iCallingName = KName;
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    _LIT(KNum2, "Num2");
    _LIT(KName2, "Name2");
    
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentitySuppressed;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum2;
	callInfo.iRemoteParty.iCallingName = KName2;
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData3(callId2, mobileService, callInfo);
    data.Close();
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    
    ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);     
    ASSERT_EQUALS(RMobileCall::EMobileTerminated, info.iDirection);     
    ASSERT_TRUE(0 == info.iCallingName.Compare(KName));     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);     
    ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));    

    ASSERT_EQUALS(RMobileCall::ERemoteIdentitySuppressed, info2.iRemoteIdStatus);     
    ASSERT_EQUALS(RMobileCall::EMobileTerminated, info2.iDirection);     
    ASSERT_TRUE(0 == info2.iCallingName.Compare(KName2));     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info2.iRemoteNumber.iTypeOfNumber);     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info2.iRemoteNumber.iNumberPlan);     
    ASSERT_TRUE(0 == info2.iRemoteNumber.iTelNumber.Compare(KNum2));    
	    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(8, this); 

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyRemotePartyInfoChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyRemotePartyInfoChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange00011L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RMobileCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    RMobileCall::TMobileCallRemotePartyInfoV1 info;
    RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
    
    call.NotifyRemotePartyInfoChange(requestStatus, pckg);

    RMobileCall::TMobileCallInfoV1 callInfo;
    
    _LIT(KNum, "Num");
    _LIT(KName, "Name");
    
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
	callInfo.iRemoteParty.iCallingName = KName;
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
    mockCallData2.SerialiseL(data);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    
    ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);     
    ASSERT_EQUALS(RMobileCall::EMobileTerminated, info.iDirection);     
    ASSERT_TRUE(0 == info.iCallingName.Compare(KName));     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);     
    ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));     

    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-00012
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyRemotePartyInfoChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileCall::NotifyRemotePartyInfoChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange00012L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RMobileCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    RMobileCall::TMobileCallRemotePartyInfoV1 info;
    RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);
    
    call.NotifyRemotePartyInfoChange(requestStatus, pckg);
    call.CancelAsyncRequest(EMobileCallNotifyRemotePartyInfoChange);

    RMobileCall::TMobileCallInfoV1 callInfo;    
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
    mockCallData2.SerialiseL(data);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-00013
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyRemotePartyInfoChange with bad parameter data for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyRemotePartyInfoChange with bad parameter data for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange00013L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RMobileCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    TInt8 badInfo;
    TPckg<TInt8> pckg(badInfo);
    
    call.NotifyRemotePartyInfoChange(requestStatus, pckg);

    RMobileCall::TMobileCallInfoV1 callInfo;
    
    _LIT(KNum, "Num");
    _LIT(KName, "Name");
    
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
	callInfo.iRemoteParty.iCallingName = KName;
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
    mockCallData2.SerialiseL(data);

	TRequestStatus mockLtsyStatus;
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_TRUE(KErrArgument == requestStatus.Int());
        
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNRPIC-00014
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyRemotePartyInfoChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyRemotePartyInfoChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyRemotePartyInfoChange00014L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyFaxLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);


	RMobileCall call;
	RMobileCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);

    //----------------------------------------
    
    RMobileCall::TMobileCallRemotePartyInfoV1 info;
    RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg(info);

    RMobileCall::TMobileCallRemotePartyInfoV1 info2;
    RMobileCall::TMobileCallRemotePartyInfoV1Pckg pckg2(info2);
    
    call.NotifyRemotePartyInfoChange(requestStatus, pckg);
    call2.NotifyRemotePartyInfoChange(requestStatus2, pckg2);

    RMobileCall::TMobileCallInfoV1 callInfo;   
    
    _LIT(KNum, "Num");
    _LIT(KName, "Name");
    
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityAvailable;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum;
	callInfo.iRemoteParty.iCallingName = KName;
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData2(callId, mobileService, callInfo);
    mockCallData2.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    _LIT(KNum2, "Num2");
    _LIT(KName2, "Name2");
    
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentitySuppressed;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNum2;
	callInfo.iRemoteParty.iCallingName = KName2;
    
    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData3(callId2, mobileService, callInfo);
    data.Close();
    mockCallData3.SerialiseL(data);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());



    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    
    ASSERT_EQUALS(RMobileCall::ERemoteIdentityAvailable, info.iRemoteIdStatus);     
    ASSERT_EQUALS(RMobileCall::EMobileTerminated, info.iDirection);     
    ASSERT_TRUE(0 == info.iCallingName.Compare(KName));     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info.iRemoteNumber.iTypeOfNumber);     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info.iRemoteNumber.iNumberPlan);     
    ASSERT_TRUE(0 == info.iRemoteNumber.iTelNumber.Compare(KNum));    

    ASSERT_EQUALS(RMobileCall::ERemoteIdentitySuppressed, info2.iRemoteIdStatus);     
    ASSERT_EQUALS(RMobileCall::EMobileTerminated, info2.iDirection);     
    ASSERT_TRUE(0 == info2.iCallingName.Compare(KName2));     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumber, info2.iRemoteNumber.iTypeOfNumber);     
    ASSERT_EQUALS(RMobilePhone::EUnknownNumberingPlan, info2.iRemoteNumber.iNumberPlan);     
    ASSERT_TRUE(0 == info2.iRemoteNumber.iTelNumber.Compare(KNum2));    
	    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(8, this); 

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallStatusChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyMobileCallStatusChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    RMobileCall::TMobileCallStatus statusToGet;
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusRinging, statusToGet);

	//--------------------
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusDialling;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusDialling, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusConnecting;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusConnecting, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusAnswering;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusAnswering, statusToGet);

	//-----------------------	
	
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusConnected;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusConnected, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusDisconnecting;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusDisconnecting, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusDisconnectingWithInband;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusDisconnectingWithInband, statusToGet);

	//-----------------------	
	
	// for other status values CompleteNotifyStatusChange() does not complete the notify request
	
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-0002
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileCallStatusChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileCallStatusChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange0002L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	

    RMobileCall::TMobileCallStatus statusToGet;
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 
    call.CancelAsyncRequest(EMobileCallNotifyMobileCallStatusChange);

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-0004
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileCallStatusChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileCallStatusChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange0004L()
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyVoice1LineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    //----------------------------------------
    
	RMobileCall call;
	RMobileCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);


    RMobileCall::TMobileCallStatus statusToGet;
    RMobileCall::TMobileCallStatus statusToGet2;
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 
    call2.NotifyMobileCallStatusChange(requestStatus2, statusToGet2); 

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    mobileCallStatus = RMobileCall::EStatusIdle;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId2, mobileService, mobileCallStatus);
    data.Close();
    mockCallData4.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusRinging, statusToGet);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet2);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(8, this); 
	}




/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallStatusChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyMobileCallStatusChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    RMobileCall::TMobileCallStatus statusToGet;
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusRinging, statusToGet);

	//--------------------
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusDialling;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusDialling, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusConnecting;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusConnecting, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusAnswering;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusAnswering, statusToGet);

	//-----------------------	
	
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusConnected;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusConnected, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusDisconnecting;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusDisconnecting, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusDisconnectingWithInband;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusDisconnectingWithInband, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusIdle;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    
    TUint32 duration = 4; // this is a dummy value, which will be ignored, when mocksy engine is doing the validation check	
    TMockLtsyData1<TUint32> ltsyData( duration );
    data.Close();
    ltsyData.SerialiseL(data);
    // when the call state becomes idle, there is update LifeTime param into LTSY:	
    iMockLTSY.ExpectL(EMmTsyUpdateLifeTimeIPC, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet);

	//-----------------------	
	
	// for other status values CompleteNotifyStatusChange() does not complete the notify request
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-0007
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileCallStatusChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileCallStatusChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange0007L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
    RMobileCall::TMobileCallStatus statusToGet;
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 
    call.CancelAsyncRequest(EMobileCallNotifyMobileCallStatusChange);

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this);
	
	}



/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-0009
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileCallStatusChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileCallStatusChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange0009L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyDataLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);

    //----------------------------------------
      
	RMobileCall call;
	RMobileCall call2;	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);



    RMobileCall::TMobileCallStatus statusToGet;
    RMobileCall::TMobileCallStatus statusToGet2;
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 
    call2.NotifyMobileCallStatusChange(requestStatus2, statusToGet2); 

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    mobileCallStatus = RMobileCall::EStatusIdle;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId2, mobileService, mobileCallStatus);
    data.Close();
    mockCallData4.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusRinging, statusToGet);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet2);

	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(8, this); 

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobileCall::NotifyMobileCallStatusChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RMobileCall::NotifyMobileCallStatusChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange00011L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusAnswering;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    RMobileCall::TMobileCallStatus statusToGet;
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

	mobileCallStatus = RMobileCall::EStatusRinging;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusRinging, statusToGet);

	//--------------------
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusDialling;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusDialling, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusConnecting;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusConnecting, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusAnswering;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusAnswering, statusToGet);

	//-----------------------	
	
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusConnected;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusConnected, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusDisconnecting;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusDisconnecting, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusDisconnectingWithInband;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusDisconnectingWithInband, statusToGet);

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

    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 

    mobileCallStatus = RMobileCall::EStatusIdle;  
    data.Close();
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    TUint32 duration = 4; // this is a dummy value, which will be ignored, when mocksy engine is doing the validation check	
    TMockLtsyData1<TUint32> ltsyData( duration );
    data.Close();
    ltsyData.SerialiseL(data);
    // when the call state becomes idle, there is update LifeTime param into LTSY:	
    iMockLTSY.ExpectL(EMmTsyUpdateLifeTimeIPC, data);
        
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet);

	//-----------------------	
	
	// for other status values CompleteNotifyStatusChange() does not complete the notify request
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-00012
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileCall::NotifyMobileCallStatusChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes cancelling of RMobileCall::NotifyMobileCallStatusChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange00012L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
    //----------------------------------------
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

    RMobileCall::TMobileCallStatus statusToGet;
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 
    call.CancelAsyncRequest(EMobileCallNotifyMobileCallStatusChange);

    mobileCallStatus = RMobileCall::EStatusIdle;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

        
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(4, this); 
	}





/**
@SYMTestCaseID BA-CTSY-CALLI-CNMCSC-00014
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileCall::NotifyMobileCallStatusChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes multiple client requests to RMobileCall::NotifyMobileCallStatusChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyMobileCallStatusChange00014L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

	// Open second client
	RTelServer telServer2;
	TInt ret = telServer2.Connect();
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(telServer2);

	RMobilePhone phone2;
	ret = phone2.Open(telServer2,KMmTsyPhoneName);
	ASSERT_EQUALS(KErrNone, ret);
	CleanupClosePushL(phone2);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

    TName lineName2(KMmTsyFaxLineName);    
    RLine line2;
    
	OpenLineLC(line2, phone2, lineName2);
    
	RMobileCall call;
	RMobileCall call2;
	
	TInt callId = 1;
	TInt callId2 = 2;
	TName incomingCallName;
	TName incomingCallName2;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus requestStatus2;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);

	CreateAndOpenIncomingCalLC(line2, call2, incomingCallName2, 
		lineName2, callId2, mobileCallStatus, mobileService);

	
    RMobileCall::TMobileCallStatus statusToGet;
    RMobileCall::TMobileCallStatus statusToGet2;
    call.NotifyMobileCallStatusChange(requestStatus, statusToGet); 
    call2.NotifyMobileCallStatusChange(requestStatus2, statusToGet2); 
    
    mobileCallStatus = RMobileCall::EStatusConnected;  
    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData3(callId, mobileService, mobileCallStatus);
    mockCallData3.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    mobileCallStatus = RMobileCall::EStatusIdle;    

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId2, mobileService, mobileCallStatus);
    data.Close();
    mockCallData4.SerialiseL(data);
	
    iMockLTSY.NotifyTerminated(mockLtsyStatus);
    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
    User::WaitForRequest(mockLtsyStatus);
    AssertMockLtsyStatusL();
    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());


    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNone, requestStatus.Int());
    ASSERT_EQUALS(RMobileCall::EStatusConnected, statusToGet);

    User::WaitForRequest(requestStatus2);
    ASSERT_EQUALS(KErrNone, requestStatus2.Int());
    ASSERT_EQUALS(RMobileCall::EStatusIdle, statusToGet2);


	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(8, this); 
	}


void CCTsyCallInformationFU::AuxGetIncomingCallType0001L(const TDesC& aLineName, RMobilePhone::TMobileService aMobileService)
	{
	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    RLine line;
    
	OpenLineLC(line, iPhone, aLineName);
    
	RMobileCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		aLineName, callId, mobileCallStatus, aMobileService);

    //---------------------------------------
    TRequestStatus notifyStatus;
    RMobileCall::TMobileCallCapsV1 mcaps;
    RMobileCall::TMobileCallCapsV1Pckg   mcapsPckg(mcaps);
    
    RMobilePhone::TMobilePhoneIncomingCallType type;
    RMobileCall::TMobileDataCallParamsV1 callParams;
    RMobileCall::TMobileDataCallParamsV1Pckg callParamsPckg(callParams);

    iPhone.GetIncomingCallType(requestStatus, type, callParamsPckg);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
           
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(3, this); 	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-MGICT-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetIncomingCallType
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhone::GetIncomingCallType
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetIncomingCallType0001L()
	{

	AuxGetIncomingCallType0001L(KMmTsyVoice1LineName, RMobilePhone::EVoiceService);

	}

/**
@SYMTestCaseID BA-CTSY-CALLI-MGICT-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetIncomingCallType
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhone::GetIncomingCallType
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetIncomingCallType0006L()
	{

	AuxGetIncomingCallType0001L(KMmTsyDataLineName, RMobilePhone::ECircuitDataService);

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-MGICT-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhone::GetIncomingCallType
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhone::GetIncomingCallType
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestGetIncomingCallType00011L()
	{

	AuxGetIncomingCallType0001L(KMmTsyFaxLineName, RMobilePhone::EFaxService);

	}


/**
@SYMTestCaseID BA-CTSY-CALLI-MNICTC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RMobilePhone::NotifyIncomingCallTypeChange
@SYMTestPriority High
@SYMTestActions Invokes RMobilePhone::NotifyIncomingCallTypeChange
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyIncomingCallTypeChange0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

    TRequestStatus requestStatus;

    RMobilePhone::TMobilePhoneIncomingCallType type;
	RMobileCall::TMobileDataCallParamsV1 callParams;
    RMobileCall::TMobileDataCallParamsV1Pckg callParamsPckg(callParams);
    iPhone.NotifyIncomingCallTypeChange(requestStatus, type, callParamsPckg);

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());
    
	AssertMockLtsyStatusL();
	CleanupStack::PopAndDestroy(1, this); 
	}






/**
@SYMTestCaseID BA-CTSY-CALLI-LNHCC-0001
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::NotifyHookChange for voice calls
@SYMTestPriority High
@SYMTestActions Invokes RLine::NotifyHookChange for voice calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyLineHookChange0001L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyVoice1LineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

	RCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;

    TRequestStatus notifyStatus;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
	RCall::THookStatus hookStatus;
	line.NotifyHookChange(requestStatus, hookStatus); 
	    
	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

    // this test is written supposing that NotifyHookChange() is supported
    // however RCall::NotifyHookChange returns KErrNotSupported
    // because CTSY does NOT support this feature
    // the rationale would be that NotifyStatusChange performs the same function
    
    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

	AssertMockLtsyStatusL();
    
	CleanupStack::PopAndDestroy(4, this);
	
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LNHCC-0006
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::NotifyHookChange for data calls
@SYMTestPriority High
@SYMTestActions Invokes RLine::NotifyHookChange for data calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyLineHookChange0006L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyDataLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);
    
	RCall call;
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::ECircuitDataService;

    TRequestStatus notifyStatus;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
	RCall::THookStatus hookStatus;
	line.NotifyHookChange(requestStatus, hookStatus); 
	    
	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    TMockLtsyCallData0 mockData01(callId, mobileService);
    mockData01.SerialiseL(data);
    iMockLTSY.ExpectL(EEtelCallAnswer, data);
    iMockLTSY.CompleteL(EEtelCallAnswer, KErrNone, data);
    call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNone, requestStatus1.Int());

    // this test is written supposing that NotifyHookChange() is supported
    // however RCall::NotifyHookChange returns KErrNotSupported
    // because CTSY does NOT support this feature
    // the rationale would be that NotifyStatusChange performs the same function

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

	AssertMockLtsyStatusL();    
	CleanupStack::PopAndDestroy(4, this);
		
	}


/**
@SYMTestCaseID BA-CTSY-CALLI-LNHCC-00011
@SYMComponent  telephony_ctsy
@SYMTestCaseDesc Test support in CTSY for RLine::NotifyHookChange for fax calls
@SYMTestPriority High
@SYMTestActions Invokes RLine::NotifyHookChange for fax calls
@SYMTestExpectedResults Pass
@SYMTestType CT
*/
void CCTsyCallInformationFU::TestNotifyLineHookChange00011L()
	{

	OpenEtelServerL(EUseExtendedError);
	CleanupStack::PushL(TCleanupItem(Cleanup,this));
	OpenPhoneL();

	RBuf8 data;
	CleanupClosePushL(data);

    TName lineName(KMmTsyFaxLineName);    
    RLine line;
    
	OpenLineLC(line, iPhone, lineName);

	RCall call;	
	TInt callId = 1;
	TName incomingCallName;
    TRequestStatus requestStatus;
    TRequestStatus requestStatus1;
    TRequestStatus mockLtsyStatus;
			
    RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusRinging;    
    RMobilePhone::TMobileService mobileService = RMobilePhone::EFaxService;

    TRequestStatus notifyStatus;

	CreateAndOpenIncomingCalLC(line, call, incomingCallName, 
		lineName, callId, mobileCallStatus, mobileService);
	
	RCall::THookStatus hookStatus;
	line.NotifyHookChange(requestStatus, hookStatus); 
	    
	RMobileCall::TMobileCallParamsV1 callParamsV1;
	TPckg<RMobileCall::TMobileCallParamsV1> mmParamsPckgV1(callParamsV1);
	
    call.AnswerIncomingCall(requestStatus1, mmParamsPckgV1);
    User::WaitForRequest(requestStatus1);
    ASSERT_EQUALS(KErrNotSupported, requestStatus1.Int());

    // this test is written supposing that NotifyHookChange() is supported
    // however RCall::NotifyHookChange returns KErrNotSupported
    // because CTSY does NOT support this feature
    // the rationale would be that NotifyStatusChange performs the same function

    User::WaitForRequest(requestStatus);
    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

	AssertMockLtsyStatusL();    
	CleanupStack::PopAndDestroy(4, this);


	}





//  ExpectL and CompleteL must precede this function.
void CCTsyCallInformationFU::CallGetMobileCallInfoL(TInt aCallId, 
                                               RMobilePhone::TMobileService aService, 
                                               const TDesC &aTelNumber)
	{
	RBuf8 data;
	CleanupClosePushL(data);

	RMobileCall::TMobileCallInfoV1 callInfo;

	callInfo.iDialledParty.iTelNumber.Copy(aTelNumber);
	callInfo.iService = aService;
	callInfo.iEmergency = EFalse;
	callInfo.iRemoteParty.iCallingName = KNullDesC;
	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityUnknown;
	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNullDesC;
	callInfo.iRemoteParty.iRemoteNumber.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
	callInfo.iRemoteParty.iRemoteNumber.iTypeOfNumber = RMobilePhone::EUnknownNumber;
	callInfo.iForwarded = EFalse;
	callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallRemoteParty;

	TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> callInfoData(aCallId, aService, callInfo);
	callInfoData.SerialiseL(data);
		
    iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
    
    CleanupStack::PopAndDestroy(1);
	}


void CCTsyCallInformationFU::OpenLineLC(RLine& aLine, RPhone& aPhone, const TDesC& aName)
	{
	
	TInt res = aLine.Open(aPhone, aName);
	ASSERT_EQUALS(KErrNone, res);
	CleanupClosePushL(aLine);
	AssertMockLtsyStatusL();
	
	}

	
void CCTsyCallInformationFU::CreateAndOpenIncomingCalLC(RLine &aLine, 
														RCall &aCall,
														TName& aCallName,
														const TDesC& aLineName,
														const TInt aCallId,
														RMobileCall::TMobileCallStatus aMobileCallStatus,
														RMobilePhone::TMobileService aMobileService
														)
	{
	
	TInt ret = CreateIncomingCallL(aLine, aCallId, aLineName, aCallName, 
	                               aMobileService, aMobileCallStatus);	
	ASSERT_EQUALS(KErrNone, ret);
	
    ret = aCall.OpenExistingCall(aLine, aCallName);
    ASSERT_EQUALS(KErrNone, ret);
    
    CleanupClosePushL(aCall);
	}


void CCTsyCallInformationFU::OpenNewCallLC(RCall& aCall, RLine& aLine, TDes* aCallName)
	{
	TInt res;
	if (aCallName)
		{
		res = aCall.OpenNewCall(aLine, *aCallName);
		}
	else
		{
		res = aCall.OpenNewCall(aLine);
		}
	ASSERT_EQUALS(KErrNone, res);
	CleanupClosePushL(aCall);
	AssertMockLtsyStatusL();
	}
void CCTsyCallInformationFU::ValidateMobileCallInfo(TDes8* aCallInfo, TName &aCallName, const TDesC& aLineName, TBool aCallFlagActive, RMobileCall::TMobileCallStatus aStatus)
	{
	
	_LIT(KEmpty, "");
	const TDateTime KZeroTime(0,TMonth(0),0,0,0,0,0);
	
	RMobilePhone::TMultimodeTypePckg* infoParamsPckg =
       reinterpret_cast<RMobilePhone::TMultimodeTypePckg*>(
    		   aCallInfo );
    RMobilePhone::TMultimodeType& callInfo = ( *infoParamsPckg )();
        
    // get extensionid 
    TInt extensionId( callInfo.ExtensionId() );
    
    if ( (KETelExtMultimodeV1 == extensionId) || 
    	 (KETelExtMultimodeV3 == extensionId) ||
    	 (KEtelExtMultimodeV7 == extensionId) ||
    	 (KEtelExtMultimodeV8 == extensionId) )
        {
           
        RMobileCall::TMobileCallInfoV1Pckg* paramsPckgV1 =
            reinterpret_cast<RMobileCall::TMobileCallInfoV1Pckg*>(aCallInfo );
        RMobileCall::TMobileCallInfoV1& info = ( *paramsPckgV1 )();
        
        if(aCallFlagActive)
        	{
        	ASSERT_TRUE(RMobilePhone::ECircuitDataService == info.iService);
        	ASSERT_TRUE(1 == info.iCallId);
        	ASSERT_TRUE(0 == info.iExitCode);
        	ASSERT_TRUE(RMobileCall::EMobileTerminated == info.iRemoteParty.iDirection);
        	ASSERT_TRUE(aStatus == info.iStatus);
        	}
        else
        	{
        	ASSERT_TRUE(RMobileCall::EServiceUnspecified == info.iService);
        	ASSERT_TRUE(0 == info.iCallId);
        	ASSERT_TRUE(-1 == info.iExitCode);
        	ASSERT_TRUE(RMobileCall::EDirectionUnknown == info.iRemoteParty.iDirection);
        	ASSERT_TRUE(RMobileCall::EStatusIdle == info.iStatus);
        	ASSERT_TRUE(0 == info.iCallName.Compare(aCallName));
        	}
		ASSERT_TRUE((RMobileCall::KCallStartTime | 
	        RMobileCall::KCallDuration | 
	            RMobileCall::KCallId | 
	                RMobileCall::KCallExitCode | 
	                    RMobileCall::KCallEmergency) == info.iValid);
	    
	 
	    
	    ASSERT_TRUE(0 == info.iEmergency);
	    ASSERT_TRUE(0 == info.iForwarded);
	    ASSERT_TRUE(RMobilePhone::EPrivacyUnspecified == info.iPrivacy);     
	    ASSERT_TRUE(RMobilePhone::EAlternatingModeUnspecified == info.iAlternatingCall);
	    ASSERT_TRUE(RMobileCall::ETchUnknown == info.iTch);
	    ASSERT_TRUE(RMobileCall::ERemoteIdentityUnknown == info.iRemoteParty.iRemoteIdStatus);
	    ASSERT_TRUE(0 == info.iRemoteParty.iCallingName.Compare(KEmpty));
	    ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTelNumber.Size());
	    ASSERT_TRUE(0 == info.iRemoteParty.iRemoteNumber.iTypeOfNumber);
	    ASSERT_TRUE(RMobilePhone::EUnknownNumber == info.iDialledParty.iTypeOfNumber);
	    ASSERT_TRUE(RMobilePhone::EUnknownNumberingPlan == info.iDialledParty.iNumberPlan);
	    ASSERT_TRUE(0 == info.iDialledParty.iTelNumber.Compare(KEmpty));
	    ASSERT_TRUE(0 == memcmp( &info.iStartTime, &KZeroTime, sizeof(KZeroTime)));
	    ASSERT_TRUE(0 == info.iLineName.Compare(aLineName));
        }
   
    if ( (KETelExtMultimodeV3 == extensionId) ||
         (KEtelExtMultimodeV7 == extensionId) ||
         (KEtelExtMultimodeV8 == extensionId) )
        {
           
        RMobileCall::TMobileCallInfoV3Pckg* paramsPckgV3 =
            reinterpret_cast<RMobileCall::TMobileCallInfoV3Pckg*>(aCallInfo );
        RMobileCall::TMobileCallInfoV3& info = ( *paramsPckgV3 )();
        
        ASSERT_TRUE(RMobilePhone::ECipheringOff == info.iSecurity);
		}
    
    if ( (KEtelExtMultimodeV7 == extensionId) ||
         (KEtelExtMultimodeV8 == extensionId) )
        {
           
        RMobileCall::TMobileCallInfoV7Pckg* paramsPckgV7 =
            reinterpret_cast<RMobileCall::TMobileCallInfoV7Pckg*>(aCallInfo );
        RMobileCall::TMobileCallInfoV7& info = ( *paramsPckgV7 )();
           
        ASSERT_TRUE(RMobileCall::EOriginatorUnknown == info.iCallParamOrigin);
        ASSERT_TRUE(RMobileCall::EIconQualifierNotSet == info.iIconId.iQualifier);
        ASSERT_TRUE(0 == info.iIconId.iIdentifier);
        ASSERT_TRUE(info.iAlphaId.Length() == 0);
        ASSERT_TRUE(EFalse == info.iParamsCallControlModified);
      
		}
    
    if (KEtelExtMultimodeV8 == extensionId )
        {
           
        RMobileCall::TMobileCallInfoV8Pckg* paramsPckgV8 =
            reinterpret_cast<RMobileCall::TMobileCallInfoV8Pckg*>(aCallInfo );
        RMobileCall::TMobileCallInfoV8& info = ( *paramsPckgV8 )();
        
        ASSERT_TRUE(0 ==  info.iSubAddress.Length());
        ASSERT_TRUE(0 ==  info.iBearerCap1.Length());
        ASSERT_TRUE(0 ==  info.iBearerCap2.Length());
        ASSERT_EQUALS(RMobileCall::EBCAlternateMode,info.iBCRepeatIndicator);
         
		}
            
    }

void CCTsyCallInformationFU::ValidateCallParams(const TDesC8* aCallParams, TBool aCallFlagActive)
	{
	
	
	//use base class to determine callparam version
    RCall::TCallParamsPckg* callParamsPckg = 
        reinterpret_cast<RCall::TCallParamsPckg*>(const_cast<TDesC8*>( aCallParams ) ); 

    RCall::TCallParams& callParams = ( *callParamsPckg )();
        
    // get extensionid 
    TInt extensionId( callParams.ExtensionId() );
    _LIT( KStringAlphaId,  "Alpha Id"  );
    
    if ( (RMobileCall::KETelMobileCallParamsV1 == extensionId) || 
    	 (RMobileCall::KETelMobileCallParamsV2 == extensionId) ||
    	 (RMobileCall::KETelMobileCallParamsV7 == extensionId))
        {
           
        RMobileCall::TMobileCallParamsV1Pckg* paramsPckgV1 = 
            reinterpret_cast<RMobileCall::TMobileCallParamsV1Pckg*>( 
            const_cast<TDesC8*>( aCallParams ) );
       RMobileCall::TMobileCallParamsV1& callParams1 = (*paramsPckgV1)();
        
        if(aCallFlagActive)
        	{
        	ASSERT_EQUALS(RCall::EMonitorSpeakerControlAlwaysOff, callParams1.iSpeakerControl);
    	    ASSERT_EQUALS(RCall::EMonitorSpeakerVolumeMedium, callParams1.iSpeakerVolume);
    	    ASSERT_TRUE(2 == callParams1.iInterval);
    	    ASSERT_EQUALS(RCall::EDialToneWait, callParams1.iWaitForDialTone);
    	    ASSERT_EQUALS(RMobileCall::EIdRestrictDefault, callParams1.iIdRestrict);
    	    ASSERT_TRUE(EFalse == callParams1.iCug.iExplicitInvoke);
    	    ASSERT_TRUE(0 == callParams1.iCug.iCugIndex);
    	    ASSERT_TRUE(EFalse == callParams1.iCug.iSuppressOA);
    	    ASSERT_TRUE(EFalse == callParams1.iCug.iSuppressPrefCug);
    	    ASSERT_TRUE(EFalse == callParams1.iAutoRedial);
        	}
        else
        	{
        	ASSERT_EQUALS(RCall::EMonitorSpeakerControlOnUntilCarrier, callParams1.iSpeakerControl);
	        ASSERT_EQUALS(RCall::EMonitorSpeakerVolumeLow, callParams1.iSpeakerVolume);
	        ASSERT_TRUE(4 == callParams1.iInterval);
	        ASSERT_EQUALS(RCall::EDialToneWait, callParams1.iWaitForDialTone);
	        ASSERT_EQUALS(RMobileCall::EIdRestrictDefault, callParams1.iIdRestrict);
	        ASSERT_TRUE(EFalse == callParams1.iCug.iExplicitInvoke);
	        ASSERT_TRUE(0 == callParams1.iCug.iCugIndex);
	        ASSERT_TRUE(EFalse == callParams1.iCug.iSuppressOA);
	        ASSERT_TRUE(EFalse == callParams1.iCug.iSuppressPrefCug);
	        ASSERT_TRUE(EFalse == callParams1.iAutoRedial);
        	}
       
        }
    
    if ((RMobileCall::KETelMobileCallParamsV2 == extensionId) ||
        (RMobileCall::KETelMobileCallParamsV7 == extensionId))
        {
        RMobileCall::TMobileCallParamsV2Pckg* paramsPckgV2 = 
            reinterpret_cast<RMobileCall::TMobileCallParamsV2Pckg*>( 
            const_cast<TDesC8*>( aCallParams ) );
       RMobileCall::TMobileCallParamsV2& callParams2 = (*paramsPckgV2)();
       if(aCallFlagActive)
    	   {
    	   ASSERT_EQUALS(RMobileCall::EMulticallNotSupported, callParams2.iBearerMode );
    	   }
       else
    	   {
    	   ASSERT_EQUALS(RMobileCall::EMulticallNotSupported, callParams2.iBearerMode );
    	   }
        }
    
    if ((RMobileCall::KETelMobileCallParamsV7 == extensionId))
        {
        RMobileCall::TMobileCallParamsV7Pckg* paramsPckgV7 = 
            reinterpret_cast<RMobileCall::TMobileCallParamsV7Pckg*>( 
            const_cast<TDesC8*>( aCallParams ) );
        RMobileCall::TMobileCallParamsV7& callParams7 = (*paramsPckgV7)();
        if(aCallFlagActive)
        	{
        	ASSERT_EQUALS(RMobileCall::EOriginatorUnknown, callParams7.iCallParamOrigin);
    	    ASSERT_TRUE(0 ==  callParams7.iSubAddress.Length());
    	    ASSERT_TRUE(0 ==  callParams7.iBearerCap1.Length());
    	    ASSERT_TRUE(0 ==  callParams7.iBearerCap2.Length());
    	    ASSERT_EQUALS(RMobileCall::EBCAlternateMode,callParams7.iBCRepeatIndicator);
    	    ASSERT_TRUE(RMobileCall::EIconQualifierNotSet == callParams7.iIconId.iQualifier);
	        ASSERT_TRUE(0 == callParams7.iIconId.iIdentifier);
    	    ASSERT_TRUE(0 == callParams7.iAlphaId.Compare(KStringAlphaId));
        	}
        else
        	{
        	ASSERT_EQUALS(RMobileCall::EOriginatorUnknown, callParams7.iCallParamOrigin);
    	    ASSERT_TRUE(0 ==  callParams7.iSubAddress.Length());
    	    ASSERT_TRUE(0 ==  callParams7.iBearerCap1.Length());
    	    ASSERT_TRUE(0 ==  callParams7.iBearerCap2.Length());
    	    ASSERT_EQUALS(RMobileCall::EBCAlternateMode,callParams7.iBCRepeatIndicator);
    	    ASSERT_TRUE(RMobileCall::EIconQualifierNotSet == callParams7.iIconId.iQualifier);
	        ASSERT_TRUE(0 == callParams7.iIconId.iIdentifier);
    	    ASSERT_TRUE(0 == callParams7.iAlphaId.Length());
        	}
       
         }
    
    }


void CCTsyCallInformationFU::ValidateDataCallParams(const TDesC8* aCallParams, TBool aDataCallFlagActive)
	{
	
	//use base class to determine datacallparam version
    RMobileCall::TMobileDataCallParamsV1Pckg* paramsPckgV1 =
        reinterpret_cast<RMobileCall::TMobileDataCallParamsV1Pckg*>(
            const_cast<TDesC8*>( aCallParams ) );

    RMobileCall::TMobileDataCallParamsV1& dataParams = (*paramsPckgV1)();
        
    // get extensionid 
    TInt extensionId( dataParams.ExtensionId() );
    _LIT( KStringSubAddress,  "An Unknown SubAddress");
    _LIT( KStringAlphaId,  "Alpha Id"  );
    
    if ( (RMobileCall::KETelMobileDataCallParamsV1 == extensionId) || 
    	 (RMobileCall::KETelMobileDataCallParamsV2 == extensionId) ||
    	 (RMobileCall::KETelMobileDataCallParamsV8 == extensionId))
        {
          
        if(aDataCallFlagActive)
        	{
        	ASSERT_EQUALS(RCall::EMonitorSpeakerControlAlwaysOff, dataParams.iSpeakerControl);
    	    ASSERT_EQUALS(RCall::EMonitorSpeakerVolumeMedium, dataParams.iSpeakerVolume);
    	    ASSERT_TRUE(2 == dataParams.iInterval);
    	    ASSERT_EQUALS(RCall::EDialToneWait, dataParams.iWaitForDialTone);
    	    ASSERT_EQUALS(RMobileCall::EIdRestrictDefault, dataParams.iIdRestrict);
    	    ASSERT_TRUE(EFalse == dataParams.iCug.iExplicitInvoke);
    	    ASSERT_TRUE(0xFFFF == dataParams.iCug.iCugIndex);
    	    ASSERT_TRUE(EFalse == dataParams.iCug.iSuppressOA);
    	    ASSERT_TRUE(EFalse == dataParams.iCug.iSuppressPrefCug);
    	    ASSERT_TRUE(EFalse == dataParams.iAutoRedial);
    	    ASSERT_EQUALS(RMobileCall::EServiceDataCircuitAsync, dataParams.iService);
		    ASSERT_EQUALS(RMobileCall::ESpeedUnspecified, dataParams.iSpeed);
		    ASSERT_EQUALS(RMobileCall::EProtocolUnspecified, dataParams.iProtocol);
		    ASSERT_EQUALS(RMobileCall::EQosTransparentPreferred, dataParams.iQoS);
		    ASSERT_EQUALS(RMobileCall::ERLPNotRequested, dataParams.iRLPVersion);
		    ASSERT_EQUALS(RMobileCall::EV42bisTxDirection, dataParams.iV42bisReq);
		    ASSERT_TRUE(0 == dataParams.iModemToMSWindowSize);
		    ASSERT_TRUE(0 == dataParams.iMSToModemWindowSize);
		    ASSERT_TRUE(0 == dataParams.iAckTimer);
		    ASSERT_TRUE(0 == dataParams.iRetransmissionAttempts);
		    ASSERT_TRUE(0 == dataParams.iResequencingPeriod);
		    ASSERT_TRUE(0 == dataParams.iV42bisCodewordsNum);
		    ASSERT_TRUE(0 == dataParams.iV42bisMaxStringLength);
		    ASSERT_TRUE(EFalse == dataParams.iUseEdge);
        	}
        else
        	{
        	ASSERT_EQUALS(RCall::EMonitorSpeakerControlOnUntilCarrier, dataParams.iSpeakerControl);
	        ASSERT_EQUALS(RCall::EMonitorSpeakerVolumeLow, dataParams.iSpeakerVolume);
	        ASSERT_TRUE(4 == dataParams.iInterval);
	        ASSERT_EQUALS(RCall::EDialToneWait, dataParams.iWaitForDialTone);
	        ASSERT_EQUALS(RMobileCall::EIdRestrictDefault, dataParams.iIdRestrict);
	        ASSERT_TRUE(EFalse == dataParams.iCug.iExplicitInvoke);
	        ASSERT_TRUE(0 == dataParams.iCug.iCugIndex);
	        ASSERT_TRUE(EFalse == dataParams.iCug.iSuppressOA);
	        ASSERT_TRUE(EFalse == dataParams.iCug.iSuppressPrefCug);
	        ASSERT_TRUE(EFalse == dataParams.iAutoRedial);
	            
		    ASSERT_EQUALS(RMobileCall::EServiceDataCircuitAsync, dataParams.iService);
		    ASSERT_EQUALS(RMobileCall::ESpeedUnspecified, dataParams.iSpeed);
		    ASSERT_EQUALS(RMobileCall::EProtocolUnspecified, dataParams.iProtocol);
		    ASSERT_EQUALS(RMobileCall::EQoSNonTransparent, dataParams.iQoS);
		    ASSERT_EQUALS(RMobileCall::ERLPNotRequested, dataParams.iRLPVersion);
		    ASSERT_EQUALS(RMobileCall::EV42bisNeitherDirection, dataParams.iV42bisReq);
		    ASSERT_TRUE(0 == dataParams.iModemToMSWindowSize);
		    ASSERT_TRUE(0 == dataParams.iMSToModemWindowSize);
		    ASSERT_TRUE(0 == dataParams.iAckTimer);
		    ASSERT_TRUE(0 == dataParams.iRetransmissionAttempts);
		    ASSERT_TRUE(0 == dataParams.iResequencingPeriod);
		    ASSERT_TRUE(0 == dataParams.iV42bisCodewordsNum);
		    ASSERT_TRUE(0 == dataParams.iV42bisMaxStringLength);
		    ASSERT_TRUE(EFalse == dataParams.iUseEdge);
		 	}
       
        }
    
    if ((RMobileCall::KETelMobileDataCallParamsV2 == extensionId) ||
        (RMobileCall::KETelMobileDataCallParamsV8 == extensionId))
        {
        RMobileCall::TMobileDataCallParamsV2Pckg* dataParamsPckgV2 = 
            reinterpret_cast<RMobileCall::TMobileDataCallParamsV2Pckg*>( 
            const_cast<TDesC8*>( aCallParams ) );
       RMobileCall::TMobileDataCallParamsV2& dataCallParams2 = (*dataParamsPckgV2)();
       if(aDataCallFlagActive)
    	   {
    	   ASSERT_EQUALS(RMobileCall::EMulticallShareBearer, dataCallParams2.iBearerMode );
    	   }
       else
    	   {
    	   ASSERT_EQUALS(RMobileCall::EMulticallNotSupported, dataCallParams2.iBearerMode );
    	   }
        }
    
    if ((RMobileCall::KETelMobileDataCallParamsV8 == extensionId))
        {
        RMobileCall::TMobileDataCallParamsV8Pckg* dataParamsPckgV8 = 
            reinterpret_cast<RMobileCall::TMobileDataCallParamsV8Pckg*>( 
            const_cast<TDesC8*>( aCallParams ) );
        RMobileCall::TMobileDataCallParamsV8& dataCallParams8 = (*dataParamsPckgV8)();
       
        if(aDataCallFlagActive)
        	{
        	ASSERT_EQUALS(RMobileCall::EOriginatorSIM, dataCallParams8.iCallParamOrigin);
    	    ASSERT_TRUE(0 ==  dataCallParams8.iSubAddress.Compare(KStringSubAddress));
    	    ASSERT_TRUE(0 ==  dataCallParams8.iBearerCap1.Length());
    	    ASSERT_TRUE(0 ==  dataCallParams8.iBearerCap2.Length());
    	    ASSERT_EQUALS(RMobileCall::EBCAlternateMode,dataCallParams8.iBCRepeatIndicator);
    	    ASSERT_TRUE(0 == dataCallParams8.iAlphaId.Compare(KStringAlphaId))
    	   	}
        else
        	{
        	ASSERT_EQUALS(RMobileCall::EOriginatorUnknown, dataCallParams8.iCallParamOrigin);
    	    ASSERT_TRUE(0 ==  dataCallParams8.iSubAddress.Length());
    	    ASSERT_TRUE(0 ==  dataCallParams8.iBearerCap1.Length());
    	    ASSERT_TRUE(0 ==  dataCallParams8.iBearerCap2.Length());
    	    ASSERT_EQUALS(RMobileCall::EBCAlternateMode,dataCallParams8.iBCRepeatIndicator);
    	    ASSERT_TRUE(0 == dataCallParams8.iAlphaId.Length())
    	   	}
       
         }
    
    }


void CCTsyCallInformationFU::ValidateHscsdCallParams(const TDesC8* aCallParams, TBool aHscsdCallFlagActive)
	{
	//use base class to determine hscsdcallparam version
    RMobileCall::TMobileHscsdCallParamsV1Pckg* paramsPckgV1 =
        reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV1Pckg*>(
            const_cast<TDesC8*>( aCallParams ) );

    RMobileCall::TMobileHscsdCallParamsV1& hscsdParams = (*paramsPckgV1)();
        
    // get extensionid 
    TInt extensionId( hscsdParams.ExtensionId() );
    _LIT( KStringAlphaId,  "Alpha Id"  );
    _LIT( KStringSubAddress,  "An Unknown SubAddress");
    
    if ( (RMobileCall::KETelMobileHscsdCallParamsV1 == extensionId) || 
    	 (RMobileCall::KETelMobileHscsdCallParamsV2 == extensionId) ||
    	 (RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId) ||
    	 (RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId))
        {
          
        if(aHscsdCallFlagActive)
        	{
        	ASSERT_EQUALS(RCall::EMonitorSpeakerControlAlwaysOff, hscsdParams.iSpeakerControl);
    	    ASSERT_EQUALS(RCall::EMonitorSpeakerVolumeMedium, hscsdParams.iSpeakerVolume);
    	    ASSERT_TRUE(2 == hscsdParams.iInterval);
    	    ASSERT_EQUALS(RCall::EDialToneWait, hscsdParams.iWaitForDialTone);
    	    ASSERT_EQUALS(RMobileCall::EIdRestrictDefault, hscsdParams.iIdRestrict);
    	    ASSERT_TRUE(EFalse == hscsdParams.iCug.iExplicitInvoke);
    	    ASSERT_TRUE(0xFFFF == hscsdParams.iCug.iCugIndex);
    	    ASSERT_TRUE(EFalse == hscsdParams.iCug.iSuppressOA);
    	    ASSERT_TRUE(EFalse == hscsdParams.iCug.iSuppressPrefCug);
    	    ASSERT_TRUE(EFalse == hscsdParams.iAutoRedial);
    	    ASSERT_EQUALS(RMobileCall::EServiceDataCircuitAsync, hscsdParams.iService);
		    ASSERT_EQUALS(RMobileCall::ESpeedUnspecified, hscsdParams.iSpeed);
		    ASSERT_EQUALS(RMobileCall::EProtocolUnspecified, hscsdParams.iProtocol);
		    ASSERT_EQUALS(RMobileCall::EQosTransparentPreferred, hscsdParams.iQoS);
		    ASSERT_EQUALS(RMobileCall::ERLPNotRequested, hscsdParams.iRLPVersion);
		    ASSERT_EQUALS(RMobileCall::EV42bisTxDirection, hscsdParams.iV42bisReq);
		    ASSERT_TRUE(0 == hscsdParams.iModemToMSWindowSize);
		    ASSERT_TRUE(0 == hscsdParams.iMSToModemWindowSize);
		    ASSERT_TRUE(0 == hscsdParams.iAckTimer);
		    ASSERT_TRUE(0 == hscsdParams.iRetransmissionAttempts);
		    ASSERT_TRUE(0 == hscsdParams.iResequencingPeriod);
		    ASSERT_TRUE(0 == hscsdParams.iV42bisCodewordsNum);
		    ASSERT_TRUE(0 == hscsdParams.iV42bisMaxStringLength);
		    ASSERT_TRUE(EFalse == hscsdParams.iUseEdge);
		    
		    ASSERT_TRUE(RMobileCall::EAiurBpsUnspecified == hscsdParams.iWantedAiur);
	        ASSERT_TRUE(RMobileCall::EAsymmetryNoPreference == hscsdParams.iAsymmetry);
	        ASSERT_TRUE(2 == hscsdParams.iWantedRxTimeSlots);
	        ASSERT_TRUE(3 == hscsdParams.iCodings);
	        ASSERT_TRUE(EFalse == hscsdParams.iUserInitUpgrade);    
		    
        	}
        else
        	{
        	ASSERT_EQUALS(RCall::EMonitorSpeakerControlOnUntilCarrier, hscsdParams.iSpeakerControl);
	        ASSERT_EQUALS(RCall::EMonitorSpeakerVolumeLow, hscsdParams.iSpeakerVolume);
	        ASSERT_TRUE(4 == hscsdParams.iInterval);
	        ASSERT_EQUALS(RCall::EDialToneWait, hscsdParams.iWaitForDialTone);
	        ASSERT_EQUALS(RMobileCall::EIdRestrictDefault, hscsdParams.iIdRestrict);
	        ASSERT_TRUE(EFalse == hscsdParams.iCug.iExplicitInvoke);
	        ASSERT_TRUE(0 == hscsdParams.iCug.iCugIndex);
	        ASSERT_TRUE(EFalse == hscsdParams.iCug.iSuppressOA);
	        ASSERT_TRUE(EFalse == hscsdParams.iCug.iSuppressPrefCug);
	        ASSERT_TRUE(EFalse == hscsdParams.iAutoRedial);
	            
		    ASSERT_EQUALS(RMobileCall::EServiceDataCircuitAsync, hscsdParams.iService);
		    ASSERT_EQUALS(RMobileCall::ESpeedUnspecified, hscsdParams.iSpeed);
		    ASSERT_EQUALS(RMobileCall::EProtocolUnspecified, hscsdParams.iProtocol);
		    ASSERT_EQUALS(RMobileCall::EQoSNonTransparent, hscsdParams.iQoS);
		    ASSERT_EQUALS(RMobileCall::ERLPNotRequested, hscsdParams.iRLPVersion);
		    ASSERT_EQUALS(RMobileCall::EV42bisNeitherDirection, hscsdParams.iV42bisReq);
		    ASSERT_TRUE(0 == hscsdParams.iModemToMSWindowSize);
		    ASSERT_TRUE(0 == hscsdParams.iMSToModemWindowSize);
		    ASSERT_TRUE(0 == hscsdParams.iAckTimer);
		    ASSERT_TRUE(0 == hscsdParams.iRetransmissionAttempts);
		    ASSERT_TRUE(0 == hscsdParams.iResequencingPeriod);
		    ASSERT_TRUE(0 == hscsdParams.iV42bisCodewordsNum);
		    ASSERT_TRUE(0 == hscsdParams.iV42bisMaxStringLength);
		    ASSERT_TRUE(EFalse == hscsdParams.iUseEdge);
		    
		    ASSERT_TRUE(RMobileCall::EAiurBpsUnspecified == hscsdParams.iWantedAiur);
	        ASSERT_TRUE(RMobileCall::EAsymmetryNoPreference == hscsdParams.iAsymmetry);
	        ASSERT_TRUE(0 == hscsdParams.iWantedRxTimeSlots);
	        ASSERT_TRUE(0 == hscsdParams.iCodings);
	        ASSERT_TRUE(EFalse == hscsdParams.iUserInitUpgrade); 
		 	}
       
        }
   
    if ((RMobileCall::KETelMobileHscsdCallParamsV2 == extensionId) ||
		(RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId) ||
        (RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId))
        {
        RMobileCall::TMobileHscsdCallParamsV2Pckg* paramsPckgV2 =
            reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV2Pckg*>(
                const_cast<TDesC8*>( aCallParams ) );

        RMobileCall::TMobileHscsdCallParamsV2& hscsdParams2 = (*paramsPckgV2)();
                
       if(aHscsdCallFlagActive)
    	   {
    	   ASSERT_EQUALS(RMobileCall::EMulticallShareBearer, hscsdParams2.iBearerMode );
    	   }
       else
    	   {
    	   ASSERT_EQUALS(RMobileCall::EMulticallNotSupported, hscsdParams2.iBearerMode );
    	   }
        }
   
    if ((RMobileCall::KETelMobileHscsdCallParamsV7 == extensionId)||
    	(RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId))
        {
        RMobileCall::TMobileHscsdCallParamsV7Pckg* hscsdParamsPckgV7 = 
            reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV7Pckg*>( 
            const_cast<TDesC8*>( aCallParams ) );
        RMobileCall::TMobileHscsdCallParamsV7& hscsdParams7 = (*hscsdParamsPckgV7)();
       
        if(aHscsdCallFlagActive)
        	{
        	ASSERT_EQUALS(RMobileCall::EOriginatorSIM, hscsdParams7.iCallParamOrigin);
        	ASSERT_TRUE(RMobileCall::EIconQualifierNotSet == hscsdParams7.iIconId.iQualifier);
        	ASSERT_TRUE(0 == hscsdParams7.iIconId.iIdentifier);
        	ASSERT_TRUE(0 == hscsdParams7.iAlphaId.Compare(KStringAlphaId));
    	   	}
        else
        	{
        	ASSERT_EQUALS(RMobileCall::EOriginatorUnknown, hscsdParams7.iCallParamOrigin);
        	ASSERT_TRUE(RMobileCall::EIconQualifierNotSet == hscsdParams7.iIconId.iQualifier);
	        ASSERT_TRUE(0 == hscsdParams7.iIconId.iIdentifier);
    	    ASSERT_TRUE(0 == hscsdParams7.iAlphaId.Length());
    	   	}
        }
   
    if (RMobileCall::KETelMobileHscsdCallParamsV8 == extensionId)
        {
        RMobileCall::TMobileHscsdCallParamsV8Pckg* hscsdParamsPckgV8 = 
            reinterpret_cast<RMobileCall::TMobileHscsdCallParamsV8Pckg*>( 
            const_cast<TDesC8*>( aCallParams ) );
        RMobileCall::TMobileHscsdCallParamsV8& hscsdParams8 = (*hscsdParamsPckgV8)();
       
        if(aHscsdCallFlagActive)
        	{
        	ASSERT_TRUE(0 ==  hscsdParams8.iSubAddress.Compare(KStringSubAddress));
    	    ASSERT_TRUE(0 ==  hscsdParams8.iBearerCap1.Length());
    	    ASSERT_TRUE(0 ==  hscsdParams8.iBearerCap2.Length());
    	    ASSERT_EQUALS(RMobileCall::EBCAlternateMode,hscsdParams8.iBCRepeatIndicator);
    	   	}
        else
        	{
        	ASSERT_TRUE(0 ==  hscsdParams8.iSubAddress.Length());
    	    ASSERT_TRUE(0 ==  hscsdParams8.iBearerCap1.Length());
    	    ASSERT_TRUE(0 ==  hscsdParams8.iBearerCap2.Length());
    	    ASSERT_EQUALS(RMobileCall::EBCAlternateMode,hscsdParams8.iBCRepeatIndicator);
    	   	}
        
         }

    }


	


	

