/*

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

#include "mccuids.hrh"

#include "Mccdldatapath.h"

#include "mccresourcepool.h"

#include "mccredpayloadread.h"

#include "mccrtpdatasource.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 "IlbcPayloadFormatRead.h"

const TUid KRtpDataSource            =  { KImplUidRtpDataSource   };

const TUid KRtpDataSink              =  { KImplUidRtpDataSink     };

const TUint KiLBCSampleRate = 8000; //8 kHz

// CONSTRUCTION

UT_CIlbcPayloadFormatRead* UT_CIlbcPayloadFormatRead::NewL()

    {

    UT_CIlbcPayloadFormatRead* self = UT_CIlbcPayloadFormatRead::NewLC(); 

    CleanupStack::Pop();

    return self;

    }

UT_CIlbcPayloadFormatRead* UT_CIlbcPayloadFormatRead::NewLC()

    {

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

    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_CIlbcPayloadFormatRead::~UT_CIlbcPayloadFormatRead()

    {

    }

// Default constructor

UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead()

    {

    }

// Second phase construct

void UT_CIlbcPayloadFormatRead::ConstructL()

    {

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

    // It generates the test case table.

    iFourCC.Set( TFourCC( 'I','L','B','C' ) );

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CIlbcPayloadFormatRead::SetupAL(  )

    {

    iAlloc = ETrue;

    iRtpDataSourceStub = MDataSource::NewSourceL( KRtpDataSource, KNullDesC8 );

    iMediaId = KUidMediaTypeAudio;

    MAsyncEventHandler* eventHandler = NULL;

    CMccResourcePool* mccresource = NULL;

    iDLDataPathStub = CMccDlDataPath::NewL( eventHandler, mccresource, iMediaId ); 

    iRead = CIlbcPayloadFormatRead::NewL( iRtpDataSourceStub );

    iConsumer = MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );

    iBuffi = CMMFDescriptorBuffer::NewL( 10 );

    iBuffi->Data().Append( _L("1234512345") ); 

    iCodec.iAlgoUsed = ENoAlgoUsed;

    iCodec.iBitrate = 15200;

    iCodec.iCNFrameSize = 0;

    iCodec.iCodecMode = 3;

    iCodec.iEnableDTX = 1;

    iCodec.iFourCC = 0x31313747;

    iCodec.iFrameSize = 0;

    iCodec.iHwFrameTime = 20;

    iCodec.iMaxPtime = 200;

    iCodec.iPayloadType = 8;

    iCodec.iPtime = 20;

    iCodec.iRedundancyCount = 0;

    iCodec.iRedundantPayload = 99;

    TMccCodecInfoBuffer buffer( iCodec );

    iRead->SetSourceDataTypeCode( iFourCC, KUidMediaTypeAudio );

    iRead->SourceThreadLogon( *this );

    iRead->ConfigurePayloadFormatL( buffer );

    iRead->NegotiateSourceL( *iDLDataPathStub );

    iRead->SourcePrimeL();

    iRead->SourcePlayL();

    } 

void UT_CIlbcPayloadFormatRead::SetupL(  )

    {

    iAlloc = EFalse; 

    iRtpDataSourceStub = MDataSource::NewSourceL( KRtpDataSource, KNullDesC8 );

    iMediaId = KUidMediaTypeAudio;

    MAsyncEventHandler* eventHandler = NULL;

    CMccResourcePool* mccresource = NULL;

    iDLDataPathStub = CMccDlDataPath::NewL( eventHandler, mccresource, iMediaId ); 

    EUNIT_ASSERT_LEAVE( iRead = CIlbcPayloadFormatRead::NewL( NULL ));

    iRead = CIlbcPayloadFormatRead::NewL( iRtpDataSourceStub );

    iConsumer = MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );

    iBuffi = CMMFDescriptorBuffer::NewL( 10 );

    iBuffi->Data().Append( _L("1234512345") ); 

    iCodec.iAlgoUsed = ENoAlgoUsed;

    iCodec.iBitrate = 15200;

    iCodec.iCNFrameSize = 20;

    iCodec.iCodecMode = 3;

    iCodec.iEnableDTX = 1;

    iCodec.iFourCC = 0x31313747;

    iCodec.iFrameSize = 20;

    iCodec.iHwFrameTime = 20;

    iCodec.iMaxPtime = 200;

    iCodec.iPayloadType = 8;

    iCodec.iPtime = 20;

    iCodec.iRedundancyCount = 0;

    iCodec.iRedundantPayload = 99;

    TMccCodecInfoBuffer buffer( iCodec );

    iRead->SetSourceDataTypeCode( iFourCC, KUidMediaTypeAudio );

    iRead->SourceThreadLogon( *this );

    iRead->ConfigurePayloadFormatL( buffer );

    iRead->NegotiateSourceL( *iDLDataPathStub );

    iRead->SourcePrimeL();

    iRead->SourcePlayL();

    } 

void UT_CIlbcPayloadFormatRead::Teardown(  )

    {

    delete iBuffi;

    delete iDLDataPathStub;   

    delete iRtpDataSourceStub;

    delete iRead;   

    delete iConsumer;

    REComSession::FinalClose();

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_SendDataToSinkLL(  )

    {

    if ( !iAlloc )

        {       

        EUNIT_ASSERT_NO_LEAVE( iRead->FillBufferL( iBuffi, iDLDataPathStub, iMediaId ) );

        EUNIT_ASSERT_NO_LEAVE( iRead->SendDataToSinkL() );

        EUNIT_ASSERT_NO_LEAVE( iRead->FillBufferL( iBuffi, iDLDataPathStub, iMediaId ) );

        EUNIT_ASSERT_NO_LEAVE( iRead->SendDataToSinkL() );

        iRead->iBufferToReadExists = ETrue;

        EUNIT_ASSERT_NO_LEAVE( iRead->FillBufferL( iBuffi, iDLDataPathStub, iMediaId ) );

        EUNIT_ASSERT_NO_LEAVE( iRead->SendDataToSinkL() );

        }        

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->FillBufferL( iBuffi, iDLDataPathStub, iMediaId ) );

        EUNIT_ASSERT_NO_LEAVE( iRead->SendDataToSinkL() );       

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_FillSinkBufferL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->FillSinkBufferL() );

        iRead->iBufferToReadExists = 1;

        EUNIT_ASSERT_NO_LEAVE( iRead->FillSinkBufferL() );

        iRead->iCnFrame = 1;

        EUNIT_ASSERT_NO_LEAVE( iRead->FillSinkBufferL() );

        iRead->iCurrentBuffer = iRead->EBufferTwo;

        EUNIT_ASSERT_NO_LEAVE( iRead->FillSinkBufferL() ); 

        iRead->iCurrentBuffer = iRead->EBufferOne;

        iRead->iCInfo.iCodecMode =  KIlbcMode20msFrame;

        EUNIT_ASSERT_NO_LEAVE( iRead->FillSinkBufferL() );

        iRead->iFrameIndex = 5;  

        EUNIT_ASSERT_NO_LEAVE( iRead->FillSinkBufferL() );

        }        

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->FillSinkBufferL() );

        } 

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_FillSourceBufferLL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->FillSourceBufferL() );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->FillSourceBufferL() );

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_StreamsL(  )

    {

    TUid uid = {0x101F7D07};

    if ( !iAlloc )

        {

        EUNIT_ASSERT_EQUALS( iRead->Streams( KUidMediaTypeAudio ), 1 );

        EUNIT_ASSERT_EQUALS( iRead->Streams( KUidMediaTypeVideo ), 0 );

        EUNIT_ASSERT_EQUALS( iRead->Streams( KUidMediaTypeMidi ), 0 );

        EUNIT_ASSERT_EQUALS( iRead->Streams( uid ), 0 );

        }

    else

        {

        EUNIT_ASSERT_EQUALS( iRead->Streams( KUidMediaTypeAudio ), 1 );

        EUNIT_ASSERT_EQUALS( iRead->Streams( KUidMediaTypeVideo ), 0 );

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_FrameTimeIntervalL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_EQUALS( iRead->FrameTimeInterval( KUidMediaTypeAudio ).Int64(), 200 );

        EUNIT_ASSERT_EQUALS( iRead->FrameTimeInterval( KUidMediaTypeVideo ).Int64(), 0 );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->FrameTimeInterval( KUidMediaTypeAudio ) );

        EUNIT_ASSERT_NO_LEAVE( iRead->FrameTimeInterval( KUidMediaTypeVideo ) );

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_DurationL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_EQUALS( iRead->Duration( KUidMediaTypeAudio ).Int64(), 0 );

        EUNIT_ASSERT_EQUALS( iRead->Duration( KUidMediaTypeMidi ).Int64(), 0 );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->Duration( KUidMediaTypeAudio ) );

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_NumChannelsL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_EQUALS( iRead->NumChannels( ), KMono );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->NumChannels( ) );

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_SampleRateL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_EQUALS( iRead->SampleRate(), KiLBCSampleRate );        

        }      

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->SampleRate() );     

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_SetSampleRateL(  )

    {

    TUint sample(0);

    if ( !iAlloc )

        {

        sample = iRead->SampleRate(); // 8000

        EUNIT_ASSERT_EQUALS( iRead->SetSampleRate( sample ), KErrNone );

        EUNIT_ASSERT_EQUALS( iRead->SetSampleRate( sample + 1 ), KErrNotSupported );

        EUNIT_ASSERT_EQUALS( iRead->SetSampleRate( sample - 8000 ), KErrNotSupported );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->SetSampleRate( sample ) );

        EUNIT_ASSERT_NO_LEAVE( iRead->SetSampleRate( sample + 1 ) );

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_SourceDataTypeCodeL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_EQUALS( iRead->SourceDataTypeCode( KUidMediaTypeAudio ), iFourCC );

        EUNIT_ASSERT_EQUALS( iRead->SourceDataTypeCode( KUidMediaTypeVideo ), TFourCC( ) );  

        }

    else 

        {

        EUNIT_ASSERT_EQUALS( iRead->SourceDataTypeCode( KUidMediaTypeAudio ), iFourCC );

        EUNIT_ASSERT_EQUALS( iRead->SourceDataTypeCode( KUidMediaTypeVideo ), TFourCC( ) );

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_SetSourceDataTypeCodeL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_EQUALS( iRead->SetSourceDataTypeCode( iFourCC, KUidMediaTypeAudio ), KErrNone );

        EUNIT_ASSERT_EQUALS( iRead->SetSourceDataTypeCode( iFourCC, KUidMediaTypeVideo ), KErrNotSupported );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->SetSourceDataTypeCode( iFourCC, KUidMediaTypeAudio ) );

        EUNIT_ASSERT_NO_LEAVE( iRead->SetSourceDataTypeCode( iFourCC, KUidMediaTypeVideo ) );

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_CreateSourceBufferLL(  )

    {

    TBool refO( ETrue );

    TBool refV( EFalse );

    if ( !iAlloc )

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeAudio, refO ) );

        EUNIT_ASSERT_NO_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeAudio, refV ) );

        EUNIT_ASSERT_SPECIFIC_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeVideo, refO ), KErrNotSupported );

        EUNIT_ASSERT_SPECIFIC_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeVideo, refV ), KErrNotSupported );

        EUNIT_ASSERT_SPECIFIC_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeMidi, refO ), KErrNotSupported );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeAudio, refO ) );

        EUNIT_ASSERT_SPECIFIC_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeVideo, refO ), KErrNotSupported );

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_CreateSourceBufferL_1L(  )

    {

    TBool refO( ETrue );

    TBool refV( EFalse );

    if ( !iAlloc )

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeAudio, *iBuffi, refO ) );

        EUNIT_ASSERT_NO_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeAudio, *iBuffi, refV ) );

        EUNIT_ASSERT_SPECIFIC_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeVideo, *iBuffi, refO ), KErrNotSupported );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeAudio, *iBuffi, refO ) );

        EUNIT_ASSERT_NO_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeAudio, *iBuffi, refV ) );

        EUNIT_ASSERT_SPECIFIC_LEAVE( iRead->CreateSourceBufferL( KUidMediaTypeVideo, *iBuffi, refO ), KErrNotSupported );

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_FillBufferLL(  )

    {

    if ( !iAlloc )

        {

        iRead->iCurrentBuffer = iRead->EBufferOne;

        EUNIT_ASSERT_NO_LEAVE( iRead->FillBufferL( iBuffi, iDLDataPathStub, KUidMediaTypeAudio ) );

        EUNIT_ASSERT_LEAVE( iRead->FillBufferL( iBuffi, iDLDataPathStub, KUidMediaTypeVideo ) ); // KErrNotSupported

        iRead->iCurrentBuffer = iRead->EBufferTwo;

        EUNIT_ASSERT_NO_LEAVE( iRead->FillBufferL( iBuffi, iDLDataPathStub, KUidMediaTypeAudio ) );

        EUNIT_ASSERT_LEAVE( iRead->FillBufferL( NULL, iDLDataPathStub, KUidMediaTypeAudio ) );

        iRead->iBufferToReadExists = ETrue;

        EUNIT_ASSERT_LEAVE( iRead->FillBufferL( NULL, iDLDataPathStub, KUidMediaTypeAudio ) );

        }        

    else

        {

        EUNIT_ASSERT_LEAVE( iRead->FillBufferL( iBuffi, iDLDataPathStub, KUidMediaTypeMidi ) );    

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_SourceThreadLogonL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_EQUALS( iRead->SourceThreadLogon( *aEventH ), KErrNone );

        CMccRtpDataSource* rtpDataSourceStub = 

            reinterpret_cast<CMccRtpDataSource*>( MDataSource::NewSourceL( KRtpDataSource, KNullDesC8 ) );

        CleanupStack::PushL( rtpDataSourceStub );

        CMccRedPayloadRead* redDecoder = CMccRedPayloadRead::NewL( rtpDataSourceStub );

        CleanupStack::PushL( redDecoder );

        CIlbcPayloadFormatRead* read2 = CIlbcPayloadFormatRead::NewL( redDecoder );

        CleanupStack::PushL( read2 );

        read2->iClip = NULL;

        EUNIT_ASSERT_EQUALS( read2->SourceThreadLogon( *aEventH ), KErrNotReady );

        CleanupStack::PopAndDestroy( 3 ); 

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->SourceThreadLogon( *aEventH ) );

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_SourceThreadLogoffL(  )

    {

    if ( !iAlloc )

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->SourceThreadLogoff( ) );

        }

    else

        {

        EUNIT_ASSERT_NO_LEAVE( iRead->SourceThreadLogoff( ) );

        }

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_NegotiateSourceLL(  )

    {

    EUNIT_ASSERT_NO_LEAVE( iRead->NegotiateSourceL( *iDLDataPathStub ) );

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_SourcePrimeLL(  )

    {

    EUNIT_ASSERT_NO_LEAVE( iRead->SourcePrimeL() );

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_SourcePlayLL(  )

    {

    iRead->SourceStopL();

    EUNIT_ASSERT_NO_LEAVE( iRead->SourcePlayL() );

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_SourcePauseLL(  )

    {

    EUNIT_ASSERT_NO_LEAVE( iRead->SourcePauseL() );

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_SourceStopLL(  )

    {

    EUNIT_ASSERT_NO_LEAVE( iRead->SourceStopL() );

    }

void UT_CIlbcPayloadFormatRead::UT_CIlbcPayloadFormatRead_BufferFilledLL(  )

    {

    TRtpRecvHeader test;

    test.iPayloadType = 13;

    if ( !iAlloc )

        { 

        CMMFDescriptorBuffer* buffi = CMMFDescriptorBuffer::NewL( 60 );

        CMMFBuffer* buf = buffi; 

        CleanupStack::PushL( buf );

        iRtpDataSourceStub->FillBufferL( buf, iConsumer, KUidMediaTypeAudio ); 

        buffi->Data().Append( _L("12345678901234567890123456789012345678901234567890123456789") );        

        EUNIT_ASSERT_NO_LEAVE( iRead->DataBufferFilledL( iRead->iSourceBuffer, test ) );

        CleanupStack::PopAndDestroy( buf );

        iRead->iNumOfFrames = 1;

        CMMFDescriptorBuffer* buffi2 = CMMFDescriptorBuffer::NewL( 38 );

        CMMFBuffer* buf2 = buffi2; 

        CleanupStack::PushL( buf2 );

        iRtpDataSourceStub->FillBufferL( buf2, iConsumer, KUidMediaTypeAudio ); 

        buffi2->Data().Append( _L("12345678901234567890123456789012345678") );        

        EUNIT_ASSERT_NO_LEAVE( iRead->DataBufferFilledL( iRead->iSourceBuffer, test ) );

        CleanupStack::PopAndDestroy( buf2 );

        }     

    else

        {

        CMMFDescriptorBuffer* buffi = CMMFDescriptorBuffer::NewL( 60 );

        CMMFBuffer* buf = buffi; 

        CleanupStack::PushL( buf );