/*

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

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

//  INTERNAL INCLUDES

#include "mmcccodecamrwb.h"

// CONSTRUCTION

UT_CMccCodecAmrWb* UT_CMccCodecAmrWb::NewL()

    {

    UT_CMccCodecAmrWb* self = UT_CMccCodecAmrWb::NewLC();

    CleanupStack::Pop();

    return self;

    }

UT_CMccCodecAmrWb* UT_CMccCodecAmrWb::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

UT_CMccCodecAmrWb::~UT_CMccCodecAmrWb()

    {

    }

// Default constructor

UT_CMccCodecAmrWb::UT_CMccCodecAmrWb()

    {

    }

// Second phase construct

void UT_CMccCodecAmrWb::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CMccCodecAmrWb::SetupL(  )

    {

    iCodecAmr = CMccCodecAmrWb::NewL();

    }

void UT_CMccCodecAmrWb::Teardown(  )

    {

    delete iCodecAmr;

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_GetFmtpL(  )

    {

    TDesC8* fmtp;

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

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_RequireSignallingL(  )

    {

    CMccCodecInformation* codec = CMccCodecAmrWb::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 = CMccCodecAmrWb::NewL();

    codec->SetAllowedBitrates( KMccAllowedAmrNbBitrate122 );

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

    delete codec;

    codec = NULL; 

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_CloneDefaultsLL(  )

    {

    CMccCodecInformation* codec;

    codec = iCodecAmr->CloneDefaultsL();

    delete codec;

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_CloneDetailedLL(  )

    {

    CMccCodecInformation* codec;

    codec = iCodecAmr->CloneDetailedL();

    delete codec;

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_EnableVADL(  )

    {

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

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetAllowedBitratesL(  )

    {

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

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetAllowedBitrates( 

                                    KMccAllowedAmrWbBitrateAll ), KErrNone );   

    EUNIT_ASSERT_EQUALS( iCodecAmr->SetAllowedBitrates( 

        KMccAllowedAmrWbBitrateAll | 

        KMccAllowedAmrWbModeChangePeriod2 | 

        KMccAllowedAmrWbModeChangeNeighbor1 ), KErrNone );  

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetChannelsL(  )

    {

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

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_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_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetMaxRedL(  )

    {

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

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_GetChannelsL(  )

    {

    TInt channels;

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_ParseFmtpAttrLL(  )

    {

    // TC implemnted in base class.

    EUNIT_ASSERT( ETrue);

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_CreateFmtpAttrListL_1L(  )

    {

    iCodecAmr->CreateFmtpAttrListL();

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_GetBitrateModeSetL()

    {

    TInt  mode = iCodecAmr->GetBitrateModeSet(0);

    EUNIT_ASSERT( mode == -1 );

    mode = iCodecAmr->GetBitrateModeSet(KAmrWbBitrate660);

    EUNIT_ASSERT( mode == KAMRMode0);

    mode = iCodecAmr->GetBitrateModeSet(KAmrWbBitrate885);

    EUNIT_ASSERT( mode == KAMRMode1);

    mode = iCodecAmr->GetBitrateModeSet(KAmrWbBitrate1265);

    EUNIT_ASSERT( mode == KAMRMode2);

    mode = iCodecAmr->GetBitrateModeSet(KAmrWbBitrate1425);

    EUNIT_ASSERT( mode == KAMRMode3);

    mode = iCodecAmr->GetBitrateModeSet(KAmrWbBitrate1585);

    EUNIT_ASSERT( mode == KAMRMode4);

    mode = iCodecAmr->GetBitrateModeSet(KAmrWbBitrate1825);

    EUNIT_ASSERT( mode == KAMRMode5);

    mode = iCodecAmr->GetBitrateModeSet(KAmrWbBitrate1985);

    EUNIT_ASSERT( mode == KAMRMode6);

    mode = iCodecAmr->GetBitrateModeSet(KAmrWbBitrate2305);

    EUNIT_ASSERT( mode == KAMRMode7);

    mode = iCodecAmr->GetBitrateModeSet(KAmrWbBitrate2385);

    EUNIT_ASSERT( mode == KAMRMode8);  

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_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(KAMRMode8);

    iCodecAmr->SetBitrateModeSet(9);

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_GetBitrateMaskFromModeL()

    {

    TUint bitmask;

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

    EUNIT_ASSERT( err == KErrNotFound );

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

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrWbBitrate660 );

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

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrWbBitrate885 );

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

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrWbBitrate1265 );

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

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrWbBitrate1425 );

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

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrWbBitrate1585 );

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

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrWbBitrate1825 );

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

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrWbBitrate1985 );

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

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrWbBitrate2305 );

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

    EUNIT_ASSERT( err == KErrNone );

    EUNIT_ASSERT( bitmask == KMccAllowedAmrWbBitrateAll );        

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_CreateFmtpModeSetL()

    {

    RArray<TUint> bitratearray;

    CleanupClosePushL(bitratearray);

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

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

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

    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_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetBitrateL()

    {

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

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

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

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

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

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

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

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

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

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetBitrateFromBitrateMaskL()

    {

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

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

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

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

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

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

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

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

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

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetSamplingFreqL()

    {

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

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

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetPTimeL()

    {

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

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetMaxPTimeL(  )

    {

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

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

    }    

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetSdpNameL()

    {

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

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

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

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

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

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

    CleanupStack::PopAndDestroy(name);

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetPayloadTypeL(  )

    {

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

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetCodecModeL(  )

    {

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

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

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

    } 

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_CreateFmtpAttrListLL(  )

    {

    // tested in base class

    EUNIT_ASSERT( ETrue );

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetModeChangePeriodL()

    {

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

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_ModeChangePeriodL()

    {

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_SetModeChangeNeighborL()

    {

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_ModeChangeNeighborL()

    {

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

    }               

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_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_CMccCodecAmrWb::UT_CMccCodecAmrWb_GetCrcL()

    {

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

    }

void UT_CMccCodecAmrWb::UT_CMccCodecAmrWb_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_CMccCodecAmrWb::UT_CMccCodecAmrWb_GetRobustSortingL()

    {

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

    }

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(

    UT_CMccCodecAmrWb,

    "CMccCodecAmrWb test",

    "UNIT" )

EUNIT_TEST(

    "GetFmtpL - test ",

    "CMccCodecAmrWb",

    "GetFmtpL",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAmrWb_GetFmtpL, Teardown)

EUNIT_TEST(

    "RequireSignalling - test ",

    "CMccCodecAmrWb",

    "RequireSignalling",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAmrWb_RequireSignallingL, Teardown)   

EUNIT_TEST(

    "CloneDefaultsL - test ",

    "CMccCodecAmrWb",

    "CloneDefaultsL",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAmrWb_CloneDefaultsLL, Teardown) 

EUNIT_TEST(

    "CloneDetailedL - test ",

    "CMccCodecAmrWb",

    "CloneDetailedL",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAmrWb_CloneDetailedLL, Teardown)     

EUNIT_TEST(

    "EnableVAD - test ",

    "CMccCodecAmrWb",

    "EnableVAD",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAmrWb_EnableVADL, Teardown)          

EUNIT_TEST(

    "SetBitrate - test ",

    "CMccCodecAmrWb",

    "SetBitrate",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAmrWb_SetBitrateL, Teardown)

EUNIT_TEST(

    "SetBitrateModeSet - test ",

    "CMccCodecAmrWb",

    "SetBitrateModeSet",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAmrWb_SetBitrateModeSetL, Teardown)

EUNIT_TEST(

    "SetSamplingFreq - test ",

    "CMccCodecAmrWb",

    "SetSamplingFreq",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAmrWb_SetSamplingFreqL, Teardown)

EUNIT_TEST(

    "SetPTime - test ",

    "CMccCodecAmrWb",

    "SetPTime",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAmrWb_SetPTimeL, Teardown)

EUNIT_TEST(

    "SetMaxPTime - test ",

    "CMccCodecAmrWb",

    "SetMaxPTime",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAmrWb_SetMaxPTimeL, Teardown)

EUNIT_TEST(

    "SetSdpName - test ",

    "CMccCodecAmrWb",

    "SetSdpName",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAmrWb_SetSdpNameL, Teardown)

EUNIT_TEST(

    "SetPayloadType - test ",

    "CMccCodecAmrWb",

    "SetPayloadType",

    "FUNCTIONALITY",

    SetupL, UT_CMccCodecAmrWb_SetPayloadTypeL, Teardown)

EUNIT_TEST(