/*

* 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_musengtwowayrecvsession.h"

#include "musengstubs.h"

#include "musengtestdefs.h"

#include "musengtwowayrecvsession.h"

#include "musengmceutils.h"

#include "mussessionproperties.h"

#include "contactenginestub.h"

#include "musenglivevideoplayer.h"

//  SYSTEM INCLUDES

#include <eunitmacros.h>

#include <mceinsession.h>

#include <mcestreambundle.h>

#include <mcevideostream.h>

#include <mceaudiostream.h>

#include <mcertpsource.h>

#include <mcedisplaysink.h>

#include <mcespeakersink.h>

#include <mcecamerasource.h>

#include <mcefilesource.h>

#include <mcertpsink.h>

#include <mceaudiocodec.h>

#include <mceh263codec.h>

#include <mceavccodec.h>

#include <musmanager.h>

#include <audiopreference.h>

// Incoming session may be rejected silently due memory running out. Ensure that 

// incoming session was handled fully by using this macro.

#define MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L \

__ASSERT_ALWAYS( iReceiveSession->iSession && \

iReceiveSession->iSession->iState != CMceSession::ETerminated, User::Leave( KErrNoMemory ) );

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

//

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

//

UT_CMusEngTwoWayRecvSession* UT_CMusEngTwoWayRecvSession::NewL()

    {

    UT_CMusEngTwoWayRecvSession* self = UT_CMusEngTwoWayRecvSession::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

// 

UT_CMusEngTwoWayRecvSession* UT_CMusEngTwoWayRecvSession::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

UT_CMusEngTwoWayRecvSession::~UT_CMusEngTwoWayRecvSession()

    {

    // NOP

    }

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

// Default constructor

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

//

UT_CMusEngTwoWayRecvSession::UT_CMusEngTwoWayRecvSession()

    {

    // NOP

    }

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

// Second phase construct

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

//

void UT_CMusEngTwoWayRecvSession::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

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

//

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

//

void UT_CMusEngTwoWayRecvSession::SetupL(  )

    {

    iLcSessionObserver = new( ELeave )CLcSessionObserverStub;

    iReceiveSession = CMusEngTwoWayRecvSession::NewL();

    iReceiveSession->SetLcSessionObserver( iLcSessionObserver );

    }

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

//

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

//

void UT_CMusEngTwoWayRecvSession::Teardown(  )

    {

    delete iReceiveSession;

    delete iLcSessionObserver;

    PropertyHelper::Close();

    }

// TEST HELPERS

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

//

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

//

CMceVideoStream* UT_CMusEngTwoWayRecvSession::ConstructVideoInStreamLC()

    {

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

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

    CleanupStack::Pop();

    videoStream->AddSinkL( 

                CMceDisplaySink::NewLC( *iReceiveSession->iManager ) );

    CleanupStack::Pop();    

    return videoStream;

    }

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

//

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

//

CMceVideoStream* UT_CMusEngTwoWayRecvSession::ConstructVideoOutStreamLC()

    {

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();    

    videoStream->SetSourceL( 

                CMceCameraSource::NewLC( *iReceiveSession->iManager ) );

    CleanupStack::Pop();

    videoStream->AddSinkL( CMceRtpSink::NewLC() );

    CleanupStack::Pop();

    return videoStream;

    }    

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

//

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

//   

CMceAudioStream* UT_CMusEngTwoWayRecvSession::ConstructAudioInStreamLC()

    {

    CMceAudioStream* audioStream = CMceAudioStream::NewLC();

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

    CleanupStack::Pop();

    audioStream->AddSinkL( CMceSpeakerSink::NewLC() );

    CleanupStack::Pop();

    return audioStream;

    }

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

//

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

//   

CMceAudioStream* UT_CMusEngTwoWayRecvSession::ConstructAudioOutStreamLC()

    {

    CMceAudioStream* audioStream = CMceAudioStream::NewLC();

    audioStream->SetSourceL( 

        CMceFileSource::NewLC( *iReceiveSession->iManager, KNullDesC() ) );

    CleanupStack::Pop();

    audioStream->AddSinkL( CMceRtpSink::NewLC() );

    CleanupStack::Pop();

    return audioStream;

    }

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

// Helper to construct incoming sessions.

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

//

CMceInSession* UT_CMusEngTwoWayRecvSession::ConstructInSessionLC( 

                                             TInt aVideoStreamCount,

                                             TInt aAudioStreamCount,

                                             TBool aConstructSinks )

    {

    CMceInSession* inSession = CMceInSession::NewL( 

                                        *(iReceiveSession->iManager), 

                                        KTestOriginator() );

    CleanupStack::PushL( inSession );

    for ( TInt i = 0; i < aVideoStreamCount; ++i )

        {

        CMceVideoStream* videoStream = CMceVideoStream::NewLC();

        CMceRtpSource* rtpSource = CMceRtpSource::NewLC();

        videoStream->SetSourceL( rtpSource );

        CleanupStack::Pop( rtpSource );

        if ( aConstructSinks )

            {

            CMceDisplaySink* display = CMceDisplaySink::NewLC( 

                                                *(iReceiveSession->iManager) );

            videoStream->AddSinkL( display );

            CleanupStack::Pop( display );

            }

        inSession->AddStreamL( videoStream );

        CleanupStack::Pop( videoStream );

        }

    for ( TInt i = 0; i < aAudioStreamCount; ++i )

        {

        CMceAudioStream* audioStream = CMceAudioStream::NewLC();

        CMceRtpSource* rtpSource = CMceRtpSource::NewLC();

        audioStream->SetSourceL( rtpSource );

        CleanupStack::Pop( rtpSource );

        if ( aConstructSinks )

            {

            CMceSpeakerSink* speaker = CMceSpeakerSink::NewLC();

            audioStream->AddSinkL( speaker );

            CleanupStack::Pop( speaker );

            }

        inSession->AddStreamL( audioStream );

        CleanupStack::Pop( audioStream );

        }    

    return inSession;

    }

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

// Helper to construct incoming two-way video session.

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

//

CMceInSession* UT_CMusEngTwoWayRecvSession::ConstructTwoWayInSessionLC( TBool aConstructSinks )

    {

    CMceInSession* inSession = CMceInSession::NewL( 

                                        *(iReceiveSession->iManager), 

                                        KTestOriginator() );

    CleanupStack::PushL( inSession );

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

    CMceRtpSource* rtpSource = CMceRtpSource::NewLC();

    videoStream->SetSourceL( rtpSource );

    CleanupStack::Pop( rtpSource );

    if ( aConstructSinks )

        {

        CMceDisplaySink* display = CMceDisplaySink::NewLC( 

                                            *(iReceiveSession->iManager) );

        videoStream->AddSinkL( display );

        CleanupStack::Pop( display );

        }

    CMceVideoStream* videoOutStream = CMceVideoStream::NewLC();

    CMceCameraSource* cameraSource = CMceCameraSource::NewLC( *(iReceiveSession->iManager) );

    videoOutStream->SetSourceL( cameraSource );

    CleanupStack::Pop( cameraSource );

    if ( aConstructSinks )

        {

        CMceRtpSink* rtpSink = CMceRtpSink::NewLC();

        videoOutStream->AddSinkL( rtpSink );

        CleanupStack::Pop( rtpSink );

        }

    videoStream->BindL( videoOutStream );

    CleanupStack::Pop( videoOutStream );

    inSession->AddStreamL( videoStream );

    CleanupStack::Pop( videoStream );

    return inSession;

    }                                             

// TEST CASES

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

//

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

//

void UT_CMusEngTwoWayRecvSession::UT_NewLL(  )

    {

    EUNIT_ASSERT( iReceiveSession );

    EUNIT_ASSERT( !iReceiveSession->iSession );

    EUNIT_ASSERT( iReceiveSession->iMceManagerUid == 

                  TUid::Uid(CMusManager::ESipInviteDesired2WayVideo) );

    }

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

//

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

//

void UT_CMusEngTwoWayRecvSession::UT_EnableDisplayLL()

    {

    TRAPD( error, iReceiveSession->EnableDisplayL( ETrue ) );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    TMceTransactionDataContainer container;

    CMceInSession* inSession = ConstructTwoWayInSessionLC();

    iReceiveSession->IncomingSession( inSession, &container );

    CleanupStack::Pop( inSession );

    MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

    CMceDisplaySink* display = 

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

    CMceDisplaySink* receivingDisplay = 

                    MusEngMceUtils::GetReceivingDisplayL( *iReceiveSession->iSession );

    // Disable

    iReceiveSession->EnableDisplayL( EFalse );

    EUNIT_ASSERT( !display->iIsEnabled );

    EUNIT_ASSERT( !receivingDisplay->iIsEnabled );

    // Try to disable again, request should be ignored

    iReceiveSession->EnableDisplayL( EFalse );

    EUNIT_ASSERT( !display->iIsEnabled );

    EUNIT_ASSERT( !receivingDisplay->iIsEnabled );

    // Enable

    iReceiveSession->EnableDisplayL( ETrue );

    EUNIT_ASSERT( display->iIsEnabled );

    EUNIT_ASSERT( receivingDisplay->iIsEnabled );

    // Try to enable again, request should be ignored

    iReceiveSession->EnableDisplayL( ETrue );

    EUNIT_ASSERT( display->iIsEnabled );

    EUNIT_ASSERT( receivingDisplay->iIsEnabled );

    // Session does not have sending stream (viewfinder does not exist)

    //

    delete iReceiveSession->iSession;

    iReceiveSession->iSession = NULL;

    inSession = ConstructInSessionLC( 1, 0 );

    iReceiveSession->IncomingSession( inSession, &container );

    CleanupStack::Pop( inSession );

    display = MusEngMceUtils::GetVfDisplay( *(iReceiveSession->iSession) );  

    EUNIT_ASSERT( display == NULL );

    receivingDisplay = MusEngMceUtils::GetReceivingDisplayL( *iReceiveSession->iSession );

    iReceiveSession->EnableDisplayL( EFalse );

    EUNIT_ASSERT( !receivingDisplay->iIsEnabled );  

    }

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

//

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

//

void UT_CMusEngTwoWayRecvSession::UT_SetOrientationLL()

    {

    // Try without session, fails

    EUNIT_ASSERT_SPECIFIC_LEAVE( iReceiveSession->SetOrientationL( 

                                               CMusEngMceSession::EPortrait ), 

                                KErrNotReady )

    TMceTransactionDataContainer container;

    CMceInSession* inSession = ConstructTwoWayInSessionLC();

    iReceiveSession->IncomingSession( inSession, &container );

    CleanupStack::Pop( inSession );

    MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

    CMceDisplaySink* display = 

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

    CMceDisplaySink* receivingDisplay = 

                   MusEngMceUtils::GetReceivingDisplayL( *iReceiveSession->iSession );

    // Check the initial state

    display->iRotation = CMceDisplaySink::ENone;

    receivingDisplay->iRotation = CMceDisplaySink::ENone;

    EUNIT_ASSERT_EQUALS( iReceiveSession->OrientationL(), 

                        CMusEngMceSession::EPortrait )      

    // Successfully change orientation

    iReceiveSession->SetOrientationL( CMusEngMceSession::ELandscape );

    EUNIT_ASSERT_EQUALS( iReceiveSession->OrientationL(), 

                        CMusEngMceSession::ELandscape )

    EUNIT_ASSERT_EQUALS( display->iRotation, CMceDisplaySink::EClockwise90Degree );

    EUNIT_ASSERT_EQUALS( receivingDisplay->iRotation, CMceDisplaySink::EClockwise90Degree );

    iReceiveSession->SetOrientationL( CMusEngMceSession::EPortrait );

    EUNIT_ASSERT_EQUALS( iReceiveSession->OrientationL(), 

                        CMusEngMceSession::EPortrait )          

    EUNIT_ASSERT_EQUALS( display->iRotation, CMceDisplaySink::ENone );

    EUNIT_ASSERT_EQUALS( receivingDisplay->iRotation, CMceDisplaySink::ENone );

    // Session does not have sending stream (viewfinder does not exist)

    delete iReceiveSession->iSession;

    iReceiveSession->iSession = NULL;

    inSession = ConstructInSessionLC( 1, 0 );

    iReceiveSession->IncomingSession( inSession, &container );

    CleanupStack::Pop( inSession );

    MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

    display = MusEngMceUtils::GetVfDisplay( *(iReceiveSession->iSession) );  

    EUNIT_ASSERT( display == NULL );

    receivingDisplay = MusEngMceUtils::GetReceivingDisplayL( *iReceiveSession->iSession );

    iReceiveSession->SetOrientationL( CMusEngMceSession::ELandscape );

    EUNIT_ASSERT_EQUALS( receivingDisplay->iRotation, CMceDisplaySink::EClockwise90Degree );

    }

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

//

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

//

void UT_CMusEngTwoWayRecvSession::UT_OrientationLL()

    {

    // Try without session, fails

    EUNIT_ASSERT_SPECIFIC_LEAVE( iReceiveSession->OrientationL(), 

                                KErrNotReady )

    TMceTransactionDataContainer container;

    CMceInSession* inSession = ConstructTwoWayInSessionLC();

    iReceiveSession->IncomingSession( inSession, &container );

    CleanupStack::Pop( inSession );

    MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

    CMceDisplaySink* receivingDisplay = 

         MusEngMceUtils::GetReceivingDisplayL( *iReceiveSession->iSession );

    receivingDisplay->iRotation = CMceDisplaySink::ENone;

    EUNIT_ASSERT_EQUALS( iReceiveSession->OrientationL(), 

                           CMusEngMceSession::EPortrait )      

    receivingDisplay->iRotation = CMceDisplaySink::EClockwise90Degree;

    EUNIT_ASSERT_EQUALS( iReceiveSession->OrientationL(), 

                               CMusEngMceSession::ELandscape ) 

    }

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

//

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

//

void UT_CMusEngTwoWayRecvSession::UT_SetLocalRectLL()

    {

    // Does nothing real before session establishment

    TRect rect1( 100, 200, 300, 500 );

    iReceiveSession->SetSecondaryRectL( rect1 ); 

    EUNIT_ASSERT( rect1 == iReceiveSession->iLocalRect );

    // Local rect changing affects to viewfinder display sink not to receiving video

    //

    TMceTransactionDataContainer container;

    CMceInSession* inSession = ConstructTwoWayInSessionLC();

    iReceiveSession->IncomingSession( inSession, &container );

    CleanupStack::Pop( inSession );

    MUSENG_TEST_ASSERT_INCOMING_SESSION_ALLOC_FAILURE_L

    CMceDisplaySink* vfDisplay = 

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

    CMceDisplaySink* receivingDisplay = 

                   MusEngMceUtils::GetReceivingDisplayL( *( iReceiveSession->iSession ) );

    EUNIT_ASSERT( vfDisplay->DisplayRectL() == iReceiveSession->iLocalRect );

    EUNIT_ASSERT( receivingDisplay->DisplayRectL() != iReceiveSession->iLocalRect );

    TRect rect2( 200, 200, 300, 500 );

    iReceiveSession->SetSecondaryRectL( rect2 ); 

    EUNIT_ASSERT( rect2 == iReceiveSession->iLocalRect );

    EUNIT_ASSERT( vfDisplay->DisplayRectL() == iReceiveSession->iLocalRect );

    EUNIT_ASSERT( receivingDisplay->DisplayRectL() != iReceiveSession->iLocalRect );

    // Terminate session and try again, rect must not be changed

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

    TRect rect3( 300, 300, 400, 600 );

    iReceiveSession->SetSecondaryRectL( rect3 ); 

    EUNIT_ASSERT( vfDisplay->DisplayRectL() != rect3 )