/*

* 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 <digia/eunit/eunitmacros.h>

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

    {

    iObserver = new( ELeave ) CMusEngObserverStub;

    iClipSession = CMusEngClipSession::NewL( TRect(0,0, 100,100),

                                             *iObserver,

                                             *iObserver,

                                             *iObserver );

    iClipSession->SetClipL( KTestVideoFileName );

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

    SIPStrings::OpenL();

    }

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

//

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

//

void UT_CMusEngClipSession::Setup2L()

    {

    iObserver = new( ELeave ) CMusEngObserverStub;

    iClipSession = CMusEngClipSession::NewL( TRect(0,0, 100,100),

                                             *iObserver,

                                             *iObserver,

                                             *iObserver );

    iClipSession->SetClipL( KTestVideoFileName );

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

    SIPStrings::OpenL();

    }

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

//

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

//

void UT_CMusEngClipSession::Teardown()

    {

    SIPStrings::Close();

    delete iClipSession;

    delete iObserver;

    }

// TEST CASES

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

//

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

//

void UT_CMusEngClipSession::UT_NewLL()

    {

    EUNIT_ASSERT( iClipSession )

    EUNIT_ASSERT( iClipSession->iFileName != KNullDesC() )

    EUNIT_ASSERT( !iClipSession->iSession )

    }

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

//

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

//

void UT_CMusEngClipSession::UT_SetClipLL()

    {

    // Try with protected file, cannot use EUNIT_ASSERT_SPECIFIC_LEAVE

    TRAPD( error, iClipSession->SetClipL( KMusDrmProtectedFileName() ) )

    MUS_TEST_FORWARD_ALLOC_FAILURE( error );

    EUNIT_ASSERT( error == KErrPermissionDenied )

    EUNIT_ASSERT_EQUALS( iClipSession->iFileName, KTestVideoFileName() )

    // Change the file before session is established

    iClipSession->SetClipL( KTestAvcVideoFileName() );

    EUNIT_ASSERT_EQUALS( iClipSession->iFileName, KTestAvcVideoFileName() )

    EUNIT_ASSERT( !iClipSession->iSession )

    // simulate session establishment

    ESTABLISH_OUT_SESSION( iClipSession );

    // Now test with established session

    iClipSession->SetClipL( KTestVideoFileName() );

    CMceFileSource* file = 

                    MusEngMceUtils::GetFileSourceL( *iClipSession->iSession );

    EUNIT_ASSERT_EQUALS( iClipSession->iFileName, KTestVideoFileName() )

    EUNIT_ASSERT_EQUALS( file->iFileName, KTestVideoFileName() )

    }

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

//

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

//

void UT_CMusEngClipSession::UT_FastForwardLL()

    {

    // Try before establishment

    EUNIT_ASSERT_SPECIFIC_LEAVE( iClipSession->FastForwardL( ETrue ),

                                 KErrNotReady )

    // Establish session, simulate position and duration and try again   

    ESTABLISH_OUT_SESSION( iClipSession );

    CMceFileSource* file = 

                    MusEngMceUtils::GetFileSourceL( *iClipSession->iSession );

    file->iDuration = KMusEngTestFileDuration;

    file->iPosition = KMusEngTestFilePosition; 

    iClipSession->FastForwardL( ETrue );

    EUNIT_ASSERT( !file->iIsEnabled )

    EUNIT_ASSERT( iClipSession->iFFWDStartTime.Int64() > 0 )

    EUNIT_ASSERT( iClipSession->iFRWDStartTime.Int64() == 0 )

    // Simulate fastforwarding for a while

    User::After( 1000 );

    // Try to fastforward when already fastforwarding, will be ignored

    iClipSession->FastForwardL( ETrue );

    EUNIT_ASSERT( !file->iIsEnabled )

    EUNIT_ASSERT( iClipSession->iFFWDStartTime.Int64() > 0 )

    EUNIT_ASSERT( iClipSession->iFRWDStartTime.Int64() == 0 )

    // Stop fastforwarding

    iClipSession->FastForwardL( EFalse );

    EUNIT_ASSERT( file->iPosition > KMusEngTestFilePosition )

    EUNIT_ASSERT( file->iPosition != file->iDuration )

    EUNIT_ASSERT( !file->iIsEnabled )

    EUNIT_ASSERT( iClipSession->iFFWDStartTime.Int64() == 0 )

    EUNIT_ASSERT( iClipSession->iFRWDStartTime.Int64() == 0 )

    // Try to stop fastforwarding again, leaves 

    EUNIT_ASSERT_SPECIFIC_LEAVE( iClipSession->FastForwardL( EFalse ),

                                 KErrAlreadyExists )

    // Start fastrewinding

    iClipSession->FastRewindL( ETrue );

    EUNIT_ASSERT( !file->iIsEnabled )

    EUNIT_ASSERT( iClipSession->iFFWDStartTime.Int64() == 0 )

    EUNIT_ASSERT( iClipSession->iFRWDStartTime.Int64() > 0 )

    // Start fastforwarding, rewinding should be stopped and FFWD started

    iClipSession->FastForwardL( ETrue );

    EUNIT_ASSERT( !file->iIsEnabled )

    EUNIT_ASSERT( iClipSession->iFFWDStartTime.Int64() > 0 )

    EUNIT_ASSERT( iClipSession->iFRWDStartTime.Int64() == 0 )

    // Simulate fastforwarding for a while

    User::After( 1000 );

    // Simulate that clip is almost in end and fastforwarding would have 

    // continued over end, position should be set to duration.

    file->iPosition = TTimeIntervalMicroSeconds( file->iDuration.Int64() - 1 );

    iClipSession->FastForwardL( EFalse );

    EUNIT_ASSERT( file->iPosition == file->iDuration )

    EUNIT_ASSERT( !file->iIsEnabled )

    EUNIT_ASSERT( iClipSession->iFFWDStartTime.Int64() == 0 )

    EUNIT_ASSERT( iClipSession->iFRWDStartTime.Int64() == 0 )

    }

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

//

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

//

void UT_CMusEngClipSession::UT_FastRewindLL()

    {

    // Try before establishment

    EUNIT_ASSERT_SPECIFIC_LEAVE( iClipSession->FastRewindL( ETrue ),

                                 KErrNotReady )

    // Establish session, simulate position and duration and try again   

    ESTABLISH_OUT_SESSION( iClipSession );

    CMceFileSource* file = 

                    MusEngMceUtils::GetFileSourceL( *iClipSession->iSession );

    file->iDuration = KMusEngTestFileDuration;

    file->iPosition = KMusEngTestFilePosition; 

    iClipSession->FastRewindL( ETrue );

    EUNIT_ASSERT( !file->iIsEnabled )

    EUNIT_ASSERT( iClipSession->iFFWDStartTime.Int64() == 0 )

    EUNIT_ASSERT( iClipSession->iFRWDStartTime.Int64() > 0 )

    // Simulate fastrewinding for a while

    User::After( 1000 );

    // Try to fastrewind when already fastrewinding, will be ignored

    iClipSession->FastRewindL( ETrue );

    EUNIT_ASSERT( !file->iIsEnabled )

    EUNIT_ASSERT( iClipSession->iFFWDStartTime.Int64() == 0 )

    EUNIT_ASSERT( iClipSession->iFRWDStartTime.Int64() > 0 )

    // Stop fastrewinding

    iClipSession->FastRewindL( EFalse );

    EUNIT_ASSERT( file->iPosition < KMusEngTestFilePosition )

    EUNIT_ASSERT( file->iPosition != TTimeIntervalMicroSeconds( 0 ) )

    EUNIT_ASSERT( !file->iIsEnabled )

    EUNIT_ASSERT( iClipSession->iFFWDStartTime.Int64() == 0 )

    EUNIT_ASSERT( iClipSession->iFRWDStartTime.Int64() == 0 )

    // Try to stop fastrewinding again, leaves 

    EUNIT_ASSERT_SPECIFIC_LEAVE( iClipSession->FastRewindL( EFalse ),

                                 KErrAlreadyExists )

    // Start fastforwarding

    iClipSession->FastForwardL( ETrue );

    EUNIT_ASSERT( !file->iIsEnabled )

    EUNIT_ASSERT( iClipSession->iFFWDStartTime.Int64() >= 0 )

    EUNIT_ASSERT( iClipSession->iFRWDStartTime.Int64() == 0 )

    // Start fastrewinding, forwarding should be stopped and FFWD started

    iClipSession->FastRewindL( ETrue );

    EUNIT_ASSERT( !file->iIsEnabled );

    EUNIT_ASSERT( iClipSession->iFFWDStartTime.Int64() == 0 )

    EUNIT_ASSERT( iClipSession->iFRWDStartTime.Int64() >= 0 )

    // Simulate that clip has just begun and fastrewinding would have 

    // continued over beginning, position should be set to zero.

    file->iPosition = TTimeIntervalMicroSeconds( 1 );

    // Simulate fastrewinding for a while

    User::After( 1000 );

    iClipSession->FastRewindL( EFalse );

    EUNIT_ASSERT( file->iPosition == TTimeIntervalMicroSeconds( 0 ) )

    EUNIT_ASSERT( !file->iIsEnabled )

    EUNIT_ASSERT( iClipSession->iFFWDStartTime.Int64() == 0 )

    EUNIT_ASSERT( iClipSession->iFRWDStartTime.Int64() == 0 ) 

    }

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

//

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

//

void UT_CMusEngClipSession::UT_PositionLL()

    {

    // Try before establishment

    EUNIT_ASSERT_SPECIFIC_LEAVE( iClipSession->PositionL(), KErrNotReady )

    // Establish session and try again

    ESTABLISH_OUT_SESSION( iClipSession );

    CMceFileSource* file = 

                    MusEngMceUtils::GetFileSourceL( *iClipSession->iSession );

    file->iPosition = 2000000;

    EUNIT_ASSERT( iClipSession->PositionL().Int() * 1000000 == 

                  file->iPosition.Int64() )

    // Ask position while fastforwarding, it should be bigger than real position

    iClipSession->FastForwardL( ETrue );

    User::After( 1000000 ); // We have to wait since dividing in PositionL and 

                            // multiplying before comparison loses difference 

    EUNIT_ASSERT( iClipSession->PositionL().Int() * 1000000 >

                  file->iPosition.Int64() )

    // Ask position while fastforwarding beyond end of clip, clip duration is

    // returned

    file->iPosition = file->iDuration;

    EUNIT_ASSERT( iClipSession->PositionL().Int() * 1000000 ==

                  file->iDuration.Int64() )

    // Stop fastforwarding, start fastrewinding, position is set to the end clip

    iClipSession->FastForwardL( EFalse );

    iClipSession->FastRewindL( ETrue );

    User::After( 1000000 ); // We have to wait since dividing in PositionL and 

                            // multiplying before comparison loses difference 

    // Ask position while fastrewinding, it should be smaller than real 

    // position

    EUNIT_ASSERT( iClipSession->PositionL().Int() * 1000000 <

                  file->iPosition.Int64() )

    // Ask position while fastrewinding beyond the beginning of clip, zero 

    // returned

    file->iPosition = 0;

    EUNIT_ASSERT( iClipSession->PositionL().Int() * 1000000 == 0 )

    // Asking position when rewinded to beginning but rewinding has ended 

    // and clip has not ended (position should not be altered in that case)

    iClipSession->iRewindedToBeginning = ETrue;

    file->iPosition = 0;

    iClipSession->iFRWDStartTime = TTime( 0 );

    EUNIT_ASSERT( iClipSession->PositionL().Int() * 1000000 == 0 )

    // Position has proceeded from beginning, rewinding to beginning info

    // is cleared.

    file->iPosition = 10000000;

    iClipSession->iFRWDStartTime = TTime( 0 );

    iClipSession->iRewindedToBeginning = EFalse;

    EUNIT_ASSERT( iClipSession->PositionL().Int() * 1000000 == 10000000 )

    EUNIT_ASSERT( iClipSession->iRewindedToBeginning == EFalse )

    }

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

//

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

//

void UT_CMusEngClipSession::UT_DurationLL()

    {

    // Try before establishment

    EUNIT_ASSERT_SPECIFIC_LEAVE( iClipSession->DurationL(), KErrNotReady )

    // Establish session and try again

    ESTABLISH_OUT_SESSION( iClipSession );

    CMceFileSource* file = 

                    MusEngMceUtils::GetFileSourceL( *iClipSession->iSession );

    file->iDuration = 2000000;

    EUNIT_ASSERT( iClipSession->DurationL().Int() * 1000000 == 

                  file->iDuration.Int64() )

    }

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

//

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

//

void UT_CMusEngClipSession::UT_SetPositionLL()

    {

    TTimeIntervalSeconds time( 20 );

    // Try before establishment

    EUNIT_ASSERT_SPECIFIC_LEAVE( iClipSession->SetPositionL( time ),

                                 KErrNotReady )

    // Normal case with already disabled file source

    ESTABLISH_OUT_SESSION( iClipSession );

    CMceFileSource* file = 

                MusEngMceUtils::GetFileSourceL( *iClipSession->iSession ); 

    file->iIsEnabled = EFalse;

    iClipSession->SetPositionL( time );

    EUNIT_ASSERT( file->iPosition.Int64() == 

                  static_cast<TInt64>(time.Int()) * 1000000 )

    EUNIT_ASSERT( !file->iIsEnabled )

    // Normal case with enabled file source

    TTimeIntervalSeconds anotherTime( 30 );

    file->iIsEnabled = ETrue;

    iClipSession->SetPositionL( anotherTime );

    EUNIT_ASSERT( file->iPosition.Int64() == 

                  static_cast<TInt64>(anotherTime.Int()) * 1000000 )

    EUNIT_ASSERT( file->iIsEnabled )

    }

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

//

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

//

void UT_CMusEngClipSession::UT_TranscodeLToAvcL()

    {

    // Check that transcoding is not possible before invite

    EUNIT_ASSERT_SPECIFIC_LEAVE( 

                    iClipSession->TranscodeL( KTestVideoFileName() ),

                    KErrNotReady )

    // Construct session with video and audio streams that must transcoded 

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

    iClipSession->iSession = CMceOutSession::NewL( 

                                    *(iClipSession->iManager),

                                    *profile,

                                    KTestRecipientSipUri8() );

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

    CMceRtpSink* rtpsink = CMceRtpSink::NewLC();

    videoStream->AddSinkL( rtpsink );

    CleanupStack::Pop( rtpsink );

    CMceFileSource* fileSource = 

        CMceFileSource::NewLC( *iClipSession->iManager, KTestAvcVideoFileName() );