/*

* 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:

*

*/

//  INTERNAL INCLUDES

#include "ut_musengmcesession.h"

#include "musengstubs.h"

#include "musengtestdefs.h"

#include "mussettings.h"

#include "musenglivesession.h"

#include "musengclipsession.h"

#include "musengreceivesession.h"

#include "musengsessiondurationtimer.h"

#include "musengtelephoneutils.h"

#include "musengmceutils.h"

//  SYSTEM INCLUDES

#include <digia/eunit/eunitmacros.h>

#include <mceinsession.h>

#include <mcevideostream.h>

#include <mcedisplaysink.h>

#include <mcertpsource.h>

#include <mcespeakersink.h>

#include <mceaudiostream.h>

#include <mcertpsink.h>

#include <mcevideocodec.h>

#include <mceaudiocodec.h>

#include <audiopreference.h>

#include <mceh263codec.h>

#include <mceavccodec.h>

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

//

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

//

UT_CMusEngMceSession* UT_CMusEngMceSession::NewL()

    {

    UT_CMusEngMceSession* self = UT_CMusEngMceSession::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

UT_CMusEngMceSession* UT_CMusEngMceSession::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

UT_CMusEngMceSession::~UT_CMusEngMceSession()

    {

    // NOP

    }

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

// Default constructor

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

//

UT_CMusEngMceSession::UT_CMusEngMceSession()

    {

    // NOP

    }

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

// Second phase construct

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

//

void UT_CMusEngMceSession::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

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

//

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

//

void UT_CMusEngMceSession::SetupL(  )

    {

    iObserver = new( ELeave ) CMusEngObserverStub;

    iLiveSession = CMusEngLiveSession::NewL( KNullDesC,

                                             TRect(0,0, 100,100),

                                             *iObserver,

                                             *iObserver,

                                             *iObserver );

    iSomeOtherSession = CMusEngLiveSession::NewL( KNullDesC,

                                                  TRect(0,0, 100,100),

                                                  *iObserver,

                                                  *iObserver,

                                                  *iObserver );

    ESTABLISH_OUT_SESSION( iSomeOtherSession );

    iClipSession = CMusEngClipSession::NewL( TRect(0,0, 100,100),

                                             *iObserver,

                                             *iObserver,

                                             *iObserver );                                             

    iClipSession->SetClipL( KTestVideoFileName() );

    TBuf<50> videoCodec;

    videoCodec.Copy( KMceSDPNameH264() );

    iClipSession->SetSupportedVideoCodecListL(videoCodec);

    // Construct and establish an incoming session

    iReceiveSession = CMusEngReceiveSession::NewL( TRect(0,0, 100,100), 

                                                   *iObserver,

                                                   *iObserver );

    CMceInSession* inSession = CMceInSession::NewL( *iReceiveSession->iManager,

                                                    KTestOriginator() );

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

    videoStream->SetSourceL( CMceRtpSource::NewLC() );

    CleanupStack::Pop();

    inSession->AddStreamL( videoStream );

    CleanupStack::Pop( videoStream );

    iReceiveSession->iManager->iInSessionObserver->IncomingSession( 

                                                        inSession, 

                                                        &iContainer );

    iReceiveSession->iSession->iState = CMceSession::EProceeding;

    iReceiveSession->AcceptInvitationL( ETrue );

    iObserver->Reset();

    }

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

//

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

//

void UT_CMusEngMceSession::Teardown(  )

    {

    delete iLiveSession;

    delete iClipSession;

    delete iReceiveSession;

    delete iObserver;

    delete iSomeOtherSession;

    }

// TEST CASES

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

//

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

//

void UT_CMusEngMceSession::UT_CMusEngMceSession_TerminateLL()

    {

    TRAPD( error, iLiveSession->TerminateL() );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    ESTABLISH_OUT_SESSION( iLiveSession );

    EUNIT_ASSERT( iLiveSession->iSession->iState == CMceSession::EEstablished );

    iLiveSession->TerminateL();

    EUNIT_ASSERT( iLiveSession->iSession->iState == CMceSession::ETerminating );

    }

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

//

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

//  

void UT_CMusEngMceSession::UT_CMusEngMceSession_GetSessionTimeL()

    {

    EUNIT_ASSERT( iLiveSession->GetSessionTime() < TTimeIntervalSeconds( 0 ) );

    // Invite

    iLiveSession->InviteL( KTestRecipientSipUri );

    EUNIT_ASSERT( iLiveSession->GetSessionTime() < TTimeIntervalSeconds( 0 ) );

    // Simulate establishment

    iLiveSession->iSession->iState = CMceSession::EEstablished;

    iLiveSession->iStartTime.HomeTime();

    TTimeIntervalSeconds sessionTime = iLiveSession->GetSessionTime();

    EUNIT_ASSERT( sessionTime >= TTimeIntervalSeconds( 0 ) );

    }

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

//

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

//

void UT_CMusEngMceSession::UT_CMusEngMceSession_ConnectionActiveL()

    {

    EUNIT_ASSERT( !iLiveSession->ConnectionActive() );

    ESTABLISH_OUT_SESSION( iLiveSession );

    EUNIT_ASSERT( iLiveSession->ConnectionActive() );

    }

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

//

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

//

void UT_CMusEngMceSession::UT_CMusEngMceSession_ContainsAudioLL()

    {

    // Try without session, fails

    EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->ContainsAudioL(), KErrNotReady )

    // Establish session without audio

    ESTABLISH_OUT_SESSION( iLiveSession )

    EUNIT_ASSERT( !iLiveSession->ContainsAudioL() )

    // Establish session with audio

    ESTABLISH_OUT_SESSION( iClipSession )

    EUNIT_ASSERT( iClipSession->ContainsAudioL() )

    }

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

