/*

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

#include "musengstubs.h"

#include "musengtestdefs.h"

#include "musenglivesession.h"

#include "mussipprofilehandler.h"

#include "musengmceutils.h"

#include "mussettings.h"

//  SYSTEM INCLUDES

#include <digia/eunit/eunitmacros.h>

#include <mceoutsession.h>

#include <mcestreambundle.h>

#include <mcevideostream.h>

#include <mcecamerasource.h>

#include <mcertpsink.h>

#include <mcefilesink.h>

#include <mceh263codec.h>

#include <mceavccodec.h>

#include <mceaudiocodec.h>

//use step in different time period

const TInt KZoomBigStepCount = 15;

const TInt KZoomSmallStepCount = KZoomBigStepCount*2;

const TInt KZoomStepMinSize = 1;

// 0.4 second

const TInt64 KZoomFasterTime = 400000;//must bigger than 1/3 second

//insure that step is 1

#define USER_SLEEP  User::After(KZoomFasterTime)

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

//

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

//

UT_CMusEngLiveSession* UT_CMusEngLiveSession::NewL()

    {

    UT_CMusEngLiveSession* self = UT_CMusEngLiveSession::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

UT_CMusEngLiveSession* UT_CMusEngLiveSession::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

UT_CMusEngLiveSession::~UT_CMusEngLiveSession()

    {

    // NOP

    }

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

// Default constructor

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

//

UT_CMusEngLiveSession::UT_CMusEngLiveSession()

    {

    // NOP

    }

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

// Second phase construct

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

//

void UT_CMusEngLiveSession::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

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

//

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

//

void UT_CMusEngLiveSession::SetupL()

    }

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

//

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

//

void UT_CMusEngLiveSession::Teardown()

    {

    delete iLiveSession;

    delete iRecordedLiveSession;

    // Delete static data from CenRep stub

    CRepository::iStaticWriteAvcKeysToStaticData = EFalse;

    CRepository::DeleteStubAvcConfigKeys();

    CRepository::iForceFailWithCode = KErrNone;

    }

// TEST CASES

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

//

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

//

void UT_CMusEngLiveSession::UT_NewLL()

    {

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_CompleteSessionStructureLL()

    {

    CMceStreamBundle* localBundle = 

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

    TRAPD( error, iLiveSession->CompleteSessionStructureL( *localBundle ) );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    // Normal case

    CSIPProfile* profile = iLiveSession->iSipProfileHandler->Profile();

    iLiveSession->iSession = CMceOutSession::NewL( 

                                    *(iLiveSession->iManager),

                                    *profile,

                                    KTestRecipientSipUri8() );

    iLiveSession->CompleteSessionStructureL( *localBundle );

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

    EUNIT_ASSERT( iLiveSession->iSession->Streams().Count() == 1 );

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

    EUNIT_ASSERT( iLiveSession->iSession->Streams()[0]->Source() );

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

                  KMceCameraSource );

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

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

                  KMceRTPSink );

    // Test that also recording stream is constructed if needed

    iRecordedLiveSession->iSession = CMceOutSession::NewL( 

                                            *(iLiveSession->iManager),

                                            *profile,

                                            KTestRecipientSipUri8() );

    iRecordedLiveSession->CompleteSessionStructureL( *localBundle );

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

    CMceCameraSource* camera = 

            MusEngMceUtils::GetCameraL( *(iRecordedLiveSession->iSession) );

    // Check that there is recorded stream and that source is same camera

    CMceMediaSink* file = NULL;

    const RPointerArray<CMceMediaStream>& streams = 

                                    iRecordedLiveSession->iSession->Streams();

    for ( TInt i = 0; i < streams.Count(); ++i )

        {

        if ( streams[i]->Type() == KMceVideo )

            {

            if ( streams[i]->Sinks()[0]->Type() == KMceFileSink )

                {

                file = streams[i]->Sinks()[0];

                }

            EUNIT_ASSERT( streams[i]->Source() == camera )

            }

        }

    EUNIT_ASSERT( file )

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_AdjustVideoCodecLL()

    {

    CRepository::SetStubAvcConfigKeysL( KNullDesC8() );

    CMceVideoCodec* codecH263 = CMceH263Codec::NewLC( KMceSDPNameH263() );    

    CMceVideoCodec* codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );

    CMceVideoCodec* codecAvc = CMceAvcCodec::NewLC( KMceSDPNameH264() );

    CMceVideoCodec* codecUnknown = CMceH263Codec::NewLC( KNullDesC8() );

    // Test that bit rates has been set to H263 & AVC codecs

    EUNIT_ASSERT( codecH263->iAllowedBitrates == KMceAllowedH263BitrateAll )

    EUNIT_ASSERT( codecH263->iMaxBitRate == KMceH263Level45Bitrate )

    EUNIT_ASSERT( codecH263->iBitrate == 80000 )

    EUNIT_ASSERT( codecH2632000->iAllowedBitrates == 

                  KMceAllowedH263BitrateAll )

    EUNIT_ASSERT( codecH2632000->iMaxBitRate == KMceH263Level45Bitrate )

    EUNIT_ASSERT( codecH2632000->iBitrate == 80000 )

    EUNIT_ASSERT( codecAvc->iAllowedBitrates == 

                                        KMceAvcCodecProfileIdBaseline | 

                                        KMceAvcCodecProfileIopConstraintSet | 

                                        KMceAvcBitrateLevel1b )

    EUNIT_ASSERT( iLiveSession->iStoreEncoderConfigInfo )

    // Test that bitrates has not been set to unknown codecs

    EUNIT_ASSERT( codecUnknown->iAllowedBitrates != 

                  KMceAllowedH263BitrateAll )

    EUNIT_ASSERT( codecUnknown->iMaxBitRate != KMceH263Level45Bitrate )

    EUNIT_ASSERT( codecUnknown->iBitrate != KMceH263Level10Bitrate )

    // Test that base class has been called to all codecs

    EUNIT_ASSERT( codecH263->iPayloadType == 96 )

    EUNIT_ASSERT( codecH2632000->iPayloadType == 96 )

    EUNIT_ASSERT( codecAvc->iPayloadType == 98 )

    EUNIT_ASSERT( codecUnknown->iPayloadType == 0 )

    CleanupStack::PopAndDestroy( codecUnknown );

    CleanupStack::PopAndDestroy( codecAvc );

    CleanupStack::PopAndDestroy( codecH2632000 );

    CleanupStack::PopAndDestroy( codecH263 );

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_AdjustAudioCodecLL()

    {

    CMceAudioCodec* codec = 

                iLiveSession->iManager->SupportedAudioCodecs()[0]->CloneL();

    CleanupStack::PushL( codec );

    iLiveSession->AdjustAudioCodecL( *codec );

    // Does nothing so just test that base class has been called

    EUNIT_ASSERT( codec->iPayloadType == 97 )

    CleanupStack::PopAndDestroy( codec );

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_DoCodecSelectionLL()

    {

    CMceVideoStream* stream = CMceVideoStream::NewLC();

    CMceVideoCodec* codecH263 = CMceH263Codec::NewLC( _L8( "Foo" ) );

    stream->AddCodecL( codecH263 );

    CleanupStack::Pop( codecH263 );

    CMceVideoCodec* codecH2632000 = CMceH263Codec::NewLC( _L8( "Bar" ) );

    stream->AddCodecL( codecH2632000 );

    CleanupStack::Pop( codecH2632000 );

    CMceVideoCodec* codecAvc = CMceAvcCodec::NewLC( KMceSDPNameH264() );

    stream->AddCodecL( codecAvc );

    CleanupStack::Pop( codecAvc );

    // No assumptions so all the codecs are left to stream 

    iLiveSession->DoCodecSelectionL( *stream );    

    EUNIT_ASSERT_EQUALS( stream->Codecs().Count(), 3 )

    // Check that AVC codecs are removed if they are known to be not supported

    iLiveSession->DoCodecSelectionL( *stream );

    EUNIT_ASSERT_EQUALS( stream->Codecs().Count(), 2 )

    EUNIT_ASSERT( stream->Codecs()[0]->SdpName() != KMceSDPNameH264() )

    EUNIT_ASSERT( stream->Codecs()[1]->SdpName() != KMceSDPNameH264() )

    CleanupStack::PopAndDestroy( stream );

    }

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

// 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_CMusEngLiveSession::UT_StreamStateChangedL()

    {

    // Try without a session, nothing happens

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

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

                                                            *videoStream );

    CleanupStack::PopAndDestroy( videoStream );

    // Simulate sending invite

    // Try all the stream states

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

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

    changedStream->iState = CMceMediaStream::EUninitialized;

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

                                                            *changedStream );

    // EInitialized, stream is initialized

    changedStream->iState = CMceMediaStream::EInitialized;

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

                                                            *changedStream );

    // EBuffering, stream is buffering

    changedStream->iState = CMceMediaStream::EBuffering;

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

                                                            *changedStream );

    // EIdle, stream is not receiving RTP

    changedStream->iState = CMceMediaStream::EIdle;

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

                                                            *changedStream );

    // EStreaming, stream is streaming

    changedStream->iState = CMceMediaStream::EStreaming;

    // EDisabled, stream is explicitly disabled

    changedStream->iState = CMceMediaStream::EDisabled;

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

                                                            *changedStream );

    // ENoResources, stream has no needed resources to stream

    changedStream->iState = CMceMediaStream::ENoResources;

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

                                                            *changedStream );

    // ETranscodingRequired, stream requires non-realtime transcoding

    changedStream->iState = CMceMediaStream::ETranscodingRequired;

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

                                                            *changedStream );

    // ETranscoding, stream is transcoding in non-realtime

    changedStream->iState = CMceMediaStream::ETranscoding;

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

                                                            *changedStream );

    }

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

// 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_CMusEngLiveSession::UT_StreamStateChangedWithSourceL()

    {

    // Try without a session, nothing happens

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

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

                    *videoStream, 

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

    CleanupStack::PopAndDestroy(); // camera

    CleanupStack::PopAndDestroy( videoStream );

    // Simulate sending invite

    // Try all the stream states

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

    CMceMediaSource* changedSource = changedStream->Source();

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

    changedStream->iState = CMceMediaStream::EUninitialized;

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

                            *changedStream, *changedSource );

    // EInitialized, stream is initialized

    changedStream->iState = CMceMediaStream::EInitialized;

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

                            *changedStream, *changedSource );;

    // EBuffering, stream is buffering

    changedStream->iState = CMceMediaStream::EBuffering;

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

                            *changedStream, *changedSource );

    // EIdle, stream is not receiving RTP

    changedStream->iState = CMceMediaStream::EIdle;

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

                            *changedStream, *changedSource );

    // EStreaming, stream is streaming

    changedStream->iState = CMceMediaStream::EStreaming;