/*

* 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>

_LIT8( KMusAvcBitrateLevel1TestText, "TestTextForAvcBrL1Level" );

_LIT8( KMusAvcBitrateLevel1bTestText, "TestTextForAvcBrL1bLevel" );

_LIT8( KMusAvcBitrateLevel1_1TestText, "TestTextForAvcBrL1_1Level" );

_LIT8( KMusAvcBitrateLevel1_2TestText, "TestTextForAvcBrL1_2Level" );

_LIT8( KMusAvcBitrateLevel1_3TestText, "TestTextForAvcBrL1_3Level" );

_LIT8( KMusAvcBitrateLevel2TestText, "TestTextForAvcBrL2Level" );

_LIT8( KMusAvcBitrateLevel_1b_ConfigKey, "AvcBrL1b=TestTextForAvcBrL1bLevel;" );

_LIT8( KMusAvcBitrateLevel_1_1_ConfigKey, 

"AvcBrL1_1=TestTextForAvcBrL1_1Level;");

_LIT8( KMusAvcBitrateLevels_1_1_And_1b_ConfigKeys, 

"AvcBrL1_1=TestTextForAvcBrL1_1Level;\

AvcBrL1b=TestTextForAvcBrL1bLevel;" );

_LIT8( KMusAvcAllLevelsConcatenation,

"AvcBrL1=TestTextForAvcBrL1Level;\

AvcBrL1b=TestTextForAvcBrL1bLevel;\

AvcBrL1_1=TestTextForAvcBrL1_1Level;\

AvcBrL1_2=TestTextForAvcBrL1_2Level;\

AvcBrL1_3=TestTextForAvcBrL1_3Level;\

AvcBrL2=TestTextForAvcBrL2Level;" );

//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()

    {

    iObserver = new( ELeave ) CMusEngObserverStub;

    iLiveSession = CMusEngLiveSession::NewL( TRect(0, 0, 100, 100),

                                             *iObserver,

                                             *iObserver,

                                             *iObserver );

    iRecordedLiveSession = CMusEngLiveSession::NewL( KTestVideoFileName(),

                                                     TRect(0, 0, 100, 100),

                                                     *iObserver,

                                                     *iObserver,

                                                     *iObserver );    

    }

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

//

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

//

void UT_CMusEngLiveSession::Teardown()

    {

    delete iLiveSession;

    delete iRecordedLiveSession;

    delete iObserver;

    // Delete static data from CenRep stub

    CRepository::iStaticWriteAvcKeysToStaticData = EFalse;

    CRepository::DeleteStubAvcConfigKeys();

    CRepository::iForceFailWithCode = KErrNone;

    }

// TEST CASES

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

//

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

//

void UT_CMusEngLiveSession::UT_NewLL()

    {

    EUNIT_ASSERT( iLiveSession );

    EUNIT_ASSERT( iLiveSession->iRecordedFile == KNullDesC() );     

    EUNIT_ASSERT( iRecordedLiveSession ); 

    EUNIT_ASSERT( iRecordedLiveSession->iRecordedFile == KTestVideoFileName() );

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_CurrentZoomLL()

    {

    // Check that checking current zoom is not possible before invite

    TRAPD( error, iLiveSession->CurrentZoomL() );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    // simulate session establishment

    ESTABLISH_OUT_SESSION( iLiveSession );

    CMceCameraSource* camera = 

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

    // Check that originally current and default zoom are the same

    EUNIT_ASSERT( iLiveSession->iDefaultZoomFactor == 

                  iLiveSession->CurrentZoomL() );

    // Zoom to maximum optical value

    while ( camera->iZoomFactor < iLiveSession->iCameraInfo.iMaxZoom )

        {

        iLiveSession->ZoomInL();

        }

    EUNIT_ASSERT( iLiveSession->iCameraInfo.iMaxZoom == 

                  iLiveSession->CurrentZoomL() );    

    // Zoom using digital zoom

    iLiveSession->ZoomInL();

    EUNIT_ASSERT( iLiveSession->CurrentZoomL() == 

                    iLiveSession->iCameraInfo.iMaxZoom + 

                    camera->iDigitalZoomFactor )

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_MaxZoomLL()

    {

    // Check that checking maximum zoom is not possible before invite

    TRAPD( error, iLiveSession->MaxZoomL() );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    // simulate session establishment

    ESTABLISH_OUT_SESSION( iLiveSession );

    EUNIT_ASSERT( iLiveSession->MaxZoomL() == 

                    iLiveSession->iCameraInfo.iMaxZoom + 

                    iLiveSession->iCameraInfo.iMaxDigitalZoom );

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_ZoomInLL()

    {    

    // Check that zooming is not possible before invite

    TRAPD( error, iLiveSession->ZoomInL() );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    // simulate session establishment

    ESTABLISH_OUT_SESSION( iLiveSession );

    CMceCameraSource* camera = 

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

    // Check the default value

    EUNIT_ASSERT( iLiveSession->iDefaultZoomFactor == camera->iZoomFactor );

    // Check that zoom factor can be increased

    USER_SLEEP;  //insure that small step is used

    iLiveSession->ZoomInL();

    EUNIT_ASSERT( camera->iZoomFactor == iLiveSession->iDefaultZoomFactor +

            iLiveSession->iSmallZoomStep );

   //Check the "burst" mode (immediate second ZoomIn), big step should be used

    TInt nZoom = camera->iZoomFactor + camera->iDigitalZoomFactor;

    iLiveSession->ZoomInL();

    TInt nStep = camera->iZoomFactor + camera->iDigitalZoomFactor - nZoom;

    EUNIT_ASSERT( nStep == iLiveSession->iBigZoomStep );

    // Zoom to maximum optical value

    while ( camera->iZoomFactor < iLiveSession->iCameraInfo.iMaxZoom )

        {

        iLiveSession->ZoomInL();

        }

    TInt maxOpticalZoomFactor = camera->ZoomFactorL();

    // Check that digital zoom is used instead of optical

    iLiveSession->ZoomInL();

    EUNIT_ASSERT( camera->iZoomFactor == maxOpticalZoomFactor );

    EUNIT_ASSERT( camera->iDigitalZoomFactor > 0 );

    // Zoom to maximum digital value

    while ( camera->iDigitalZoomFactor < 

            iLiveSession->iCameraInfo.iMaxDigitalZoom )

        {

        iLiveSession->ZoomInL();

        }

    TInt maxDigitalZoomFactor = camera->DigitalZoomFactorL();

    // Check that further zooming is impossible

    iLiveSession->ZoomInL();

    EUNIT_ASSERT( camera->iZoomFactor == maxOpticalZoomFactor );

    EUNIT_ASSERT( camera->iDigitalZoomFactor == maxDigitalZoomFactor );

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_ZoomOutLL()

    {

    // Check that zooming is not possible before invite

    TRAPD( error, iLiveSession->ZoomOutL() );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    // simulate session establishment

    ESTABLISH_OUT_SESSION( iLiveSession );

    CMceCameraSource* camera = 

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

    // Check the default value

    EUNIT_ASSERT( iLiveSession->iDefaultZoomFactor == camera->iZoomFactor );

    // Simulate maximum zoom 

    camera->iZoomFactor = iLiveSession->iCameraInfo.iMaxZoom;

    camera->iDigitalZoomFactor = iLiveSession->iCameraInfo.iMaxDigitalZoom;

    // Check that digital zoom factor can be decreased

    USER_SLEEP;  //insure that small step is used

    iLiveSession->ZoomOutL();

    EUNIT_ASSERT( camera->iZoomFactor == iLiveSession->iCameraInfo.iMaxZoom );

    EUNIT_ASSERT( camera->iDigitalZoomFactor == 

                    iLiveSession->iCameraInfo.iMaxDigitalZoom - 

                    iLiveSession->iSmallZoomStep );

    //Check the "burst" mode (immediate second ZoomOut), big step should be used

    TInt nZoom = camera->iZoomFactor + camera->iDigitalZoomFactor;

    iLiveSession->ZoomOutL();

    TInt nStep;

    nStep = nZoom - (camera->iZoomFactor + camera->iDigitalZoomFactor );

    EUNIT_ASSERT( nStep == iLiveSession->iBigZoomStep );

    // Simulate maximum zoom again

    camera->iZoomFactor = iLiveSession->iCameraInfo.iMaxZoom;

    camera->iDigitalZoomFactor = iLiveSession->iCameraInfo.iMaxDigitalZoom;

    // Zoom to minimum digital zoom

    while ( camera->iDigitalZoomFactor > 0 )

        {

        iLiveSession->ZoomOutL();

        }

    EUNIT_ASSERT( camera->iZoomFactor == iLiveSession->iCameraInfo.iMaxZoom );

    EUNIT_ASSERT( camera->iDigitalZoomFactor == 0 );

    // Check that optical zoom is decreased instead of digital

    USER_SLEEP;  //insure that step is the small one

    iLiveSession->ZoomOutL();

    EUNIT_ASSERT( camera->iZoomFactor == 

                    iLiveSession->iCameraInfo.iMaxZoom -

                    iLiveSession->iSmallZoomStep );

    EUNIT_ASSERT( camera->iDigitalZoomFactor == 0 );

    // Zoom to minimum optical zoom

    while ( camera->iZoomFactor > iLiveSession->iCameraInfo.iMinZoom )

        {

        iLiveSession->ZoomOutL();

        }

    // Check that further zooming is impossible

    iLiveSession->ZoomOutL();

    EUNIT_ASSERT( camera->iZoomFactor == iLiveSession->iCameraInfo.iMinZoom );

    EUNIT_ASSERT( camera->iDigitalZoomFactor == 0 );

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_ZoomDefaultLL()

    {

    // Check that zooming is not possible before invite

    TRAPD( error, iLiveSession->ZoomDefaultL() );

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrNotReady );

    // simulate session establishment

    ESTABLISH_OUT_SESSION( iLiveSession );

    CMceCameraSource* camera = 

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

    // Check the default value

    EUNIT_ASSERT( iLiveSession->iDefaultZoomFactor == camera->iZoomFactor );

    // increase zoom factor so much that optical zoom is in maximum value

    // and digital zoom is in use

    while ( camera->iDigitalZoomFactor == 0 )

        {

        iLiveSession->ZoomInL();

        }

    EUNIT_ASSERT( camera->iZoomFactor > iLiveSession->iDefaultZoomFactor );

    EUNIT_ASSERT( camera->iDigitalZoomFactor > 0 );

    // back to default

    iLiveSession->ZoomDefaultL();

    EUNIT_ASSERT( camera->iZoomFactor == iLiveSession->iDefaultZoomFactor  );

    EUNIT_ASSERT( camera->iDigitalZoomFactor == 0 );

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_SetBrightnessLL()

    {

    // Check that setting brightness is not possible before invite

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                        iLiveSession->SetBrightnessL( KTestSomeBrightness ),

                        KErrNotReady )

    // simulate session establishment

    ESTABLISH_OUT_SESSION( iLiveSession );

    CMceCameraSource* camera = 

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

    camera->iCameraInfo.iOptionsSupported =

    camera->iCameraInfo.iOptionsSupported | TCameraInfo::EBrightnessSupported;

    // Check that originally current and default brightness are the same

    EUNIT_ASSERT_EQUALS( iLiveSession->iDefaultBrightness,

                         iLiveSession->CurrentBrightnessL() )

    // Test setting brightness

    iLiveSession->SetBrightnessL( KTestSomeBrightness );

    EUNIT_ASSERT_EQUALS( KTestSomeBrightness,

                         iLiveSession->CurrentBrightnessL() )

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_CurrentBrightnessLL()

    {

    // Check that checking current brightness is not possible before invite

    EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->CurrentBrightnessL(),

                                 KErrNotReady )

    // All the other stuff checked in tests of SetBrightnessL

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_MaxBrightnessLL()

    {

    // MaxBrightness should return a constant

    EUNIT_ASSERT_EQUALS( KTestMaxBrightness, iLiveSession->MaxBrightnessL() )

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_MinBrightnessLL()

    {

    // MinBrightness should return a constant

    EUNIT_ASSERT_EQUALS( KTestMinBrightness, iLiveSession->MinBrightnessL() )

    }

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

//

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

//

void UT_CMusEngLiveSession::UT_IncreaseBrightnessLL()

    {

    // Check that increasing brightness is not possible before invite

    EUNIT_ASSERT_SPECIFIC_LEAVE( iLiveSession->IncreaseBrightnessL(),

                                 KErrNotReady )

    // simulate session establishment

    ESTABLISH_OUT_SESSION( iLiveSession );

    CMceCameraSource* camera = 

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