/*

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

//  EXTERNAL INCLUDES

#include <digia/eunit/EUnitMacros.h>

#include <digia/eunit/CEunitAllocTestCaseDecorator.h>

//  INTERNAL INCLUDES

#include "MmccCodecInformation.h"

#include "MmccCodecAMR.h"

#include "mmcccodecinformationfactory.h"

#include "mccinternalcodecs.h"

// CONSTRUCTION

UT_CMccCodecInformation* UT_CMccCodecInformation::NewL()

    {

    UT_CMccCodecInformation* self = UT_CMccCodecInformation::NewLC(); 

    CleanupStack::Pop();

    return self;

    }

UT_CMccCodecInformation* UT_CMccCodecInformation::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_CMccCodecInformation::~UT_CMccCodecInformation()

    {

    }

// Default constructor

UT_CMccCodecInformation::UT_CMccCodecInformation()

    {

    }

// Second phase construct

void UT_CMccCodecInformation::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//Callback functions (not used)

void UT_CMccCodecInformation::MccEventReceived( const TMccEvent& /*aEvent*/ ){}

void UT_CMccCodecInformation::MccMediaStarted( TUint32 /*aSessionId*/,

                            TUint32 /*aLinkId*/,     

                            TUint32 /*aStreamId*/,

                            TUint32 /*aSinkSourceId*/ ){}

void UT_CMccCodecInformation::MccMediaStopped( TUint32 /*aSessionId*/,

                            TUint32 /*aLinkId*/,

                            TUint32 /*aStreamId*/,

                            TUint32 /*aSinkSourceId*/ ){}

void UT_CMccCodecInformation::MccMediaPaused( TUint32 /*aSessionId*/,

                           TUint32 /*aLinkId*/,

                            TUint32 /*aStreamId*/,

                            TUint32 /*aSinkSourceId*/ ){}

void UT_CMccCodecInformation::MccMediaResumed( TUint32 /*aSessionId*/,

                            TUint32 /*aLinkId*/,

                            TUint32 /*aStreamId*/,

                            TUint32 /*aSinkSourceId*/ ){}

void UT_CMccCodecInformation::MccMediaPrepared( TUint32 /*aSessionId*/,

                             TUint32 /*aLinkId*/,

                            TUint32 /*aStreamId*/,

                            TUint32 /*aSinkSourceId*/ ){}

void UT_CMccCodecInformation::MccMediaInactive( TUint32 /*aSessionId*/,

                             TUint32 /*aLinkId*/,

                            TUint32 /*aStreamId*/,

                            TUint32 /*aSinkSourceId*/ ){}

void UT_CMccCodecInformation::MccMediaActive( TUint32 /*aSessionId*/,

                             TUint32 /*aLinkId*/,

                            TUint32 /*aStreamId*/,

                            TUint32 /*aSinkSourceId*/ ){}

void UT_CMccCodecInformation::MccCtrlError( TInt /*aError*/ ){}

void UT_CMccCodecInformation::MccCtrlError( TInt /*aError*/,

                           TUint32 /*aSessionId*/,

                           TUint32 /*aLinkId*/,

                            TUint32 /*aStreamId*/,

                            TUint32 /*aSinkSourceId*/ ){}

//  METHODS

void UT_CMccCodecInformation::SetupL()

    {

    iInterface = CMccInterface::NewL( *this );    

    GetCapabilitiesL( iCodecArray );

    iCount = iCodecArray.Count();

    } 

