/*

* Copyright (c) 2004 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:  

*

*/

//  CLASS HEADER

#include "UT_CAmrPayloadFormatWrite.h"

//  EXTERNAL INCLUDES

#include <e32base.h>

#include <digia/eunit/eunitmacros.h>

#ifdef EUNIT_ALLOC_TEST_ON

    #include <digia/eunit/CEunitAllocTestCaseDecorator.h>   //for using EUNIT_ALLOC_TEST

#endif

//  INTERNAL INCLUDES

#include "AmrPayloadFormatWrite.h"

#include "MccRtpDataSink.h"

#include <mmf/server/mmfdatasink.h>

#include <mmf/server/mmfdatasource.h>

#include "Mcculdatapath.h"

#include "mccuids.hrh"

#include "mccrtpmediaclock.h"

#include "mccresourcepool.h" 

#include "mccredpayloadwrite.h"

#include "amrpayloadencoder.h"

const TUid KRtpDataSink              =  { KImplUidRtpDataSink               };

// CONSTRUCTION

UT_CAmrPayloadFormatWrite* UT_CAmrPayloadFormatWrite::NewL()

    {

    UT_CAmrPayloadFormatWrite* self = UT_CAmrPayloadFormatWrite::NewLC(); 

    CleanupStack::Pop();

    return self;

    }

UT_CAmrPayloadFormatWrite* UT_CAmrPayloadFormatWrite::NewLC()

    {

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

    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_CAmrPayloadFormatWrite::~UT_CAmrPayloadFormatWrite()

    {   

    }

// Default constructor

UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite()

    {

    }

// Second phase construct

void UT_CAmrPayloadFormatWrite::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CAmrPayloadFormatWrite::SetupAL(  )

    {

    iAlloc = EFalse; // ETrue;

    CommonSetupL( ETrue );

    TMediaId mediaId( KUidMediaTypeAudio, 1 );

    // Datapath calls CreateSinkBufferL

    TBool bufferReference;

    iBuffer = iWrite->CreateSinkBufferL( mediaId, bufferReference );

    iWrite->SinkPrimeL();

    iWrite->SinkPlayL();

    } 

void UT_CAmrPayloadFormatWrite::Setup2AL(  )

    {

    // not call CreateSinkBufferL

    iAlloc = ETrue;

    CommonSetupL( ETrue );

    iWrite->SinkPrimeL();

    iWrite->SinkPlayL( );

    }

void UT_CAmrPayloadFormatWrite::SetupL(  )

    {

    iAlloc = EFalse;

    CommonSetupL( ETrue );

    TMediaId mediaId( KUidMediaTypeAudio, 1 );

    // Datapath calls CreateSinkBufferL

    TBool bufferReference;

    iBuffer = iWrite->CreateSinkBufferL( mediaId, bufferReference );

    iWrite->SinkStopL();

    iWrite->SinkPrimeL();

    iWrite->SinkPlayL();

    }

void UT_CAmrPayloadFormatWrite::SetupWbAL(  )

    {

    iAlloc = ETrue;

    CommonSetupL( EFalse );

    TMediaId mediaId( KUidMediaTypeAudio, 1 );

    // Datapath calls CreateSinkBufferL

    TBool bufferReference;

    iBuffer = iWrite->CreateSinkBufferL( mediaId, bufferReference );

    iWrite->SinkPrimeL();

    iWrite->SinkPlayL();

    } 

void UT_CAmrPayloadFormatWrite::SetupWbL(  )

    {

    iAlloc = EFalse;

    CommonSetupL( EFalse );

    TMediaId mediaId( KUidMediaTypeAudio, 1 );

    // Datapath calls CreateSinkBufferL

    TBool bufferReference;

    iBuffer = iWrite->CreateSinkBufferL( mediaId, bufferReference );

    iWrite->SinkStopL();

    iWrite->SinkPrimeL();

    iWrite->SinkPlayL();

    }

void UT_CAmrPayloadFormatWrite::CommonSetupL( TBool aIsNb )

    {

    MAsyncEventHandler* eventHandler = NULL;

    CMccResourcePool* mccresource = NULL;

    iRtpMediaClock = CMccRtpMediaClock::NewL();

    iUlSink = CMccUlDataPath::NewL( eventHandler, mccresource, iMediaId ); //MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );

    iRtpDataSinkStub = static_cast<CMccRtpDataSink*>(MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 ));  

    iWrite = CAmrPayloadFormatWrite::NewL( iRtpDataSinkStub );

    if ( aIsNb )    

        {

        iCodec.iFourCC.Set( TFourCC(' ','A','M','R') );

        iCodec.iBitrate = 12200;

        iCodec.iFrameSize = 32;

        }

    else

        {

        iCodec.iFourCC.Set( TFourCC(' ','A','W','B') );

        iCodec.iBitrate = 23850;

        iCodec.iFrameSize = 64;

        }

    iCodec.iCodecMode = KAmrCodecModeOctetAlign;

    iCodec.iPtime = 40;

    iCodec.iMaxPtime = 200;

    iCodec.iPayloadType = 96;

    iCodec.iRedundancyCount = 0;

    iCodec.iEnableDTX = EFalse;

    iCodec.iRedundantPayload = 0;

    iCodec.iHwFrameTime = 20;

    iCodec.iAlgoUsed = 0;

    iWrite->SetSinkDataTypeCode( iCodec.iFourCC, KUidMediaTypeAudio );

    TMccCodecInfoBuffer buffer( iCodec );

    iWrite->ConfigurePayloadFormatL( buffer, *iRtpMediaClock );

    iBuff = CMMFDescriptorBuffer::NewL( 300 );

    }

