/*
* Copyright (c) 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:
*
*/

#include "T_MediatorSender.h"
#include <EUnitMacros.h>
#include <EUnitDecorators.h>

#include <PEVirtualEngine.h>
#include <mediatoreventsfromtelephonyapi.h>
#include <videotelcontrolmediatorapi.h>
#include <MediatorEventProvider.h>
//#include <bmbubblemanager.h>
#include "mphoneshutdowncommand.h"
#include "phoneui.pan"
#include "TPhoneCmdParamBoolean.h"
#include "TPhoneCmdParamCallHeaderData.h"
#include "PhoneViewCommandDefinitions.h"
#include "CPhoneMediatorSender.h"
#include "MediatorDomainUIDs.h"

CPhoneMediatorSender* coeEnvMediatorSenderInstance;

// Mediator registeration
TInt mediatorRegisterationReturnValue;
TUid domain;
TUid category;
MediatorService::REventList eventList;

// Raise event
TUid raiseEventDomain;
TUid raiseEventCategory;
TInt raiseEventEventId;
TVersion raiseEventVersion;
HBufC8* raiseEventData;

// Issue command
TInt issueCommandReturnValue;
TUid issueCommandDomain;
TUid issueCommandCategory;
TInt issueCommandCommandId;
TVersion issueCommandVersion;
HBufC8* issueCommandData;




// - Construction -----------------------------------------------------------

T_MediatorSender* T_MediatorSender::NewL()
    {
    T_MediatorSender* self = T_MediatorSender::NewLC();
    CleanupStack::Pop();
    return self;
    }