void UT_CMccCodecInformation::Teardown()

    {

    if( iInterface )

        {

        delete iInterface;

        iInterface = NULL;

        }

    iCodecArray.ResetAndDestroy();

    iCodecArray.Close();    

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_CloneDefaultsLL()

    {

    RPointerArray< CMccCodecInformation > codecArray1;

    RPointerArray< CMccCodecInformation > codecArray2;

    CleanupResetAndDestroy< RPointerArray< CMccCodecInformation > >::PushL( codecArray1 );

    CleanupResetAndDestroy< RPointerArray< CMccCodecInformation > >::PushL( codecArray2 );

    GetCapabilitiesL( codecArray1 );

    TInt count = codecArray1.Count();

    CMccCodecInformation* temp = NULL;

    EUNIT_ASSERT( count > 0 );

    for( TInt k = 0; k < count; k++ )

        {

        //Clone defaults

        temp = codecArray1[k]->CloneDefaultsL();

        CleanupStack::PushL( temp );

        User::LeaveIfError( codecArray2.Append( temp ) );

        CleanupStack::Pop( temp );

        temp = NULL;

        EUNIT_ASSERT( codecArray2[k] != NULL );

        }

    CleanupStack::Pop(2); // array1 & array2        

    codecArray1.ResetAndDestroy();

    codecArray1.Close();

    codecArray2.ResetAndDestroy();

    codecArray2.Close();

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_CloneDetailedLL()

    {

    RPointerArray<CMccCodecInformation> codecArray1;

    RPointerArray<CMccCodecInformation> codecArray2;

    CleanupResetAndDestroy< RPointerArray<CMccCodecInformation> >::PushL( codecArray1 );

    CleanupResetAndDestroy< RPointerArray<CMccCodecInformation> >::PushL( codecArray2 );

    GetCapabilitiesL( codecArray1 );

    TInt count = codecArray1.Count();

    CMccCodecInformation* temp = NULL;

    //Check that the arrary is not empty

    EUNIT_ASSERT( count > 0 );

    for( TInt k = 0; k < count; k++ )

        {

        //Clone detailed

        temp = codecArray1[k]->CloneDetailedL();

        CleanupStack::PushL( temp );

        User::LeaveIfError( codecArray2.Append( temp ) );

        CleanupStack::Pop( temp );

        temp = NULL;

        EUNIT_ASSERT( codecArray2[k] != NULL );

        }

    CleanupStack::Pop(2); // array1 & array2

    codecArray1.ResetAndDestroy();

    codecArray1.Close();

    codecArray2.ResetAndDestroy();

    codecArray2.Close();

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_RequireSignallingL()

    {        

    // Test base class

    EUNIT_ASSERT( !iCodecArray[ 0 ]->CMccCodecInformation::RequireSignalling( *iCodecArray[ 0 ] ) );

    // Test not changing

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

        {

        EUNIT_ASSERT( !iCodecArray[ i ]->RequireSignalling( *iCodecArray[ i ] ) );

        }

    // Test changing

    for ( TInt j = 0; j < iCodecArray.Count(); j++ )

        {

        CMccCodecInformation* codec = iCodecArray[ j ]->CloneDetailedL();

        CleanupStack::PushL( codec );

        codec->SetPTime( 100 );

        codec->SetMaxPTime( 100 );

        codec->SetPayloadType( 99 );

        codec->SetCodecMode( EOctetAligned );

        codec->SetAllowedBitrates( 0 );

        codec->SetMaxBitrate( 63000 );

        codec->SetFramerate( 13 );

        codec->SetFrameHeight( 100 );

        codec->SetFrameWidth( 100 );

        EUNIT_ASSERT( iCodecArray[ j ]->RequireSignalling( *codec ) );

        CleanupStack::PopAndDestroy( codec );

        }

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_SetValuesL()

    {

    for( TInt k = 1; k < iCount; k++ )

        {      

        TMccCodecInfo codecInfo;

        iCodecArray[k]->SetValues(codecInfo);

        }    

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_GetValuesL()

    {

    TMccCodecInfo codecinfo;

    for( TInt k = 1; k < iCount; k++ )

        {      

        TMccCodecInfo codecinfo;

        iCodecArray[k]->GetValues(codecinfo);

        }

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_TypeL(  )

    {

    TMccCodecInfo codecinfo;

    for( TInt k = 1; k < iCount; k++ )

        {      

        TMccCodecInfo codecinfo;

        TUid uidi = iCodecArray[k]->Type();

        }

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_EnableVADL()

    {  

    //Confirm that the arrary is not empty

    EUNIT_ASSERT( iCount > 0 );

    TInt error( KErrNone );

    for( TInt k = 0; k < iCount; k++ )

        {

        //If AMR

        if ( iCodecArray[k]->SdpName().Compare( KAMRSdpName ) == 0 )

            {

            error = iCodecArray[k]->EnableVAD( EFalse );

            EUNIT_ASSERT_EQUALS( error, KErrNone );

            error = iCodecArray[k]->EnableVAD( ETrue );

            EUNIT_ASSERT_EQUALS( error, KErrNone );

            }

        else

            {

            error = iCodecArray[k]->EnableVAD( EFalse );

            //EUNIT_ASSERT_EQUALS( error, KErrNotSupported );

            error = iCodecArray[k]->EnableVAD( ETrue );

            //EUNIT_ASSERT_EQUALS( error, KErrNotSupported );

            }

        }

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_SetBitrateL()

    {  

    //Confirm that the arrary is not empty

    EUNIT_ASSERT( iCount > 0 );

    CMccCodecInformation* codecAMR = NULL;

    TInt bitrate( 0 );

    // Find the AMR codec

    for ( TInt i = 0; i < iCount; i++ )

        {

        //If amr

        if ( iCodecArray[i]->SdpName().Compare( KAMRSdpName ) == 0 )

            {

            EUNIT_ASSERT_EQUALS( KErrNotSupported, iCodecArray[i]->SetBitrate( bitrate ) );

            }

        else

            {

            iCodecArray[i]->SetBitrate( bitrate );

            }

        }  

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_SetSamplingFreqL()

    {    

    //Confirm that the arrary is not empty

    EUNIT_ASSERT( iCount > 0 );

    TInt error( KErrNone );

    //Call parent class method

    //Currently no other sampling frequencies than 8000Hz are supported

    error = iCodecArray[0]->SetSamplingFreq( 5 );

    EUNIT_ASSERT_EQUALS( error, KErrNotSupported );

    // Real codecs may support also other freqs

    for( TInt k = 0; k < iCount; k++ )

        {

        error = iCodecArray[k]->SetSamplingFreq( 0 );

        //EUNIT_ASSERT_EQUALS( error, KErrNone );

        }

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_SetSdpNameL(  )

    {

    // test implemented in inhereted classes.

    EUNIT_ASSERT( ETrue );

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_SetPayloadTypeL(  )

    {

    // test implemented in inhereted classes.

    EUNIT_ASSERT( ETrue );

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_SetCodecModeL(  )

    {

    // test implemented in inhereted classes.

    EUNIT_ASSERT( ETrue );

    }

void UT_CMccCodecInformation::UT_CMccCodecInformation_SetAllowedBitratesL(  )

    {        

    TInt error( KErrNone );

    TUint bitrateMask;

    TInt bitrate;    

    HBufC* fmtp16 = NULL;

    for( TInt k = 0; k < iCount; k++ )

        {

        /*

        const TUint KMccAllowedAmrNbBitrate475 = 0x0001;

        const TUint KMccAllowedAmrNbBitrate515 = 0x0002;

        const TUint KMccAllowedAmrNbBitrate590 = 0x0004;

        const TUint KMccAllowedAmrNbBitrate670 = 0x0008;

        const TUint KMccAllowedAmrNbBitrate740 = 0x0010;

        const TUint KMccAllowedAmrNbBitrate795 = 0x0020;

        const TUint KMccAllowedAmrNbBitrate102 = 0x0040;

        const TUint KMccAllowedAmrNbBitrate122 = 0x0080;

        const TUint KMccAllowedAmrNbBitrateAll = 0x00FF;

        */

        //If AMR

        if ( iCodecArray[k]->SdpName().Compare( KAMRSdpName ) == 0 )

            {

            _LIT( KTxtFmtp2, "TestSetAllowedBitratesL, Fmtp : %s" );

            TUint bitrateNotAllowed = 0xFFFF;

            bitrateMask = KMccAllowedAmrNbBitrateAll;

            bitrate = iCodecArray[k]->Bitrate();

            if( bitrate == 12200 )

                {

                RDebug::Print( _L("TestSetAllowedBitratesL - CORRECT - bitrate 12200 == %d"), bitrate );

                }

            else

                {

                RDebug::Print( _L("TestSetAllowedBitratesL - ERROR - bitrate 12200 == %d"), bitrate );

                User::Leave( KErrGeneral  );

                }

            EUNIT_ASSERT_NO_LEAVE( iCodecArray[k]->CMccCodecInformation::SetAllowedBitrates( 5 ) );

            User::LeaveIfError( iCodecArray[k]->SetAllowedBitrates( bitrateMask ) );

            User::LeaveIfError( iCodecArray[k]->SetCodecMode( EOctetAligned ) );

            fmtp16 = HBufC::NewLC( iCodecArray[k]->GetFmtpL().Length() + 1 );

            fmtp16->Des().Copy( iCodecArray[k]->GetFmtpL() );

            RDebug::Print( KTxtFmtp2, fmtp16->Des().PtrZ() );

            CleanupStack::PopAndDestroy( fmtp16 );

            //////////////// new test

            bitrateMask = KMccAllowedAmrNbBitrate475;

            User::LeaveIfError( iCodecArray[k]->SetAllowedBitrates( bitrateMask ) );

            bitrate = iCodecArray[k]->Bitrate();

            if( bitrate == 4750 )

                {

                RDebug::Print( _L("TestSetAllowedBitratesL - CORRECT - bitrate 4750 == %d"), bitrate );

                }

            else

                {

                RDebug::Print( _L("TestSetAllowedBitratesL - ERROR - bitrate 4750 == %d"), bitrate );

                User::Leave( KErrGeneral  );

                }

            User::LeaveIfError( iCodecArray[k]->SetCodecMode( EOctetAligned ));

            fmtp16 = HBufC::NewLC( iCodecArray[k]->GetFmtpL().Length() + 1 );

            fmtp16->Des().Copy( iCodecArray[k]->GetFmtpL() );

            RDebug::Print( KTxtFmtp2, fmtp16->Des().PtrZ() );

            CleanupStack::PopAndDestroy( fmtp16 );

            //////////////// new test

            bitrateMask = KMccAllowedAmrNbBitrate515;

            User::LeaveIfError( iCodecArray[k]->SetAllowedBitrates( bitrateMask ) );

            bitrate = iCodecArray[k]->Bitrate();

            if( bitrate == 5150 )

                {

                RDebug::Print( _L("TestSetAllowedBitratesL - CORRECT - bitrate 5150 == %d"), bitrate );

                }

            else

                {

                RDebug::Print( _L("TestSetAllowedBitratesL - ERROR - bitrate 5150 == %d"), bitrate );

                User::Leave( KErrGeneral  );

                }

            User::LeaveIfError( iCodecArray[k]->SetCodecMode( EOctetAligned ) );

            fmtp16 = HBufC::NewLC( iCodecArray[k]->GetFmtpL().Length() + 1 );

            fmtp16->Des().Copy( iCodecArray[k]->GetFmtpL() );

            RDebug::Print( KTxtFmtp2, fmtp16->Des().PtrZ() );

            CleanupStack::PopAndDestroy( fmtp16 );

            //////////////// new test

            bitrateMask = KMccAllowedAmrNbBitrate590;

            User::LeaveIfError( iCodecArray[k]->SetAllowedBitrates( bitrateMask ) );

            bitrate = iCodecArray[k]->Bitrate();

            if( bitrate == 5900 )

                {

                RDebug::Print( _L("TestSetAllowedBitratesL - CORRECT - bitrate 5900 == %d"), bitrate );

                }

            else

                {

                RDebug::Print( _L("TestSetAllowedBitratesL - ERROR - bitrate 5900 == %d"), bitrate );

                User::Leave( KErrGeneral  );

                }

            User::LeaveIfError( iCodecArray[k]->SetCodecMode( EOctetAligned ) );

            fmtp16 = HBufC::NewLC( iCodecArray[k]->GetFmtpL().Length() + 1 );

            fmtp16->Des().Copy( iCodecArray[k]->GetFmtpL() );

            RDebug::Print( KTxtFmtp2, fmtp16->Des().PtrZ() );

            CleanupStack::PopAndDestroy( fmtp16 );

            //////////////// new test

            bitrateMask = KMccAllowedAmrNbBitrate670;

            User::LeaveIfError( iCodecArray[k]->SetAllowedBitrates( bitrateMask ) );

            bitrate = iCodecArray[k]->Bitrate();

            if( bitrate == 6700 )

                {

                RDebug::Print( _L("TestSetAllowedBitratesL - CORRECT - bitrate 6700 == %d"), bitrate );

                }

            else

                {

                RDebug::Print( _L("TestSetAllowedBitratesL - ERROR - bitrate 6700 == %d"), bitrate );

                User::Leave( KErrGeneral  );

                }

            User::LeaveIfError( iCodecArray[k]->SetCodecMode( EOctetAligned ) );

            fmtp16 = HBufC::NewLC( iCodecArray[k]->GetFmtpL().Length() + 1 );

            fmtp16->Des().Copy( iCodecArray[k]->GetFmtpL() );

            RDebug::Print( KTxtFmtp2, fmtp16->Des().PtrZ() );

            CleanupStack::PopAndDestroy( fmtp16 );

            //////////////// new test

            bitrateMask = KMccAllowedAmrNbBitrate740;

            User::LeaveIfError( iCodecArray[k]->SetAllowedBitrates( bitrateMask ) );

            bitrate = iCodecArray[k]->Bitrate();

            if( bitrate == 7400 )

                {

                RDebug::Print( _L("TestSetAllowedBitratesL - CORRECT - bitrate 7400 == %d"), bitrate );

                }

            else

                {