--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/common_tsy/test/component/src/cctsytelephonyaudiocontrolfu.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,3998 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// The TEFUnit test suite for TelephonyAudioControl in the Common TSY.
+//
+//
+
+#include "cctsytelephonyaudiocontrolfu.h"
+#include <etel.h>
+#include <etelmm.h>
+#include <ctsy/mmtsy_names.h>
+#include <et_clsvr.h>
+#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
+#include <e32property.h>
+#include "tmockltsydata.h"
+#include <ctsy/serviceapi/gsmerror.h>
+#include <ctsy/pluginapi/mtelephonyaudiocontrol.h>
+
+_LIT( KPhoneNumber, "101632960000" );
+
+CTestSuite* CCTsyTelephonyAudioControlFU::CreateSuiteL(const TDesC& aName)
+ {
+ SUB_SUITE;
+
+ ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestSetupTelephonyAudio0001aL);
+ ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestSetupTelephonyAudio0001bL);
+ ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestSetupTelephonyAudio0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestTeardownTelephonyAudio0001aL);
+ ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestTeardownTelephonyAudio0001bL);
+ ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestTeardownTelephonyAudio0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestCallStateChange0001aL);
+ ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestCallStateChange0001bL);
+ ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestCallStateChange0004L);
+ ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestNotifyTelephonyAudioControlError0001L );
+
+ END_SUITE;
+ }
+
+//
+// Actual test cases
+//
+
+
+/**
+@SYMTestCaseID BA-CTSY-CRC-CRCSUCR-0001a
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::SetUpCallRouting
+@SYMTestPriority High
+@SYMTestActions Invokes MTelephonyAudioControl::SetUpCallRouting
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsyTelephonyAudioControlFU::TestSetupTelephonyAudio0001aL()
+ {
+ DefinePropeties( ETrue, EVersion2 );
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TRequestStatus status( KErrNone );
+ TInt callId( 1 );
+ RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );
+ RMobileCall::TMobileCallParamsV7 callParams;
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ callParams.iInterval = 100;
+ callParams.iWaitForDialTone = RCall::EDialToneWait;
+ callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ callParams.iCug.iExplicitInvoke = EFalse;
+ callParams.iCug.iCugIndex = 0xFFFF;
+ callParams.iCug.iSuppressPrefCug = EFalse;
+ callParams.iCug.iSuppressOA = EFalse;
+ callParams.iAutoRedial = EFalse;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iService = mobileService;
+ callInfo.iStatus = RMobileCall::EStatusUnknown;
+ callInfo.iCallId =-1;
+ callInfo.iExitCode =0;
+ callInfo.iEmergency =0;
+ callInfo.iForwarded =0;
+ callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);
+ TMockLtsyCallData0 mockData0(callId, mobileService);
+
+ RCall::TCallParams callParamsX1;
+ TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);
+
+ TRequestStatus mockLtsyStatus( KErrNone );
+ RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting );
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus );
+
+ TInt hangUpCause( KErrGsmReleaseByUser );
+ TBool autoStChangeDisable ( EFalse );
+
+ TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable );
+
+ RLine line;
+ RMobileCall call;
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // MTelephonyAudioControl::SetUpCallRouting when result is not cached.
+ //-------------------------------------------------------------------------
+
+ // DialL
+
+ // reset the properties to ensure to get valid data
+ DefinePropeties( ETrue, EVersion2 );
+
+ // reset line & call
+ TInt error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // make the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // check that values passed to the SetupCallRouting were valid
+ CheckCallRoutingValues( line, call );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+
+ // DialNoFdnCheck
+
+ // reset line and call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ expectData.Close();
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EMobileCallDialNoFdnCheck, expectData);
+ completeData.Close();
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EMobileCallDialNoFdnCheck, KErrNone, completeData);
+
+ // make the call
+ call.DialNoFdnCheck( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // check that values passed to the SetupCallRouting were valid
+ CheckCallRoutingValues( line, call );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ // DialISV
+
+ // reset the properties to ensure to get valid data
+ DefinePropeties( ETrue, EVersion2 );
+
+ // reset line and call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ expectData.Close();
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ completeData.Close();
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ call.DialISV( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // check that values passed to the SetupCallRouting were valid
+ CheckCallRoutingValues( line, call );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ // Ghost Call
+
+ // reset the properties to ensure to get valid data
+ DefinePropeties( ETrue, EVersion2 );
+
+ // reset line
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // order NotifyStatusChange event
+ RCall::TStatus callStatus( RCall::EStatusIdle );
+ line.NotifyStatusChange( status, callStatus );
+
+ // prepare MockLTSY for NotifyStatusChange event
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ mobileCallInfo.iCallId = callId;
+ mobileCallInfo.iService = mobileService;
+ mobileCallInfo.iStatus = RMobileCall::EStatusDialling;
+ mobileCallInfo.iCallName.Copy( _L8("Voice12") );
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, mobileService, mobileCallInfo);
+ mockCallData1.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+
+ User::WaitForRequest(mockLtsyStatus);
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+ User::WaitForRequest(status);
+ ASSERT_EQUALS(KErrNone, status.Int());
+ ASSERT_EQUALS(RCall::EStatusDialling, callStatus);
+
+ error = call.OpenExistingCall( line, mobileCallInfo.iCallName );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ data.Close();
+ completeCallStatusData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+
+ call.NotifyMobileCallStatusChange( status, mobileCallStatus );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ AssertMockLtsyStatusL();
+
+ CheckCallStatus( mobileCallInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // prepare MockLTSY for hangup
+ expectData.Close();
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL( EEtelCallHangUp, expectData, KErrNone );
+
+ // hangup the call by popping the call from the cleanupstack
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ // DialEmergencyCall
+
+ // reset the properties to ensure to get valid data
+ DefinePropeties( ETrue, EVersion2 );
+
+ // reset line and call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // set rf on
+ iMockLTSY.NotifyTerminated( mockLtsyStatus );
+ TRfStateInfo rfInfo = ERfsStateInfoNormal;
+ TMockLtsyData1<TRfStateInfo> mockData1( rfInfo );
+ expectData.Close();
+ mockData1.SerialiseL(expectData);
+ iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, expectData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ // the emergency number
+ RMobileENStore::TEmergencyNumber number(_L("911"));
+ TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData( number );
+
+ CallGetMobileCallInfoL(callId, mobileService, number );
+
+ // prepare MockLTSY for EMobileCallDialEmergencyCall
+ data.Close();
+ numberLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> completeCallInfoData( callId, mobileService, callInfo );
+
+ // send EStatusDialling, EStatusConnecting and EStatusConnected events to complete DialEmergencyCall
+ data.Close();
+ completeCallInfoData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+
+ mobileCallStatus = RMobileCall::EStatusDialling;
+ completeCallStatusData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+
+ data.Close();
+ mobileCallStatus = RMobileCall::EStatusConnecting;
+ completeCallStatusData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+
+ data.Close();
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ completeCallStatusData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+
+ // On return, KErrNone if the emergency call successfully reaches the connected state.
+ call.DialEmergencyCall( status, number );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // check that values passed to the SetupCallRouting were valid
+ CheckCallRoutingValues( line, call );
+
+ // prepare MockLTSY for hangup
+ expectData.Close();
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+
+ // hangup the call by popping the call from the cleanupstack
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+
+ // cleanup
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ // answer incoming call
+
+ // reset the properties to ensure to get valid data
+ DefinePropeties( ETrue, EVersion2 );
+
+ // reset line
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ TName incomingCallName;
+ TRequestStatus requestNotify( KErrNone );
+ line.NotifyIncomingCall( status, incomingCallName);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo );
+ mockCallData.SerialiseL( completeData );
+
+ iMockLTSY.NotifyTerminated( mockLtsyStatus );
+ iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ;
+ User::WaitForRequest( mockLtsyStatus );
+
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() );
+
+ User::WaitForRequest( requestNotify );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, requestNotify.Int() );
+
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus );
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ expectData.Close();
+ mockData0.SerialiseL( expectData );
+ iMockLTSY.ExpectL( EEtelCallAnswer, expectData );
+ iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData );
+
+ // reset the call
+ error = call.OpenExistingCall( line, incomingCallName );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // answer the call
+ call.AnswerIncomingCall( status, pckgCallParamsX1 );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // check that values passed to the SetupCallRouting were valid
+ CheckCallRoutingValues( line, call );
+
+ // prepare MockLTSY for hangup
+ expectData.Close();
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+
+ // hangup the call by popping the call from the cleanupstack
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+
+ // cleanup
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ // cleanup
+ CleanupStack::PopAndDestroy( &completeData );
+ CleanupStack::PopAndDestroy( &expectData );
+ CleanupStack::PopAndDestroy( &data );
+ CleanupStack::PopAndDestroy( this );
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CRC-CRCSUCR-0001b
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::SetUpCallRouting by using LTSY version1
+@SYMTestPriority High
+@SYMTestActions Test that call routing is not set up
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsyTelephonyAudioControlFU::TestSetupTelephonyAudio0001bL()
+ {
+ DefinePropeties( ETrue, EVersion1 );
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ TRequestStatus status( KErrNone );
+ TInt callId( 1 );
+ RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );
+ RMobileCall::TMobileCallParamsV7 callParams;
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ callParams.iInterval = 100;
+ callParams.iWaitForDialTone = RCall::EDialToneWait;
+ callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ callParams.iCug.iExplicitInvoke = EFalse;
+ callParams.iCug.iCugIndex = 0xFFFF;
+ callParams.iCug.iSuppressPrefCug = EFalse;
+ callParams.iCug.iSuppressOA = EFalse;
+ callParams.iAutoRedial = EFalse;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iService = mobileService;
+ callInfo.iStatus = RMobileCall::EStatusUnknown;
+ callInfo.iCallId =-1;
+ callInfo.iExitCode =0;
+ callInfo.iEmergency =0;
+ callInfo.iForwarded =0;
+ callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);
+ TMockLtsyCallData0 mockData0(callId, mobileService);
+
+ RCall::TCallParams callParamsX1;
+ TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);
+
+ RLine line;
+ RMobileCall call;
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // MTelephonyAudioControl::SetUpCallRouting when result is not cached.
+ //-------------------------------------------------------------------------
+
+ // Test that CMockLtsyFactoryV1 is used instead of CMockLtsyFactoryV2
+
+ // DialL
+
+ // reset line & call
+ TInt error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // make the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+
+ // DialNoFdnCheck
+
+ // reset the properties to ensure to get valid data
+ DefinePropeties( ETrue, EVersion1 );
+
+ // reset line and call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ expectData.Close();
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EMobileCallDialNoFdnCheck, expectData);
+ completeData.Close();
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EMobileCallDialNoFdnCheck, KErrNone, completeData);
+
+ // make the call
+ call.DialNoFdnCheck( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ // DialEmergencyCall
+
+ // reset the properties to ensure to get valid data
+ DefinePropeties( ETrue, EVersion1 );
+
+ // reset line and call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // set rf on
+ TRequestStatus mockLtsyStatus(KErrNone);
+ iMockLTSY.NotifyTerminated( mockLtsyStatus );
+ TRfStateInfo rfInfo = ERfsStateInfoNormal;
+ TMockLtsyData1<TRfStateInfo> mockData1( rfInfo );
+ expectData.Close();
+ mockData1.SerialiseL(expectData);
+ iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, expectData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ // the emergency number
+ RMobileENStore::TEmergencyNumber number(_L("911"));
+ TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData( number );
+
+ CallGetMobileCallInfoL(callId, mobileService, number );
+
+ // prepare MockLTSY for EMobileCallDialEmergencyCall
+ data.Close();
+ numberLtsyData.SerialiseL(data);
+ iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> completeCallInfoData( callId, mobileService, callInfo );
+
+ // send EStatusDialling, EStatusConnecting and EStatusConnected events to complete DialEmergencyCall
+ data.Close();
+ completeCallInfoData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);
+
+ RMobileCall::TMobileCallStatus mobileCallStatus(RMobileCall::EStatusDialling);
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus );
+ completeCallStatusData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+
+ data.Close();
+ mobileCallStatus = RMobileCall::EStatusConnecting;
+ completeCallStatusData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+
+ data.Close();
+ mobileCallStatus = RMobileCall::EStatusConnected;
+ completeCallStatusData.SerialiseL(data);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);
+
+ // On return, KErrNone if the emergency call successfully reaches the connected state.
+ call.DialEmergencyCall( status, number );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // prepare MockLTSY for hangup
+ expectData.Close();
+ TInt hangUpCause( KErrGsmReleaseByUser );
+ TBool autoStChangeDisable ( EFalse );
+ TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable );
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+
+ // hangup the call by popping the call from the cleanupstack
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+
+ // cleanup
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ // cleanup
+ CleanupStack::PopAndDestroy( &data );
+ CleanupStack::PopAndDestroy( &completeData );
+ CleanupStack::PopAndDestroy( &expectData );
+ CleanupStack::PopAndDestroy( this );
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-CRC-CRCSUCR-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to MTelephonyAudioControl::SetUpCallRouting
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to MTelephonyAudioControl::SetUpCallRouting
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsyTelephonyAudioControlFU::TestSetupTelephonyAudio0004L()
+ {
+ DefinePropeties( EFalse, EVersion2 );
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting MTelephonyAudioControl::SetUpCallRouting
+ //-------------------------------------------------------------------------
+
+ TInt callId1( 1 );
+ RCall::TCallParams callParamsX1;
+ TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);
+ RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );
+ RMobileCall::TMobileCallParamsV7 callParams;
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ callParams.iInterval = 100;
+ callParams.iWaitForDialTone = RCall::EDialToneWait;
+ callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ callParams.iCug.iExplicitInvoke = EFalse;
+ callParams.iCug.iCugIndex = 0xFFFF;
+ callParams.iCug.iSuppressPrefCug = EFalse;
+ callParams.iCug.iSuppressOA = EFalse;
+ callParams.iAutoRedial = EFalse;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iService = mobileService;
+ callInfo.iStatus = RMobileCall::EStatusUnknown;
+ callInfo.iCallId =-1;
+ callInfo.iExitCode =0;
+ callInfo.iEmergency =0;
+ callInfo.iForwarded =0;
+ callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+
+ RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);
+ TMockLtsyCallData0 mockData0(callId1, mobileService);
+
+ // reset line & call
+ RLine line;
+ TInt error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ RMobileCall call;
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber);
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // make the call
+ TRequestStatus status( KErrNone );
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ // Open second client
+ RTelServer telServer2;
+ error = telServer2.Connect();
+ ASSERT_EQUALS( KErrNone, error );
+ CleanupClosePushL( telServer2 );
+
+ RMobilePhone phone2;
+ error = phone2.Open( iTelServer,KMmTsyPhoneName );
+ ASSERT_EQUALS( KErrNone, error );
+ CleanupClosePushL( phone2 );
+
+ RLine line2;
+ error = line2.Open( phone2, KMmTsyVoice1LineName );
+ CleanupClosePushL( line2 );
+ ASSERT_EQUALS( KErrNone, error );
+
+ RMobileCall call2;
+ error = call2.OpenNewCall( line2 );
+ CleanupClosePushL( call2 );
+ ASSERT_EQUALS( KErrNone, error );
+
+ TInt callId2( 2 );
+ // prepare MockLTSY
+ RMobileCall::TMobileCallInfoV8 callInfo2;
+ callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo2.iService = mobileService;
+ callInfo2.iStatus = RMobileCall::EStatusUnknown;
+ callInfo2.iCallId =-1;
+ callInfo2.iExitCode =0;
+ callInfo2.iEmergency =0;
+ callInfo2.iForwarded =0;
+ callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+ TMockLtsyCallData0 mockData01(callId2, mobileService);
+ CallGetMobileCallInfoL(callId2, mobileService, KPhoneNumber);
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData3(0, mobileService, callParams, callInfo2);
+ mockData3.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData01.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // make the call
+ call2.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call2.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call2, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call2, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call2, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ TInt callCount(0);
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // there should be 2 calls now
+ ASSERT_EQUALS( 2, callCount );
+
+ // cleanup
+
+ // prepare MockLTSY for hangup
+ TInt hangUpCause( KErrGsmReleaseByUser );
+ TBool autoStChangeDisable ( EFalse );
+ TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId2, mobileService, hangUpCause, autoStChangeDisable );
+ expectData.Close();
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+
+ CleanupStack::PopAndDestroy( &call2 );
+ CleanupStack::PopAndDestroy( &line2 );
+ CleanupStack::PopAndDestroy( &phone2 );
+ CleanupStack::PopAndDestroy( &telServer2 );
+
+ // prepare MockLTSY for hangup
+ TMockLtsyCallData2<TInt, TBool> mockHangUpData2( callId1, mobileService, hangUpCause, autoStChangeDisable );
+ expectData.Close();
+ mockHangUpData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+ CleanupStack::PopAndDestroy( &completeData );
+ CleanupStack::PopAndDestroy( &expectData );
+ CleanupStack::PopAndDestroy( this );
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-CRC-CRCTCR-0001a
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::TeardownCallRouting
+@SYMTestPriority High
+@SYMTestActions Invokes MTelephonyAudioControl::TeardownCallRouting
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsyTelephonyAudioControlFU::TestTeardownTelephonyAudio0001aL()
+ {
+ DefinePropeties( ETrue, EVersion2 );
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TRequestStatus status( KErrNone );
+ TInt callId( 1 );
+ RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );
+ RMobileCall::TMobileCallParamsV7 callParams;
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ callParams.iInterval = 100;
+ callParams.iWaitForDialTone = RCall::EDialToneWait;
+ callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ callParams.iCug.iExplicitInvoke = EFalse;
+ callParams.iCug.iCugIndex = 0xFFFF;
+ callParams.iCug.iSuppressPrefCug = EFalse;
+ callParams.iCug.iSuppressOA = EFalse;
+ callParams.iAutoRedial = EFalse;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iService = mobileService;
+ callInfo.iStatus = RMobileCall::EStatusUnknown;
+ callInfo.iCallId =-1;
+ callInfo.iExitCode =0;
+ callInfo.iEmergency =0;
+ callInfo.iForwarded =0;
+ callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+
+ RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);
+ TMockLtsyCallData0 mockData0(callId, mobileService);
+
+ RCall::TCallParams callParamsX1;
+ TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);
+
+ TRequestStatus mockLtsyStatus( KErrNone );
+ RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting );
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus );
+
+ RLine line;
+ RMobileCall call;
+
+ TInt error( KErrNone );
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // MTelephonyAudioControl::TeardownCallRouting when result is not cached.
+ //-------------------------------------------------------------------------
+
+ // MO Call Audio Teardown
+
+ // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that call status it is OK
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ // prepare MockLTSY for hangup
+ TInt hangUpCause( KErrGsmReleaseByUser );
+ TBool autoStChangeDisable ( ETrue );
+ TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable );
+ expectData.Close();
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+
+ completeData.Close();
+ TMockLtsyCallData0 mockData3(callId, mobileService);
+ mockData3.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData);
+ // hangup the call
+ call.HangUp( status );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+
+ TInt callCount(0);
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // there should not be any calls
+ ASSERT_EQUALS( 0, callCount );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // MT Call Audio Teardown
+
+ // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband
+
+ DefinePropeties( ETrue, EVersion2 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // notify incoming call
+ TName incomingCallName;
+ line.NotifyIncomingCall( status, incomingCallName );
+
+ // create incoming call notification
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo );
+ mockCallData.SerialiseL( completeData );
+ iMockLTSY.NotifyTerminated( mockLtsyStatus );
+ iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ;
+ User::WaitForRequest( mockLtsyStatus );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() );
+
+ // wait for notification
+ User::WaitForRequest( status );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // create call ringing notification
+ completeData.Close();
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus );
+ mockCallData2.SerialiseL(completeData);
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ // prepare MockLTSY for answer
+ expectData.Close();
+ mockData0.SerialiseL( expectData );
+ iMockLTSY.ExpectL( EEtelCallAnswer, expectData );
+ iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData );
+
+ // reset the call
+ error = call.OpenExistingCall( line, incomingCallName );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // answer the call
+ call.AnswerIncomingCall( status, pckgCallParamsX1 );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusAnswering );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusAnswering );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // there should not be any calls
+ ASSERT_EQUALS( 0, callCount );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // MT Call Audio Setup - Immediate Failure Case
+
+ DefinePropeties( ETrue, EVersion2 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // notify incoming call
+ line.NotifyIncomingCall( status, incomingCallName );
+
+ // create incoming call notification
+ mockCallData.SerialiseL( completeData );
+ iMockLTSY.NotifyTerminated( mockLtsyStatus );
+ iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ;
+ User::WaitForRequest( mockLtsyStatus );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() );
+
+ // wait for notification
+ User::WaitForRequest( status );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // create call ringing notification
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ // prepare MockLTSY for answer
+ expectData.Close();
+ mockData0.SerialiseL( expectData );
+ iMockLTSY.ExpectL( EEtelCallAnswer, expectData );
+ iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData );
+
+ // reset the call
+ error = call.OpenExistingCall( line, incomingCallName );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // answer the call
+ call.AnswerIncomingCall( status, pckgCallParamsX1 );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // create error by changing call state back to idle
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // there should not be any calls
+ ASSERT_EQUALS( 0, callCount );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // MT Call Audio Setup - In Progress Failure Case
+
+ // EStatusAnswering -> EStatusIdle
+
+ DefinePropeties( ETrue, EVersion2 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // notify incoming call
+ line.NotifyIncomingCall( status, incomingCallName );
+
+ // create incoming call notification
+ mockCallData.SerialiseL( completeData );
+ iMockLTSY.NotifyTerminated( mockLtsyStatus );
+ iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ;
+ User::WaitForRequest( mockLtsyStatus );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() );
+
+ // wait for notification
+ User::WaitForRequest( status );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // create call ringing notification
+ completeData.Close();
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ mockCallData2.SerialiseL(completeData);
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ // prepare MockLTSY for answer
+ expectData.Close();
+ mockData0.SerialiseL( expectData );
+ iMockLTSY.ExpectL( EEtelCallAnswer, expectData );
+ iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData );
+
+ // reset the call
+ error = call.OpenExistingCall( line, incomingCallName );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // answer the call
+ call.AnswerIncomingCall( status, pckgCallParamsX1 );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call state and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusAnswering );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusAnswering );
+
+ // create error by changing call state back to idle
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // there should not be any calls
+ ASSERT_EQUALS( 0, callCount );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // MT Call Audio Setup - Immediate Failure Case
+
+ DefinePropeties( ETrue, EVersion2 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ RMobileCall::TMobileCallInfoV8 callInfo2;
+ callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo2.iService = mobileService;
+ callInfo2.iStatus = RMobileCall::EStatusUnknown;
+ callInfo2.iCallId =-1;
+ callInfo2.iExitCode =0;
+ callInfo2.iEmergency =0;
+ callInfo2.iForwarded =0;
+ callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData4(0, mobileService, callParams, callInfo2);
+ mockData4.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that call status it is OK
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // there should not be any calls
+ ASSERT_EQUALS( 0, callCount );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // MO Call Audio Setup - In Progress Failure Case
+
+ DefinePropeties( ETrue, EVersion2 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData4.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that call status it is OK
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ // create error by setting the call back to the idle
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // there should not be any calls
+ ASSERT_EQUALS( 0, callCount );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ // cleanup
+ AssertMockLtsyStatusL();
+
+ DeletePropeties();
+ CleanupStack::PopAndDestroy( &completeData );
+ CleanupStack::PopAndDestroy( &expectData );
+ CleanupStack::PopAndDestroy( this );
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-CRC-CRCTCR-0001b
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::TeardownCallRouting by using LTSY version1
+@SYMTestPriority High
+@SYMTestActions Invokes MTelephonyAudioControl::TeardownCallRouting
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsyTelephonyAudioControlFU::TestTeardownTelephonyAudio0001bL()
+ {
+ DefinePropeties( ETrue, EVersion1 );
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TRequestStatus status( KErrNone );
+ TInt callId( 1 );
+ RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );
+ RMobileCall::TMobileCallParamsV7 callParams;
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ callParams.iInterval = 100;
+ callParams.iWaitForDialTone = RCall::EDialToneWait;
+ callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ callParams.iCug.iExplicitInvoke = EFalse;
+ callParams.iCug.iCugIndex = 0xFFFF;
+ callParams.iCug.iSuppressPrefCug = EFalse;
+ callParams.iCug.iSuppressOA = EFalse;
+ callParams.iAutoRedial = EFalse;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iService = mobileService;
+ callInfo.iStatus = RMobileCall::EStatusUnknown;
+ callInfo.iCallId =-1;
+ callInfo.iExitCode =0;
+ callInfo.iEmergency =0;
+ callInfo.iForwarded =0;
+ callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+
+ RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);
+ TMockLtsyCallData0 mockData0(callId, mobileService);
+
+ RCall::TCallParams callParamsX1;
+ TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);
+
+ TRequestStatus mockLtsyStatus( KErrNone );
+ RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting );
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus );
+
+ TInt hangUpCause( KErrGsmReleaseByUser );
+ TBool autoStChangeDisable ( ETrue );
+
+ TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable );
+
+ RLine line;
+ RMobileCall call;
+
+ TInt error( KErrNone );
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // MTelephonyAudioControl::TeardownCallRouting when result is not cached.
+ //-------------------------------------------------------------------------
+
+ // MO Call Audio Teardown
+
+ // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // prepare MockLTSY for hangup
+ expectData.Close();
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+
+ completeData.Close();
+ TMockLtsyCallData0 mockData3(callId, mobileService);
+ mockData3.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData);
+ // hangup the call
+ call.HangUp( status );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // MT Call Audio Teardown
+
+ // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband
+
+ DefinePropeties( ETrue, EVersion1 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // notify incoming call
+ TName incomingCallName;
+ line.NotifyIncomingCall( status, incomingCallName );
+
+ // create incoming call notification
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo );
+ mockCallData.SerialiseL( completeData );
+ iMockLTSY.NotifyTerminated( mockLtsyStatus );
+ iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ;
+ User::WaitForRequest( mockLtsyStatus );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() );
+
+ // wait for notification
+ User::WaitForRequest( status );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // create call ringing notification
+ completeData.Close();
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus );
+ mockCallData2.SerialiseL(completeData);
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ // prepare MockLTSY for answer
+ expectData.Close();
+ mockData0.SerialiseL( expectData );
+ iMockLTSY.ExpectL( EEtelCallAnswer, expectData );
+ iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData );
+
+ // reset the call
+ error = call.OpenExistingCall( line, incomingCallName );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // answer the call
+ call.AnswerIncomingCall( status, pckgCallParamsX1 );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusAnswering );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ // cleanup
+ DeletePropeties();
+ CleanupStack::PopAndDestroy( &completeData );
+ CleanupStack::PopAndDestroy( &expectData );
+ CleanupStack::PopAndDestroy( this );
+ }
+
+
+/**
+@SYMTestCaseID BA-CTSY-CRC-CRCTCR-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to MTelephonyAudioControl::TeardownCallRouting
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to MTelephonyAudioControl::TeardownCallRouting
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsyTelephonyAudioControlFU::TestTeardownTelephonyAudio0004L()
+ {
+ DefinePropeties( EFalse, EVersion2 );
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TInt hangUpCause( KErrGsmReleaseByUser );
+ TBool autoStChangeDisable ( ETrue );
+
+ TInt callId1( 1 );
+ RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );
+ TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId1, mobileService, hangUpCause, autoStChangeDisable );
+
+ RCall::TCallParams callParamsX1;
+ TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);
+ RMobileCall::TMobileCallParamsV7 callParams;
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ callParams.iInterval = 100;
+ callParams.iWaitForDialTone = RCall::EDialToneWait;
+ callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ callParams.iCug.iExplicitInvoke = EFalse;
+ callParams.iCug.iCugIndex = 0xFFFF;
+ callParams.iCug.iSuppressPrefCug = EFalse;
+ callParams.iCug.iSuppressOA = EFalse;
+ callParams.iAutoRedial = EFalse;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iService = mobileService;
+ callInfo.iStatus = RMobileCall::EStatusUnknown;
+ callInfo.iCallId =-1;
+ callInfo.iExitCode =0;
+ callInfo.iEmergency =0;
+ callInfo.iForwarded =0;
+ callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);
+ TMockLtsyCallData0 mockData0(callId1, mobileService);
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting MTelephonyAudioControl::SetUpCallRouting
+ //-------------------------------------------------------------------------
+
+ // reset line & call
+ RLine line;
+ TInt error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ RMobileCall call;
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber);
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // make the call
+ TRequestStatus status( KErrNone );
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+
+ ASSERT_EQUALS( KErrNone, status.Int() );
+ RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo );
+ error = call.GetMobileCallInfo( callInfoPckg );
+
+ ASSERT_EQUALS( KErrNone, error );
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ TInt callCount(0);
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+ // there should be 1 call now
+ ASSERT_EQUALS( 1, callCount );
+
+ // Open second client
+ RTelServer telServer2;
+ error = telServer2.Connect();
+ ASSERT_EQUALS( KErrNone, error );
+ CleanupClosePushL( telServer2 );
+
+ RMobilePhone phone2;
+ error = phone2.Open( telServer2,KMmTsyPhoneName );
+ CleanupClosePushL( phone2 );
+ ASSERT_EQUALS( KErrNone, error );
+
+ RLine line2;
+ error = line2.Open( phone2, KMmTsyVoice1LineName );
+ CleanupClosePushL( line2 );
+ ASSERT_EQUALS( KErrNone, error );
+
+ RMobileCall call2;
+ error = call2.OpenNewCall( line2 );
+ CleanupClosePushL( call2 );
+ ASSERT_EQUALS( KErrNone, error );
+
+ TInt callId2( 2 );
+ // prepare MockLTSY
+ TMockLtsyCallData0 mockData01(callId2, mobileService);
+ CallGetMobileCallInfoL(callId2, mobileService, KPhoneNumber);
+ RMobileCall::TMobileCallInfoV8 callInfo2;
+ callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo2.iService = mobileService;
+ callInfo2.iStatus = RMobileCall::EStatusUnknown;
+ callInfo2.iCallId =-1;
+ callInfo2.iExitCode =0;
+ callInfo2.iEmergency =0;
+ callInfo2.iForwarded =0;
+ callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData3(0, mobileService, callParams, callInfo2);
+ mockData3.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData01.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // make the call
+ call2.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call2.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call2, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call2, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call2, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // there should be 2 calls now
+ ASSERT_EQUALS( 2, callCount );
+
+ // hangup call 1
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // there should 1 call
+ ASSERT_EQUALS( 1, callCount );
+
+ // hangup call 2
+ error = call2.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+ UpdateCallStatusL( call2, RMobileCall::EStatusDisconnectingWithInband, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call2, RMobileCall::EStatusIdle, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // there should not be any calls
+ ASSERT_EQUALS( 0, callCount );
+
+ // cleanup
+ CleanupStack::PopAndDestroy( &call2 );
+ CleanupStack::PopAndDestroy( &line2 );
+ CleanupStack::PopAndDestroy( &phone2 );
+ CleanupStack::PopAndDestroy( &telServer2 );
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+ CleanupStack::PopAndDestroy( &completeData );
+ CleanupStack::PopAndDestroy( &expectData );
+ CleanupStack::PopAndDestroy( this );
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-CRC-CRCCRST-0001a
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::CallStateChange
+@SYMTestPriority High
+@SYMTestActions Invokes MTelephonyAudioControl::CallStateChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsyTelephonyAudioControlFU::TestCallStateChange0001aL()
+
+ {
+
+ /* CallStateChange function is called when call has changed its state to the following states:
+ EStatusDialling
+ EStatusAnswering
+ EStatusConnecting
+ EStatusHold
+ EStatusDisconnecting
+ EStatusDisconnectingWithInband
+ EStatusConnected
+ */
+ DefinePropeties( ETrue, EVersion2 );
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TRequestStatus status( KErrNone );
+ TInt callId( 1 );
+ RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );
+ RMobileCall::TMobileCallParamsV7 callParams;
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ callParams.iInterval = 100;
+ callParams.iWaitForDialTone = RCall::EDialToneWait;
+ callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ callParams.iCug.iExplicitInvoke = EFalse;
+ callParams.iCug.iCugIndex = 0xFFFF;
+ callParams.iCug.iSuppressPrefCug = EFalse;
+ callParams.iCug.iSuppressOA = EFalse;
+ callParams.iAutoRedial = EFalse;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iService = mobileService;
+ callInfo.iStatus = RMobileCall::EStatusUnknown;
+ callInfo.iCallId =-1;
+ callInfo.iExitCode =0;
+ callInfo.iEmergency =0;
+ callInfo.iForwarded =0;
+ callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+
+ RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);
+ TMockLtsyCallData0 mockData0(callId, mobileService);
+
+ RCall::TCallParams callParamsX1;
+ TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);
+
+ TRequestStatus mockLtsyStatus( KErrNone );
+ RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting );
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus );
+
+ TInt hangUpCause( KErrGsmReleaseByUser );
+ TBool autoStChangeDisable ( ETrue );
+
+ TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable );
+
+ RLine line;
+ RMobileCall call;
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // MTelephonyAudioControl::CallStateChange when result is not cached.
+ //-------------------------------------------------------------------------
+
+ // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting
+
+ // reset line & call
+ TInt error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that call status it is OK
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ // prepare MockLTSY for hangup
+ expectData.Close();
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+
+ completeData.Close();
+ TMockLtsyCallData0 mockData3(callId, mobileService);
+ mockData3.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData);
+ // hangup the call
+ call.HangUp( status );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband
+
+ DefinePropeties( ETrue, EVersion2 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ RMobileCall::TMobileCallInfoV8 callInfo2;
+ callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo2.iService = mobileService;
+ callInfo2.iStatus = RMobileCall::EStatusUnknown;
+ callInfo2.iCallId =-1;
+ callInfo2.iExitCode =0;
+ callInfo2.iEmergency =0;
+ callInfo2.iForwarded =0;
+ callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData6(0, mobileService, callParams, callInfo2);
+ mockData6.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that call status it is OK
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting
+
+ DefinePropeties( ETrue, EVersion2 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // notify incoming call
+ TName incomingCallName;
+ line.NotifyIncomingCall( status, incomingCallName );
+
+ // create incoming call notification
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo );
+ mockCallData.SerialiseL( completeData );
+ iMockLTSY.NotifyTerminated( mockLtsyStatus );
+ iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ;
+ User::WaitForRequest( mockLtsyStatus );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() );
+
+ // wait for notification
+ User::WaitForRequest( status );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // create call ringing notification
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus );
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ // prepare MockLTSY for answer
+ expectData.Close();
+ mockData0.SerialiseL( expectData );
+ iMockLTSY.ExpectL( EEtelCallAnswer, expectData );
+ iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData );
+
+ // reset the call
+ error = call.OpenExistingCall( line, incomingCallName );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // answer the call
+ call.AnswerIncomingCall( status, pckgCallParamsX1 );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusAnswering );
+ CheckCallStatus( incomingCallName, RMobileCall::EStatusAnswering );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+ CheckCallStatus( incomingCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( incomingCallName, RMobileCall::EStatusConnected );
+
+ // prepare MockLTSY for hangup
+ expectData.Close();
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+
+ completeData.Close();
+ TMockLtsyCallData0 mockData4(callId, mobileService);
+ mockData4.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData);
+ // hangup the call
+ call.HangUp( status );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting );
+ CheckCallStatus( incomingCallName, RMobileCall::EStatusDisconnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+ CheckCallStatus( incomingCallName, RMobileCall::EStatusIdle );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband
+
+ // reset properties
+ DefinePropeties( ETrue, EVersion2 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // notify incoming call
+ line.NotifyIncomingCall( status, incomingCallName );
+
+ // create incoming call notification
+ mockCallData.SerialiseL( completeData );
+ iMockLTSY.NotifyTerminated( mockLtsyStatus );
+ iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ;
+ User::WaitForRequest( mockLtsyStatus );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() );
+
+ // wait for notification
+ User::WaitForRequest( status );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // create call ringing notification
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ // prepare MockLTSY for answer
+ expectData.Close();
+ mockData0.SerialiseL( expectData );
+ iMockLTSY.ExpectL( EEtelCallAnswer, expectData );
+ iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData );
+
+ // reset the call
+ error = call.OpenExistingCall( line, incomingCallName );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // answer the call
+ call.AnswerIncomingCall( status, pckgCallParamsX1 );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusAnswering );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusAnswering );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusHold -> EStatusConnected -> EStatusDisconnectingWithInband -> EStatusIdle
+
+ DefinePropeties( ETrue, EVersion2 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData6.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that call status it is OK
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ // prepare MockLTSY for hold
+ expectData.Close();
+ mockData0.SerialiseL(expectData);
+ iMockLTSY.ExpectL( EMobileCallHold, expectData );
+ iMockLTSY.CompleteL( EMobileCallHold, KErrNone, expectData );
+
+ call.Hold( status );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusHold );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusHold );
+
+ // prepare MockLTSY for resume
+ expectData.Close();
+ mockData0.SerialiseL( expectData );
+ iMockLTSY.ExpectL( EMobileCallResume, expectData );
+ iMockLTSY.CompleteL( EMobileCallResume, KErrNone, expectData );
+
+ call.Resume( status );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusHold -> EStatusDisconnecting -> EStatusIdle
+
+ DefinePropeties( ETrue, EVersion2 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData6.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that call status it is OK
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ // prepare MockLTSY for hold
+ expectData.Close();
+ mockData0.SerialiseL(expectData);
+ iMockLTSY.ExpectL( EMobileCallHold, expectData );
+ iMockLTSY.CompleteL( EMobileCallHold, KErrNone, expectData );
+
+ call.Hold( status );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusHold );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusHold );
+
+ // prepare MockLTSY for hangup
+ expectData.Close();
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+
+ completeData.Close();
+ TMockLtsyCallData0 mockData5(callId, mobileService);
+ mockData5.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData);
+ // hangup the call
+ call.HangUp( status );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusHold -> EStatusDisconnectingWithInband -> EStatusIdle
+
+ DefinePropeties( ETrue, EVersion2 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData6.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that call status it is OK
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ // prepare MockLTSY for hold
+ expectData.Close();
+ mockData0.SerialiseL(expectData);
+ iMockLTSY.ExpectL( EMobileCallHold, expectData );
+ iMockLTSY.CompleteL( EMobileCallHold, KErrNone, expectData );
+
+ call.Hold( status );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusHold );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusHold );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ // cleanup
+ CleanupStack::PopAndDestroy( &completeData );
+ CleanupStack::PopAndDestroy( &expectData );
+ CleanupStack::PopAndDestroy( &data );
+ CleanupStack::PopAndDestroy( this );
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-CRC-CRCCRST-0001b
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::CallStateChange by using LTSY version1
+@SYMTestPriority High
+@SYMTestActions Invokes MTelephonyAudioControl::CallStateChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsyTelephonyAudioControlFU::TestCallStateChange0001bL()
+
+ {
+
+ /* CallStateChange function is called when call has changed its state to the following states:
+ EStatusDialling
+ EStatusAnswering
+ EStatusConnecting
+ EStatusDisconnecting
+ EStatusDisconnectingWithInband
+ EStatusConnected
+ */
+ DefinePropeties( ETrue, EVersion1 );
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TRequestStatus status( KErrNone );
+ TInt callId( 1 );
+ RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );
+ RMobileCall::TMobileCallParamsV7 callParams;
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ callParams.iInterval = 100;
+ callParams.iWaitForDialTone = RCall::EDialToneWait;
+ callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ callParams.iCug.iExplicitInvoke = EFalse;
+ callParams.iCug.iCugIndex = 0xFFFF;
+ callParams.iCug.iSuppressPrefCug = EFalse;
+ callParams.iCug.iSuppressOA = EFalse;
+ callParams.iAutoRedial = EFalse;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iService = mobileService;
+ callInfo.iStatus = RMobileCall::EStatusUnknown;
+ callInfo.iCallId =-1;
+ callInfo.iExitCode =0;
+ callInfo.iEmergency =0;
+ callInfo.iForwarded =0;
+ callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+
+ RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);
+ TMockLtsyCallData0 mockData0(callId, mobileService);
+
+ RCall::TCallParams callParamsX1;
+ TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);
+
+ TRequestStatus mockLtsyStatus( KErrNone );
+ RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting );
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus );
+
+ TInt hangUpCause( KErrGsmReleaseByUser );
+ TBool autoStChangeDisable ( ETrue );
+
+ TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable );
+
+ RLine line;
+ RMobileCall call;
+
+ //-------------------------------------------------------------------------
+ // TEST C: Successful completion request of
+ // MTelephonyAudioControl::CallStateChange when result is not cached.
+ //-------------------------------------------------------------------------
+
+ // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting
+
+ // reset line & call
+ TInt error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // prepare MockLTSY for hangup
+ expectData.Close();
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+
+ completeData.Close();
+ TMockLtsyCallData0 mockData3(callId, mobileService);
+ mockData3.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData);
+ // hangup the call
+ call.HangUp( status );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband
+
+ DefinePropeties( ETrue, EVersion1 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ RMobileCall::TMobileCallInfoV8 callInfo2;
+ callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo2.iService = mobileService;
+ callInfo2.iStatus = RMobileCall::EStatusUnknown;
+ callInfo2.iCallId =-1;
+ callInfo2.iExitCode =0;
+ callInfo2.iEmergency =0;
+ callInfo2.iForwarded =0;
+ callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData5(0, mobileService, callParams, callInfo2);
+ mockData5.SerialiseL(expectData);
+
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting
+
+ DefinePropeties( ETrue, EVersion1 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // notify incoming call
+ TName incomingCallName;
+ line.NotifyIncomingCall( status, incomingCallName );
+
+ // create incoming call notification
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo );
+ mockCallData.SerialiseL( completeData );
+ iMockLTSY.NotifyTerminated( mockLtsyStatus );
+ iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ;
+ User::WaitForRequest( mockLtsyStatus );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() );
+
+ // wait for notification
+ User::WaitForRequest( status );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // create call ringing notification
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus );
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ // prepare MockLTSY for answer
+ expectData.Close();
+ mockData0.SerialiseL( expectData );
+ iMockLTSY.ExpectL( EEtelCallAnswer, expectData );
+ iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData );
+
+ // reset the call
+ error = call.OpenExistingCall( line, incomingCallName );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // answer the call
+ call.AnswerIncomingCall( status, pckgCallParamsX1 );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusAnswering );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // prepare MockLTSY for hangup
+ expectData.Close();
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+
+ completeData.Close();
+ TMockLtsyCallData0 mockData4(callId, mobileService);
+ mockData4.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData);
+ // hangup the call
+ call.HangUp( status );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband
+
+ DefinePropeties( ETrue, EVersion1 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // notify incoming call
+ line.NotifyIncomingCall( status, incomingCallName );
+
+ // create incoming call notification
+ mockCallData.SerialiseL( completeData );
+ iMockLTSY.NotifyTerminated( mockLtsyStatus );
+ iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ;
+ User::WaitForRequest( mockLtsyStatus );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() );
+
+ // wait for notification
+ User::WaitForRequest( status );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // create call ringing notification
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ // prepare MockLTSY for answer
+ expectData.Close();
+ mockData0.SerialiseL( expectData );
+ iMockLTSY.ExpectL( EEtelCallAnswer, expectData );
+ iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData );
+
+ // reset the call
+ error = call.OpenExistingCall( line, incomingCallName );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // answer the call
+ call.AnswerIncomingCall( status, pckgCallParamsX1 );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusAnswering );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ DoCleanup();
+
+ // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusHold -> EStatusDisconnectingWithInband -> EStatusIdle
+
+ DefinePropeties( ETrue, EVersion1 );
+ OpenEtelServerL(EUseExtendedError);
+ OpenPhoneL();
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData5.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // prepare MockLTSY for hold
+ expectData.Close();
+ mockData0.SerialiseL(expectData);
+ iMockLTSY.ExpectL( EMobileCallHold, expectData );
+ iMockLTSY.CompleteL( EMobileCallHold, KErrNone, expectData );
+
+ call.Hold( status );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusHold );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // change call status
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+
+ // check that there is no call routing done
+ CheckNoCallRouting();
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ // cleanup
+ CleanupStack::PopAndDestroy( &completeData );
+ CleanupStack::PopAndDestroy( &expectData );
+ CleanupStack::PopAndDestroy( &data );
+ CleanupStack::PopAndDestroy( this );
+
+ }
+
+/**
+@SYMTestCaseID BA-CTSY-CRC-CRCCRST-0004
+@SYMComponent telephony_ctsy
+@SYMTestCaseDesc Test support in CTSY for multiple client requests to MTelephonyAudioControl::CallStateChange
+@SYMTestPriority High
+@SYMTestActions Invokes multiple client requests to MTelephonyAudioControl::CallStateChange
+@SYMTestExpectedResults Pass
+@SYMTestType CT
+ */
+void CCTsyTelephonyAudioControlFU::TestCallStateChange0004L()
+ {
+ DefinePropeties( EFalse, EVersion2 );
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TRequestStatus status( KErrNone );
+ TInt callId( 1 );
+ RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );
+ RMobileCall::TMobileCallParamsV7 callParams;
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ callParams.iInterval = 100;
+ callParams.iWaitForDialTone = RCall::EDialToneWait;
+ callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ callParams.iCug.iExplicitInvoke = EFalse;
+ callParams.iCug.iCugIndex = 0xFFFF;
+ callParams.iCug.iSuppressPrefCug = EFalse;
+ callParams.iCug.iSuppressOA = EFalse;
+ callParams.iAutoRedial = EFalse;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iService = mobileService;
+ callInfo.iStatus = RMobileCall::EStatusUnknown;
+ callInfo.iCallId =-1;
+ callInfo.iExitCode =0;
+ callInfo.iEmergency =0;
+ callInfo.iForwarded =0;
+ callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+ RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);
+ TMockLtsyCallData0 mockData0(callId, mobileService);
+
+ RCall::TCallParams callParamsX1;
+ TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);
+
+ TRequestStatus mockLtsyStatus( KErrNone );
+ RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting );
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus );
+
+ TInt hangUpCause( KErrGsmReleaseByUser );
+ TBool autoStChangeDisable ( ETrue );
+
+ TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable );
+
+ RLine line;
+ RMobileCall call;
+
+ //-------------------------------------------------------------------------
+ // Test A: Test multiple clients requesting MTelephonyAudioControl::CallStateChange
+ //-------------------------------------------------------------------------
+ // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband -> EStatusIdle
+
+ // reset line & call
+ TInt error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // dial the call
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ AssertMockLtsyStatusL();
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that call status it is OK
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ AssertMockLtsyStatusL();
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ AssertMockLtsyStatusL();
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ AssertMockLtsyStatusL();
+
+ // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting
+
+ // Open second client
+ RTelServer telServer2;
+ error = telServer2.Connect();
+ ASSERT_EQUALS( KErrNone, error );
+ CleanupClosePushL( telServer2 );
+
+ RMobilePhone phone2;
+ error = phone2.Open( telServer2,KMmTsyPhoneName );
+ ASSERT_EQUALS( KErrNone, error );
+ CleanupClosePushL( phone2 );
+
+ RLine line2;
+ error = line2.Open( phone2, KMmTsyVoice1LineName );
+ CleanupClosePushL( line2 );
+ ASSERT_EQUALS( KErrNone, error );
+
+ RMobileCall call2;
+ error = call2.OpenNewCall( line2 );
+ CleanupClosePushL( call2 );
+ ASSERT_EQUALS( KErrNone, error );
+
+ TInt callId2( 2 );
+ // prepare MockLTSY for call 2 dial
+ TMockLtsyCallData0 mockData01(callId2, mobileService);
+ CallGetMobileCallInfoL(callId2, mobileService, KPhoneNumber);
+ RMobileCall::TMobileCallInfoV8 callInfo2;
+ callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo2.iService = mobileService;
+ callInfo2.iStatus = RMobileCall::EStatusUnknown;
+ callInfo2.iCallId =-1;
+ callInfo2.iExitCode =0;
+ callInfo2.iEmergency =0;
+ callInfo2.iForwarded =0;
+ callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData3(0, mobileService, callParams, callInfo2);
+ mockData3.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData01.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // make the call 2
+ call2.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ AssertMockLtsyStatusL();
+
+ error = call2.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // check that call status it is OK
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call2, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ AssertMockLtsyStatusL();
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call2, RMobileCall::EStatusConnecting );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ AssertMockLtsyStatusL();
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call2, RMobileCall::EStatusConnected );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ TInt callCount(0);
+ error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // there should be 2 calls now
+ ASSERT_EQUALS( 2, callCount );
+
+ // hangup call 1
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+ UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ error = call2.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // hangup call 2
+ // change call status and check it is OK
+ UpdateCallStatusL( call2, RMobileCall::EStatusDisconnectingWithInband, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call2, RMobileCall::EStatusIdle, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ // cleanup
+ CleanupStack::PopAndDestroy( &call2 );
+ CleanupStack::PopAndDestroy( &line2 );
+ CleanupStack::PopAndDestroy( &phone2 );
+ CleanupStack::PopAndDestroy( &telServer2 );
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+ CleanupStack::PopAndDestroy( &completeData );
+ CleanupStack::PopAndDestroy( &expectData );
+ CleanupStack::PopAndDestroy( &data );
+ CleanupStack::PopAndDestroy( this );
+ }
+
+void CCTsyTelephonyAudioControlFU::UpdateCallStatusL( RMobileCall& aMobileCall,
+ RMobileCall::TMobileCallStatus aMobileCallStatus,
+ TBool aUpdateTimer,
+ TBool aHangUp )
+ {
+ RMobileCall::TMobileCallInfoV1 callInfo;
+ RMobileCall::TMobileCallInfoV1Pckg callInfoPckg( callInfo );
+ TInt error = aMobileCall.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData(callInfo.iCallId, callInfo.iService, aMobileCallStatus );
+ completeData.Close();
+ mockCallData.SerialiseL(completeData);
+
+ TRequestStatus mockLtsyStatus( KErrNone );
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData );
+
+ if ( aHangUp )
+ {
+ TInt callId( 1 );
+ RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );
+ RMobileCall::TMobileCallParamsV1 callParams;
+ TInt hangUpCause( KErrGsmReleaseByUser );
+ TBool autoStChangeDisable ( ETrue );
+ TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable );
+ expectData.Close();
+ mockHangUpData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );
+ }
+
+ if ( aUpdateTimer )
+ {
+ // when call becomes idle, remaining duration of the call is added to life time param in LTSY:
+ TUint32 duration = 9; // this is a dummy value, which won't be checked by mocksy engine
+ TMockLtsyData1<TUint32> timerData( duration );
+ expectData.Close();
+ timerData.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EMmTsyUpdateLifeTimeIPC, expectData);
+ }
+
+ User::WaitForRequest(mockLtsyStatus);
+
+ AssertMockLtsyStatusL();
+
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int() );
+
+ CleanupStack::PopAndDestroy( &expectData );
+ CleanupStack::PopAndDestroy( &completeData );
+
+ error = aMobileCall.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+ }
+
+void CCTsyTelephonyAudioControlFU::CheckCallRoutingValues( RLine& aLine, RMobileCall& aCall )
+ {
+ TInt callCount(0);
+ TInt error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ TInt count(0);
+ error = aLine.EnumerateCall( count );
+ ASSERT_EQUALS( KErrNone, error );
+ ASSERT_EQUALS( callCount, count );
+
+ RMobileCall::TMobileCallInfoV1 callInfo;
+ RMobileCall::TMobileCallInfoV1Pckg callInfoPckg( callInfo );
+ error = aCall.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ TName callName;
+ error = RProperty::Get( KMockLtsyFactoryProperty, ECallName, callName );
+ ASSERT_EQUALS( KErrNone, error );
+ ASSERT_EQUALS( 0, callInfo.iCallName.Compare( callName ) );
+
+ TBool emergency( ETrue );
+ error = RProperty::Get( KMockLtsyFactoryProperty, EEmergencyCall, emergency );
+ ASSERT_EQUALS( KErrNone, error );
+ ASSERT_EQUALS( emergency, callInfo.iEmergency );
+
+ TInt direction(0);
+ error = RProperty::Get( KMockLtsyFactoryProperty, ECallDirection, direction );
+ RMobileCall::TMobileCallDirection calldirection = (RMobileCall::TMobileCallDirection) direction;
+ ASSERT_EQUALS( KErrNone, error );
+ ASSERT_EQUALS( calldirection, callInfo.iRemoteParty.iDirection );
+
+ TInt callType( 0 );
+ error = RProperty::Get( KMockLtsyFactoryProperty, ECallType, callType );
+ MTelephonyAudioControl::TTelephonyAudioControlCallType callRoutingType = ( MTelephonyAudioControl::TTelephonyAudioControlCallType ) callType;
+ ASSERT_EQUALS( KErrNone, error );
+ ASSERT_EQUALS( callRoutingType, MTelephonyAudioControl::ECallTypeVoice );
+ }
+
+
+void CCTsyTelephonyAudioControlFU::DefinePropeties( TBool aReset, TMockLtsyFactoryVersions aVersion )
+ {
+ DeletePropeties();
+
+ TInt error = RProperty::Define( KMockLtsyFactoryProperty, ENumberOfCalls, RProperty::EInt );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Define( KMockLtsyFactoryProperty, ECallName, RProperty::EText );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Define( KMockLtsyFactoryProperty, EEmergencyCall, RProperty::EInt );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Define( KMockLtsyFactoryProperty, ECallDirection, RProperty::EInt );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Define( KMockLtsyFactoryProperty, EHangUpReason, RProperty::EInt );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Define( KMockLtsyFactoryProperty, ECallType, RProperty::EInt );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Define( KMockLtsyFactoryProperty, EReturnErrorCode, RProperty::EInt );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Define( KMockLtsyFactoryProperty, EReset, RProperty::EInt );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Define( KMockLtsyFactoryProperty, ECallStatus, RProperty::EInt );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EReset, aReset );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Define( KMockLtsyFactoryProperty, EVersionProperty, RProperty::EInt );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EVersionProperty, aVersion );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Define( KMockLtsyFactoryProperty, EComplete, RProperty::EInt );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EComplete, EFalse );
+ ASSERT_EQUALS( KErrNone, error );
+ }
+
+
+void CCTsyTelephonyAudioControlFU::CheckCallStatus( TName& aCallName, RMobileCall::TMobileCallStatus aMobileCallStatus )
+ {
+ TName callName;
+ TInt error = RProperty::Get( KMockLtsyFactoryProperty, ECallName, callName );
+ ASSERT_EQUALS( KErrNone, error );
+ ASSERT_EQUALS( 0, aCallName.Compare( callName ) );
+
+ TInt status( 0 );
+ error = RProperty::Get( KMockLtsyFactoryProperty, ECallStatus, status );
+ RMobileCall::TMobileCallStatus callStatus = ( RMobileCall::TMobileCallStatus ) status;
+ ASSERT_EQUALS( KErrNone, error );
+ ASSERT_EQUALS( callStatus, aMobileCallStatus );
+ }
+
+void CCTsyTelephonyAudioControlFU::DeletePropeties()
+ {
+ TInt error = RProperty::Delete(KMockLtsyFactoryProperty, ENumberOfCalls );
+ error = RProperty::Delete(KMockLtsyFactoryProperty, ECallName );
+ error = RProperty::Delete(KMockLtsyFactoryProperty, EEmergencyCall );
+ error = RProperty::Delete(KMockLtsyFactoryProperty, ECallDirection );
+ error = RProperty::Delete(KMockLtsyFactoryProperty, EHangUpReason );
+ error = RProperty::Delete(KMockLtsyFactoryProperty, ECallType );
+ error = RProperty::Delete(KMockLtsyFactoryProperty, EReturnErrorCode );
+ error = RProperty::Delete(KMockLtsyFactoryProperty, EReset );
+ error = RProperty::Delete(KMockLtsyFactoryProperty, ECallStatus );
+ error = RProperty::Delete(KMockLtsyFactoryProperty, EVersionProperty );
+ error = RProperty::Delete(KMockLtsyFactoryProperty, EComplete );
+ }
+
+void CCTsyTelephonyAudioControlFU::CheckNoCallRouting()
+ {
+ // check that there is no calls in call routing control
+ TInt callCount(0);
+ TInt error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // there should not be any calls
+ ASSERT_EQUALS( 0, callCount );
+
+ // check that the call name is still undefined
+ TName callName;
+ error = RProperty::Get( KMockLtsyFactoryProperty, ECallName, callName );
+ ASSERT_EQUALS( KErrNone, error );
+ ASSERT_EQUALS( 0, callName.Compare( KNullDesC ) );
+ }
+
+CCTsyTelephonyAudioControlFU::~CCTsyTelephonyAudioControlFU()
+ {
+ DeletePropeties();
+ }
+
+void CCTsyTelephonyAudioControlFU::TestNotifyTelephonyAudioControlError0001L()
+ {
+ DefinePropeties( ETrue, EVersion2 );
+
+ OpenEtelServerL(EUseExtendedError);
+ CleanupStack::PushL(TCleanupItem(Cleanup,this));
+ OpenPhoneL();
+
+ RBuf8 data;
+ CleanupClosePushL(data);
+
+ RBuf8 expectData;
+ CleanupClosePushL(expectData);
+
+ RBuf8 completeData;
+ CleanupClosePushL(completeData);
+
+ TRequestStatus status( KErrNone );
+ TInt callId( 1 );
+ RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );
+ RMobileCall::TMobileCallParamsV7 callParams;
+ RMobileCall::TMobileCallInfoV8 callInfo;
+ callParams.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ callParams.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ callParams.iInterval = 100;
+ callParams.iWaitForDialTone = RCall::EDialToneWait;
+ callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ callParams.iCug.iExplicitInvoke = EFalse;
+ callParams.iCug.iCugIndex = 0xFFFF;
+ callParams.iCug.iSuppressPrefCug = EFalse;
+ callParams.iCug.iSuppressOA = EFalse;
+ callParams.iAutoRedial = EFalse;
+ callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo.iService = mobileService;
+ callInfo.iStatus = RMobileCall::EStatusUnknown;
+ callInfo.iCallId =-1;
+ callInfo.iExitCode =0;
+ callInfo.iEmergency =0;
+ callInfo.iForwarded =0;
+ callInfo.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);
+ TMockLtsyCallData0 mockData0(callId, mobileService);
+
+ RCall::TCallParams callParamsX1;
+ TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);
+
+ TRequestStatus mockLtsyStatus( KErrNone );
+ RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting );
+
+ TInt hangUpCause( KErrGsmReleaseByUser );
+ TBool autoStChangeDisable ( EFalse );
+
+ TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable );
+
+ RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo );
+
+ RLine line;
+ RMobileCall call;
+
+ //-------------------------------------------------------------------------
+ // TEST A: failure to dispatch request to LTSY
+ //-------------------------------------------------------------------------
+
+ // DialL
+
+ // error when call is in RMobileCall::EStatusDialling
+
+ // reset the properties to ensure to get valid data
+ DefinePropeties( ETrue, EVersion2 );
+
+ // reset line & call
+ TInt error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData2.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // make the call where SetupTelephonyAudio fails
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNotSupported );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling, EFalse, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNone );
+ ASSERT_EQUALS( KErrNone, error );
+
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+
+ // DialL
+
+ // error when call is in RMobileCall::EStatusDialling
+ // in VoiceLine 2
+
+ // reset the properties to ensure to get valid data
+ DefinePropeties( ETrue, EVersion2 );
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice2LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ RMobilePhone::TMobileService mobileService2( RMobilePhone::EAuxVoiceService );
+ RMobileCall::TMobileCallParamsV7 callParams2;
+ RMobileCall::TMobileCallInfoV8 callInfo2;
+ callParams2.iSpeakerControl = RCall::EMonitorSpeakerControlOnUntilCarrier;
+ callParams2.iSpeakerVolume = RCall::EMonitorSpeakerVolumeLow;
+ callParams2.iInterval = 100;
+ callParams2.iWaitForDialTone = RCall::EDialToneWait;
+ callParams2.iIdRestrict = RMobileCall::EIdRestrictDefault;
+ callParams2.iCug.iExplicitInvoke = EFalse;
+ callParams2.iCug.iCugIndex = 0xFFFF;
+ callParams2.iCug.iSuppressPrefCug = EFalse;
+ callParams2.iCug.iSuppressOA = EFalse;
+ callParams2.iAutoRedial = EFalse;
+ callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo2.iService = mobileService2;
+ callInfo2.iStatus = RMobileCall::EStatusUnknown;
+ callInfo2.iCallId =-1;
+ callInfo2.iExitCode =0;
+ callInfo2.iEmergency =0;
+ callInfo2.iForwarded =0;
+ callInfo2.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo2.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData3(0, mobileService2, callParams2, callInfo2);
+ TMockLtsyCallData0 mockData4(callId, mobileService2);
+
+ RCall::TCallParams callParamsX2;
+ TPckg<RCall::TCallParams> pckgCallParamsX2(callParamsX2);
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService2, KPhoneNumber );
+ mockData3.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData4.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // make the call where SetupTelephonyAudio fails
+ call.Dial( status, pckgCallParamsX2, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNotSupported );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling, EFalse, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNone );
+ ASSERT_EQUALS( KErrNone, error );
+
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+
+ // error when call is in RMobileCall::EStatusConnecting
+
+ // reset the properties to ensure to get valid data
+ DefinePropeties( ETrue, EVersion2 );
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ RMobileCall::TMobileCallInfoV8 callInfo3;
+ callInfo3.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;
+ callInfo3.iService = mobileService;
+ callInfo3.iStatus = RMobileCall::EStatusUnknown;
+ callInfo3.iCallId =-1;
+ callInfo3.iExitCode =0;
+ callInfo3.iEmergency =0;
+ callInfo3.iForwarded =0;
+ callInfo3.iPrivacy = RMobilePhone::EPrivacyUnspecified;
+ callInfo3.iAlternatingCall = RMobilePhone::EAlternatingModeUnspecified;
+ callInfo3.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;
+ callInfo3.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;
+ callInfo3.iDialledParty.iTelNumber.Copy( KPhoneNumber );
+ TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData5(0, mobileService, callParams, callInfo3);
+ mockData5.SerialiseL(expectData);
+
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // make the call where SetupTelephonyAudio fails
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNotSupported );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting, EFalse, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNone );
+ ASSERT_EQUALS( KErrNone, error );
+
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+
+ // error when call is in RMobileCall::EStatusConnected
+
+ // reset the properties to ensure to get valid data
+ DefinePropeties( ETrue, EVersion2 );
+
+ // reset line & call
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = call.OpenNewCall( line );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // prepare MockLTSY
+ CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);
+ mockData5.SerialiseL(expectData);
+ iMockLTSY.ExpectL(EEtelCallDial, expectData);
+ mockData0.SerialiseL(completeData);
+ iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);
+
+ // make the call where SetupTelephonyAudio fails
+ call.Dial( status, pckgCallParamsX1, KPhoneNumber );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusDialling );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnecting, EFalse, EFalse );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNotSupported );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusConnected, EFalse, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNone );
+ ASSERT_EQUALS( KErrNone, error );
+
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue, EFalse );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ // cleanup
+ AssertMockLtsyStatusL();
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+
+ // error when call is in RMobileCall::EStatusAnswering
+
+ // reset the properties to ensure to get valid data
+ DefinePropeties( ETrue, EVersion2 );
+
+ // reset line
+ error = line.Open( iPhone, KMmTsyVoice1LineName );
+ CleanupClosePushL( line );
+ ASSERT_EQUALS( KErrNone, error );
+
+ TName incomingCallName;
+ TRequestStatus requestNotify( KErrNone );
+ line.NotifyIncomingCall( status, incomingCallName);
+
+ TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo );
+ mockCallData.SerialiseL( completeData );
+
+ iMockLTSY.NotifyTerminated( mockLtsyStatus );
+ iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ;
+ User::WaitForRequest( mockLtsyStatus );
+
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() );
+
+ User::WaitForRequest( requestNotify );
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS( KErrNone, requestNotify.Int() );
+
+ mobileCallStatus = RMobileCall::EStatusRinging;
+ TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus );
+ completeData.Close();
+ mockCallData2.SerialiseL(completeData);
+
+ iMockLTSY.NotifyTerminated(mockLtsyStatus);
+ iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);
+ User::WaitForRequest(mockLtsyStatus);
+ AssertMockLtsyStatusL();
+ ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());
+
+ expectData.Close();
+ mockData0.SerialiseL( expectData );
+ iMockLTSY.ExpectL( EEtelCallAnswer, expectData );
+ iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData );
+
+ // reset the call
+ error = call.OpenExistingCall( line, incomingCallName );
+ CleanupClosePushL( call );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // answer the call
+ call.AnswerIncomingCall( status, pckgCallParamsX1 );
+ User::WaitForRequest( status );
+ ASSERT_EQUALS( KErrNone, status.Int() );
+
+ error = call.GetMobileCallInfo( callInfoPckg );
+ ASSERT_EQUALS( KErrNone, error );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNotSupported );
+ ASSERT_EQUALS( KErrNone, error );
+
+ // change call status and check it is OK
+ UpdateCallStatusL( call, RMobileCall::EStatusAnswering, EFalse, ETrue );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusAnswering );
+
+ error = RProperty::Set( KMockLtsyFactoryProperty, EReturnErrorCode, KErrNone );
+ ASSERT_EQUALS( KErrNone, error );
+
+ UpdateCallStatusL( call, RMobileCall::EStatusIdle, EFalse, EFalse );
+ CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );
+
+ CleanupStack::PopAndDestroy( &call );
+ CleanupStack::PopAndDestroy( &line );
+ AssertMockLtsyStatusL();
+
+ // cleanup
+ CleanupStack::PopAndDestroy( &completeData );
+ CleanupStack::PopAndDestroy( &expectData );
+ CleanupStack::PopAndDestroy( &data );
+ CleanupStack::PopAndDestroy( this );
+ }
+
+// End of File