multimediacommscontroller/mmccinterface/tsrc/ut_interface/src/UT_CMccCodecAMR.cpp
/*
* 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)
EUNIT_TEST(
"SetSdpName - test ",
"CMccCodecAMR",
"SetSdpName",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_SetSdpNameL, Teardown)
EUNIT_TEST(
"SetPayloadType - test ",
"CMccCodecAMR",
"SetPayloadType",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_SetPayloadTypeL, Teardown)
EUNIT_TEST(
"SetCodecMode - test ",
"CMccCodecAMR",
"SetCodecMode",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_SetCodecModeL, Teardown)
EUNIT_TEST(
"SetAllowedBitrates - test ",
"CMccCodecAMR",
"SetAllowedBitrates",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_SetAllowedBitratesL, Teardown)
EUNIT_TEST(
"SetChannels - test ",
"CMccCodecAMR",
"SetChannels",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_SetChannelsL, Teardown)
EUNIT_TEST(
"SetRedCount - test ",
"CMccCodecAMR",
"SetRedCount",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_SetRedCountL, Teardown)
EUNIT_TEST(
"SetMaxRed - test ",
"CMccCodecAMR",
"SetMaxRed",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_SetMaxRedL, Teardown)
EUNIT_TEST(
"GetBitrateModeSet - test ",
"CMccCodecAMR",
"GetBitrateModeSet",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_GetBitrateModeSetL, Teardown)
EUNIT_TEST(
"GetBitrateMaskFromMode - test ",
"CMccCodecAMR",
"GetBitrateMaskFromMode",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_GetBitrateMaskFromModeL, Teardown)
EUNIT_TEST(
"GetChannels - test ",
"CMccCodecAMR",
"GetChannels",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_GetChannelsL, Teardown)
EUNIT_TEST(
"ParseFmtpAttrL - test ",
"CMccCodecAMR",
"ParseFmtpAttrL",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_ParseFmtpAttrLL, Teardown)
EUNIT_TEST(
"CreateFmtpAttrListL - test ",
"CMccCodecAMR",
"CreateFmtpAttrListL",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_CreateFmtpAttrListLL, Teardown)
EUNIT_TEST(
"CreateFmtpAttrListL - test ",
"CMccCodecAMR",
"CreateFmtpAttrListL",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_CreateFmtpAttrListL_1L, Teardown)
EUNIT_TEST(
"CreateFmtpModeSetL - test ",
"CMccCodecAMR",
"CreateFmtpModeSetL",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_CreateFmtpModeSetL, Teardown)
EUNIT_TEST(
"SetBitrateFromBitrateMaskL - test ",
"CMccCodecAMR",
"SetBitrateFromBitrateMaskL",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_SetBitrateFromBitrateMaskL, Teardown)
EUNIT_TEST(
"SetModeChangePeriod - test ",
"CMccCodecAMR",
"SetModeChangePeriod",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_SetModeChangePeriodL, Teardown)
EUNIT_TEST(
"ModeChangePeriod - test ",
"CMccCodecAMR",
"ModeChangePeriod",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_ModeChangePeriodL, Teardown)
EUNIT_TEST(
"SetModeChangeNeighbor - test ",
"CMccCodecAMR",
"SetModeChangeNeighbor",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_SetModeChangeNeighborL, Teardown)
EUNIT_TEST(
"ModeChangeNeighbor - test ",
"CMccCodecAMR",
"ModeChangeNeighbor",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_ModeChangeNeighborL, Teardown)
EUNIT_TEST(
"SetCrc - test ",
"CMccCodecAMR",
"SetCrc",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_SetCrcL, Teardown)
EUNIT_TEST(
"GetCrc - test ",
"CMccCodecAMR",
"GetCrc",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_GetCrcL, Teardown)
EUNIT_TEST(
"SetRobustSorting - test ",
"CMccCodecAMR",
"SetRobustSorting",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_SetRobustSortingL, Teardown)
EUNIT_TEST(
"GetRobustSorting - test ",
"CMccCodecAMR",
"GetRobustSorting",
"FUNCTIONALITY",
SetupL, UT_CMccCodecAMR_GetRobustSortingL, Teardown)
EUNIT_END_TEST_TABLE
// END OF FILE