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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // The TEFUnit test suite for TelephonyAudioControl in the Common TSY.

    15 // 

    16 //

    17 

    18 #include "cctsytelephonyaudiocontrolfu.h"

    19 #include <etel.h>

    20 #include <etelmm.h>

    21 #include <ctsy/mmtsy_names.h>

    22 #include <et_clsvr.h>

    23 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>

    24 #include <e32property.h>

    25 #include "tmockltsydata.h"

    26 #include <ctsy/serviceapi/gsmerror.h>

    27 #include <ctsy/pluginapi/mtelephonyaudiocontrol.h>

    28 

    29 _LIT( KPhoneNumber, "101632960000" );  

    30 

    31 CTestSuite* CCTsyTelephonyAudioControlFU::CreateSuiteL(const TDesC& aName)

    32     {

    33     SUB_SUITE;

    34 

    35     ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestSetupTelephonyAudio0001aL);

    36     ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestSetupTelephonyAudio0001bL);

    37     ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestSetupTelephonyAudio0004L);

    38     ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestTeardownTelephonyAudio0001aL);

    39     ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestTeardownTelephonyAudio0001bL);    

    40     ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestTeardownTelephonyAudio0004L);

    41     ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestCallStateChange0001aL);

    42     ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestCallStateChange0001bL);

    43     ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestCallStateChange0004L);

    44     ADD_TEST_STEP_ISO_CPP(CCTsyTelephonyAudioControlFU, TestNotifyTelephonyAudioControlError0001L );

    45 

    46     END_SUITE;

    47     }

    48 

    49 //

    50 // Actual test cases

    51 //

    52 

    53 

    54 /**

    55 @SYMTestCaseID BA-CTSY-CRC-CRCSUCR-0001a

    56 @SYMComponent  telephony_ctsy

    57 @SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::SetUpCallRouting

    58 @SYMTestPriority High

    59 @SYMTestActions Invokes MTelephonyAudioControl::SetUpCallRouting

    60 @SYMTestExpectedResults Pass

    61 @SYMTestType CT

    62  */   

    63 void CCTsyTelephonyAudioControlFU::TestSetupTelephonyAudio0001aL()

    64     {

    65     DefinePropeties( ETrue, EVersion2 );

    66 

    67     OpenEtelServerL(EUseExtendedError);

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

    69     OpenPhoneL();

    70 

    71     RBuf8 data;

    72     CleanupClosePushL(data);

    73 

    74     RBuf8 expectData;

    75     CleanupClosePushL(expectData);

    76 

    77     RBuf8 completeData;

    78     CleanupClosePushL(completeData);

    79 

    80     TRequestStatus status( KErrNone );

    81     TInt callId( 1 );

    82     RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );

    83     RMobileCall::TMobileCallParamsV7 callParams; 

    84     RMobileCall::TMobileCallInfoV8 callInfo;   

    85     callParams.iSpeakerControl  = RCall::EMonitorSpeakerControlOnUntilCarrier;

    86     callParams.iSpeakerVolume   = RCall::EMonitorSpeakerVolumeLow;

    87     callParams.iInterval        = 100;

    88     callParams.iWaitForDialTone = RCall::EDialToneWait;

    89     callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;

    90     callParams.iCug.iExplicitInvoke = EFalse;

    91     callParams.iCug.iCugIndex = 0xFFFF;

    92     callParams.iCug.iSuppressPrefCug = EFalse;

    93     callParams.iCug.iSuppressOA = EFalse;

    94     callParams.iAutoRedial = EFalse;

    95     callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;    

    96     callInfo.iService   = mobileService;

    97     callInfo.iStatus    = RMobileCall::EStatusUnknown;

    98     callInfo.iCallId    =-1;

    99     callInfo.iExitCode  =0; 

   100     callInfo.iEmergency =0;

   101     callInfo.iForwarded =0; 

   102     callInfo.iPrivacy               = RMobilePhone::EPrivacyUnspecified;

   103     callInfo.iAlternatingCall       = RMobilePhone::EAlternatingModeUnspecified;    

   104     callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;

   105     callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;   

   106     callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );

   107     TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);

   108     TMockLtsyCallData0 mockData0(callId, mobileService);

   109 

   110     RCall::TCallParams callParamsX1;

   111     TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);

   112 

   113     TRequestStatus mockLtsyStatus( KErrNone );

   114     RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting );

   115     TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus );

   116 

   117     TInt hangUpCause( KErrGsmReleaseByUser );

   118     TBool autoStChangeDisable ( EFalse );

   119 

   120     TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable );

   121 

   122     RLine line;

   123     RMobileCall call;

   124 

   125     //-------------------------------------------------------------------------

   126     // TEST C: Successful completion request of

   127     // MTelephonyAudioControl::SetUpCallRouting when result is not cached.

   128     //-------------------------------------------------------------------------

   129 

   130     // DialL

   131 

   132     // reset the properties to ensure to get valid data

   133     DefinePropeties( ETrue, EVersion2 );

   134 

   135     // reset line & call

   136     TInt error = line.Open( iPhone, KMmTsyVoice1LineName );

   137     CleanupClosePushL( line );

   138     ASSERT_EQUALS( KErrNone, error );

   139 

   140     error = call.OpenNewCall( line );

   141     CleanupClosePushL( call );

   142     ASSERT_EQUALS( KErrNone, error );

   143 

   144     // prepare MockLTSY

   145     CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);

   146     mockData2.SerialiseL(expectData);

   147     iMockLTSY.ExpectL(EEtelCallDial, expectData);

   148     mockData0.SerialiseL(completeData);

   149     iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);

   150 

   151     // make the call

   152     call.Dial( status, pckgCallParamsX1, KPhoneNumber );

   153     User::WaitForRequest( status );

   154     ASSERT_EQUALS( KErrNone, status.Int() );

   155 

   156     // check that values passed to the SetupCallRouting were valid

   157     CheckCallRoutingValues( line, call );

   158 

   159     // cleanup 

   160     AssertMockLtsyStatusL();   

   161     CleanupStack::PopAndDestroy( &call );

   162     CleanupStack::PopAndDestroy( &line );

   163 

   164     // DialNoFdnCheck 

   165 

   166     // reset line and call

   167     error = line.Open( iPhone, KMmTsyVoice1LineName );

   168     CleanupClosePushL( line );

   169     ASSERT_EQUALS( KErrNone, error );

   170 

   171     error = call.OpenNewCall( line );

   172     CleanupClosePushL( call );

   173     ASSERT_EQUALS( KErrNone, error );

   174 

   175     // prepare MockLTSY

   176     CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);

   177     expectData.Close();

   178     mockData2.SerialiseL(expectData);

   179     iMockLTSY.ExpectL(EMobileCallDialNoFdnCheck, expectData);

   180     completeData.Close();

   181     mockData0.SerialiseL(completeData);

   182     iMockLTSY.CompleteL(EMobileCallDialNoFdnCheck, KErrNone, completeData);

   183 

   184     // make the call    

   185     call.DialNoFdnCheck( status, pckgCallParamsX1, KPhoneNumber );

   186     User::WaitForRequest( status );

   187     ASSERT_EQUALS( KErrNone, status.Int() );

   188 

   189     // check that values passed to the SetupCallRouting were valid

   190     CheckCallRoutingValues( line, call ); 

   191 

   192     // cleanup 

   193     AssertMockLtsyStatusL();

   194     CleanupStack::PopAndDestroy( &call );

   195     CleanupStack::PopAndDestroy( &line );    

   196     AssertMockLtsyStatusL();

   197 

   198     // DialISV

   199 

   200     // reset the properties to ensure to get valid data

   201     DefinePropeties( ETrue, EVersion2 );

   202 

   203     // reset line and call

   204     error = line.Open( iPhone, KMmTsyVoice1LineName );

   205     CleanupClosePushL( line );

   206     ASSERT_EQUALS( KErrNone, error );

   207 

   208     error = call.OpenNewCall( line );

   209     CleanupClosePushL( call );

   210     ASSERT_EQUALS( KErrNone, error );

   211 

   212     // prepare MockLTSY

   213     CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);

   214     expectData.Close();

   215     mockData2.SerialiseL(expectData);

   216     iMockLTSY.ExpectL(EEtelCallDial, expectData);

   217     completeData.Close();

   218     mockData0.SerialiseL(completeData);

   219     iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);

   220 

   221     call.DialISV( status, pckgCallParamsX1, KPhoneNumber );

   222     User::WaitForRequest( status );

   223     ASSERT_EQUALS( KErrNone, status.Int() );

   224 

   225     // check that values passed to the SetupCallRouting were valid

   226     CheckCallRoutingValues( line, call ); 

   227 

   228     // cleanup 

   229     AssertMockLtsyStatusL();

   230     CleanupStack::PopAndDestroy( &call );

   231     CleanupStack::PopAndDestroy( &line );

   232     AssertMockLtsyStatusL();

   233 

   234     // Ghost Call

   235 

   236     // reset the properties to ensure to get valid data

   237     DefinePropeties( ETrue, EVersion2 );

   238 

   239     // reset line

   240     error = line.Open( iPhone, KMmTsyVoice1LineName );

   241     CleanupClosePushL( line );

   242     ASSERT_EQUALS( KErrNone, error );

   243 

   244     // order NotifyStatusChange event

   245     RCall::TStatus callStatus( RCall::EStatusIdle );  

   246     line.NotifyStatusChange( status, callStatus );

   247 

   248     // prepare MockLTSY for NotifyStatusChange event

   249     iMockLTSY.NotifyTerminated(mockLtsyStatus);       

   250     RMobileCall::TMobileCallInfoV1 mobileCallInfo;

   251     mobileCallInfo.iCallId = callId;

   252     mobileCallInfo.iService = mobileService;

   253     mobileCallInfo.iStatus = RMobileCall::EStatusDialling;

   254     mobileCallInfo.iCallName.Copy( _L8("Voice12") );

   255 

   256     TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData1(callId, mobileService, mobileCallInfo);

   257     mockCallData1.SerialiseL(data);        

   258     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);    

   259 

   260     User::WaitForRequest(mockLtsyStatus);

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

   262     User::WaitForRequest(status);

   263     ASSERT_EQUALS(KErrNone, status.Int());    

   264     ASSERT_EQUALS(RCall::EStatusDialling, callStatus);   

   265 

   266     error = call.OpenExistingCall( line, mobileCallInfo.iCallName );

   267     CleanupClosePushL( call );

   268     ASSERT_EQUALS( KErrNone, error );  

   269 

   270     data.Close();

   271     completeCallStatusData.SerialiseL(data);

   272     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   273 

   274     call.NotifyMobileCallStatusChange( status, mobileCallStatus );  

   275     User::WaitForRequest( status );

   276     ASSERT_EQUALS( KErrNone, status.Int() ); 

   277 

   278     AssertMockLtsyStatusL();

   279 

   280     CheckCallStatus( mobileCallInfo.iCallName, RMobileCall::EStatusConnecting );  

   281 

   282     // prepare MockLTSY for hangup

   283     expectData.Close();

   284     mockHangUpData.SerialiseL(expectData);

   285     iMockLTSY.ExpectL( EEtelCallHangUp, expectData, KErrNone );

   286 

   287     // hangup the call by popping the call from the cleanupstack

   288     CleanupStack::PopAndDestroy( &call );

   289     AssertMockLtsyStatusL();    

   290 

   291     CleanupStack::PopAndDestroy( &line );

   292     AssertMockLtsyStatusL();    

   293 

   294     // DialEmergencyCall

   295 

   296     // reset the properties to ensure to get valid data

   297     DefinePropeties( ETrue, EVersion2 );

   298 

   299     // reset line and call

   300     error = line.Open( iPhone, KMmTsyVoice1LineName );

   301     CleanupClosePushL( line );

   302     ASSERT_EQUALS( KErrNone, error );

   303 

   304     error = call.OpenNewCall( line );

   305     CleanupClosePushL( call );

   306     ASSERT_EQUALS( KErrNone, error );

   307 

   308     // set rf on

   309     iMockLTSY.NotifyTerminated( mockLtsyStatus );    

   310     TRfStateInfo rfInfo = ERfsStateInfoNormal;    

   311     TMockLtsyData1<TRfStateInfo> mockData1( rfInfo );

   312     expectData.Close();

   313     mockData1.SerialiseL(expectData);

   314     iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, expectData);

   315     User::WaitForRequest(mockLtsyStatus);

   316     AssertMockLtsyStatusL();

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

   318 

   319     // the emergency number

   320     RMobileENStore::TEmergencyNumber number(_L("911"));

   321     TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData( number );    

   322 

   323     CallGetMobileCallInfoL(callId, mobileService, number );

   324 

   325     // prepare MockLTSY for EMobileCallDialEmergencyCall

   326     data.Close();

   327     numberLtsyData.SerialiseL(data);

   328     iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   329 

   330     TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> completeCallInfoData( callId, mobileService, callInfo );

   331 

   332     // send EStatusDialling, EStatusConnecting and EStatusConnected events to complete DialEmergencyCall

   333     data.Close();

   334     completeCallInfoData.SerialiseL(data);

   335     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   336 

   337     mobileCallStatus = RMobileCall::EStatusDialling;

   338     completeCallStatusData.SerialiseL(data);

   339     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   340 

   341     data.Close();

   342     mobileCallStatus = RMobileCall::EStatusConnecting;

   343     completeCallStatusData.SerialiseL(data);

   344     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   345 

   346     data.Close();

   347     mobileCallStatus = RMobileCall::EStatusConnected;

   348     completeCallStatusData.SerialiseL(data);

   349     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   350 

   351     // On return, KErrNone if the emergency call successfully reaches the connected state.

   352     call.DialEmergencyCall( status, number );

   353     User::WaitForRequest( status );

   354     ASSERT_EQUALS( KErrNone, status.Int() );

   355 

   356     // check that values passed to the SetupCallRouting were valid

   357     CheckCallRoutingValues( line, call ); 

   358 

   359     // prepare MockLTSY for hangup 

   360     expectData.Close();

   361     mockHangUpData.SerialiseL(expectData);

   362     iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );

   363 

   364     // hangup the call by popping the call from the cleanupstack

   365     CleanupStack::PopAndDestroy( &call );

   366     AssertMockLtsyStatusL();    

   367 

   368     // cleanup

   369     CleanupStack::PopAndDestroy( &line );

   370     AssertMockLtsyStatusL();   

   371 

   372     // answer incoming call

   373 

   374     // reset the properties to ensure to get valid data

   375     DefinePropeties( ETrue, EVersion2 );

   376 

   377     // reset line

   378     error = line.Open( iPhone, KMmTsyVoice1LineName );

   379     CleanupClosePushL( line );

   380     ASSERT_EQUALS( KErrNone, error );

   381 

   382     TName incomingCallName;

   383     TRequestStatus requestNotify( KErrNone );

   384     line.NotifyIncomingCall( status, incomingCallName);

   385 

   386     TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo );

   387     mockCallData.SerialiseL( completeData );

   388 

   389     iMockLTSY.NotifyTerminated( mockLtsyStatus );

   390     iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ;

   391     User::WaitForRequest( mockLtsyStatus );

   392 

   393     AssertMockLtsyStatusL();

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

   395 

   396     User::WaitForRequest( requestNotify );

   397     AssertMockLtsyStatusL();

   398     ASSERT_EQUALS( KErrNone, requestNotify.Int() );

   399 

   400     mobileCallStatus = RMobileCall::EStatusRinging;

   401     TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus );

   402     completeData.Close();

   403     mockCallData2.SerialiseL(completeData);

   404 

   405     iMockLTSY.NotifyTerminated(mockLtsyStatus);

   406     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);

   407     User::WaitForRequest(mockLtsyStatus);

   408     AssertMockLtsyStatusL();

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

   410 

   411     expectData.Close();

   412     mockData0.SerialiseL( expectData );

   413     iMockLTSY.ExpectL( EEtelCallAnswer, expectData );

   414     iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData );

   415 

   416     // reset the call

   417     error = call.OpenExistingCall( line, incomingCallName );

   418     CleanupClosePushL( call );

   419     ASSERT_EQUALS( KErrNone, error ); 

   420 

   421     // answer the call

   422     call.AnswerIncomingCall( status, pckgCallParamsX1 );

   423     User::WaitForRequest( status );

   424     ASSERT_EQUALS( KErrNone, status.Int() );

   425 

   426     // check that values passed to the SetupCallRouting were valid

   427     CheckCallRoutingValues( line, call ); 

   428 

   429     // prepare MockLTSY for hangup 

   430     expectData.Close();

   431     mockHangUpData.SerialiseL(expectData);

   432     iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );

   433 

   434     // hangup the call by popping the call from the cleanupstack

   435     CleanupStack::PopAndDestroy( &call );

   436     AssertMockLtsyStatusL();    

   437 

   438     // cleanup

   439     CleanupStack::PopAndDestroy( &line );

   440     AssertMockLtsyStatusL(); 

   441 

   442     // cleanup 

   443     CleanupStack::PopAndDestroy( &completeData );

   444     CleanupStack::PopAndDestroy( &expectData );    

   445     CleanupStack::PopAndDestroy( &data );

   446     CleanupStack::PopAndDestroy( this );

   447     }

   448 

   449 

   450 /**

   451 @SYMTestCaseID BA-CTSY-CRC-CRCSUCR-0001b

   452 @SYMComponent  telephony_ctsy

   453 @SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::SetUpCallRouting by using LTSY version1

   454 @SYMTestPriority High

   455 @SYMTestActions Test that call routing is not set up

   456 @SYMTestExpectedResults Pass

   457 @SYMTestType CT

   458  */ 

   459 void CCTsyTelephonyAudioControlFU::TestSetupTelephonyAudio0001bL()

   460     {

   461     DefinePropeties( ETrue, EVersion1 );

   462 

   463     OpenEtelServerL(EUseExtendedError);

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

   465     OpenPhoneL();

   466 

   467     RBuf8 expectData;

   468     CleanupClosePushL(expectData);

   469 

   470     RBuf8 completeData;

   471     CleanupClosePushL(completeData);

   472 

   473     RBuf8 data;

   474     CleanupClosePushL(data);

   475 

   476     TRequestStatus status( KErrNone );

   477     TInt callId( 1 );

   478     RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );

   479     RMobileCall::TMobileCallParamsV7 callParams; 

   480     RMobileCall::TMobileCallInfoV8 callInfo;   

   481     callParams.iSpeakerControl  = RCall::EMonitorSpeakerControlOnUntilCarrier;

   482     callParams.iSpeakerVolume   = RCall::EMonitorSpeakerVolumeLow;

   483     callParams.iInterval        = 100;

   484     callParams.iWaitForDialTone = RCall::EDialToneWait;

   485     callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;

   486     callParams.iCug.iExplicitInvoke = EFalse;

   487     callParams.iCug.iCugIndex = 0xFFFF;

   488     callParams.iCug.iSuppressPrefCug = EFalse;

   489     callParams.iCug.iSuppressOA = EFalse;

   490     callParams.iAutoRedial = EFalse;

   491     callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;    

   492     callInfo.iService   = mobileService;

   493     callInfo.iStatus    = RMobileCall::EStatusUnknown;

   494     callInfo.iCallId    =-1;

   495     callInfo.iExitCode  =0; 

   496     callInfo.iEmergency =0;

   497     callInfo.iForwarded =0; 

   498     callInfo.iPrivacy               = RMobilePhone::EPrivacyUnspecified;

   499     callInfo.iAlternatingCall       = RMobilePhone::EAlternatingModeUnspecified;    

   500     callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;

   501     callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;   

   502     callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );

   503     TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);

   504     TMockLtsyCallData0 mockData0(callId, mobileService);

   505 

   506     RCall::TCallParams callParamsX1;

   507     TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);

   508 

   509     RLine line;

   510     RMobileCall call;

   511 

   512     //-------------------------------------------------------------------------

   513     // TEST C: Successful completion request of

   514     // MTelephonyAudioControl::SetUpCallRouting when result is not cached.

   515     //-------------------------------------------------------------------------

   516 

   517     // Test that CMockLtsyFactoryV1 is used instead of CMockLtsyFactoryV2

   518 

   519     // DialL

   520 

   521     // reset line & call

   522     TInt error = line.Open( iPhone, KMmTsyVoice1LineName );

   523     CleanupClosePushL( line );

   524     ASSERT_EQUALS( KErrNone, error );

   525 

   526     error = call.OpenNewCall( line );

   527     CleanupClosePushL( call );

   528     ASSERT_EQUALS( KErrNone, error );

   529 

   530     // prepare MockLTSY

   531     CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);

   532     mockData2.SerialiseL(expectData);

   533     iMockLTSY.ExpectL(EEtelCallDial, expectData);

   534     mockData0.SerialiseL(completeData);

   535     iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);

   536 

   537     // make the call

   538     call.Dial( status, pckgCallParamsX1, KPhoneNumber );

   539     User::WaitForRequest( status );

   540     ASSERT_EQUALS( KErrNone, status.Int() );

   541 

   542     // check that there is no call routing done

   543     CheckNoCallRouting();

   544 

   545     // cleanup 

   546     AssertMockLtsyStatusL();   

   547     CleanupStack::PopAndDestroy( &call );

   548     CleanupStack::PopAndDestroy( &line );

   549 

   550     // DialNoFdnCheck 

   551 

   552     // reset the properties to ensure to get valid data

   553     DefinePropeties( ETrue, EVersion1 );

   554 

   555     // reset line and call

   556     error = line.Open( iPhone, KMmTsyVoice1LineName );

   557     CleanupClosePushL( line );

   558     ASSERT_EQUALS( KErrNone, error );

   559 

   560     error = call.OpenNewCall( line );

   561     CleanupClosePushL( call );

   562     ASSERT_EQUALS( KErrNone, error );

   563 

   564     // prepare MockLTSY

   565 

   566     CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);

   567     expectData.Close();

   568     mockData2.SerialiseL(expectData);

   569     iMockLTSY.ExpectL(EMobileCallDialNoFdnCheck, expectData);

   570     completeData.Close();

   571     mockData0.SerialiseL(completeData);

   572     iMockLTSY.CompleteL(EMobileCallDialNoFdnCheck, KErrNone, completeData);

   573 

   574     // make the call    

   575     call.DialNoFdnCheck( status, pckgCallParamsX1, KPhoneNumber );

   576     User::WaitForRequest( status );

   577     ASSERT_EQUALS( KErrNone, status.Int() );

   578 

   579     // check that there is no call routing done

   580     CheckNoCallRouting();

   581 

   582     // cleanup 

   583     AssertMockLtsyStatusL();

   584     CleanupStack::PopAndDestroy( &call );

   585     CleanupStack::PopAndDestroy( &line );    

   586     AssertMockLtsyStatusL();

   587 

   588     // DialEmergencyCall

   589 

   590     // reset the properties to ensure to get valid data

   591     DefinePropeties( ETrue, EVersion1 );

   592 

   593     // reset line and call

   594     error = line.Open( iPhone, KMmTsyVoice1LineName );

   595     CleanupClosePushL( line );

   596     ASSERT_EQUALS( KErrNone, error );

   597 

   598     error = call.OpenNewCall( line );

   599     CleanupClosePushL( call );

   600     ASSERT_EQUALS( KErrNone, error );

   601 

   602     // set rf on

   603     TRequestStatus mockLtsyStatus(KErrNone);

   604     iMockLTSY.NotifyTerminated( mockLtsyStatus );    

   605     TRfStateInfo rfInfo = ERfsStateInfoNormal;    

   606     TMockLtsyData1<TRfStateInfo> mockData1( rfInfo );

   607     expectData.Close();

   608     mockData1.SerialiseL(expectData);

   609     iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, expectData);

   610     User::WaitForRequest(mockLtsyStatus);

   611     AssertMockLtsyStatusL();

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

   613 

   614     // the emergency number

   615     RMobileENStore::TEmergencyNumber number(_L("911"));

   616     TMockLtsyData1<RMobileENStore::TEmergencyNumber> numberLtsyData( number );    

   617 

   618     CallGetMobileCallInfoL(callId, mobileService, number );

   619 

   620     // prepare MockLTSY for EMobileCallDialEmergencyCall

   621     data.Close();

   622     numberLtsyData.SerialiseL(data);

   623     iMockLTSY.ExpectL(EMobileCallDialEmergencyCall, data, KErrNone);

   624 

   625     TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> completeCallInfoData( callId, mobileService, callInfo );

   626 

   627     // send EStatusDialling, EStatusConnecting and EStatusConnected events to complete DialEmergencyCall

   628     data.Close();

   629     completeCallInfoData.SerialiseL(data);

   630     iMockLTSY.CompleteL(EMobileCallGetMobileCallInfo, KErrNone, data);

   631 

   632     RMobileCall::TMobileCallStatus mobileCallStatus(RMobileCall::EStatusDialling);

   633     TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus );

   634     completeCallStatusData.SerialiseL(data);

   635     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   636 

   637     data.Close();

   638     mobileCallStatus = RMobileCall::EStatusConnecting;

   639     completeCallStatusData.SerialiseL(data);

   640     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   641 

   642     data.Close();

   643     mobileCallStatus = RMobileCall::EStatusConnected;

   644     completeCallStatusData.SerialiseL(data);

   645     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, data);

   646 

   647     // On return, KErrNone if the emergency call successfully reaches the connected state.

   648     call.DialEmergencyCall( status, number );

   649     User::WaitForRequest( status );

   650     ASSERT_EQUALS( KErrNone, status.Int() );

   651 

   652     // check that there is no call routing done

   653     CheckNoCallRouting();

   654 

   655     // prepare MockLTSY for hangup 

   656     expectData.Close();

   657     TInt hangUpCause( KErrGsmReleaseByUser );

   658     TBool autoStChangeDisable ( EFalse );

   659     TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable );

   660     mockHangUpData.SerialiseL(expectData);

   661     iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );

   662 

   663     // hangup the call by popping the call from the cleanupstack

   664     CleanupStack::PopAndDestroy( &call );

   665     AssertMockLtsyStatusL();    

   666 

   667     // cleanup

   668     CleanupStack::PopAndDestroy( &line );

   669     AssertMockLtsyStatusL();  

   670 

   671     // cleanup 

   672     CleanupStack::PopAndDestroy( &data );

   673     CleanupStack::PopAndDestroy( &completeData );

   674     CleanupStack::PopAndDestroy( &expectData );    

   675     CleanupStack::PopAndDestroy( this );

   676     }

   677 

   678 /**

   679 @SYMTestCaseID BA-CTSY-CRC-CRCSUCR-0004

   680 @SYMComponent  telephony_ctsy

   681 @SYMTestCaseDesc Test support in CTSY for multiple client requests to MTelephonyAudioControl::SetUpCallRouting

   682 @SYMTestPriority High

   683 @SYMTestActions Invokes multiple client requests to MTelephonyAudioControl::SetUpCallRouting

   684 @SYMTestExpectedResults Pass

   685 @SYMTestType CT

   686  */

   687 void CCTsyTelephonyAudioControlFU::TestSetupTelephonyAudio0004L()

   688     {

   689     DefinePropeties( EFalse, EVersion2 );

   690 

   691     OpenEtelServerL(EUseExtendedError);

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

   693     OpenPhoneL();

   694 

   695     RBuf8 expectData;

   696     CleanupClosePushL(expectData);

   697 

   698     RBuf8 completeData;

   699     CleanupClosePushL(completeData);

   700 

   701     //-------------------------------------------------------------------------

   702     // Test A: Test multiple clients requesting MTelephonyAudioControl::SetUpCallRouting

   703     //-------------------------------------------------------------------------

   704 

   705     TInt callId1( 1 );

   706     RCall::TCallParams callParamsX1;

   707     TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);

   708     RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );

   709     RMobileCall::TMobileCallParamsV7 callParams; 

   710     RMobileCall::TMobileCallInfoV8 callInfo;   

   711     callParams.iSpeakerControl  = RCall::EMonitorSpeakerControlOnUntilCarrier;

   712     callParams.iSpeakerVolume   = RCall::EMonitorSpeakerVolumeLow;

   713     callParams.iInterval        = 100;

   714     callParams.iWaitForDialTone = RCall::EDialToneWait;

   715     callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;

   716     callParams.iCug.iExplicitInvoke = EFalse;

   717     callParams.iCug.iCugIndex = 0xFFFF;

   718     callParams.iCug.iSuppressPrefCug = EFalse;

   719     callParams.iCug.iSuppressOA = EFalse;

   720     callParams.iAutoRedial = EFalse;

   721     callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;    

   722     callInfo.iService   = mobileService;

   723     callInfo.iStatus    = RMobileCall::EStatusUnknown;

   724     callInfo.iCallId    =-1;

   725     callInfo.iExitCode  =0; 

   726     callInfo.iEmergency =0;

   727     callInfo.iForwarded =0; 

   728     callInfo.iPrivacy               = RMobilePhone::EPrivacyUnspecified;

   729     callInfo.iAlternatingCall       = RMobilePhone::EAlternatingModeUnspecified;    

   730     callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;

   731     callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;   

   732     callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );

   733 

   734     RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo );

   735     TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);

   736     TMockLtsyCallData0 mockData0(callId1, mobileService);

   737 

   738     // reset line & call

   739     RLine line;

   740     TInt error = line.Open( iPhone, KMmTsyVoice1LineName );

   741     CleanupClosePushL( line );

   742     ASSERT_EQUALS( KErrNone, error );

   743 

   744     RMobileCall call;

   745     error = call.OpenNewCall( line );

   746     CleanupClosePushL( call );

   747     ASSERT_EQUALS( KErrNone, error );

   748 

   749     // prepare MockLTSY

   750     CallGetMobileCallInfoL(callId1, mobileService, KPhoneNumber);

   751     mockData2.SerialiseL(expectData);

   752     iMockLTSY.ExpectL(EEtelCallDial, expectData);

   753     mockData0.SerialiseL(completeData);

   754     iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);

   755 

   756     // make the call

   757     TRequestStatus status( KErrNone );

   758     call.Dial( status, pckgCallParamsX1, KPhoneNumber );

   759     User::WaitForRequest( status );

   760     ASSERT_EQUALS( KErrNone, status.Int() );

   761 

   762     error = call.GetMobileCallInfo( callInfoPckg );

   763     ASSERT_EQUALS( KErrNone, error );

   764 

   765     // change call status and check it is OK

   766     UpdateCallStatusL( call, RMobileCall::EStatusDialling );

   767     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );

   768 

   769     // change call status and check it is OK

   770     UpdateCallStatusL( call, RMobileCall::EStatusConnecting );

   771     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );

   772 

   773     // change call status and check it is OK

   774     UpdateCallStatusL( call, RMobileCall::EStatusConnected );

   775     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );

   776 

   777     // Open second client

   778     RTelServer telServer2;

   779     error = telServer2.Connect();

   780     ASSERT_EQUALS( KErrNone, error );

   781     CleanupClosePushL( telServer2 );

   782 

   783     RMobilePhone phone2;

   784     error = phone2.Open( iTelServer,KMmTsyPhoneName );

   785     ASSERT_EQUALS( KErrNone, error );

   786     CleanupClosePushL( phone2 );

   787 

   788     RLine line2;

   789     error = line2.Open( phone2, KMmTsyVoice1LineName );

   790     CleanupClosePushL( line2 );

   791     ASSERT_EQUALS( KErrNone, error );

   792 

   793     RMobileCall call2;

   794     error = call2.OpenNewCall( line2 );

   795     CleanupClosePushL( call2 );

   796     ASSERT_EQUALS( KErrNone, error );

   797 

   798     TInt callId2( 2 );

   799     // prepare MockLTSY

   800     RMobileCall::TMobileCallInfoV8 callInfo2;

   801     callInfo2.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;    

   802     callInfo2.iService   = mobileService;

   803     callInfo2.iStatus    = RMobileCall::EStatusUnknown;

   804     callInfo2.iCallId    =-1;

   805     callInfo2.iExitCode  =0; 

   806     callInfo2.iEmergency =0;

   807     callInfo2.iForwarded =0; 

   808     callInfo2.iPrivacy               = RMobilePhone::EPrivacyUnspecified;

   809     callInfo2.iAlternatingCall       = RMobilePhone::EAlternatingModeUnspecified;    

   810     callInfo2.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;

   811     callInfo2.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;   

   812     callInfo2.iDialledParty.iTelNumber.Copy( KPhoneNumber );

   813     TMockLtsyCallData0 mockData01(callId2, mobileService);

   814     CallGetMobileCallInfoL(callId2, mobileService, KPhoneNumber);

   815     TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData3(0, mobileService, callParams, callInfo2);

   816     mockData3.SerialiseL(expectData);

   817     iMockLTSY.ExpectL(EEtelCallDial, expectData);

   818     mockData01.SerialiseL(completeData);

   819     iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);

   820 

   821     // make the call

   822     call2.Dial( status, pckgCallParamsX1, KPhoneNumber );

   823     User::WaitForRequest( status );

   824     ASSERT_EQUALS( KErrNone, status.Int() );

   825 

   826     error = call2.GetMobileCallInfo( callInfoPckg );

   827     ASSERT_EQUALS( KErrNone, error );

   828 

   829     // change call status and check it is OK

   830     UpdateCallStatusL( call2, RMobileCall::EStatusDialling );

   831     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );

   832 

   833     // change call status and check it is OK

   834     UpdateCallStatusL( call2, RMobileCall::EStatusConnecting );

   835     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );

   836 

   837     // change call status and check it is OK

   838     UpdateCallStatusL( call2, RMobileCall::EStatusConnected );

   839     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );

   840 

   841     TInt callCount(0);

   842     error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );

   843     ASSERT_EQUALS( KErrNone, error );

   844 

   845     // there should be 2 calls now

   846     ASSERT_EQUALS( 2, callCount );

   847 

   848     // cleanup 

   849 

   850     // prepare MockLTSY for hangup 

   851     TInt hangUpCause( KErrGsmReleaseByUser );

   852     TBool autoStChangeDisable ( EFalse );

   853     TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId2, mobileService, hangUpCause, autoStChangeDisable );

   854     expectData.Close();

   855     mockHangUpData.SerialiseL(expectData);

   856     iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );

   857 

   858     CleanupStack::PopAndDestroy( &call2 );

   859     CleanupStack::PopAndDestroy( &line2 );

   860     CleanupStack::PopAndDestroy( &phone2 );

   861     CleanupStack::PopAndDestroy( &telServer2 );

   862 

   863     // prepare MockLTSY for hangup 

   864     TMockLtsyCallData2<TInt, TBool> mockHangUpData2( callId1, mobileService, hangUpCause, autoStChangeDisable );

   865     expectData.Close();

   866     mockHangUpData2.SerialiseL(expectData);

   867     iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );

   868     CleanupStack::PopAndDestroy( &call );

   869     CleanupStack::PopAndDestroy( &line );

   870     CleanupStack::PopAndDestroy( &completeData );

   871     CleanupStack::PopAndDestroy( &expectData );    

   872     CleanupStack::PopAndDestroy( this );

   873     }

   874 

   875 /**

   876 @SYMTestCaseID BA-CTSY-CRC-CRCTCR-0001a

   877 @SYMComponent  telephony_ctsy

   878 @SYMTestCaseDesc Test support in CTSY for MTelephonyAudioControl::TeardownCallRouting

   879 @SYMTestPriority High

   880 @SYMTestActions Invokes MTelephonyAudioControl::TeardownCallRouting

   881 @SYMTestExpectedResults Pass

   882 @SYMTestType CT

   883  */

   884 void CCTsyTelephonyAudioControlFU::TestTeardownTelephonyAudio0001aL()

   885     {

   886     DefinePropeties( ETrue, EVersion2 );

   887     OpenEtelServerL(EUseExtendedError);

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

   889     OpenPhoneL();

   890 

   891     RBuf8 expectData;

   892     CleanupClosePushL(expectData);

   893 

   894     RBuf8 completeData;

   895     CleanupClosePushL(completeData);

   896 

   897     TRequestStatus status( KErrNone );

   898     TInt callId( 1 );

   899     RMobilePhone::TMobileService mobileService( RMobilePhone::EVoiceService );

   900     RMobileCall::TMobileCallParamsV7 callParams; 

   901     RMobileCall::TMobileCallInfoV8 callInfo;   

   902     callParams.iSpeakerControl  = RCall::EMonitorSpeakerControlOnUntilCarrier;

   903     callParams.iSpeakerVolume   = RCall::EMonitorSpeakerVolumeLow;

   904     callParams.iInterval        = 100;

   905     callParams.iWaitForDialTone = RCall::EDialToneWait;

   906     callParams.iIdRestrict = RMobileCall::EIdRestrictDefault;

   907     callParams.iCug.iExplicitInvoke = EFalse;

   908     callParams.iCug.iCugIndex = 0xFFFF;

   909     callParams.iCug.iSuppressPrefCug = EFalse;

   910     callParams.iCug.iSuppressOA = EFalse;

   911     callParams.iAutoRedial = EFalse;

   912     callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;    

   913     callInfo.iService   = mobileService;

   914     callInfo.iStatus    = RMobileCall::EStatusUnknown;

   915     callInfo.iCallId    =-1;

   916     callInfo.iExitCode  =0; 

   917     callInfo.iEmergency =0;

   918     callInfo.iForwarded =0; 

   919     callInfo.iPrivacy               = RMobilePhone::EPrivacyUnspecified;

   920     callInfo.iAlternatingCall       = RMobilePhone::EAlternatingModeUnspecified;    

   921     callInfo.iDialledParty.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;

   922     callInfo.iDialledParty.iTypeOfNumber = RMobilePhone::EUnknownNumber;   

   923     callInfo.iDialledParty.iTelNumber.Copy( KPhoneNumber );

   924 

   925     RMobileCall::TMobileCallInfoV8Pckg callInfoPckg( callInfo );

   926     TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1> mockData2(0, mobileService, callParams, callInfo);

   927     TMockLtsyCallData0 mockData0(callId, mobileService);

   928 

   929     RCall::TCallParams callParamsX1;

   930     TPckg<RCall::TCallParams> pckgCallParamsX1(callParamsX1);

   931 

   932     TRequestStatus mockLtsyStatus( KErrNone );

   933     RMobileCall::TMobileCallStatus mobileCallStatus( RMobileCall::EStatusConnecting );

   934     TMockLtsyCallData1<RMobileCall::TMobileCallStatus> completeCallStatusData( callId, mobileService, mobileCallStatus );

   935 

   936     RLine line;

   937     RMobileCall call;

   938 

   939     TInt error( KErrNone );

   940 

   941     //-------------------------------------------------------------------------

   942     // TEST C: Successful completion request of

   943     // MTelephonyAudioControl::TeardownCallRouting when result is not cached.

   944     //-------------------------------------------------------------------------

   945 

   946     // MO Call Audio Teardown

   947 

   948     // EStatusDialling -> EStatusConnecting -> EStatusConnected -> EStatusDisconnecting

   949 

   950     // reset line & call

   951     error = line.Open( iPhone, KMmTsyVoice1LineName );

   952     CleanupClosePushL( line );

   953     ASSERT_EQUALS( KErrNone, error );

   954 

   955     error = call.OpenNewCall( line );

   956     CleanupClosePushL( call );

   957     ASSERT_EQUALS( KErrNone, error );

   958 

   959     // prepare MockLTSY

   960     CallGetMobileCallInfoL(callId, mobileService, KPhoneNumber);

   961     mockData2.SerialiseL(expectData);

   962     iMockLTSY.ExpectL(EEtelCallDial, expectData);

   963     mockData0.SerialiseL(completeData);

   964     iMockLTSY.CompleteL(EEtelCallDial, KErrNone, completeData);

   965 

   966     // dial the call 

   967     call.Dial( status, pckgCallParamsX1, KPhoneNumber );

   968     User::WaitForRequest( status );

   969     ASSERT_EQUALS( KErrNone, status.Int() );   

   970 

   971     error = call.GetMobileCallInfo( callInfoPckg );

   972     ASSERT_EQUALS( KErrNone, error );

   973 

   974     // check that call status it is OK

   975     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusUnknown );

   976 

   977     // change call status and check it is OK

   978     UpdateCallStatusL( call, RMobileCall::EStatusDialling );

   979     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDialling );

   980 

   981     // change call status and check it is OK

   982     UpdateCallStatusL( call, RMobileCall::EStatusConnecting );

   983     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );

   984 

   985     // change call status and check it is OK

   986     UpdateCallStatusL( call, RMobileCall::EStatusConnected );

   987     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );

   988 

   989     // prepare MockLTSY for hangup 

   990     TInt hangUpCause( KErrGsmReleaseByUser );

   991     TBool autoStChangeDisable ( ETrue );

   992     TMockLtsyCallData2<TInt, TBool> mockHangUpData( callId, mobileService, hangUpCause, autoStChangeDisable );

   993     expectData.Close();

   994     mockHangUpData.SerialiseL(expectData);

   995     iMockLTSY.ExpectL(EEtelCallHangUp, expectData, KErrNone );

   996 

   997     completeData.Close();

   998     TMockLtsyCallData0 mockData3(callId, mobileService);

   999     mockData3.SerialiseL(completeData);

  1000     iMockLTSY.CompleteL(EEtelCallHangUp, KErrNone, completeData);

  1001     // hangup the call

  1002     call.HangUp( status );

  1003     User::WaitForRequest( status );

  1004     ASSERT_EQUALS( KErrNone, status.Int() );

  1005 

  1006     // change call status and check it is OK

  1007     UpdateCallStatusL( call, RMobileCall::EStatusDisconnecting );

  1008     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnecting );

  1009 

  1010     // change call status and check it is OK

  1011     UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );

  1012     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );

  1013 

  1014 

  1015     TInt callCount(0);

  1016     error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );

  1017     ASSERT_EQUALS( KErrNone, error );

  1018 

  1019     // there should not be any calls 

  1020     ASSERT_EQUALS( 0, callCount );    

  1021 

  1022     // cleanup

  1023     AssertMockLtsyStatusL();

  1024     CleanupStack::PopAndDestroy( &call );

  1025     AssertMockLtsyStatusL();    

  1026     CleanupStack::PopAndDestroy( &line );

  1027     AssertMockLtsyStatusL();

  1028 

  1029     DoCleanup();

  1030 

  1031     // MT Call Audio Teardown 

  1032 

  1033     // EStatusAnswering -> EStatusConnecting -> EStatusConnected -> EStatusDisconnectingWithInband    

  1034 

  1035     DefinePropeties( ETrue, EVersion2 );

  1036     OpenEtelServerL(EUseExtendedError);

  1037     OpenPhoneL();

  1038 

  1039     // reset line

  1040     error = line.Open( iPhone, KMmTsyVoice1LineName );

  1041     CleanupClosePushL( line );

  1042     ASSERT_EQUALS( KErrNone, error );

  1043 

  1044     // notify incoming call

  1045     TName incomingCallName;

  1046     line.NotifyIncomingCall( status, incomingCallName );

  1047 

  1048     // create incoming call notification

  1049     TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> mockCallData( callId, mobileService, callInfo );

  1050     mockCallData.SerialiseL( completeData );

  1051     iMockLTSY.NotifyTerminated( mockLtsyStatus );

  1052     iMockLTSY.CompleteL( EEtelLineNotifyIncomingCall, KErrNone, completeData) ;

  1053     User::WaitForRequest( mockLtsyStatus );

  1054     AssertMockLtsyStatusL();

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

  1056 

  1057     // wait for notification

  1058     User::WaitForRequest( status );

  1059     AssertMockLtsyStatusL();

  1060     ASSERT_EQUALS( KErrNone, status.Int() );

  1061 

  1062     // create call ringing notification

  1063     completeData.Close();

  1064     mobileCallStatus = RMobileCall::EStatusRinging;

  1065     TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData2(callId, mobileService, mobileCallStatus );

  1066     mockCallData2.SerialiseL(completeData);

  1067     iMockLTSY.NotifyTerminated(mockLtsyStatus);

  1068     iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);

  1069     User::WaitForRequest(mockLtsyStatus);

  1070     AssertMockLtsyStatusL();

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

  1072 

  1073     // prepare MockLTSY for answer 

  1074     expectData.Close();

  1075     mockData0.SerialiseL( expectData );

  1076     iMockLTSY.ExpectL( EEtelCallAnswer, expectData );

  1077     iMockLTSY.CompleteL( EEtelCallAnswer, KErrNone, expectData );

  1078 

  1079     // reset the call

  1080     error = call.OpenExistingCall( line, incomingCallName );

  1081     CleanupClosePushL( call );

  1082     ASSERT_EQUALS( KErrNone, error ); 

  1083 

  1084     // answer the call

  1085     call.AnswerIncomingCall( status, pckgCallParamsX1 );

  1086     User::WaitForRequest( status );

  1087     ASSERT_EQUALS( KErrNone, status.Int() );

  1088 

  1089     error = call.GetMobileCallInfo( callInfoPckg );

  1090     ASSERT_EQUALS( KErrNone, error );

  1091 

  1092     // change call status and check it is OK

  1093     UpdateCallStatusL( call, RMobileCall::EStatusAnswering );

  1094     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusAnswering );

  1095 

  1096     // change call status and check it is OK

  1097     UpdateCallStatusL( call, RMobileCall::EStatusConnecting );

  1098     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnecting );

  1099 

  1100     // change call status and check it is OK

  1101     UpdateCallStatusL( call, RMobileCall::EStatusConnected );

  1102     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusConnected );

  1103 

  1104     // change call status and check it is OK

  1105     UpdateCallStatusL( call, RMobileCall::EStatusDisconnectingWithInband, ETrue );

  1106     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusDisconnectingWithInband );

  1107 

  1108     // change call status and check it is OK

  1109     UpdateCallStatusL( call, RMobileCall::EStatusIdle, ETrue );

  1110     CheckCallStatus( callInfo.iCallName, RMobileCall::EStatusIdle );

  1111 

  1112     error = RProperty::Get( KMockLtsyFactoryProperty, ENumberOfCalls, callCount );

  1113     ASSERT_EQUALS( KErrNone, error );

  1114 

  1115     // there should not be any calls 

  1116     ASSERT_EQUALS( 0, callCount );    

  1117 

  1118     // cleanup

  1119     AssertMockLtsyStatusL();

  1120     CleanupStack::PopAndDestroy( &call );

  1121     AssertMockLtsyStatusL();    

  1122     CleanupStack::PopAndDestroy( &line );

  1123     AssertMockLtsyStatusL();  

  1124 

  1125     DoCleanup();

  1126 

  1127     // MT Call Audio Setup - Immediate Failure Case

  1128 

  1129     DefinePropeties( ETrue, EVersion2 );

  1130     OpenEtelServerL(EUseExtendedError);

  1131     OpenPhoneL();    

  1132 

  1133     // reset line

  1134     error = line.Open( iPhone, KMmTsyVoice1LineName );