/*

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

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

//  INTERNAL INCLUDES

#include "mmcccodecamr.h"

// CONSTRUCTION

UT_CMccCodecAMR* UT_CMccCodecAMR::NewL()

    {

    UT_CMccCodecAMR* self = UT_CMccCodecAMR::NewLC();

    CleanupStack::Pop();

    return self;

    }

UT_CMccCodecAMR* UT_CMccCodecAMR::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

UT_CMccCodecAMR::~UT_CMccCodecAMR()

    {

    }

// Default constructor

UT_CMccCodecAMR::UT_CMccCodecAMR()

    {

    }

// Second phase construct

void UT_CMccCodecAMR::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CMccCodecAMR::SetupL(  )

    {

    iCodecAmr = CMccCodecAMR::NewL();

    }

void UT_CMccCodecAMR::Teardown(  )

    {

    delete iCodecAmr;

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_GetFmtpL(  )

    {

    TDesC8* fmtp;

    fmtp = &(iCodecAmr->GetFmtpL());

    fmtp = &(iCodecAmr->GetFmtpL());

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_RequireSignallingL(  )

    {

    CMccCodecInformation* codec = CMccCodecAMR::NewL();

    EUNIT_ASSERT_EQUALS( iCodecAmr->RequireSignalling( *codec ), EFalse );

    codec->SetBitrate( KAmrNbBitrate122 );    

    codec->SetPTime( 20 );

    codec->SetMaxPTime( 200 );

    EUNIT_ASSERT_EQUALS( iCodecAmr->RequireSignalling( *codec ), ETrue );

    delete codec;

    codec = NULL;

    codec = CMccCodecAMR::NewL();

    codec->SetAllowedBitrates( KMccAllowedAmrNbBitrate122 );

    EUNIT_ASSERT_EQUALS( iCodecAmr->RequireSignalling( *codec ), ETrue );

    delete codec;

    codec = NULL; 

    codec = CMccCodecAMR::NewL();

    iCodecAmr->iBitrateMask = KMccAllowedModeChangeNeighbor1;

    codec->SetAllowedBitrates( KMccAllowedModeChangeNeighbor1 );

    //512 == 512

    EUNIT_ASSERT_EQUALS( iCodecAmr->RequireSignalling( *codec ), EFalse );

    codec->SetAllowedBitrates( KMccAllowedModeChangeNeighbor1 | KMccAllowedAmrNbBitrateAll );

    //512 == 767

    EUNIT_ASSERT_EQUALS( iCodecAmr->RequireSignalling( *codec ), EFalse );

    codec->SetAllowedBitrates( KMccAllowedAmrNbBitrate740 );

    //512 != 16

    EUNIT_ASSERT_EQUALS( iCodecAmr->RequireSignalling( *codec ), ETrue );

    iCodecAmr->iBitrateMask = KMccAllowedAmrNbBitrate740;

    codec->SetAllowedBitrates( KMccAllowedModeChangeNeighbor1 );

    //16 != 512

    EUNIT_ASSERT_EQUALS( iCodecAmr->RequireSignalling( *codec ), ETrue );

    delete codec;

    codec = NULL;

    codec = CMccCodecAMR::NewL();

    iCodecAmr->iBitrateMask = KMccAllowedModeChangeNeighbor1 | KMccAllowedAmrNbBitrateAll;

    codec->SetAllowedBitrates( KMccAllowedModeChangeNeighbor1 );

    //767 == 512

    EUNIT_ASSERT_EQUALS( iCodecAmr->RequireSignalling( *codec ), EFalse );

    codec->SetAllowedBitrates( KMccAllowedModeChangeNeighbor1 | KMccAllowedAmrNbBitrateAll );

    //767 == 767

    EUNIT_ASSERT_EQUALS( iCodecAmr->RequireSignalling( *codec ), EFalse );

    codec->SetAllowedBitrates( KMccAllowedAmrNbBitrateAll );

    //767 != 255

    EUNIT_ASSERT_EQUALS( iCodecAmr->RequireSignalling( *codec ), ETrue );

    delete codec;

    codec = NULL;

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_CloneDefaultsLL(  )

    {

    CMccCodecInformation* codec;

    codec = iCodecAmr->CloneDefaultsL();

    delete codec;

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_CloneDetailedLL(  )

    {

    CMccCodecInformation* codec;

    codec = iCodecAmr->CloneDetailedL();

    delete codec;

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_EnableVADL(  )

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->EnableVAD( ETrue ), KErrNone );

    EUNIT_ASSERT_EQUALS( iCodecAmr->EnableVAD( EFalse ), KErrNone );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetAllowedBitratesL(  )

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetAllowedBitrates( 0xFFFF ), KErrArgument );  

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetAllowedBitrates( 

                                    KMccAllowedAmrNbBitrateAll ), KErrNone );   

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetAllowedBitrates( 

        KMccAllowedAmrNbBitrateAll | KMccAllowedModeChangePeriod2 | KMccAllowedModeChangeNeighbor1 ), KErrNone );  

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetChannelsL(  )

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetChannels( 1 ), KErrNone );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetChannels( 0 ), KErrNotSupported );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetRedCountL(  )

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetRedCount( 0 ), KErrNone );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetRedCount( 1 ), KErrNone );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetRedCount( 3 ), KErrArgument );

    iCodecAmr->iMaxRed = 1;

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetRedCount( 0 ), KErrNone );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetRedCount( 1 ), KErrNone );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetRedCount( KMaxAmrFecRedCount + 1 ), KErrArgument );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetMaxRedL(  )

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetMaxRed( 40 ), KErrNone );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetMaxRed( 3 ), KErrArgument );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_GetChannelsL(  )

    {

    TInt channels;

    EUNIT_ASSERT_EQUALS( iCodecAmr->GetChannels( channels ), KErrNone );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_ParseFmtpAttrLL(  )

    {

    // TC implemnted in base class.

    EUNIT_ASSERT( ETrue);

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_CreateFmtpAttrListL_1L(  )

    {

    iCodecAmr->CreateFmtpAttrListL();

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_GetBitrateModeSetL()

    {

    TInt  mode = iCodecAmr->GetBitrateModeSet( 0 );

    EUNIT_ASSERT( mode == -1 );

    mode = iCodecAmr->GetBitrateModeSet( KAmrNbBitrate475 );

    EUNIT_ASSERT( mode == KAMRMode0 );

    mode = iCodecAmr->GetBitrateModeSet( KAmrNbBitrate515 );

    EUNIT_ASSERT( mode == KAMRMode1 );

    mode = iCodecAmr->GetBitrateModeSet( KAmrNbBitrate590 );

    EUNIT_ASSERT( mode == KAMRMode2 );

    mode = iCodecAmr->GetBitrateModeSet( KAmrNbBitrate670 );

    EUNIT_ASSERT( mode == KAMRMode3 );

    mode = iCodecAmr->GetBitrateModeSet( KAmrNbBitrate740 );

    EUNIT_ASSERT( mode == KAMRMode4 );

    mode = iCodecAmr->GetBitrateModeSet( KAmrNbBitrate795 );

    EUNIT_ASSERT( mode == KAMRMode5 );

    mode = iCodecAmr->GetBitrateModeSet( KAmrNbBitrate102 );

    EUNIT_ASSERT( mode == KAMRMode6 );

    mode = iCodecAmr->GetBitrateModeSet( KAmrNbBitrate122 );

    EUNIT_ASSERT( mode == KAMRMode7 );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetBitrateModeSetL()

    {

    iCodecAmr->SetBitrateModeSet( KAMRMode0 );

    iCodecAmr->SetBitrateModeSet( KAMRMode1 );

    iCodecAmr->SetBitrateModeSet( KAMRMode2 );

    iCodecAmr->SetBitrateModeSet( KAMRMode3 );

    iCodecAmr->SetBitrateModeSet( KAMRMode4 );

    iCodecAmr->SetBitrateModeSet( KAMRMode5 );

    iCodecAmr->SetBitrateModeSet( KAMRMode6 );

    iCodecAmr->SetBitrateModeSet( KAMRMode7 );

    iCodecAmr->SetBitrateModeSet( 8 );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_GetBitrateMaskFromModeL()

    {

    TUint bitmask;

    TInt err = iCodecAmr->GetBitrateMaskFromMode(8, bitmask);

    EUNIT_ASSERT( err == KErrNotFound );

    err = iCodecAmr->GetBitrateMaskFromMode(KAMRMode0, bitmask);

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrNbBitrate475 );

    err = iCodecAmr->GetBitrateMaskFromMode(KAMRMode1, bitmask);

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrNbBitrate515 );

    err = iCodecAmr->GetBitrateMaskFromMode(KAMRMode2, bitmask);

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrNbBitrate590 );

    err = iCodecAmr->GetBitrateMaskFromMode(KAMRMode3, bitmask);

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrNbBitrate670 );

    err = iCodecAmr->GetBitrateMaskFromMode(KAMRMode4, bitmask);

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrNbBitrate740 );

    err = iCodecAmr->GetBitrateMaskFromMode(KAMRMode5, bitmask);

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrNbBitrate795 );

    err = iCodecAmr->GetBitrateMaskFromMode(KAMRMode6, bitmask);

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrNbBitrate102 );

    err = iCodecAmr->GetBitrateMaskFromMode(KAMRMode7, bitmask);

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrNbBitrate122 ); 	          

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_CreateFmtpModeSetL()

    {

    RArray<TUint> bitratearray;

    CleanupClosePushL( bitratearray );

    User::LeaveIfError( bitratearray.Append( KAmrNbBitrate475 ) );

    User::LeaveIfError( bitratearray.Append( KAmrNbBitrate515 ) );

    User::LeaveIfError( bitratearray.Append( KAmrNbBitrate590 ) );

    CleanupStack::PopAndDestroy( &bitratearray );

  //  bitratearray.Reset();

  //  bitratearray.Close();

    HBufC8* buf = HBufC8::NewLC( 10 );

    buf->Des().Copy( _L8("hello") );

    TPtr8 bufPtr( buf->Des() );

    TBool returnValue = iCodecAmr->CreateFmtpModeSet( bufPtr, bitratearray );

    CleanupStack::PopAndDestroy( buf );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetBitrateL()

    {

    EUNIT_ASSERT(iCodecAmr->SetBitrate(0) == KErrNotSupported );

    EUNIT_ASSERT(iCodecAmr->SetBitrate(KAmrNbBitrate475) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrate(KAmrNbBitrate515) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrate(KAmrNbBitrate590) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrate(KAmrNbBitrate670) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrate(KAmrNbBitrate740) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrate(KAmrNbBitrate795) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrate(KAmrNbBitrate102) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrate(KAmrNbBitrate122) == KErrNone );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetBitrateFromBitrateMaskL()

    {

    EUNIT_ASSERT(iCodecAmr->SetBitrateFromBitrateMask(KMccAllowedAmrNbBitrate122) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrateFromBitrateMask(KMccAllowedAmrNbBitrate102) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrateFromBitrateMask(KMccAllowedAmrNbBitrate795) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrateFromBitrateMask(KMccAllowedAmrNbBitrate740) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrateFromBitrateMask(KMccAllowedAmrNbBitrate670) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrateFromBitrateMask(KMccAllowedAmrNbBitrate590) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrateFromBitrateMask(KMccAllowedAmrNbBitrate515) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrateFromBitrateMask(KMccAllowedAmrNbBitrate475) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetBitrateFromBitrateMask(0) == KErrArgument );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetSamplingFreqL()

    {

    EUNIT_ASSERT(iCodecAmr->SetSamplingFreq(KAmrNbSamplingFreq) == KErrNone );

    EUNIT_ASSERT(iCodecAmr->SetSamplingFreq(0) == KErrNotSupported );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetPTimeL()

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetPTime( 9 ), KErrArgument);

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetPTime( 20 ), KErrNone);

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetMaxPTimeL(  )

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetMaxPTime( 9 ), KErrArgument);

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetMaxPTime( 20 ), KErrNone);

    }    

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetSdpNameL()

    {

    HBufC8* name = HBufC8::NewLC(KAMRSdpName().Length());

    EUNIT_ASSERT(iCodecAmr->SetSdpName(*name) == KErrNotSupported );

    name->Des().Copy(KAMRSdpName);

    EUNIT_ASSERT(iCodecAmr->SetSdpName(*name) == KErrNone );

    CleanupStack::PopAndDestroy(name);

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetPayloadTypeL(  )

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetPayloadType( KDefaultAmrNbPT ), KErrNone );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetPayloadType( KPcmuPayloadType ), KErrArgument);

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetCodecModeL(  )

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetCodecMode( ENothing ), KErrNotSupported);

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetCodecMode( EBandwidthEfficient ), KErrNone);

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetCodecMode( EOctetAligned ), KErrNone);

    } 

void UT_CMccCodecAMR::UT_CMccCodecAMR_CreateFmtpAttrListLL(  )

    {

    // tested in base class

    EUNIT_ASSERT( ETrue );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetModeChangePeriodL()

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetModeChangePeriod( 0 ), KErrArgument );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetModeChangePeriod( 1 ), KErrNone );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_ModeChangePeriodL()

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->ModeChangePeriod(), iCodecAmr->iModeChangePeriod );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetModeChangeNeighborL()

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetModeChangeNeighbor( EFalse ), KErrNone );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_ModeChangeNeighborL()

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->ModeChangeNeighbor(), iCodecAmr->iNeighbor );

    }               

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetCrcL()

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetCrc( 0 ), KErrNone );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetCrc( 1 ), KErrNotSupported );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetCrc( -1 ), KErrNotSupported );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetCrc( 2 ), KErrNotSupported );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_GetCrcL()

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->GetCrc(), EFalse );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_SetRobustSortingL()

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetRobustSorting( 0 ), KErrNone );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetRobustSorting( 1 ), KErrNotSupported );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetRobustSorting( -1 ), KErrNotSupported );

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetRobustSorting( 2 ), KErrNotSupported );

    }

void UT_CMccCodecAMR::UT_CMccCodecAMR_GetRobustSortingL()

    {

    EUNIT_ASSERT_EQUALS( iCodecAmr->GetRobustSorting(), EFalse );

    }

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(

    UT_CMccCodecAMR,

    "CMccCodecAMR test",

    "UNIT" )

EUNIT_TEST(

    "GetFmtpL - test ",

    "CMccCodecAMR",

    "GetFmtpL",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAMR_GetFmtpL, Teardown)

EUNIT_TEST(

    "RequireSignalling - test ",

    "CMccCodecAMR",

    "RequireSignalling",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAMR_RequireSignallingL, Teardown)   

EUNIT_TEST(

    "CloneDefaultsL - test ",

    "CMccCodecAMR",

    "CloneDefaultsL",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAMR_CloneDefaultsLL, Teardown) 

EUNIT_TEST(

    "CloneDetailedL - test ",

    "CMccCodecAMR",

    "CloneDetailedL",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAMR_CloneDetailedLL, Teardown)     

EUNIT_TEST(

    "EnableVAD - test ",

    "CMccCodecAMR",

    "EnableVAD",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAMR_EnableVADL, Teardown)          

EUNIT_TEST(

    "SetBitrate - test ",

    "CMccCodecAMR",

    "SetBitrate",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAMR_SetBitrateL, Teardown)

EUNIT_TEST(

    "SetBitrateModeSet - test ",

    "CMccCodecAMR",

    "SetBitrateModeSet",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAMR_SetBitrateModeSetL, Teardown)

EUNIT_TEST(

    "SetSamplingFreq - test ",

    "CMccCodecAMR",

    "SetSamplingFreq",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAMR_SetSamplingFreqL, Teardown)

EUNIT_TEST(

    "SetPTime - test ",

    "CMccCodecAMR",

    "SetPTime",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAMR_SetPTimeL, Teardown)

EUNIT_TEST(

    "SetMaxPTime - test ",

    "CMccCodecAMR",

    "SetMaxPTime",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAMR_SetMaxPTimeL, Teardown)