//

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

//

void UT_CMusEngMceSession::UT_CMusEngMceSession_IsMutedLL()

    {

    // Try without session, fails

    EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->IsMutedL(), KErrNotReady )

    // Establish session without audio

    ESTABLISH_OUT_SESSION( iLiveSession )

    EUNIT_ASSERT( iLiveSession->IsMutedL() )

    // Establish session with audio

    ESTABLISH_OUT_SESSION( iClipSession )

    EUNIT_ASSERT( !iClipSession->IsMutedL() )  // Not muted although disabled

    iClipSession->EnableDisplayL( ETrue ); // Enabled also speaker

    EUNIT_ASSERT( !iClipSession->IsMutedL() )  // Enabled and not muted

    iClipSession->MuteL();

    EUNIT_ASSERT( iClipSession->IsMutedL() ) // Explicitly muted

    iClipSession->UnmuteL();

    EUNIT_ASSERT( !iClipSession->IsMutedL() ) // Explicitly unmuted

    }

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

//

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

//

void UT_CMusEngMceSession::UT_CMusEngMceSession_OrientationLL()

    {

    // Try without session, fails

    EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->OrientationL(), KErrNotReady )

    // Establish a session and try all the MCE rotation values

    ESTABLISH_OUT_SESSION( iLiveSession )

    CMceDisplaySink* display = 

                    MusEngMceUtils::GetDisplayL( *iLiveSession->iSession );

    display->iRotation = CMceDisplaySink::ENone;

    EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

                         CMusEngMceSession::EPortrait )

    display->iRotation = CMceDisplaySink::EClockwise90Degree;

    EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

                         CMusEngMceSession::ELandscape )

    display->iRotation = CMceDisplaySink::EClockwise180Degree;

    EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

                         CMusEngMceSession::ELandscape )

    display->iRotation = CMceDisplaySink::EClockwise270Degree;

    EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

                         CMusEngMceSession::ELandscape )

    }

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

//

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

//

void UT_CMusEngMceSession::UT_CMusEngMceSession_SetOrientationLL()

    {

    // Try without session, fails

    EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->SetOrientationL( 

                                                CMusEngMceSession::EPortrait ), 

                                 KErrNotReady )

    // Establish a session

    ESTABLISH_OUT_SESSION( iLiveSession )

    CMceDisplaySink* display = 

                    MusEngMceUtils::GetDisplayL( *iLiveSession->iSession );

    // Check the initial state

    display->iRotation = CMceDisplaySink::ENone;

    EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

                         CMusEngMceSession::EPortrait )      

    // Successfully change orientation

    iLiveSession->SetOrientationL( CMusEngMceSession::ELandscape );

    EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

                         CMusEngMceSession::ELandscape )

    iLiveSession->SetOrientationL( CMusEngMceSession::EPortrait );

    EUNIT_ASSERT_EQUALS( iLiveSession->OrientationL(), 

                         CMusEngMceSession::EPortrait )                     

    }

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

//

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

//

