/*

* Copyright (c) 2004-2007 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:  Unit tests for CMusAvailabilityPluginManager class

*

*/

#include "UT_CMusManagerServerCore.h"

#include "musunittesting.h"

#include "musmanagerservercore.h"

#include "musavailabilitypluginmanager.h"

#include "musavaavailability.h"

#include "musavaavailabilitystub.h"

#include "musavainterface.h"

#include "cmusavainterfacestub.h"

#include "mussessionproperties.h"

#include "mustesthelp.h"

#include <e32property.h>

#include <apgtask.h>

#include <digia/eunit/eunitmacros.h>

_LIT8( KMusEngineName, "MultimediaSharing" );

_LIT8( KAnotherEngineName, "AnotherEngine" );

// ======== MEMBER FUNCTIONS ========

UT_CMusManagerServerCore* UT_CMusManagerServerCore::NewL()

    {

    UT_CMusManagerServerCore* self = UT_CMusManagerServerCore::NewLC();

    CleanupStack::Pop();

    return self;

    }

UT_CMusManagerServerCore* UT_CMusManagerServerCore::NewLC()

    {

    UT_CMusManagerServerCore* self = new( ELeave ) UT_CMusManagerServerCore();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

UT_CMusManagerServerCore::~UT_CMusManagerServerCore()

    {

    }

UT_CMusManagerServerCore::UT_CMusManagerServerCore()

    {

    }

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

// The ConstructL from the base class CEUnitTestSuiteClass must be called.

// It generates the test case table.

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

//

void UT_CMusManagerServerCore::ConstructL()

    {

    CEUnitTestSuiteClass::ConstructL();

    }

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

// From MMusManagerServerCoreObserver.

// Stops server.

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

//

void UT_CMusManagerServerCore::StopServer()

    {

    iStopServerCalled = ETrue;

    }

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

// From MMusManagerServerCoreObserver.

// Returns count of sessions.

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

//

TUint UT_CMusManagerServerCore::SessionCount()

    {

    return iSessionCount;

    }

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

// From MMusMonitorAvailabilityObserver.

// Informs of a change in multimediasharing availability.

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

//

void UT_CMusManagerServerCore::AvailabilityChangedL(

    MultimediaSharing::TMusAvailabilityStatus /*aStatus*/ )

    {

    iAvailabilityChangedLCalled = ETrue;

    }

void UT_CMusManagerServerCore::RequestComplete()

	{

	}

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

// Setups the test by instantiating tested class.

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

//

void UT_CMusManagerServerCore::SetupL()

    {

    iCore = CMusManagerServerCore::NewL( *this );

    iStopServerCalled = EFalse;

    iAvailabilityChangedLCalled = EFalse;

    iSessionCount = 0;

    }

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

// Finalizes test by deleting instance of tested class.

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

//

void UT_CMusManagerServerCore::Teardown()

    {

    delete iCore;

    PropertyHelper::Close();

    Dll::FreeTls(); // Used by the RProcess and TFindProcess stubs 

    }

// ======== TEST METHODS ========

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

// Asserts that instance creation is successful.

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

//

void UT_CMusManagerServerCore::UT_CMusManagerServerCore_NewLL()

    {

    EUNIT_ASSERT( iCore );

    }

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

// Asserts that instance creation is successful.

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

//

void UT_CMusManagerServerCore::UT_CMusManagerServerCore_NewLCL()

    {

    delete iCore;

    iCore = NULL;

    iCore = CMusManagerServerCore::NewLC( *this );

    EUNIT_ASSERT( iCore );

    CleanupStack::Pop( iCore );

    }

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

// Availability query should return MMusAvaObserver::EMusAvaStatusNotAvailable

// when videosharing is not yet available.

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

//

void UT_CMusManagerServerCore::UT_CMusManagerServerCore_AvailabilityQueryLL()

    {

    EUNIT_ASSERT( iCore->AvailabilityQueryL()

        == MultimediaSharing::EMultimediaSharingNotAvailable );

    }

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

// Dummy test to increase execution coverage.

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

//

void UT_CMusManagerServerCore::

    UT_CMusManagerServerCore_InvestigateAvailabilityLL()

    {

    iCore->InvestigateAvailabilityL();

    }

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

// Asserts that invitation with inappropriate UID should leave.

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

//

void UT_CMusManagerServerCore::UT_CMusManagerServerCore_InvitationReceivedLL()

    {

    // 1. The cases with MuS engine

    iCore->iPluginName = KMusEngineName;

    TUid uid = { 0x10101010 }; // Not a valid UID in musmanager.h

    // since used UID is not in appropriate, this should leave

    EUNIT_ASSERT_SPECIFIC_LEAVE(

        iCore->InvitationReceivedL( uid ), KErrNotReady );

    uid.iUid = 0x1028238D; // ESipInviteNotDesired from musmanager.h

    iCore->InvitationReceivedL( uid );

    uid.iUid = 0x10282391; // ESipInviteDesired from musmanager.h

    EUNIT_ASSERT_SPECIFIC_LEAVE(

        iCore->InvitationReceivedL( uid ), KErrNotReady );

    // 2. The cases with non-MuS engine

    iCore->iPluginName = KAnotherEngineName;

    uid.iUid = 0x10101010; // Not a valid UID in musmanager.h

    iCore->InvitationReceivedL( uid );

    uid.iUid = 0x1028238D; // ESipInviteNotDesired from musmanager.h

    iCore->InvitationReceivedL( uid );

    uid.iUid = 0x10282391; // ESipInviteDesired from musmanager.h

    iCore->InvitationReceivedL( uid );    

    }

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

// Dummy test to increase execution coverage.

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

//

void UT_CMusManagerServerCore::UT_CMusManagerServerCore_OptionsReceivedLL()

    {

    TUid uid = { 0x10101010 };

    iCore->iPluginName = KMusEngineName;

    iCore->iPluginManager->iPluginStarted = EFalse;

    iCore->OptionsReceivedL( uid );

    EUNIT_ASSERT( iCore->iPluginManager->iPluginStarted );

    iCore->iPluginName = KAnotherEngineName;

    iCore->iPluginManager->iPluginStarted = EFalse;

    iCore->OptionsReceivedL( uid );

    EUNIT_ASSERT ( !(iCore->iPluginManager->iPluginStarted) );

    }

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

// Asserts that tested method does not leave. In certain case it could leave

// with KErrPermissionDenied, but with this this test, used capabilities

// and used stubs, tested method shouldn't leave.

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

//

void UT_CMusManagerServerCore::

    UT_CMusManagerServerCore_StartMultimediaSharingLL()

    {

    CMusAvaInterface* interface = iCore->iPluginManager->iPlugin;

    CMusAvaInterface2* interface2 =  static_cast<CMusAvaInterface2*>( interface );

    CMusAvaAvailabilityStub* abilityStub =  

	static_cast<CMusAvaAvailabilityStub*>( interface2->iAvailabilities[0] ); 

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

    // Dummy test that shouldn't leave ->

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

	MUS_EUNIT_ASSERT_NO_LEAVE(

        iCore->StartMultimediaSharingL( MultimediaSharing::EMusLiveVideo ) );

    // <- Dummy test that shouldn't leave

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

    // Test for "if( !iApplicationManager->ApplicationRunning() &&

    // iPluginManager->ApplicationAllowed() ) branch ->

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

    // CMusAvailabilityPluginManager::ApplicationAllowed = ETrue

    abilityStub->iNameStub = MMusAvaObserver::EMusAvaNameRegistration;

    abilityStub->iStatusStub = MMusAvaObserver::EMusAvaStatusAvailable;

  	interface2->iCurrentAvailability =MMusAvaObserver::EMusAvaOptionHandler;

    PropertyHelper::SetErrorCode(KErrGeneral);

    // Should leave in WriteSessionPropertiesL

    MUS_EUNIT_ASSERT_SPECIFIC_LEAVE(

        iCore->StartMultimediaSharingL( MultimediaSharing::EMusLiveVideo ),

        KErrGeneral );

    PropertyHelper::SetErrorCode(KErrNone);

    // Should go all the way to StartApplicationL

    MUS_EUNIT_ASSERT_NO_LEAVE(

        iCore->StartMultimediaSharingL( MultimediaSharing::EMusLiveVideo ) );

    EUNIT_ASSERT( PropertyHelper::GetCalledFunction() == RProperty::EDefine );

    // <- Test for "if( !iApplicationManager->ApplicationRunning() &&

    // iPluginManager->ApplicationAllowed() ) branch

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

    // Test for else branch ->

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

    // CMusAvailabilityPluginManager::ApplicationAllowed = EFalse

    abilityStub->iNameStub = MMusAvaObserver::EMusAvaNameRegistration;

    abilityStub->iStatusStub = MMusAvaObserver::EMusAvaStatusNotExecuted;

  	interface2->iCurrentAvailability =MMusAvaObserver::EMusAvaNameRegistration;

    // CMusApplicationManager::ApplicationRunning = EFalse

    MUS_EUNIT_ASSERT_NO_LEAVE(

        iCore->StartMultimediaSharingL( MultimediaSharing::EMusLiveVideo ) );

    }

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

// Asserts that tested method checks if task exists and calls

// TApaTask::KillTask if task exists.

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

//

void UT_CMusManagerServerCore::

    UT_CMusManagerServerCore_StopMultimediaSharingLL()

    {

    // MuS not running

    iCore->StopMultimediaSharingL();

    // MuS running

    User::LeaveIfError( 

        Dll::SetTls( reinterpret_cast< TAny* >( 1 ) ) ); 

    // TLS is used by TFindProcess stub

    iCore->StopMultimediaSharingL();

    TInt availability = MultimediaSharing::EMultimediaSharingAvailable;

    TUint key( NMusSessionApi::KStatus );

    RProperty::Get( key, availability );

    EUNIT_ASSERT_EQUALS( PropertyHelper::GetCalledFunction(), RProperty::EDefine ) 

    EUNIT_ASSERT_EQUALS( availability, 

                         MultimediaSharing::EMultimediaSharingNotAvailable )

    }

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

// Asserts that observer method MMusManagerServerCoreObserver::StopServer is

// called.

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

//

void UT_CMusManagerServerCore::UT_CMusManagerServerCore_EventNoSessionsL()

    {

    iCore->iPluginName = KMusEngineName;

    iCore->iPluginManager->iPluginStarted = ETrue;

    iCore->EventNoSessions();

    EUNIT_ASSERT ( !(iCore->iPluginManager->iPluginStarted) );

    EUNIT_ASSERT( iStopServerCalled );

    iCore->iPluginName = KAnotherEngineName;

    iCore->iPluginManager->iPluginStarted = ETrue;

    iCore->EventNoSessions();

    EUNIT_ASSERT ( iCore->iPluginManager->iPluginStarted );

    EUNIT_ASSERT( iStopServerCalled );

    }

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

// Asserts that MMusManagerServerCoreObserver::StopServer is called when it

// should.

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

//

void UT_CMusManagerServerCore::UT_CMusManagerServerCore_PluginStoppedL()

    {

    // Should not call iStopServer when sessions still exists.

    iSessionCount = 1;

    iCore->PluginStopped();

    EUNIT_ASSERT( !iStopServerCalled );

    // Should call iStopServer when sessioncount = 0.

    iSessionCount = 0;

    iCore->PluginStopped();

    EUNIT_ASSERT( iStopServerCalled );

    }

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

// Asserts that KErrNone should be returned.

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

//

void UT_CMusManagerServerCore::

    UT_CMusManagerServerCore_AvailabilityChangedLL()

    {

    iCore->iPluginName = KMusEngineName;

    MUS_EUNIT_ASSERT_NO_LEAVE( iCore->AvailabilityChangedL(

        (MultimediaSharing::TMusAvailabilityStatus) KErrNone ) );

    EUNIT_ASSERT( iCore->iAvailabilityMonitors.Count() == 0 );

    iCore->iPluginName = KAnotherEngineName;

    MUS_EUNIT_ASSERT_NO_LEAVE( iCore->AvailabilityChangedL(

        (MultimediaSharing::TMusAvailabilityStatus) KErrNone ) );

    EUNIT_ASSERT( iCore->iAvailabilityMonitors.Count() == 0 );

    }

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

// Asserts that called method removes *this* monitor.

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

//

void UT_CMusManagerServerCore::UT_CMusManagerServerCore_RegisterObserverL()

    {

    TInt monitors = iCore->iAvailabilityMonitors.Count();

    iCore->RegisterObserverL( this );

    EUNIT_ASSERT( iCore->iAvailabilityMonitors.Count() == monitors + 1 );

    iCore->RemoveObserver( this );

    EUNIT_ASSERT( iCore->iAvailabilityMonitors.Count() == monitors );

    }

void UT_CMusManagerServerCore::UT_CMusManagerServerCore_IsMusEnginePluginL()

    {

    iCore->iPluginName = KMusEngineName;

    EUNIT_ASSERT( iCore->IsMusEnginePlugin() );

    iCore->iPluginName = KAnotherEngineName;

    EUNIT_ASSERT( !(iCore->IsMusEnginePlugin()) );

    }

// ======== EUNIT TEST TABLE ========

EUNIT_BEGIN_TEST_TABLE(

    UT_CMusManagerServerCore,

    "CMusManagerServerCore",

    "UNIT" )

EUNIT_TEST(

    "NewL - test ",

    "CMusManagerServerCore",

    "NewL",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_NewLL, Teardown)

EUNIT_TEST(

    "NewLC - test ",

    "CMusManagerServerCore",

    "NewLC",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_NewLCL, Teardown)

EUNIT_TEST(

    "RegisterObserver - test ",

    "CMusManagerServerCore",

    "RegisterObserver",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_RegisterObserverL, Teardown)

EUNIT_TEST(

    "AvailabilityQueryL - test ",

    "CMusManagerServerCore",

    "AvailabilityQueryL",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_AvailabilityQueryLL, Teardown)

EUNIT_TEST(

    "InvestigateAvailabilityL - test ",

    "CMusManagerServerCore",

    "InvestigateAvailabilityL",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_InvestigateAvailabilityLL, Teardown)

EUNIT_TEST(

    "InvitationReceivedL - test ",

    "CMusManagerServerCore",

    "InvitationReceivedL",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_InvitationReceivedLL, Teardown)

EUNIT_TEST(

    "OptionsReceivedL - test ",

    "CMusManagerServerCore",

    "OptionsReceivedL",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_OptionsReceivedLL, Teardown)

EUNIT_TEST(

    "StartMultimediaSharingL - test ",

    "CMusManagerServerCore",

    "StartMultimediaSharingL",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_StartMultimediaSharingLL, Teardown)

EUNIT_TEST(

    "StopMultimediaSharingL - test ",

    "CMusManagerServerCore",

    "StopMultimediaSharingL",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_StopMultimediaSharingLL, Teardown)

EUNIT_TEST(

    "EventNoSessions - test ",

    "CMusManagerServerCore",

    "EventNoSessions",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_EventNoSessionsL, Teardown)

EUNIT_TEST(

    "PluginStopped - test ",

    "CMusManagerServerCore",

    "PluginStopped",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_PluginStoppedL, Teardown)

EUNIT_TEST(

    "AvailabilityChangedL - test ",

    "CMusManagerServerCore",

    "AvailabilityChangedL",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_AvailabilityChangedLL, Teardown)

EUNIT_TEST(

    "IsMusEnginePlugin - test ",

    "CMusManagerServerCore",

    "IsMusEnginePlugin",

    "FUNCTIONALITY",

    SetupL, UT_CMusManagerServerCore_IsMusEnginePluginL, Teardown)

EUNIT_END_TEST_TABLE