// 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;