/*

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

#include "musengstubs.h"

#include "musengtestdefs.h"

#include "musengclipsession.h"

#include "mussipprofilehandler.h"

#include "musengmceutils.h"

//  SYSTEM INCLUDES

#include <mceoutsession.h>

#include <mcestreambundle.h>

#include <mcevideostream.h>

#include <mceaudiostream.h>

#include <mcefilesource.h>

#include <mcertpsink.h>

#include <mcedisplaysink.h>

#include <mcespeakersink.h>

#include <mcertpsource.h>

#include <mcevideocodec.h>

#include <mceamrcodec.h>

#include <drmcommon.h>

#include <sipprofile.h>

#include <sipstrings.h>

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

//

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

//

UT_CMusEngClipSession* UT_CMusEngClipSession::NewL()

    {

    UT_CMusEngClipSession* self = UT_CMusEngClipSession::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

UT_CMusEngClipSession* UT_CMusEngClipSession::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

UT_CMusEngClipSession::~UT_CMusEngClipSession()

    {

    // NOP

    }

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

// Default constructor

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

//

UT_CMusEngClipSession::UT_CMusEngClipSession()

    {

    // NOP

    }

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

// Second phase construct

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

//

void UT_CMusEngClipSession::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

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

//

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

//

void UT_CMusEngClipSession::SetupL()

    {

    iClipSession->iVideoCodecList = KMceSDPNameH264().AllocL();

    SIPStrings::OpenL();

    }

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

//

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

//

void UT_CMusEngClipSession::Teardown()

    {

    SIPStrings::Close();

    delete iClipSession;

    }

// TEST CASES

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

//

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

//

void UT_CMusEngClipSession::UT_NewLL()

    {

    EUNIT_ASSERT( iClipSession )

    EUNIT_ASSERT( !iClipSession->iSession )

    }

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

//

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

//

void UT_CMusEngClipSession::UT_CompleteSessionStructureLL()

    CMceStreamBundle* localBundle = 

    // Check that structure cannot be completed before creating the session

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                iClipSession->CompleteSessionStructureL( *localBundle ),

                KErrNotReady )

    iClipSession->iSession = CMceOutSession::NewL( 

    iClipSession->CompleteSessionStructureL( *localBundle );

    EUNIT_ASSERT( iClipSession->iSession->Streams().Count() == 3 )

    EUNIT_ASSERT( iClipSession->iSession->Streams()[0]->Type() == KMceVideo )

    EUNIT_ASSERT( iClipSession->iSession->Streams()[0]->Source() )

    EUNIT_ASSERT( iClipSession->iSession->Streams()[0]->Source()->Type() ==

    EUNIT_ASSERT( iClipSession->iSession->Streams()[0]->Sinks().Count() == 1 )

    EUNIT_ASSERT( iClipSession->iSession->Streams()[0]->Sinks()[0]->Type() ==

                  KMceRTPSink )

    // Check that only stream with speaker has been added to a bundle

    EUNIT_ASSERT( localBundle->Streams().Count() == 1 )

    EUNIT_ASSERT( localBundle->Streams()[0]->Type() == KMceAudio )

    EUNIT_ASSERT( localBundle->Streams()[0]->Sinks().Count() > 0 )

    EUNIT_ASSERT( localBundle->Streams()[0]->Sinks()[0]->Type() == 

                  KMceSpeakerSink )

    CleanupStack::PopAndDestroy( localBundle );

    }

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

// Although all states are not meaningfull for LiveSession, all states are

// tested in order to force the updating of unit tests when behavior is changed 

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

//

void UT_CMusEngClipSession::UT_StreamStateChangedL()

    {

    // Try without a session, nothing happens

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *videoStream );

    CleanupStack::PopAndDestroy( videoStream );

    // Simulate sending invite

    // Try all the stream states

    CMceMediaStream* changedStream = iClipSession->iSession->Streams()[0];

    // EUninitialized, stream is created, unexpected change, nothing happens

    changedStream->iState = CMceMediaStream::EUninitialized;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream );

    // EInitialized, stream is initialized

    changedStream->iState = CMceMediaStream::EInitialized;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream );

    // EBuffering, stream is buffering

    changedStream->iState = CMceMediaStream::EBuffering;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream );

    // EIdle, stream is not receiving RTP

    changedStream->iState = CMceMediaStream::EIdle;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream );

    // EStreaming, stream is streaming

    changedStream->iState = CMceMediaStream::EStreaming;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream );

    // EDisabled, stream is explicitly disabled

    changedStream->iState = CMceMediaStream::EDisabled;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream );

    // ENoResources, stream has no needed resources to stream

    changedStream->iState = CMceMediaStream::ENoResources;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream );

    // ETranscodingRequired, stream requires non-realtime transcoding

    changedStream->iState = CMceMediaStream::ETranscodingRequired;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream );

    // ETranscoding, stream is transcoding in non-realtime

    changedStream->iState = CMceMediaStream::ETranscoding;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream );

    }

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

// Although all states are not meaningfull for ClipSession, all states are

// tested in order to force the updating of unit tests when behavior is changed 

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

//

void UT_CMusEngClipSession::UT_StreamStateChangedWithSourceL()

    {

    // Try without a session, nothing happens

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

    CMceRtpSource* rtpSource = CMceRtpSource::NewLC();

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                    *videoStream,

                    *rtpSource );     

    CleanupStack::PopAndDestroy( rtpSource );         

    CleanupStack::PopAndDestroy( videoStream );

    // Simulate sending invite

    // Try all the non-default stream states

    CMceMediaStream* changedStream = iClipSession->iSession->Streams()[0];

    CMceMediaSource* changedSource = changedStream->Source();

    // EDisabled, end of clip

    changedStream->iState = CMceMediaStream::EDisabled;

    changedSource->iIsEnabled = EFalse;

    iClipSession->StreamStateChanged( *changedStream, *changedSource );

    changedSource->iIsEnabled = ETrue;

    // Test default stream state change behavior, remove or change when

    // behavior changes

    // EUninitialized, stream is created, unexpected change, nothing happens

    changedStream->iState = CMceMediaStream::EUninitialized;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                            *changedStream, *changedSource );

    // EInitialized, stream is initialized

    changedStream->iState = CMceMediaStream::EInitialized;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                            *changedStream, *changedSource );

    // Special meaning (Transcoding ready), tested separately

    // EBuffering, stream is buffering

    changedStream->iState = CMceMediaStream::EBuffering;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                            *changedStream, *changedSource );

    // EIdle, stream is not receiving RTP

    changedStream->iState = CMceMediaStream::EIdle;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                            *changedStream, *changedSource );

    // EStreaming, stream is streaming

    changedStream->iState = CMceMediaStream::EStreaming;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                            *changedStream, *changedSource );

    // EDisabled, stream is explicitly disabled

    // This state has non-default meaning, tested before defaults

    // ENoResources, stream has no needed resources to stream

    changedStream->iState = CMceMediaStream::ENoResources;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                            *changedStream, *changedSource );

    }

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

// Although all states are not meaningfull for LiveSession, all states are

// tested in order to force the updating of unit tests when behavior is changed 

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

//

void UT_CMusEngClipSession::UT_StreamStateChangedWithSinkL()

    {

    // Try without a session, nothing happens

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                        *videoStream,

                                                        *CMceRtpSink::NewLC() );

    CleanupStack::PopAndDestroy(); // rtp

    CleanupStack::PopAndDestroy( videoStream );

    // Simulate sending invite

    // Test default stream state change behavior

    CMceMediaStream* changedStream = iClipSession->iSession->Streams()[0];

    CMceMediaSink* changedSink = changedStream->Sinks()[0];

    // EUninitialized, stream is created, unexpected change, nothing happens

    changedStream->iState = CMceMediaStream::EUninitialized;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream,

                                                            *changedSink );

    // EInitialized, stream is initialized

    changedStream->iState = CMceMediaStream::EInitialized;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream,

                                                            *changedSink );

    // EBuffering, stream is buffering

    changedStream->iState = CMceMediaStream::EBuffering;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream,

                                                            *changedSink );

    // EIdle, stream is not receiving RTP

    changedStream->iState = CMceMediaStream::EIdle;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream,

                                                            *changedSink );

    // EStreaming, stream is streaming

    changedStream->iState = CMceMediaStream::EStreaming;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream,

                                                            *changedSink );

    // EDisabled, stream is explicitly disabled

    changedStream->iState = CMceMediaStream::EDisabled;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream,

                                                            *changedSink );

    // ENoResources, stream has no needed resources to stream

    changedStream->iState = CMceMediaStream::ENoResources;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream,

                                                            *changedSink );

    // ETranscodingRequired, stream requires non-realtime transcoding

    changedStream->iState = CMceMediaStream::ETranscodingRequired;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream,

                                                            *changedSink );

    // ETranscoding, stream is transcoding in non-realtime

    changedStream->iState = CMceMediaStream::ETranscoding;

    static_cast<MMceStreamObserver*>(iClipSession)->StreamStateChanged( 

                                                            *changedStream,

                                                            *changedSink );

    }

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

//

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

//

void UT_CMusEngClipSession::UT_AddAmrCodecLL()

    {

    // Check that all the codecs are replaced with AMR codec

    CMceAudioStream* audioStream = CMceAudioStream::NewLC();

    audioStream->InitializeL( iClipSession->iManager );

    EUNIT_ASSERT( audioStream->Codecs().Count() == 2 )

    iClipSession->AddAmrCodecL( *audioStream );

    EUNIT_ASSERT( audioStream->Codecs().Count() == 1 )

    EUNIT_ASSERT( audioStream->Codecs()[0]->SdpName() == KMceSDPNameAMR() )

    EUNIT_ASSERT( audioStream->Codecs()[0]->AllowedBitrates() == 

                  KMceAllowedAmrNbBitrate475 )

    EUNIT_ASSERT( audioStream->Codecs()[0]->Bitrate() == 

                  KMceAmrNbBitrate475 )

    // Check that function leaves  if there is no AMR codec

    iClipSession->iManager->iSupportedAudioCodecs.ResetAndDestroy();

    EUNIT_ASSERT_SPECIFIC_LEAVE( iClipSession->AddAmrCodecL( *audioStream ),

                                 KErrNotFound )

    CleanupStack::PopAndDestroy( audioStream );

    }

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

//

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

//

void UT_CMusEngClipSession::UT_AddVideoCodecLL()

    {

    // Check that all the codecs are replaced with H263 codec if other end

    // does not support H264

    //

    delete iClipSession->iVideoCodecList;

    iClipSession->iVideoCodecList = NULL;

    iClipSession->iVideoCodecList = KMceSDPNameH263().AllocL();

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

    videoStream->InitializeL( iClipSession->iManager );

    EUNIT_ASSERT( videoStream->Codecs().Count() > 1 )

    iClipSession->AddVideoCodecL( *videoStream );

    EUNIT_ASSERT( videoStream->Codecs().Count() == 1 )

    EUNIT_ASSERT( videoStream->Codecs()[0]->SdpName() == KMceSDPNameH2632000() )

    // Check that all codecs are replaced with H264 codec if other end

    // supports it

    //

    _LIT8( KMusTestCodecListDelim, ";" );

    delete iClipSession->iVideoCodecList;

    iClipSession->iVideoCodecList = NULL;

    iClipSession->iVideoCodecList = 

        HBufC8::NewL( KMceSDPNameH263().Length() + 

                      KMceSDPNameH264().Length() + 

                      KMusTestCodecListDelim().Length() );

    iClipSession->iVideoCodecList->Des().Copy( KMceSDPNameH263() );

    iClipSession->iVideoCodecList->Des().Append( KMusTestCodecListDelim() );