T_MediatorSender* T_MediatorSender::NewLC()
    {
    T_MediatorSender* self = new( ELeave ) T_MediatorSender();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

T_MediatorSender::~T_MediatorSender()
    {
    }

T_MediatorSender::T_MediatorSender()
    {
    }

void T_MediatorSender::ConstructL()
    {
    CEUnitTestSuiteClass::ConstructL();
    }

class CShutdownCommandMock : public CBase, public MPhoneShutdownCommand
    {
public:
    
    static CShutdownCommandMock* NewL() { return new( ELeave )CShutdownCommandMock(); }
    
    void ExecuteLD() { iExecuteLDCalled = ETrue; }
    
    TBool iExecuteLDCalled;
    };

// - Test methods -----------------------------------------------------------



void T_MediatorSender::SetupL(  )
    {
    eventList = MediatorService::REventList();
    coeEnvMediatorSenderInstance = NULL;
    domain = TUid::Null();
    category = TUid::Null();
    mediatorRegisterationReturnValue = KErrNone;
    issueCommandDomain = raiseEventDomain = TUid::Null();
    issueCommandCategory = raiseEventCategory = TUid::Null();
    issueCommandCommandId = raiseEventEventId = 0;
    issueCommandVersion = raiseEventVersion = TVersion(); 
    issueCommandData = raiseEventData = NULL;
    issueCommandReturnValue = KErrNone;
    iSender = CPhoneMediatorSender::Instance();
    }    

void T_MediatorSender::Teardown(  )
    {
    eventList.Close();
    delete iSender;
    delete raiseEventData;
    delete issueCommandData;
    }

void T_MediatorSender::VerifyIssueCommandBoilerplateL()
    {
    EUNIT_ASSERT( issueCommandDomain == KMediatorVideoTelephonyDomain );
    EUNIT_ASSERT( issueCommandCategory == KCatPhoneToVideotelCommands );
    EUNIT_ASSERT( issueCommandVersion.iMajor == KPhoneToVideotelCmdVersionMajor );
    EUNIT_ASSERT( issueCommandVersion.iMinor == KPhoneToVideotelCmdVersionMinor );
    EUNIT_ASSERT( issueCommandVersion.iBuild == KPhoneToVideotelCmdVersionBuild );
    }

void T_MediatorSender::VerifyRaiseEventBoilerplateL()
    {
    EUNIT_ASSERT( raiseEventDomain == KMediatorTelephonyDomain );
    EUNIT_ASSERT( raiseEventCategory == KCatEventsFromTelephony );
    EUNIT_ASSERT( raiseEventEventId == EPhoneEventCallData );
    EUNIT_ASSERT( raiseEventVersion.iMajor == KTelephonyEventsVersionMajor );
    EUNIT_ASSERT( raiseEventVersion.iMinor == KTelephonyEventsVersionMinor );
    EUNIT_ASSERT( raiseEventVersion.iBuild == KTelephonyEventsVersionBuild );

    }
    
void T_MediatorSender::FreeIssueCommandGlobals()
    {
    issueCommandDomain = TUid::Null();
    issueCommandCategory = TUid::Null();
    issueCommandCommandId = 0;
    issueCommandVersion = TVersion(); 
    delete issueCommandData; issueCommandData = NULL; 
    }

void T_MediatorSender::TestInstanceGotFromCoeEnvL()
    {
    coeEnvMediatorSenderInstance = reinterpret_cast<CPhoneMediatorSender*>( 0xdeadbeef );
    
    CPhoneMediatorSender* instance = CPhoneMediatorSender::Instance();
    EUNIT_ASSERT( instance == coeEnvMediatorSenderInstance );
    }

void T_MediatorSender::TestInstanceCreatedL()
    {
    CPhoneMediatorSender* instance = CPhoneMediatorSender::Instance();
    EUNIT_ASSERT( instance != NULL );
    delete instance;
    }

void T_MediatorSender::TestGenericEventsAreRegisteredL()
    {    
    EUNIT_ASSERT( domain == KMediatorTelephonyDomain );
    EUNIT_ASSERT( category == KCatEventsFromTelephony );
    EUNIT_ASSERT( eventList.Count() == 1 );
    MediatorService::TEvent event = eventList[0];
    EUNIT_ASSERT( event.iEventId == EPhoneEventCallData );
    EUNIT_ASSERT( event.iVersion.iMajor == KTelephonyEventsVersionMajor );
    EUNIT_ASSERT( event.iVersion.iMinor == KTelephonyEventsVersionMinor );
    EUNIT_ASSERT( event.iVersion.iBuild == KTelephonyEventsVersionBuild );
    }

void T_MediatorSender::TestGenericEventRegisterationFailsL()
    {    
    mediatorRegisterationReturnValue = KErrGeneral;
    EUNIT_ASSERT_PANIC( CPhoneMediatorSender::Instance(), "Common phone", EPhoneMediatorCenterRegistrationFailed  );
    }

void T_MediatorSender::TestSendingCallDataWhenCallHeaderIsRemovedL()
    {       
    iSender->SendEvent( EPhoneViewRemoveCallHeader, 2 );
    
    VerifyRaiseEventBoilerplateL();
    
    TTelephonyCallDataParamPackage pckg;
    pckg.Copy( *raiseEventData );
    const TTelephonyCallDataParam params = pckg();  

    EUNIT_ASSERT( params.iCallId == 2 );
    EUNIT_ASSERT( params.iCallState == ECallStateIdle );   
    }

void T_MediatorSender::TestSendingAudioMuteCommandL()
    {
    TPhoneCmdParamBoolean param;
    param.SetBoolean( ETrue );
    
    iSender->SendEvent( EPhoneViewActivateMuteUIChanges, param );
    
    VerifyIssueCommandBoilerplateL();
    EUNIT_ASSERT( issueCommandCommandId == EVtCmdMute );
    EUNIT_ASSERT( issueCommandData->Match( KNullDesC8 ) == KErrNone );  
    }

void T_MediatorSender::TestSendingAudioUnMuteCommandL()
    {
    TPhoneCmdParamBoolean param;
    param.SetBoolean( EFalse );
    
    iSender->SendEvent( EPhoneViewActivateMuteUIChanges, param );
    
    VerifyIssueCommandBoilerplateL();
    EUNIT_ASSERT( issueCommandCommandId == EVtCmdUnmute );
    EUNIT_ASSERT( issueCommandData->Match( KNullDesC8 ) == KErrNone );  
    }

void T_MediatorSender::TestAudioMuteCommandBufferedIfMediatorBusyAndResendWhenResponseArrivesL()
    {
    issueCommandReturnValue = KErrInUse; // Make the mediator busy
    
    TPhoneCmdParamBoolean param;
    param.SetBoolean( ETrue );
    iSender->SendEvent( EPhoneViewActivateMuteUIChanges, param );
    
    // Clear the issue command sensing globals, because SendEvent tries to send the data and we need to verify
    // that when response arrives the mute command is send again.
    FreeIssueCommandGlobals();
    
    iSender->CommandResponseL( TUid::Null(), TUid::Null(), 0, 0, KNullDesC8() );
    
    
    VerifyIssueCommandBoilerplateL();
    EUNIT_ASSERT( issueCommandCommandId == EVtCmdMute );
    EUNIT_ASSERT( issueCommandData->Match( KNullDesC8 ) == KErrNone ); 
    
    // Verify that next response wont send the mute command
    FreeIssueCommandGlobals();
    iSender->CommandResponseL( TUid::Null(), TUid::Null(), 0, 0, KNullDesC8() );
    
    EUNIT_ASSERT( issueCommandDomain == TUid::Null() );
    }


// - EUnit test table -------------------------------------------------------

EUNIT_BEGIN_TEST_TABLE(
    T_MediatorSender,
    "Tests for CPhoneMediatorSender",
    "UNIT" )

EUNIT_TEST(
    "Instance got from coeenv",
    "CPhoneMediatorSender",
    "Instance",
    "FUNCTIONALITY",
    SetupL, TestInstanceGotFromCoeEnvL, Teardown)
    
EUNIT_TEST(
    "Instance created",
    "CPhoneMediatorSender",
    "Instance",
    "FUNCTIONALITY",
    SetupL, TestInstanceCreatedL, Teardown)
    
EUNIT_TEST(
    "Generic event registeration",
    "CPhoneMediatorSender",
    "SendEvent",
    "FUNCTIONALITY",
    SetupL, TestGenericEventsAreRegisteredL, Teardown)
    
EUNIT_TEST(
    "Generic event registeration fails",
    "CPhoneMediatorSender",
    "SendEvent",
    "FUNCTIONALITY",
    SetupL, TestGenericEventRegisterationFailsL, Teardown)

    
EUNIT_TEST(
    "Sending call data when call header is removed",
    "CPhoneMediatorSender",
    "SendEvent",
    "FUNCTIONALITY",
    SetupL, TestSendingCallDataWhenCallHeaderIsRemovedL, Teardown)

EUNIT_TEST(
    "Sending audio mute command",
    "CPhoneMediatorSender",
    "SendEvent",
    "FUNCTIONALITY",
    SetupL, TestSendingAudioMuteCommandL, Teardown)

EUNIT_TEST(
    "Sending audio unmute command",
    "CPhoneMediatorSender",
    "SendEvent",
    "FUNCTIONALITY",
    SetupL, TestSendingAudioUnMuteCommandL, Teardown)
    
EUNIT_TEST(
    "Mute command sending buffered",
    "CPhoneMediatorSender",
    "CommandResponseL",
    "FUNCTIONALITY",
    SetupL, TestAudioMuteCommandBufferedIfMediatorBusyAndResendWhenResponseArrivesL, Teardown)

EUNIT_END_TEST_TABLE