void UT_CMusEngMceSession::UT_CMusEngMceSession_VolumeUpLL()

    {    

    // Try without session, fails

    TRAPD( error, iLiveSession->VolumeUpL() );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    // Test only usage of CMceSpeaker, phone part is tested in base class

    // Check that nothing crashes without any speakers    

    iReceiveSession->VolumeUpL();

    // Establish session

    ESTABLISH_OUT_SESSION( iClipSession )

    TInt initialVolume = iClipSession->VolumeL();

    iClipSession->VolumeUpL();

    // Check that all speaker volumes are adjusted and store one speaker pointer

    CMceSpeakerSink* speaker = NULL;

    CMceSession* session = iClipSession->iSession;

    for ( TInt i = 0; i < session->Streams().Count(); ++i )

        {

        for ( TInt j = 0; j < session->Streams()[i]->Sinks().Count(); ++j )

            {

            if ( session->Streams()[i]->Sinks()[j]->Type() == KMceSpeakerSink )

                {

                speaker = static_cast<CMceSpeakerSink*>(

                                            session->Streams()[i]->Sinks()[j] );

                EUNIT_ASSERT( speaker->VolumeL() == initialVolume + 1 );

                }

            }

        } 

    while ( iClipSession->VolumeL() < speaker->MaxVolumeL() )

        {

        iClipSession->VolumeUpL();

        }

    iClipSession->VolumeUpL(); // Does not do anything to volume

    EUNIT_ASSERT( iClipSession->VolumeL() == speaker->MaxVolumeL() );

    }

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

//

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

//

void UT_CMusEngMceSession::UT_CMusEngMceSession_VolumeDownLL()

    {

        // Try without session, fails

    TRAPD( error, iLiveSession->VolumeDownL() );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    // Test only usage of CMceSpeaker, phone part is tested in base class

    // Check that nothing crashes without any speakers    

    iReceiveSession->VolumeUpL();

    // Establish session

    ESTABLISH_OUT_SESSION( iClipSession )

    TInt initialVolume = iClipSession->VolumeL();

    iClipSession->VolumeDownL();

    // Check that all speaker volumes are adjusted and store one speaker pointer

    CMceSpeakerSink* speaker = NULL;

    CMceSession* session = iClipSession->iSession;

    for ( TInt i = 0; i < session->Streams().Count(); ++i )

        {

        for ( TInt j = 0; j < session->Streams()[i]->Sinks().Count(); ++j )

            {

            if ( session->Streams()[i]->Sinks()[j]->Type() == KMceSpeakerSink )

                {

                speaker = static_cast<CMceSpeakerSink*>(

                                            session->Streams()[i]->Sinks()[j] );

                EUNIT_ASSERT( speaker->VolumeL() == initialVolume - 1 );

                }

            }

        } 

    while ( iClipSession->VolumeL() > 0 )

        {

        iClipSession->VolumeDownL();

        }

    iClipSession->VolumeDownL(); // Does not do anything to volume

    EUNIT_ASSERT_EQUALS( iClipSession->VolumeL(), 0 );

    }

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

//

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

//

void UT_CMusEngMceSession::UT_CMusEngMceSession_SetVolumeLL()

    {    

    // Try without session, fails

    TInt newVolume = KTelephonyVolumeDefaultValue + 1;

    TRAPD( error, iLiveSession->SetVolumeL( newVolume ) );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    // Test only usage of CMceSpeaker, phone part is tested in base class

    // Check that nothing crashes without any speakers    

    iReceiveSession->SetVolumeL( newVolume );

    // Establish session

    ESTABLISH_OUT_SESSION( iClipSession )

    TInt initialVolume = iClipSession->VolumeL();

    iClipSession->SetVolumeL( newVolume );

    // Check that all speaker volumes are adjusted and store one speaker pointer

    CMceSpeakerSink* speaker = NULL;

    CMceSession* session = iClipSession->iSession;

    for ( TInt i = 0; i < session->Streams().Count(); ++i )

        {

        for ( TInt j = 0; j < session->Streams()[i]->Sinks().Count(); ++j )

            {

            if ( session->Streams()[i]->Sinks()[j]->Type() == KMceSpeakerSink )

                {

                speaker = static_cast<CMceSpeakerSink*>(

                                            session->Streams()[i]->Sinks()[j] );

                EUNIT_ASSERT( speaker->VolumeL() == newVolume );

                }

            }

        } 

    newVolume = speaker->MaxVolumeL() + 1;

    iClipSession->SetVolumeL( newVolume );

    EUNIT_ASSERT( iClipSession->VolumeL() == speaker->MaxVolumeL() );

    newVolume = -1;

    iClipSession->SetVolumeL( newVolume );

    EUNIT_ASSERT( iClipSession->VolumeL() == 0 );

    // Test situation where MCE max volume is bigger than MUS max vol

    SetMaxVolForSpeakersL(*session, KMusEngMaxVolume * 10);

    newVolume = 5;

    iClipSession->SetVolumeL( newVolume );

    EUNIT_ASSERT( iClipSession->VolumeL() == newVolume );

    EUNIT_ASSERT( speaker->VolumeL() == newVolume * 10 );

    newVolume = 1;

    iClipSession->SetVolumeL( newVolume );