/*

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

#include "musengmceutils.h"

#include "mussipprofilehandler.h"

#include "musengstubs.h"

#include "musengtestdefs.h"

//  SYSTEM INCLUDES

#include <digia/eunit/eunitmacros.h>

#include <mcemanager.h>

#include <mceoutsession.h>

#include <mcevideostream.h>

#include <mceaudiostream.h>

#include <mcertpsink.h>

#include <mcedisplaysink.h>

#include <mcecamerasource.h>

#include <mcefilesource.h>

#include <mcespeakersink.h>

#include <mcertpsource.h>

#include <mcefilesink.h>

const TUint KSipProfileId( 1 );

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

//

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

//

UT_MusEngMceUtils* UT_MusEngMceUtils::NewL()

    {

    UT_MusEngMceUtils* self = UT_MusEngMceUtils::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

UT_MusEngMceUtils* UT_MusEngMceUtils::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

UT_MusEngMceUtils::~UT_MusEngMceUtils()

    {

    // NOP

    }

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

// Default constructor

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

//

UT_MusEngMceUtils::UT_MusEngMceUtils()

    {

    // NOP

    }

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

// Second phase construct

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

//

void UT_MusEngMceUtils::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

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

//

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

//

void UT_MusEngMceUtils::SetupL()

    {

    iManager = CMceManager::NewL( TUid::Null(), NULL );

    iProfileHandler->CreateProfileL( KSipProfileId );

    iEmptySession = CMceOutSession::NewL( *iManager, 

                                          *iProfileHandler->Profile(),

                                          KTestRecipientSipUri8() );

    // Contruct an outgoing video sesssion                                 

    iVideoOutSession = CMceOutSession::NewL( *iManager,

                                             *iProfileHandler->Profile(),

                                             KTestRecipientSipUri8() );

    CMceVideoStream* videoOut = CMceVideoStream::NewLC();

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

    CleanupStack::Pop();

    videoOut->AddSinkL( CMceDisplaySink::NewLC( *iManager ) );

    CleanupStack::Pop();

    videoOut->SetSourceL( CMceCameraSource::NewLC( *iManager ) );

    CleanupStack::Pop();

    iVideoOutSession->AddStreamL( videoOut );

    CleanupStack::Pop( videoOut );

    // Consruct a video session with incoming video and audio stream

    // Audio part

    iVideoInSession = CMceOutSession::NewL( *iManager,

                                            *iProfileHandler->Profile(), 

                                            KTestRecipientSipUri8() );

    CMceAudioStream* audioIn = CMceAudioStream::NewLC();

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

    CleanupStack::Pop();

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

    CleanupStack::Pop();

    iVideoInSession->AddStreamL( audioIn );

    CleanupStack::Pop( audioIn );

    // Video part

    CMceVideoStream* videoIn  = CMceVideoStream::NewLC();

    CleanupStack::Pop();

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

    CleanupStack::Pop();

    iVideoInSession->AddStreamL( videoIn );

    CleanupStack::Pop( videoIn );

    }

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

//

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

//

void UT_MusEngMceUtils::Teardown()

    {

    delete iEmptySession;

    delete iVideoOutSession;

    delete iVideoInSession;

    delete iProfileHandler;

    delete iManager;

    }

// TEST CASES

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

//

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

//

    {

    // Stream 0 is audio stream

    EUNIT_ASSERT( !MusEngMceUtils::IsVideoInStream( 

                                        *iVideoInSession->Streams()[0] ) )

    // No source

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

    EUNIT_ASSERT( !MusEngMceUtils::IsVideoInStream( *videoStream ) )

    CleanupStack::PopAndDestroy( videoStream );

    // Camera source

    EUNIT_ASSERT( !MusEngMceUtils::IsVideoInStream( 

                                        *iVideoOutSession->Streams()[0] ) )

    // Video in stream

    EUNIT_ASSERT( MusEngMceUtils::IsVideoInStream( 

                                        *iVideoInSession->Streams()[1] ) )

    }

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

//

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

//

    {

    // Stream 0 is video stream

    EUNIT_ASSERT( !MusEngMceUtils::IsAudioInStream( 

                                        *iVideoOutSession->Streams()[0] ) )

    // No source

    CMceAudioStream* audioStream = CMceAudioStream::NewLC();

    EUNIT_ASSERT( !MusEngMceUtils::IsAudioInStream( *audioStream ) )

    // File source

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

    CleanupStack::Pop();

    EUNIT_ASSERT( !MusEngMceUtils::IsAudioInStream( *audioStream ) )

    CleanupStack::PopAndDestroy( audioStream );

    // Audio in stream

    EUNIT_ASSERT( MusEngMceUtils::IsAudioInStream( 

                                        *iVideoInSession->Streams()[0] ) )

    }   

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

//

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

//

    {

    // No streams, must fail

    EUNIT_ASSERT_SPECIFIC_LEAVE(

                MusEngMceUtils::GetVideoOutStreamL( *iEmptySession ),

                KErrNotFound )

    // Add an audio out stream to empty sessionand and try again, still fails

    CMceAudioStream* audioStream = CMceAudioStream::NewLC();

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

    CleanupStack::Pop();

    iEmptySession->AddStreamL( audioStream );

    CleanupStack::Pop(audioStream);

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                MusEngMceUtils::GetVideoOutStreamL( *iEmptySession ),

                KErrNotFound )

    // Incoming video stream, fails

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                MusEngMceUtils::GetVideoOutStreamL( *iVideoInSession ),

                KErrNotFound )

    CMceVideoStream* videoStream = MusEngMceUtils::GetVideoOutStreamL( 

    EUNIT_ASSERT( videoStream )

    EUNIT_ASSERT( videoStream->Type() == KMceVideo )

    EUNIT_ASSERT( videoStream->Sinks().Count() == 2 ) // Rtp, Display

    EUNIT_ASSERT( videoStream->Sinks()[0]->Type() == KMceRTPSink )

    EUNIT_ASSERT( videoStream->Sinks()[1]->Type() == KMceDisplaySink )

    // Add another stream

    CMceVideoStream* videoOut = CMceVideoStream::NewLC();

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

    CleanupStack::Pop();

    videoOut->SetSourceL( CMceFileSource::NewLC( *iManager,

                                                 KTestVideoFileName() ) );

    CleanupStack::Pop();

    iVideoOutSession->AddStreamL( videoOut );

    CleanupStack::Pop( videoOut );

    // Now there are two outgoing video streams, must fail

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                MusEngMceUtils::GetVideoOutStreamL( *iVideoOutSession ),

                KErrOverflow )

    }

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

//

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

//

    {

    // No streams, must fail

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                MusEngMceUtils::GetVideoInStreamL( *iEmptySession ),

                KErrNotFound )

    // Outgoing video stream, fails

    EUNIT_ASSERT_SPECIFIC_LEAVE(

                MusEngMceUtils::GetVideoInStreamL( *iVideoOutSession ),

                KErrNotFound )

    // Add stream without source and try again, still fails

    CMceVideoStream* newVideoStream = CMceVideoStream::NewLC();

    iVideoOutSession->AddStreamL( newVideoStream );

    CleanupStack::Pop( newVideoStream );

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                MusEngMceUtils::GetVideoInStreamL( *iVideoOutSession ),

                KErrNotFound )

    // One incoming video stream, succeeds

    CMceVideoStream* videoStream = MusEngMceUtils::GetVideoInStreamL( 

                                                        *iVideoInSession );

    EUNIT_ASSERT( videoStream )

    EUNIT_ASSERT( videoStream->Type() == KMceVideo )

    EUNIT_ASSERT( videoStream->Sinks().Count() == 1 ) // Display

    EUNIT_ASSERT( videoStream->Sinks()[0]->Type() == KMceDisplaySink )

    EUNIT_ASSERT( videoStream->Source() )

    EUNIT_ASSERT( videoStream->Source()->Type() == KMceRTPSource )

    // Add another video in stream

    CMceVideoStream* videoIn = CMceVideoStream::NewLC();

    videoIn->AddSinkL( CMceDisplaySink::NewLC( *iManager ) );

    CleanupStack::Pop();

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

    CleanupStack::Pop();

    iVideoInSession->AddStreamL( videoIn );

    CleanupStack::Pop( videoIn );

    // Now there are two incoming video streams, must fail

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                MusEngMceUtils::GetVideoInStreamL( *iVideoInSession ),

                KErrOverflow )

    }

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

//

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

//

    {

    CMceVideoStream* recordingStream = 

                        MusEngMceUtils::GetRecordingStream( *iVideoInSession );

    EUNIT_ASSERT( !recordingStream )

    recordingStream = MusEngMceUtils::GetRecordingStream( *iVideoOutSession );

    EUNIT_ASSERT( !recordingStream )

    // Create recording stream

    CMceVideoStream* streamForRecording = CMceVideoStream::NewLC();

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

    streamForRecording->AddSinkL( fileSink );

    CleanupStack::Pop( fileSink );

    iVideoOutSession->AddStreamL( streamForRecording );

    CleanupStack::Pop( streamForRecording );

    // Test that it is found

    recordingStream = MusEngMceUtils::GetRecordingStream( *iVideoOutSession );

    EUNIT_ASSERT( recordingStream ) 

    EUNIT_ASSERT( recordingStream == streamForRecording )      

    }

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

// From stream

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

//

    {    

    CMceMediaSink* sink = MusEngMceUtils::GetMediaSink( 

                                            *(iVideoInSession->Streams()[0]), 

                                            KMceRTPSink );

    EUNIT_ASSERT( !sink )

    sink = MusEngMceUtils::GetMediaSink( *(iVideoOutSession->Streams()[0]), 

                                         KMceRTPSink );

    EUNIT_ASSERT( sink )

    EUNIT_ASSERT( sink->Type() == KMceRTPSink )

    }

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

// From stream

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

//

    {                                                      

    CMceMediaSink* sink = NULL;

    EUNIT_ASSERT_SPECIFIC_LEAVE(

            MusEngMceUtils::GetMediaSinkL( *(iVideoInSession->Streams()[0]), 

                                           KMceRTPSink ),

            KErrNotFound )

    sink = MusEngMceUtils::GetMediaSinkL( *(iVideoOutSession->Streams()[0]), 

                                          KMceRTPSink );

    EUNIT_ASSERT( sink->Type() == KMceRTPSink )

    }  

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

// From session

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

//

    {

    CMceMediaSink* sink = MusEngMceUtils::GetMediaSink( *iEmptySession, 

                                                        KMceRTPSink );

    EUNIT_ASSERT( !sink )

    sink = MusEngMceUtils::GetMediaSink( *iVideoOutSession, KMceRTPSink );

    EUNIT_ASSERT( sink )

    EUNIT_ASSERT( sink->Type() == KMceRTPSink )

    }

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

// From session

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

//

    {

    CMceMediaSink* sink = NULL;

    EUNIT_ASSERT_SPECIFIC_LEAVE( MusEngMceUtils::GetMediaSinkL( *iEmptySession, 

                                                                KMceRTPSink ),

                                 KErrNotFound )

    sink = MusEngMceUtils::GetMediaSinkL( *iVideoOutSession, KMceRTPSink );

    EUNIT_ASSERT( sink->Type() == KMceRTPSink )

    }  

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

//

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

//

    {

    // empty session fails

    EUNIT_ASSERT_SPECIFIC_LEAVE( MusEngMceUtils::GetCameraL( *iEmptySession ),

                                 KErrNotFound )

    // succeed

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iVideoOutSession );

    EUNIT_ASSERT( camera )

    EUNIT_ASSERT( camera->Type() == KMceCameraSource )

    // delete source from video out stream and try without it, fails

    iVideoOutSession->Streams()[0]->SetSourceL( NULL );

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                MusEngMceUtils::GetCameraL( *iVideoOutSession ),

                KErrNotFound )

    // Add file source and try again, still fails 

    iVideoOutSession->Streams()[0]->SetSourceL( 

                    CMceFileSource::NewLC( *iManager, KTestVideoFileName() ) );

    CleanupStack::Pop();

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                MusEngMceUtils::GetCameraL( *iVideoOutSession ),

                KErrNotFound )

    }

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

//

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

//

    {

    // empty session fails

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                MusEngMceUtils::GetFileSourceL( *iEmptySession ),

                KErrNotFound )

    // delete source from video out stream and try without it, fails

    iVideoOutSession->Streams()[0]->SetSourceL( NULL );

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                MusEngMceUtils::GetFileSourceL( *iVideoOutSession ),

                KErrNotFound )

    // Add camera source and try again, still fails 

    iVideoOutSession->Streams()[0]->SetSourceL( 

                                    CMceCameraSource::NewLC( *iManager ) );

    CleanupStack::Pop();

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                MusEngMceUtils::GetFileSourceL( *iVideoOutSession ),

                KErrNotFound )

    // Replace camera with file source, now succeeds    

    iVideoOutSession->Streams()[0]->SetSourceL(