void UT_CAmrPayloadFormatWrite::Teardown(  )

    {

    delete iUlSink;

    delete iRtpDataSinkStub;

    delete iWrite;

    delete iBuff;

    delete iRtpMediaClock;

    REComSession::FinalClose();

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_CancelUlRequestL(  )

    {

    if( !iAlloc )

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->CancelUlRequest() );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->CancelUlRequest() );

       }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_EmptySourceBufferLL(  )

    {

    if( !iAlloc ) 

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->EmptySourceBufferL() );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->EmptySourceBufferL() );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_SourceBufferEmptiedLL(  )

    {

    EUNIT_ASSERT_NO_LEAVE( iWrite->EmptyBufferL( iBuffer, iUlSink, KUidMediaTypeAudio ) );

    EUNIT_ASSERT_NO_LEAVE( iWrite->SourceBufferEmptiedL( ) );     

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_FrameTimeIntervalL(  )

    { 

    TTimeIntervalMicroSeconds catchAfish;

    TMediaId mediaIdAudio( KUidMediaTypeAudio, 1 );

    TMediaId mediaIdVideo( KUidMediaTypeVideo, 1 );

    if ( !iAlloc )

        {

        EUNIT_ASSERT_NO_LEAVE( catchAfish = iWrite->FrameTimeInterval ( mediaIdAudio ) );

        EUNIT_ASSERT_NO_LEAVE( catchAfish = iWrite->FrameTimeInterval ( mediaIdVideo ) );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->FrameTimeInterval ( mediaIdAudio ) );

        EUNIT_ASSERT_NO_LEAVE( iWrite->FrameTimeInterval ( mediaIdVideo ) );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_DurationL(  )

    {

    TTimeIntervalMicroSeconds catchAfish;

    TMediaId mediaId( KUidMediaTypeAudio, 1 );

    if ( !iAlloc )

        {

        catchAfish = iWrite->Duration( mediaId );

        //EUNIT_ASSERT_EQUALS( catchAfish.Int64(), 1000000000 );

        EUNIT_ASSERT_EQUALS( catchAfish.Int64(), 0 );

        }

    else 

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->Duration( mediaId ) );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_NumChannelsL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_EQUALS( iWrite->NumChannels( ), iWrite->iChannels );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->NumChannels( ) );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_SampleRateL(  )

    {

    TUint samplerate;

    if ( !iAlloc )

        {

        samplerate = iWrite->SampleRate( );

        EUNIT_ASSERT_EQUALS( samplerate, iWrite->iSamplingRate );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->SampleRate( ) );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_SetSampleRateL(  )

    {

    TInt rate( 8000 );

    TInt wbrate( 16000 );

    if ( !iAlloc )

        {

        EUNIT_ASSERT( iWrite->SetSampleRate( rate ) == KErrNone );

        EUNIT_ASSERT( iWrite->SetSampleRate( rate + 1 ) == KErrNotSupported );

        EUNIT_ASSERT( iWrite->SetSampleRate( wbrate ) == KErrNotSupported );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->SetSampleRate( rate ) );

        EUNIT_ASSERT_NO_LEAVE( iWrite->SetSampleRate( rate + 1 ) );

        EUNIT_ASSERT_NO_LEAVE( iWrite->SetSampleRate( wbrate ) );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_SetSampleRateWbL(  )

    {

    TInt rate( 8000 );

    TInt wbrate( 16000 );

    if ( !iAlloc )

        {

        EUNIT_ASSERT( iWrite->SetSampleRate( wbrate ) == KErrNone );

        EUNIT_ASSERT( iWrite->SetSampleRate( wbrate + 1 ) == KErrNotSupported );

        EUNIT_ASSERT( iWrite->SetSampleRate( rate ) == KErrNotSupported );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->SetSampleRate( wbrate ) );

        EUNIT_ASSERT_NO_LEAVE( iWrite->SetSampleRate( wbrate + 1 ) );

        EUNIT_ASSERT_NO_LEAVE( iWrite->SetSampleRate( rate ) );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_CreateSinkBufferLL(  )

    {

    TMediaId mediaId( KUidMediaTypeAudio, 1 );

    TMediaId mediaIdVideo( KUidMediaTypeVideo, 1 );

    TBool reference;

    CMMFBuffer* buffer = NULL;

    EUNIT_ASSERT_SPECIFIC_LEAVE( buffer = iWrite->CreateSinkBufferL( mediaIdVideo, reference ), KErrNotSupported );

    EUNIT_ASSERT_NO_LEAVE( buffer = iWrite->CreateSinkBufferL( mediaId, reference ) );

    EUNIT_ASSERT(reference);

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_SinkDataTypeCodeL(  )

    {

    TMediaId mediaId( KUidMediaTypeAudio, 1 );

    TMediaId mediaIdVideo( KUidMediaTypeVideo, 1 );

    if ( !iAlloc )

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkDataTypeCode( mediaIdVideo ) );

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkDataTypeCode( mediaId ) );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkDataTypeCode( mediaIdVideo ) );

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkDataTypeCode( mediaId ) );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_SetSinkDataTypeCodeL(  )

    {

    TFourCC fourcc;

    TMediaId mediaId( KUidMediaTypeAudio, 1 );

    TMediaId mediaIdVideo( KUidMediaTypeVideo, 1 );

    if ( !iAlloc )

        {

        fourcc = iWrite->SinkDataTypeCode( mediaId );

        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaId ), KErrNone );

        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaIdVideo ), KErrNotSupported );

        fourcc = iWrite->SinkDataTypeCode( mediaIdVideo );

        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaId ), KErrNotSupported );

        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaIdVideo ), KErrNotSupported );

        }

    else

        {

        fourcc = iWrite->SinkDataTypeCode( mediaIdVideo );

        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaIdVideo ), KErrNotSupported );

        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaId ), KErrNotSupported );

        fourcc = iWrite->SinkDataTypeCode( mediaId  );

        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaId ), KErrNone );

        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaIdVideo ), KErrNotSupported );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_SinkThreadLogonL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_EQUALS( iWrite->SinkThreadLogon( *this ), KErrNone );

        }

    else

        {

        EUNIT_ASSERT_EQUALS( iWrite->SinkThreadLogon( *this ), KErrNone );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_SinkThreadLogoffL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkThreadLogoff() );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkThreadLogoff() );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_EmptyBufferLL(  )

    {

    TMediaId mediaId( KUidMediaTypeAudio, 1 );

    TMediaId mediaIdVideo( KUidMediaTypeVideo, 1 );

    EUNIT_ASSERT_NO_LEAVE( iWrite->EmptyBufferL( iBuffer, iUlSink, mediaId ) );

    EUNIT_ASSERT_SPECIFIC_LEAVE( iWrite->EmptyBufferL( iBuffer, iUlSink, mediaIdVideo ), KErrNotSupported );

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_BufferEmptiedLL(  )

    {

    // Only alloc test   

    if ( iAlloc )

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->BufferEmptiedL( iBuffer ) );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_SinkPrimeLL(  )

    {

    if ( !iAlloc ) 

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkPrimeL() );

        }

    else 

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkPrimeL() );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_SinkPauseLL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkPauseL() );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkPauseL() );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_SinkStopLL(  )

    {

    if ( !iAlloc )

        {

        //iWrite->iStateMachine = CFormatEncodeStateMachine::NewL(this);

        iWrite->iStateMachine->Cancel();

        iWrite->iStateMachine->ChangeState( EEmptySourceBuffer );

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkStopL() );

        iWrite->iStateMachine->Cancel();

        iWrite->iStateMachine->ChangeState( ESourceBufferEmptied );

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkStopL() );

        //delete iWrite->iStateMachine;

        //iWrite->iStateMachine = NULL;

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkStopL() );

        }

    }

void UT_CAmrPayloadFormatWrite::UT_CAmrPayloadFormatWrite_ConfigurePayloadFormatLL(  )

    {      

    if ( !iAlloc)

        {

        EUNIT_ASSERT_SPECIFIC_LEAVE( iWrite->ConfigurePayloadFormatL( TPckgBuf<TInt>( 4 ), *iRtpMediaClock ), 

                                     KErrArgument );

        TMccCodecInfo codec;

        codec.iRedundancyCount = 0;

        codec.iRedundantPayload = 0;

        codec.iHwFrameTime = 0;

        codec.iAlgoUsed = 0;

        iCodec.iFrameSize = 32;

        TMccCodecInfoBuffer buffer( codec );

        EUNIT_ASSERT_LEAVE( iWrite->ConfigurePayloadFormatL( buffer, *iRtpMediaClock ) );