diff -r 000000000000 -r 1bce908db942 multimediacommscontroller/mmccinterface/tsrc/ut_interface/src/UT_CMCCCodecInformation.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/multimediacommscontroller/mmccinterface/tsrc/ut_interface/src/UT_CMCCCodecInformation.cpp	Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,2124 @@
+/*
+* 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
+                {
+                RDebug::Print( _L("TestSetAllowedBitratesL - ERROR - bitrate 7400 == %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 = KMccAllowedAmrNbBitrate795;
+            
+            User::LeaveIfError( iCodecArray[k]->SetAllowedBitrates( bitrateMask ) );
+            
+            bitrate = iCodecArray[k]->Bitrate();
+            
+            if( bitrate == 7950 )
+                {
+                RDebug::Print( _L("TestSetAllowedBitratesL - CORRECT - bitrate 7950 == %d"), bitrate );
+                }
+            else
+                {
+                RDebug::Print( _L("TestSetAllowedBitratesL - ERROR - bitrate 7950 == %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 = KMccAllowedAmrNbBitrate102;
+            
+            User::LeaveIfError( iCodecArray[k]->SetAllowedBitrates( bitrateMask ) );
+            
+            bitrate = iCodecArray[k]->Bitrate();
+            
+            if( bitrate == 10200 )
+                {
+                RDebug::Print( _L("TestSetAllowedBitratesL - CORRECT - bitrate 10200 == %d"), bitrate );
+                }
+            else
+                {
+                RDebug::Print( _L("TestSetAllowedBitratesL - ERROR - bitrate 10200 == %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 = KMccAllowedAmrNbBitrate122;
+            
+            User::LeaveIfError( iCodecArray[k]->SetAllowedBitrates( bitrateMask ) );
+            
+            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  );
+                }
+                
+            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 | KMccAllowedAmrNbBitrate102;
+            
+            User::LeaveIfError( iCodecArray[k]->SetAllowedBitrates( bitrateMask ) );
+            bitrate = iCodecArray[k]->Bitrate();
+            
+            if( bitrate == 10200 )
+                {
+                RDebug::Print( _L("TestSetAllowedBitratesL - CORRECT - bitrate 10200 == %d"), bitrate );
+                }
+            else
+                {
+                RDebug::Print( _L("TestSetAllowedBitratesL - ERROR - bitrate 10200 == %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 );
+            }
+        
+        else
+            {
+            }
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetPTimeL(  )
+    {
+    // test implemented in inhereted classes.
+    EUNIT_ASSERT( ETrue );
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetMaxPTimeL(  )
+    {
+    // test implemented in inhereted classes.
+    EUNIT_ASSERT( ETrue );
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetJitterBufBufferLengthL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetJitterBufBufferLength( 4 ), KErrUnderflow );
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetJitterBufBufferLength( 5 ), KErrNone );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetJitterBufThresholdL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetJitterBufThreshold( 5 ), KErrNone );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetJitterBufInactivityTimeOutL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetJitterBufInactivityTimeOut( 5 ), KErrNone );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetMaxBitrateL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetMaxBitrate( 128000 ), KErrNone );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetAverageBitrateL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetAverageBitrate( 12200 ), KErrNone );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetFramerateL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetFramerate( 100 ), KErrNone );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetFrameHeightL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetFrameHeight( 100 ), KErrNone );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetFrameWidthL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetFrameWidth( 100 ), KErrNone );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetAlgoL()
+    {
+    TInt error( KErrNone );
+    
+    //Confirm that the arrary is not empty
+    EUNIT_ASSERT( iCount > 0 );
+    
+    //Call parent class method
+    TAlgoUsed algo;
+    
+    error = iCodecArray[0]->CMccCodecInformation::SetAlgo( ENoAlgoUsed );
+    EUNIT_ASSERT_EQUALS( KErrNone, error );
+    
+    algo = iCodecArray[0]->CMccCodecInformation::Algo();
+    EUNIT_ASSERT_EQUALS( ENoAlgoUsed, algo );
+    
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        error = iCodecArray[k]->SetAlgo( ENoAlgoUsed );
+        EUNIT_ASSERT_EQUALS( KErrNone, error );
+        
+        algo = iCodecArray[k]->Algo();
+        EUNIT_ASSERT_EQUALS( ENoAlgoUsed, algo );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetRedCountL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        if (k != 0 )// other codecs
+            {
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetRedCount( 0 ), KErrNone );
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetRedCount( 1 ), KErrNone );
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetRedCount( 2 ), KErrArgument );
+            }
+        else // AMR
+            {
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetRedCount( 0 ), KErrNone );
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetRedCount( 1 ), KErrNone );
+            iCodecArray[k]->iMaxRed = 1;
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetRedCount( 0 ), KErrNone );
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetRedCount( 1 ), KErrNone );
+            }
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetRedundancyPTL()
+    {    
+    EUNIT_ASSERT( iCount > 0 );
+    TInt error( KErrNone );
+    TInt redundancy( 0 );
+
+     //Call parent class method
+    error = iCodecArray[0]->CMccCodecInformation::SetRedundancyPT( redundancy );
+    EUNIT_ASSERT_EQUALS( KErrNone, error );
+    
+    redundancy = iCodecArray[0]->CMccCodecInformation::RedundancyPT();
+    EUNIT_ASSERT_EQUALS( 0, redundancy );
+    
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        error = iCodecArray[k]->SetRedundancyPT( 0 );
+        EUNIT_ASSERT_EQUALS( KErrNone, error );
+        
+        redundancy = iCodecArray[k]->RedundancyPT();
+        EUNIT_ASSERT_EQUALS( 0, redundancy );
+        } 
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetPriorityL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        iCodecArray[k]->SetPriority( 1 );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetPriorityPreferenceL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        iCodecArray[k]->SetPriorityPreference( 1 );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetKeepAliveTimerL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetKeepAliveTimer( 25 ), KErrNone );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetKeepAlivePTL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetKeepAlivePT( iCodecArray[k]->iPayloadType ), KErrNone );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetKeepAliveDataL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        const TUint8 KG711KAPayloadSize = 160;
+        const TUint8 KG711KeepAlivePayload[KG711KAPayloadSize] = 
+            { 
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+            };
+        TBuf8<KG711KAPayloadSize> payload;
+        payload.Append( KG711KeepAlivePayload[KG711KAPayloadSize] ); 
+        TPtrC8 ptr( payload ); 
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetKeepAliveData( ptr ), KErrNone );
+        /*TBuf8<320> payload2;
+        payload2.Append( KG711KeepAlivePayload[KG711KAPayloadSize] );
+        payload2.Append( KG711KeepAlivePayload[KG711KAPayloadSize] );
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetKeepAliveData( payload2 ), KErrArgument );*/
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetComfortNoiseGenerationL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        if ( iCodecArray[k]->SdpName() == KPCMUSdpName || 
+             iCodecArray[k]->SdpName() == KPCMASdpName || 
+             iCodecArray[k]->SdpName() == KILBCSdpName )
+            {
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetComfortNoiseGeneration( 13 ), KErrNone );
+            }
+        else
+            {
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetComfortNoiseGeneration( 13 ), KErrNotSupported );
+            }        
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetChannelsL()
+    {
+#if 0 // Removed temporarily because code does not work
+    //TBuf8<5> noChannels;
+    //noChannels.Format( KNullDesC8 );
+    
+    TBuf8<5> someChannels;
+    someChannels.Format( _L8( "1 2" ) );
+
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetChannels( KNullDesC8 ), KErrNone );
+        RDebug::Print( _L( "UT_CMccCodecInformation_SetChannelsL NULL %d OK" ), k );
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetChannels( someChannels ), KErrNone );
+        RDebug::Print( _L( "UT_CMccCodecInformation_SetChannelsL %d OK" ), k );
+        }
+#endif
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetMaxRedL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        if ( !iCodecArray[k]->SdpName().CompareF( KAMRSdpName ) ||
+             !iCodecArray[k]->SdpName().CompareF( KAMRWbSdpName ) )
+            {
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetMaxRed( 40 ), KErrNone );
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetMaxRed( 3 ), KErrArgument );
+            }
+        else
+            {
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetMaxRed( 5 ), KErrNotSupported );
+            }        
+        }
+    }
+    
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_VADL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->VAD(), iCodecArray[k]->iEnableVAD ) ;
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_BitrateL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->Bitrate(), iCodecArray[k]->iBitrate );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_AllowedBitratesL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->AllowedBitrates(), iCodecArray[k]->iBitrateMask );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SamplingFreqL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SamplingFreq(), iCodecArray[k]->iSamplingFreq );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SdpNameL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SdpName(), iCodecArray[k]->iSdpName );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_PayloadTypeL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->PayloadType(), iCodecArray[k]->iPayloadType );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_CodecModeL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->CodecMode(), iCodecArray[k]->iCodecMode );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_PTimeL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->PTime(), iCodecArray[k]->iPTime );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_MaxPTimeL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->MaxPTime(), iCodecArray[k]->iMaxPTime );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_GetFmtpLL()
+    {
+    TDesC8* fmtp;
+
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        fmtp = &( iCodecArray[k]->GetFmtpL() );
+        RDebug::Print( _L( "UT_CMccCodecInformation_GetFmtpLL %d OK" ), k );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_FourCCL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->FourCC(), iCodecArray[k]->iFourCC );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_FrameTimeL()
+    {
+    TInt error( KErrNone );
+    
+    //Confirm that the arrary is not empty
+    EUNIT_ASSERT( iCount > 0 );
+    
+    //Call parent class method
+    TInt frameTime( 0 );
+    frameTime = iCodecArray[0]->CMccCodecInformation::FrameTime();
+    EUNIT_ASSERT( frameTime >= 0 );
+    
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        frameTime = iCodecArray[k]->FrameTime();
+        EUNIT_ASSERT( frameTime >= 0 );
+        }    
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_FrameSizeL()
+    {
+    TInt error( KErrNone );
+    
+    //Confirm that the arrary is not empty
+    EUNIT_ASSERT( iCount > 0 );
+    
+    //Call parent class method
+    TInt frameSize( 0 );
+    frameSize = iCodecArray[0]->CMccCodecInformation::FrameSize();
+    EUNIT_ASSERT( frameSize >= 0 );
+    
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        frameSize = iCodecArray[k]->FrameSize();
+        EUNIT_ASSERT( frameSize >= 0 );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_AlgoL()
+    {   
+    //Confirm that the arrary is not empty
+    EUNIT_ASSERT( iCount > 0 );
+    
+    TInt error( KErrNone );
+    TUint redCount( 0 );
+    
+    //Call parent class method
+    error = iCodecArray[0]->CMccCodecInformation::SetRedCount( redCount );
+    EUNIT_ASSERT_EQUALS( KErrNone, error );
+    
+    redCount = iCodecArray[0]->CMccCodecInformation::RedCount();
+    EUNIT_ASSERT_EQUALS( 0, redCount );
+    
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->RedCount(), KErrNone );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_RedCountL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->RedCount(), iCodecArray[k]->iRedCount );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_RedundancyPTL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->RedundancyPT(), iCodecArray[k]->iRedundancyPT );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_JitterBufInactivityTimeOutL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->JitterBufInactivityTimeOut(), 
+                             iCodecArray[k]->iJitterBufInactivityTimeOut );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_JitterBufThresholdL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->JitterBufThreshold(), 
+                             iCodecArray[k]->iJitterBufThreshold );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_JitterBufBufferLengthL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->JitterBufBufferLength(), 
+                             iCodecArray[k]->iJitterBufBufferLength );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_MaxBitrateL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->MaxBitrate(), 
+                             iCodecArray[k]->iMaxBitrate );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_AverageBitrateL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->AverageBitrate(), 
+                             iCodecArray[k]->iAverageBitrate );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_FramerateL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->Framerate(), 
+                             iCodecArray[k]->iFramerate );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_FrameHeightL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->FrameHeight(), 
+                             iCodecArray[k]->iVideoHeight );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetModeChangePeriodL()
+    {    
+    for( TInt k = 1; k < iCount; k++ )// AMR codec tested in it's own test class    
+        {        
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetModeChangePeriod( 0 ), KErrNotSupported );
+        RDebug::Print( _L( "UT_CMccCodecInformation_SetModeChangePeriodL %d OK" ), k );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_ModeChangePeriodL()
+    {
+    for( TInt k = 1; k < iCount; k++ )// AMR codec tested in it's own test class
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->ModeChangePeriod(), KErrNotSupported );
+        RDebug::Print( _L( "UT_CMccCodecInformation_ModeChangePeriodL %d OK" ), k );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetModeChangeNeighborL()
+    {
+    const TBool neighbor( EFalse );
+
+    for( TInt k = 1; k < iCount; k++ )// AMR codec tested in it's own test class
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetModeChangeNeighbor( neighbor ), KErrNotSupported );
+        RDebug::Print( _L( "UT_CMccCodecInformation_SetModeChangeNeighborL %d OK" ), k );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_ModeChangeNeighborL()
+    {
+    for( TInt k = 1; k < iCount; k++ )// AMR codec tested in it's own test class
+        {
+        // Always true
+        EUNIT_ASSERT( iCodecArray[k]->ModeChangeNeighbor() );
+        RDebug::Print( _L( "UT_CMccCodecInformation_ModeChangeNeighborL %d OK" ), k );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_FrameWidthL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->FrameWidth(), 
+                             iCodecArray[k]->iVideoWidth );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_PriorityL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->Priority(), 
+                             iCodecArray[k]->iPriority );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_PriorityPreferenceL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->PriorityPreference(), 
+                             iCodecArray[k]->iPriorityPreference );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_KeepAliveTimerL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->KeepAliveTimer(), 
+                             iCodecArray[k]->iKeepAliveTimer );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_KeepAlivePTL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->KeepAlivePT(), 
+                             iCodecArray[k]->iKeepAlivePT );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_KeepAliveDataL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->KeepAliveData(), 
+                             iCodecArray[k]->iKeepAliveData );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_ComfortNoiseGenerationL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->ComfortNoiseGeneration(), 
+                             iCodecArray[k]->iComfortNoiseGenerationPt );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_GetChannelsL()
+    {
+#if 0 // Removed temporarily because code does not work
+    HBufC8* buf = HBufC8::NewL( 150 );
+    TPtr8 bufRef = buf->Des();
+
+    for( TInt k = 0; k < 1/*iCount*/; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->GetChannels( bufRef ), KErrNone );
+        RDebug::Print( _L( "UT_CMccCodecInformation_GetChannelsL %d OK" ), k );
+        }
+#endif
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_MaxRedL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->MaxRed(), 
+                             iCodecArray[k]->iMaxRed );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetFmtpAttrLL()
+    {    
+    TBuf8<5> buf;
+    buf.Format( _L8( "foo42" ) );
+
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        iCodecArray[k]->SetFmtpAttrL( buf, EFalse );
+        }   
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_ParseFmtpAttrLL()
+    {    
+    //Confirm that the arrary is not empty
+    EUNIT_ASSERT( iCount > 0 );
+    
+    _LIT8( KAMRName, "AMR" );
+    CMccCodecInformation* codecAMR = NULL;
+
+    // Find the AMR codec
+    for ( TInt i = 0; i < iCount; i++ )
+        {
+        if ( iCodecArray[i]->SdpName().Compare( KAMRName ) == 0 )
+            {
+            TInt error( KErrNone );
+    
+            codecAMR = iCodecArray[i];
+            
+            EUNIT_ASSERT_EQUALS( KErrNotSupported, codecAMR->SetCodecMode( EPCMU ) );
+            EUNIT_ASSERT_EQUALS( KErrNone , codecAMR->SetCodecMode( EBandwidthEfficient ) );
+            
+            //Create fmtp string
+            _LIT8( KTxtOctetAlign1ModeSet, "octet-align=1; mode-set=0,1,3,6," );
+            
+            //Create a buffer to hold the fmtp string
+            HBufC8* fmtpBuf = HBufC8::NewLC( KTxtOctetAlign1ModeSet().Length() );
+            fmtpBuf->Des().Copy( KTxtOctetAlign1ModeSet() );
+            TPtr8 bufPtr( fmtpBuf->Des() );
+            
+            //Array for bitrates
+            RArray<TUint> bitrates;
+            CleanupClosePushL( bitrates );
+            
+            //codecAMR->CMccCodecInformation::CreateFmtpModeSet( bufPtr, bitrates );
+            //codecAMR->CreateFmtpModeSet( bufPtr, bitrates );
+            codecAMR->CMccCodecInformation::CreateFmtpAttrListL();
+            codecAMR->CreateFmtpAttrListL( bitrates );
+            codecAMR->ParseFmtpAttrL( fmtpBuf->Des() );
+            
+            CleanupStack::PopAndDestroy(); //pop and close bitrates
+            CleanupStack::PopAndDestroy( fmtpBuf ); //pop and destroy fmtpBuf
+            
+            break; //jump out of the loop
+            }
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_CreateFmtpAttrListLL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        iCodecArray[k]->CreateFmtpAttrListL();    
+        }   
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_CreateFmtpAttrListL_1L(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        iCodecArray[k]->CreateFmtpAttrListL();
+        } 
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetCrcL()
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        if ( !iCodecArray[k]->SdpName().CompareF( KAMRSdpName ) ||
+             !iCodecArray[k]->SdpName().CompareF( KAMRWbSdpName ) )
+            {
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetCrc( EFalse ), KErrNone );
+            }
+        else
+            {
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetCrc( EFalse ), KErrNotSupported );
+            }        
+        }
+
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetCrc( ETrue ), KErrNotSupported );
+        }
+
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetCrc( -1 ), KErrNotSupported );
+        }
+ 
+     for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetCrc( 2 ), KErrNotSupported );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_GetCrcL()
+    {
+    for( TInt k = 1; k < iCount; k++ )
+        {
+        // Always false
+        EUNIT_ASSERT( !iCodecArray[k]->GetCrc() );
+        RDebug::Print( _L( "UT_CMccCodecInformation_GetCrcL %d OK" ), k );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetRobustSortingL()
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        if ( !iCodecArray[k]->SdpName().CompareF( KAMRSdpName ) ||
+             !iCodecArray[k]->SdpName().CompareF( KAMRWbSdpName ) )
+            {
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetRobustSorting( EFalse ), KErrNone );
+            }
+        else
+            {
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetRobustSorting( EFalse ), KErrNotSupported );
+            }        
+        }
+
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetRobustSorting( ETrue ), KErrNotSupported );
+        }
+
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetRobustSorting( -1 ), KErrNotSupported );
+        }
+ 
+     for( TInt k = 0; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetRobustSorting( 2 ), KErrNotSupported );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_GetRobustSortingL()
+    {
+    for( TInt k = 1; k < iCount; k++ )
+        {
+        // Always false
+        EUNIT_ASSERT( !iCodecArray[k]->GetRobustSorting() );
+        RDebug::Print( _L( "UT_CMccCodecInformation_GetRobustSortingL %d OK" ), k );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetInterleavingL()
+    {
+    TInt frameBlockCount( 0 );
+
+    for( TInt k = 1; k < iCount; k++ )
+        {
+        EUNIT_ASSERT_EQUALS( iCodecArray[k]->SetInterleaving( frameBlockCount ), KErrNotSupported );
+        RDebug::Print( _L( "UT_CMccCodecInformation_SetInterleavingL %d OK" ), k );
+        }
+    }
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_GetInterleavingL()
+    {
+    for( TInt k = 1; k < iCount; k++ )
+        {
+        if ( !iCodecArray[k]->SdpName().CompareF( KAMRSdpName ) ||
+             !iCodecArray[k]->SdpName().CompareF( KAMRWbSdpName ) )
+            {
+            EUNIT_ASSERT_EQUALS( 
+                iCodecArray[k]->GetInterleaving(), iCodecArray[k]->iFrameBlockCount );
+            }
+        else
+            {
+            EUNIT_ASSERT_EQUALS( iCodecArray[k]->GetInterleaving(), KErrNotSupported );
+            }
+        RDebug::Print( _L( "UT_CMccCodecInformation_GetInterleavingL %d OK" ), k );
+        }
+    }  
+
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetConfigKeyL()
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        if ( !iCodecArray[k]->SdpName().CompareF( KAMRSdpName ) )
+            {
+            EUNIT_ASSERT_SPECIFIC_LEAVE( iCodecArray[k]->SetConfigKeyL( KNullDesC8 ), KErrNotSupported );
+            }
+        }
+    }
+    
+void UT_CMccCodecInformation::UT_CMccCodecInformation_SetPreferredEncodingDecodingDeviceL(  )
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        if ( iCodecArray[k]->SdpName().CompareF( KAVCSdpName ) == 0 )
+            {      
+            iCodecArray[k]->SetPreferredEncodingDecodingDevice( TUid::Uid( 0x20001c13 ));
+            EUNIT_ASSERT(iCodecArray[k]->PreferredEncodingDecodingDevice() == TUid::Uid( 0x20001c13 ));
+            }
+        else
+            {
+            iCodecArray[k]->SetPreferredEncodingDecodingDevice( TUid::Uid( 0x20001c13 ) );
+            EUNIT_ASSERT(iCodecArray[k]->PreferredEncodingDecodingDevice() == KNullUid );
+            }        
+        }
+    }        
+    
+void UT_CMccCodecInformation::UT_CMccCodecInformation_ConfigKeyL()
+    {
+    for( TInt k = 0; k < iCount; k++ )
+        {
+        if ( !iCodecArray[k]->SdpName().CompareF( KAMRSdpName ) )
+            {
+            HBufC8* configKey = iCodecArray[k]->ConfigKeyL();
+            EUNIT_ASSERT( configKey == NULL );
+            }
+        }
+    }
+    
+// HELPERS
+void UT_CMccCodecInformation::GetCapabilitiesL( RPointerArray<CMccCodecInformation>& aCodecArray )
+    {
+    User::LeaveIfError( iInterface->GetCapabilities( aCodecArray ) );
+    
+    // Append also other codecs which are not yet officially supported!
+    
+    CMccCodecInformationFactory* codecFactory = CMccCodecInformationFactory::NewL();
+    CleanupStack::PushL( codecFactory );
+    
+    CMccCodecInformation* codec = codecFactory->CreateCodecInformationL( KAVCSdpName );
+    CleanupStack::PushL( codec );
+    aCodecArray.AppendL( codec );
+    CleanupStack::Pop( codec );
+    
+    CMccCodecInformation* codec2 = codecFactory->CreateCodecInformationL( KRedSdpName );
+    CleanupStack::PushL( codec2 );
+    aCodecArray.AppendL( codec2 );
+    CleanupStack::Pop( codec2 );
+    
+    CMccCodecInformation* codec3 = codecFactory->CreateCodecInformationL( KTelephoneEvent );
+    CleanupStack::PushL( codec3 );
+    aCodecArray.AppendL( codec3 );
+    CleanupStack::Pop( codec3 );
+    
+    CMccCodecInformation* codec4 = codecFactory->CreateCodecInformationL( KAMRWbSdpName );
+    CleanupStack::PushL( codec4 );
+    aCodecArray.AppendL( codec4 );
+    CleanupStack::Pop( codec4 );
+    
+    CleanupStack::PopAndDestroy( codecFactory );
+    }
+
+// EUNIT TEST TABLE
+
+EUNIT_BEGIN_TEST_TABLE( 
+    UT_CMccCodecInformation,
+    "CMccCodecInformation test",
+    "UNIT" )
+
+
+EUNIT_TEST(
+    "CloneDefaultsL - test ",
+    "CMccCodecInformation",
+    "CloneDefaultsL",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_CloneDefaultsLL, Teardown)
+
+EUNIT_TEST(
+    "CloneDetailedL - test ",
+    "CMccCodecInformation",
+    "CloneDetailedL",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_CloneDetailedLL, Teardown)
+
+EUNIT_TEST(
+    "RequireSignalling - test ",
+    "CMccCodecInformation",
+    "RequireSignalling",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_RequireSignallingL, Teardown)
+
+EUNIT_TEST(
+    "SetValues - test ",
+    "CMccCodecInformation",
+    "SetValues",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetValuesL, Teardown)
+
+EUNIT_TEST(
+    "GetValues - test ",
+    "CMccCodecInformation",
+    "GetValues",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_GetValuesL, Teardown)
+
+EUNIT_TEST(
+    "Type - test ",
+    "CMccCodecInformation",
+    "Type",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_TypeL, Teardown)
+
+EUNIT_TEST(
+    "EnableVAD - test ",
+    "CMccCodecInformation",
+    "EnableVAD",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_EnableVADL, Teardown)
+
+EUNIT_TEST(
+    "SetBitrate - test ",
+    "CMccCodecInformation",
+    "SetBitrate",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetBitrateL, Teardown)
+
+EUNIT_TEST(
+    "SetSamplingFreq - test ",
+    "CMccCodecInformation",
+    "SetSamplingFreq",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetSamplingFreqL, Teardown)
+
+EUNIT_TEST(
+    "SetSdpName - test ",
+    "CMccCodecInformation",
+    "SetSdpName",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetSdpNameL, Teardown)
+
+EUNIT_TEST(
+    "SetPayloadType - test ",
+    "CMccCodecInformation",
+    "SetPayloadType",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetPayloadTypeL, Teardown)
+
+EUNIT_TEST(
+    "SetCodecMode - test ",
+    "CMccCodecInformation",
+    "SetCodecMode",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetCodecModeL, Teardown)
+
+EUNIT_TEST(
+    "SetAllowedBitrates - test ",
+    "CMccCodecInformation",
+    "SetAllowedBitrates",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetAllowedBitratesL, Teardown)
+
+EUNIT_TEST(
+    "SetPTime - test ",
+    "CMccCodecInformation",
+    "SetPTime",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetPTimeL, Teardown)
+
+EUNIT_TEST(
+    "SetMaxPTime - test ",
+    "CMccCodecInformation",
+    "SetMaxPTime",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetMaxPTimeL, Teardown)
+
+EUNIT_TEST(
+    "SetJitterBufBufferLength - test ",
+    "CMccCodecInformation",
+    "SetJitterBufBufferLength",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetJitterBufBufferLengthL, Teardown)
+
+EUNIT_TEST(
+    "SetJitterBufThreshold - test ",
+    "CMccCodecInformation",
+    "SetJitterBufThreshold",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetJitterBufThresholdL, Teardown)
+
+EUNIT_TEST(
+    "SetJitterBufInactivityTimeOut - test ",
+    "CMccCodecInformation",
+    "SetJitterBufInactivityTimeOut",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetJitterBufInactivityTimeOutL, Teardown)
+
+EUNIT_TEST(
+    "SetMaxBitrate - test ",
+    "CMccCodecInformation",
+    "SetMaxBitrate",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetMaxBitrateL, Teardown)
+
+EUNIT_TEST(
+    "SetAverageBitrate - test ",
+    "CMccCodecInformation",
+    "SetAverageBitrate",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetAverageBitrateL, Teardown)
+
+EUNIT_TEST(
+    "SetFramerate - test ",
+    "CMccCodecInformation",
+    "SetFramerate",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetFramerateL, Teardown)
+
+EUNIT_TEST(
+    "SetFrameHeight - test ",
+    "CMccCodecInformation",
+    "SetFrameHeight",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetFrameHeightL, Teardown)
+
+EUNIT_TEST(
+    "SetFrameWidth - test ",
+    "CMccCodecInformation",
+    "SetFrameWidth",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetFrameWidthL, Teardown)
+
+EUNIT_TEST(
+    "SetAlgo - test ",
+    "CMccCodecInformation",
+    "SetAlgo",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetAlgoL, Teardown)
+
+EUNIT_TEST(
+    "SetRedCount - test ",
+    "CMccCodecInformation",
+    "SetRedCount",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetRedCountL, Teardown)
+
+EUNIT_TEST(
+    "SetRedundancyPT - test ",
+    "CMccCodecInformation",
+    "SetRedundancyPT",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetRedundancyPTL, Teardown)
+
+EUNIT_TEST(
+    "SetPriority - test ",
+    "CMccCodecInformation",
+    "SetPriority",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetPriorityL, Teardown)
+
+EUNIT_TEST(
+    "SetPriorityPreference - test ",
+    "CMccCodecInformation",
+    "SetPriorityPreference",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetPriorityPreferenceL, Teardown)
+
+EUNIT_TEST(
+    "SetKeepAliveTimer - test ",
+    "CMccCodecInformation",
+    "SetKeepAliveTimer",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetKeepAliveTimerL, Teardown)
+
+EUNIT_TEST(
+    "SetKeepAlivePT - test ",
+    "CMccCodecInformation",
+    "SetKeepAlivePT",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetKeepAlivePTL, Teardown)
+
+EUNIT_TEST(
+    "SetKeepAliveData - test ",
+    "CMccCodecInformation",
+    "SetKeepAliveData",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetKeepAliveDataL, Teardown)
+
+EUNIT_TEST(
+    "SetComfortNoiseGeneration - test ",
+    "CMccCodecInformation",
+    "SetComfortNoiseGeneration",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetComfortNoiseGenerationL, Teardown)
+
+EUNIT_TEST(
+    "SetChannels - test ",
+    "CMccCodecInformation",
+    "SetChannels",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetChannelsL, Teardown)
+
+EUNIT_TEST(
+    "SetMaxRed - test ",
+    "CMccCodecInformation",
+    "SetMaxRed",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetMaxRedL, Teardown)
+
+EUNIT_TEST(
+    "VAD - test ",
+    "CMccCodecInformation",
+    "VAD",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_VADL, Teardown)
+
+EUNIT_TEST(
+    "Bitrate - test ",
+    "CMccCodecInformation",
+    "Bitrate",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_BitrateL, Teardown)
+
+EUNIT_TEST(
+    "AllowedBitrates - test ",
+    "CMccCodecInformation",
+    "AllowedBitrates",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_AllowedBitratesL, Teardown)
+
+EUNIT_TEST(
+    "SamplingFreq - test ",
+    "CMccCodecInformation",
+    "SamplingFreq",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SamplingFreqL, Teardown)
+
+EUNIT_TEST(
+    "SdpName - test ",
+    "CMccCodecInformation",
+    "SdpName",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SdpNameL, Teardown)
+
+EUNIT_TEST(
+    "PayloadType - test ",
+    "CMccCodecInformation",
+    "PayloadType",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_PayloadTypeL, Teardown)
+
+EUNIT_TEST(
+    "CodecMode - test ",
+    "CMccCodecInformation",
+    "CodecMode",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_CodecModeL, Teardown)
+
+EUNIT_TEST(
+    "PTime - test ",
+    "CMccCodecInformation",
+    "PTime",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_PTimeL, Teardown)
+
+EUNIT_TEST(
+    "MaxPTime - test ",
+    "CMccCodecInformation",
+    "MaxPTime",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_MaxPTimeL, Teardown)
+
+EUNIT_TEST(
+    "GetFmtpL - test ",
+    "CMccCodecInformation",
+    "GetFmtpL",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_GetFmtpLL, Teardown)
+
+EUNIT_TEST(
+    "FourCC - test ",
+    "CMccCodecInformation",
+    "FourCC",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_FourCCL, Teardown)
+
+EUNIT_TEST(
+    "FrameTime - test ",
+    "CMccCodecInformation",
+    "FrameTime",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_FrameTimeL, Teardown)
+
+EUNIT_TEST(
+    "FrameSize - test ",
+    "CMccCodecInformation",
+    "FrameSize",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_FrameSizeL, Teardown)
+
+EUNIT_TEST(
+    "Algo - test ",
+    "CMccCodecInformation",
+    "Algo",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_AlgoL, Teardown)
+
+EUNIT_TEST(
+    "RedCount - test ",
+    "CMccCodecInformation",
+    "RedCount",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_RedCountL, Teardown)
+
+EUNIT_TEST(
+    "RedundancyPT - test ",
+    "CMccCodecInformation",
+    "RedundancyPT",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_RedundancyPTL, Teardown)
+
+EUNIT_TEST(
+    "JitterBufInactivityTimeOut - test ",
+    "CMccCodecInformation",
+    "JitterBufInactivityTimeOut",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_JitterBufInactivityTimeOutL, Teardown)
+
+EUNIT_TEST(
+    "JitterBufThreshold - test ",
+    "CMccCodecInformation",
+    "JitterBufThreshold",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_JitterBufThresholdL, Teardown)
+
+EUNIT_TEST(
+    "JitterBufBufferLength - test ",
+    "CMccCodecInformation",
+    "JitterBufBufferLength",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_JitterBufBufferLengthL, Teardown)
+
+EUNIT_TEST(
+    "MaxBitrate - test ",
+    "CMccCodecInformation",
+    "MaxBitrate",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_MaxBitrateL, Teardown)
+
+EUNIT_TEST(
+    "AverageBitrate - test ",
+    "CMccCodecInformation",
+    "AverageBitrate",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_AverageBitrateL, Teardown)
+
+EUNIT_TEST(
+    "Framerate - test ",
+    "CMccCodecInformation",
+    "Framerate",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_FramerateL, Teardown)
+
+EUNIT_TEST(
+    "FrameHeight - test ",
+    "CMccCodecInformation",
+    "FrameHeight",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_FrameHeightL, Teardown)
+
+EUNIT_TEST(
+    "FrameWidth - test ",
+    "CMccCodecInformation",
+    "FrameWidth",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_FrameWidthL, Teardown)
+
+EUNIT_TEST(
+    "Priority - test ",
+    "CMccCodecInformation",
+    "Priority",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_PriorityL, Teardown)
+
+EUNIT_TEST(
+    "PriorityPreference - test ",
+    "CMccCodecInformation",
+    "PriorityPreference",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_PriorityPreferenceL, Teardown)
+
+EUNIT_TEST(
+    "KeepAliveTimer - test ",
+    "CMccCodecInformation",
+    "KeepAliveTimer",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_KeepAliveTimerL, Teardown)
+
+EUNIT_TEST(
+    "KeepAlivePT - test ",
+    "CMccCodecInformation",
+    "KeepAlivePT",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_KeepAlivePTL, Teardown)
+
+EUNIT_TEST(
+    "KeepAliveData - test ",
+    "CMccCodecInformation",
+    "KeepAliveData",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_KeepAliveDataL, Teardown)
+
+EUNIT_TEST(
+    "ComfortNoiseGeneration - test ",
+    "CMccCodecInformation",
+    "ComfortNoiseGeneration",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_ComfortNoiseGenerationL, Teardown)
+
+EUNIT_TEST(
+    "GetChannels - test ",
+    "CMccCodecInformation",
+    "GetChannels",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_GetChannelsL, Teardown)
+
+EUNIT_TEST(
+    "MaxRed - test ",
+    "CMccCodecInformation",
+    "MaxRed",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_MaxRedL, Teardown)
+
+EUNIT_TEST(
+    "SetFmtpAttrL - test ",
+    "CMccCodecInformation",
+    "SetFmtpAttrL",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetFmtpAttrLL, Teardown)
+
+EUNIT_TEST(
+    "ParseFmtpAttrL - test ",
+    "CMccCodecInformation",
+    "ParseFmtpAttrL",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_ParseFmtpAttrLL, Teardown)
+
+EUNIT_TEST(
+    "CreateFmtpAttrListL - test ",
+    "CMccCodecInformation",
+    "CreateFmtpAttrListL",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_CreateFmtpAttrListLL, Teardown)
+
+EUNIT_TEST(
+    "CreateFmtpAttrListL - test ",
+    "CMccCodecInformation",
+    "CreateFmtpAttrListL",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_CreateFmtpAttrListL_1L, Teardown)
+
+EUNIT_TEST(
+    "SetCrc - test ",
+    "CMccCodecInformation",
+    "SetCrc",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetCrcL, Teardown)
+
+EUNIT_TEST(
+    "GetCrc - test ",
+    "CMccCodecInformation",
+    "GetCrc",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_GetCrcL, Teardown)
+
+EUNIT_TEST(
+    "SetRobustSorting - test ",
+    "CMccCodecInformation",
+    "SetRobustSorting",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetRobustSortingL, Teardown)
+
+EUNIT_TEST(
+    "GetRobustSorting - test ",
+    "CMccCodecInformation",
+    "GetRobustSorting",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_GetRobustSortingL, Teardown)
+
+EUNIT_TEST(
+    "SetInterleaving - test ",
+    "CMccCodecInformation",
+    "SetInterleaving",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetInterleavingL, Teardown)
+
+EUNIT_TEST(
+    "GetInterleaving - test ",
+    "CMccCodecInformation",
+    "GetInterleaving",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_GetInterleavingL, Teardown)
+
+EUNIT_TEST(
+    "SetChannels - test ",
+    "CMccCodecInformation",
+    "SetChannels",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetChannelsL, Teardown)
+
+EUNIT_TEST(
+    "GetChannels - test ",
+    "CMccCodecInformation",
+    "GetChannels",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_GetChannelsL, Teardown)
+
+EUNIT_TEST(
+    "RequireSignalling - test ",
+    "CMccCodecInformation",
+    "RequireSignalling",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_RequireSignallingL, Teardown)
+    
+EUNIT_TEST(
+    "SetValuesL - test ",
+    "CMccCodecInformation",
+    "SetValuesL",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetValuesL, Teardown)
+    
+EUNIT_TEST(
+    "GetValuesL - test ",
+    "CMccCodecInformation",
+    "GetValuesL",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_GetValuesL, Teardown)
+
+EUNIT_TEST(
+    "SetConfigKeyL - test ",
+    "CMccCodecInformation",
+    "SetConfigKeyL",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetConfigKeyL, Teardown)
+    
+EUNIT_TEST(
+    "SetPreferredEncodingDecodingDeviceL - test ",
+    "CMccCodecInformation",
+    "SetPreferredEncodingDecodingDeviceL",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_SetPreferredEncodingDecodingDeviceL, Teardown)    
+
+EUNIT_TEST(
+    "ConfigKeyL - test ",
+    "CMccCodecInformation",
+    "ConfigKeyL",
+    "FUNCTIONALITY",
+    SetupL, UT_CMccCodecInformation_ConfigKeyL, Teardown)
+            
+EUNIT_END_TEST_TABLE
+
+//  END OF FILE