/*

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

#include "musenglivevideoplayer.h"

#include "musengtestdefs.h"

//  SYSTEM INCLUDES

#include <eunitmacros.h>

#include <mceoutsession.h>

#include <mcevideostream.h>

#include <mcertpsink.h>

#include <mcecamerasource.h>

#include <mcefilesink.h>

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

//

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

//

UT_CMusEngLiveVideoPlayer* UT_CMusEngLiveVideoPlayer::NewL()

    {

    UT_CMusEngLiveVideoPlayer* self = UT_CMusEngLiveVideoPlayer::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

UT_CMusEngLiveVideoPlayer* UT_CMusEngLiveVideoPlayer::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

UT_CMusEngLiveVideoPlayer::~UT_CMusEngLiveVideoPlayer()

    {

    // NOP

    }

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

// Default constructor

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

//

UT_CMusEngLiveVideoPlayer::UT_CMusEngLiveVideoPlayer()

    {

    // NOP

    }

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

// Second phase construct

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

//

void UT_CMusEngLiveVideoPlayer::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }   

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

//

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

//

void UT_CMusEngLiveVideoPlayer::SetupL()

    {

    iMceSession = CMceOutSession::NewL();

    CMceVideoStream* videoStream = CMceVideoStream::NewLC(); 

    CMceRtpSink* rtpsink = CMceRtpSink::NewLC();

    videoStream->AddSinkL( rtpsink );

    CleanupStack::Pop( rtpsink );

    CMceCameraSource* camera = CMceCameraSource::NewLC();

    iCameraHandler.InitializeL( *camera );

    videoStream->SetSourceL( camera );

    CleanupStack::Pop( camera );

    iMceSession->AddStreamL( videoStream );

    CleanupStack::Pop( videoStream );

    iCameraHandler.SetSession( iMceSession );     

    iLiveVideoPlayer = 

        CMusEngLiveVideoPlayer::NewL(  

            iDisplayHandlerStub,

            iCameraHandler, 

            iLcAudioControlStub );

    iLiveVideoPlayer->SetMceSession( iMceSession );

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::Teardown()

    {

    delete iLiveVideoPlayer;

    delete iMceSession;

    iLcAudioControlStub.Reset();

    }

// TEST CASES

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_NewLL()

    {    

    }

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

// 

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

//

void UT_CMusEngLiveVideoPlayer::UT_LcVideoPlayerStateL()

    {

    // iMceSession not set

    iLiveVideoPlayer->SetMceSession( NULL );

    EUNIT_ASSERT_EQUALS( TInt( MLcVideoPlayer::EUnavailable ), 

                         TInt( iLiveVideoPlayer->LcVideoPlayerState() ) )    

    iLiveVideoPlayer->SetMceSession( iMceSession );

    // Establish Session and simulate media playing.

    iMceSession->iState = CMceSession::EEstablished;

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

        {

        iMceSession->Streams()[i]->iState = CMceMediaStream::EStreaming;

        }

    EUNIT_ASSERT_EQUALS( TInt( MLcVideoPlayer::EPlaying ), 

                         TInt( iLiveVideoPlayer->LcVideoPlayerState() ) )

    // Media streams unavailable

    iMceSession->Streams()[0]->iState = CMceMediaStream::EUninitialized;

    EUNIT_ASSERT_EQUALS( TInt( MLcVideoPlayer::EUnavailable ), 

                         TInt( iLiveVideoPlayer->LcVideoPlayerState() ) )

    // All other stream states

    iMceSession->Streams()[0]->iState = CMceMediaStream::EInitialized;	

    EUNIT_ASSERT_EQUALS( TInt( MLcVideoPlayer::EInit ), 

                         TInt( iLiveVideoPlayer->LcVideoPlayerState() ) )	

    iMceSession->Streams()[0]->iState = CMceMediaStream::EBuffering;

    EUNIT_ASSERT_EQUALS( TInt( MLcVideoPlayer::EBuffering ), 

                         TInt( iLiveVideoPlayer->LcVideoPlayerState() ) )

    iMceSession->Streams()[0]->iState = CMceMediaStream::EIdle;

    EUNIT_ASSERT_EQUALS( TInt( MLcVideoPlayer::EPaused ), 

                         TInt( iLiveVideoPlayer->LcVideoPlayerState() ) )	

    iMceSession->Streams()[0]->iState = CMceMediaStream::EDisabled;

    EUNIT_ASSERT_EQUALS( TInt( MLcVideoPlayer::EPaused ), 

                         TInt( iLiveVideoPlayer->LcVideoPlayerState() ) )

    iMceSession->Streams()[0]->iState = CMceMediaStream::EStreaming;

    EUNIT_ASSERT_EQUALS( TInt( MLcVideoPlayer::EPlaying ), 

                         TInt( iLiveVideoPlayer->LcVideoPlayerState() ) )

    iMceSession->Streams()[0]->iState = CMceMediaStream::ENoResources;

    EUNIT_ASSERT_EQUALS( TInt( MLcVideoPlayer::EUnavailable ), 

                         TInt( iLiveVideoPlayer->LcVideoPlayerState() ) )

    iMceSession->Streams()[0]->iState = CMceMediaStream::ETranscodingRequired;

    EUNIT_ASSERT_EQUALS( TInt( MLcVideoPlayer::EUnavailable ), 

                         TInt( iLiveVideoPlayer->LcVideoPlayerState() ) )

    iMceSession->Streams()[0]->iState = CMceMediaStream::ETranscoding;

    EUNIT_ASSERT_EQUALS( TInt( MLcVideoPlayer::EUnavailable ), 

                         TInt( iLiveVideoPlayer->LcVideoPlayerState() ) )

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_LcPlayL()

    {

    // Play

    iLiveVideoPlayer->LcPlayL();

    EUNIT_ASSERT( iLiveVideoPlayer->LcIsPlayingL() );

    // Pause

    iLiveVideoPlayer->LcPauseL();

    EUNIT_ASSERT( !iLiveVideoPlayer->LcIsPlayingL() );

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_LcWindowL()

    {

    EUNIT_ASSERT( iLiveVideoPlayer->LcWindow() == iLiveVideoPlayer )

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_LcCameraControlL()

    {

    EUNIT_ASSERT( iLiveVideoPlayer->LcCameraControl() == &iCameraHandler )

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_LcSourceFileControlL()

    {

    EUNIT_ASSERT( iLiveVideoPlayer->LcSourceFileControl() == NULL )

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_LcDestinationFileControlL()

    {

    EUNIT_ASSERT( 

        iLiveVideoPlayer->LcDestinationFileControl() == iLiveVideoPlayer )

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_LcAudioControlL()

    {

    EUNIT_ASSERT( iLiveVideoPlayer->LcAudioControl() == &iLcAudioControlStub )

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_LcZoomControlL()

    {

    EUNIT_ASSERT( iLiveVideoPlayer->LcZoomControl() == &iCameraHandler )

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_LcBrightnessControlL()

    {

    EUNIT_ASSERT( iLiveVideoPlayer->LcBrightnessControl() == &iCameraHandler )

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_EnableLcWindowL()

    {

    EUNIT_ASSERT( !iLiveVideoPlayer->IsLcWindowEnabled() )

    // Enable

    iLiveVideoPlayer->EnableLcWindowL( ETrue );

    EUNIT_ASSERT( iLiveVideoPlayer->IsLcWindowEnabled() )

    // Disable

    iLiveVideoPlayer->EnableLcWindowL( EFalse );

    EUNIT_ASSERT( !iLiveVideoPlayer->IsLcWindowEnabled() )    

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_LcWindowRectL()

    {

    TRect rect( 12, 34, 56, 78 );

    iLiveVideoPlayer->SetLcWindowRectL( rect );

    EUNIT_ASSERT( iLiveVideoPlayer->LcWindowRect() == rect )

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_LcWindowOrientationL()

    {

    iLiveVideoPlayer->SetLcWindowOrientationL( MLcWindow::EPortrait );

    EUNIT_ASSERT_EQUALS( TInt( MLcWindow::EPortrait ), 

                         TInt( iLiveVideoPlayer->LcWindowOrientationL() ) )

    iLiveVideoPlayer->SetLcWindowOrientationL( MLcWindow::ELandscape );

    EUNIT_ASSERT_EQUALS( TInt( MLcWindow::ELandscape ), 

                         TInt( iLiveVideoPlayer->LcWindowOrientationL() ) )

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_SetLcFileNameL()

    {

    EUNIT_ASSERT_EQUALS( KNullDesC(), iLiveVideoPlayer->LcFileName() )

    _LIT( KFileName, "my_clip.format");

    TFileName fileName( KFileName );

    iLiveVideoPlayer->SetLcFileNameL( fileName );

    EUNIT_ASSERT_EQUALS( fileName, iLiveVideoPlayer->LcFileName() )

    }

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

//

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

//

void UT_CMusEngLiveVideoPlayer::UT_LcRecordL()

    {

    // No MCE session

    iLiveVideoPlayer->SetMceSession( NULL );

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

        iLiveVideoPlayer->LcRecordL( ETrue ), KErrNotReady )

    // No file sink in the session

    iLiveVideoPlayer->SetMceSession( iMceSession );

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

        iLiveVideoPlayer->LcRecordL( ETrue ), KErrNotReady )      

    // Record, not yet recording

    EUNIT_ASSERT( !iLiveVideoPlayer->LcIsRecording() )

    CMceVideoStream* streamForRecording = CMceVideoStream::NewLC(); 

    CMceFileSink* fileSink = CMceFileSink::NewLC( KTestVideoFileName() );

    fileSink->DisableL();

    streamForRecording->AddSinkL( fileSink );

    CleanupStack::Pop( fileSink );

    iMceSession->AddStreamL( streamForRecording );

    CleanupStack::Pop( streamForRecording );   

    iLiveVideoPlayer->LcRecordL( ETrue );    

    EUNIT_ASSERT( iLiveVideoPlayer->LcIsRecording() )

    // Record, already recording

    iLiveVideoPlayer->LcRecordL( ETrue );    

    EUNIT_ASSERT( iLiveVideoPlayer->LcIsRecording() ) 

    // Stop recording

    iLiveVideoPlayer->LcRecordL( EFalse );    

    EUNIT_ASSERT( !iLiveVideoPlayer->LcIsRecording() )         

    // Stop recording, not anymore recording

    iLiveVideoPlayer->LcRecordL( EFalse );    

    EUNIT_ASSERT( !iLiveVideoPlayer->LcIsRecording() )

    }

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(

    UT_CMusEngLiveVideoPlayer,

    "UT_CMusEngLiveVideoPlayer",

    "UNIT" )

EUNIT_TEST(

    "NewL - test ",

    "CMusEngLiveVideoPlayer",

    "NewL",

    "FUNCTIONALITY",

    SetupL, UT_NewLL, Teardown)    

EUNIT_TEST(

    "LcVideoPlayerState - test ",

    "CMusEngLiveVideoPlayer",

    "LcVideoPlayerState",

    "FUNCTIONALITY",

    SetupL, UT_LcVideoPlayerStateL, Teardown)

EUNIT_TEST(

    "LcPlayL - test ",

    "CMusEngLiveVideoPlayer",

    "LcPlayL",

    "FUNCTIONALITY",

    SetupL, UT_LcPlayL, Teardown)

EUNIT_TEST(

    "LcWindow - test ",

    "CMusEngLiveVideoPlayer",

    "LcWindow",

    "FUNCTIONALITY",

    SetupL, UT_LcWindowL, Teardown)

EUNIT_TEST(

    "LcCameraControl - test ",

    "CMusEngLiveVideoPlayer",

    "LcCameraControl",

    "FUNCTIONALITY",

    SetupL, UT_LcCameraControlL, Teardown)

EUNIT_TEST(

    "LcSourceFileControl - test ",

    "CMusEngLiveVideoPlayer",

    "LcSourceFileControl",

    "FUNCTIONALITY",

    SetupL, UT_LcSourceFileControlL, Teardown)

EUNIT_TEST(

    "LcDestinationFileControl - test ",

    "CMusEngLiveVideoPlayer",

    "LcDestinationFileControl",

    "FUNCTIONALITY",

    SetupL, UT_LcDestinationFileControlL, Teardown)

EUNIT_TEST(

    "LcAudioControl - test ",

    "CMusEngLiveVideoPlayer",

    "LcAudioControl",

    "FUNCTIONALITY",

    SetupL, UT_LcAudioControlL, Teardown)

EUNIT_TEST(

    "LcZoomControl - test ",

    "CMusEngLiveVideoPlayer",

    "LcZoomControl",

    "FUNCTIONALITY",

    SetupL, UT_LcZoomControlL, Teardown)

EUNIT_TEST(

    "LcBrightnessControl - test ",

    "CMusEngLiveVideoPlayer",

    "LcBrightnessControl",

    "FUNCTIONALITY",

    SetupL, UT_LcBrightnessControlL, Teardown) 

EUNIT_TEST(

    "EnableLcWindowL - test ",

    "CMusEngLiveVideoPlayer",

    "EnableLcWindowL",

    "FUNCTIONALITY",

    SetupL, UT_EnableLcWindowL, Teardown)    

EUNIT_TEST(

    "LcWindowRect - test ",

    "CMusEngLiveVideoPlayer",

    "LcWindowRect",

    "FUNCTIONALITY",

    SetupL, UT_LcWindowRectL, Teardown)  

EUNIT_TEST(

    "LcWindowOrientation - test ",

    "CMusEngLiveVideoPlayer",

    "LcWindowOrientation",

    "FUNCTIONALITY",

    SetupL, UT_LcWindowOrientationL, Teardown)

EUNIT_TEST(

    "SetLcFileNameL - test ",

    "CMusEngLiveVideoPlayer",

    "SetLcFileNameL",

    "FUNCTIONALITY",

    SetupL, UT_SetLcFileNameL, Teardown)    

EUNIT_TEST(

    "LcRecordL - test ",

    "CMusEngLiveVideoPlayer",

    "LcRecordL",

    "FUNCTIONALITY",

    SetupL, UT_LcRecordL, Teardown)    

EUNIT_END_TEST_TABLE

//  END OF FILE