diff -r 000000000000 -r 1bce908db942 multimediacommscontroller/mmccilbcpayloadformat/tsrc/ut_ilbcpayloadformat/src/UT_CIlbcPayloadFormatWrite.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/multimediacommscontroller/mmccilbcpayloadformat/tsrc/ut_ilbcpayloadformat/src/UT_CIlbcPayloadFormatWrite.cpp	Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,875 @@
+/*
+* 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_CIlbcPayloadFormatWrite.h"
+
+//  EXTERNAL INCLUDES
+#include <e32base.h>
+#include <digia/eunit/eunitmacros.h>
+
+#ifdef EUNIT_ALLOC_TEST_ON
+    #include <digia/eunit/CEunitAllocTestCaseDecorator.h>   //for using EUNIT_ALLOC_TEST
+#endif
+
+//  INTERNAL INCLUDES
+#include "IlbcPayloadFormatWrite.h"
+#include <mmf/server/mmfdatasink.h>
+#include <mmf/server/mmfdatasource.h>
+#include "Mcculdatapath.h"
+#include "mccuids.hrh"
+#include "mccrtpmediaclock.h"
+#include "mccresourcepool.h" 
+#include "mccredpayloadwrite.h"
+#include "mccrtpdatasink.h"
+
+const TUid KRtpDataSink              =  { KImplUidRtpDataSink               };
+const TUid KRtpDataSource            =  { KImplUidRtpDataSource             };
+
+
+const TUint KiLBCSampleRate = 8000;
+
+// CONSTRUCTION
+UT_CIlbcPayloadFormatWrite* UT_CIlbcPayloadFormatWrite::NewL()
+    {
+    UT_CIlbcPayloadFormatWrite* self = UT_CIlbcPayloadFormatWrite::NewLC(); 
+    CleanupStack::Pop();
+
+    return self;
+    }
+
+UT_CIlbcPayloadFormatWrite* UT_CIlbcPayloadFormatWrite::NewLC()
+    {
+    UT_CIlbcPayloadFormatWrite* self = new( ELeave ) UT_CIlbcPayloadFormatWrite();
+    CleanupStack::PushL( self );
+
+	self->ConstructL(); 
+
+    return self;
+    }
+
+// Destructor (virtual by CBase)
+UT_CIlbcPayloadFormatWrite::~UT_CIlbcPayloadFormatWrite()
+    {
+    }
+
+// Default constructor
+UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite()
+    {
+    }
+
+// Second phase construct
+void UT_CIlbcPayloadFormatWrite::ConstructL()
+    {
+    // The ConstructL from the base class CEUnitTestSuiteClass must be called.
+    // It generates the test case table.
+    CEUnitTestSuiteClass::ConstructL();
+    }
+
+//  METHODS
+void UT_CIlbcPayloadFormatWrite::SetupAL(  )
+    {
+    iAlloc = ETrue;
+    
+    MAsyncEventHandler* eventHandler = NULL;
+    CMccResourcePool* mccresource = NULL;
+    iRtpMediaClock = CMccRtpMediaClock::NewL();
+     
+    iUlSink = CMccUlDataPath::NewL( eventHandler, mccresource, iMediaId ); //MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );
+    iRtpDataSinkStub = MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );  
+    iWrite = CIlbcPayloadFormatWrite::NewL( iRtpDataSinkStub );
+    
+    iCodec.iAlgoUsed = ENoAlgoUsed;
+    iCodec.iBitrate = 15200;
+    iCodec.iCNFrameSize = 0;
+    iCodec.iCodecMode = 3;
+    iCodec.iEnableDTX = 1;
+    iCodec.iFourCC = 0x31313747;
+    iCodec.iFrameSize = 0;
+    iCodec.iHwFrameTime = 20;
+    iCodec.iMaxPtime = 200;
+    iCodec.iPayloadType = 8;
+    iCodec.iPtime = 20;
+    iCodec.iRedundancyCount = 1;
+    iCodec.iRedundantPayload = 99;
+  
+    TMccCodecInfoBuffer buffer( iCodec );
+    
+    iWrite->ConfigurePayloadFormatL( buffer, *iRtpMediaClock );
+    
+    iBuff = CMMFDescriptorBuffer::NewL( 10 );
+
+    TMediaId mediaId( KUidMediaTypeAudio, 1 );
+  
+    // Datapath calls CreateSinkBufferL
+    TBool bufferReference;
+    iBuffer = iWrite->CreateSinkBufferL( mediaId, bufferReference );
+
+    iWrite->SinkPrimeL();
+    iWrite->SinkPlayL( );
+    }
+
+void UT_CIlbcPayloadFormatWrite::Setup2AL(  )
+    {
+    // not call CreateSinkBufferL
+    
+    iAlloc = ETrue;
+    
+    MAsyncEventHandler* eventHandler = NULL;
+    CMccResourcePool* mccresource = NULL;
+    iRtpMediaClock = CMccRtpMediaClock::NewL();
+     
+    iUlSink = CMccUlDataPath::NewL( eventHandler, mccresource, iMediaId ); //MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );
+    iRtpDataSinkStub = MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );  
+    iWrite = CIlbcPayloadFormatWrite::NewL( iRtpDataSinkStub );
+    
+    iCodec.iAlgoUsed = ENoAlgoUsed;
+    iCodec.iBitrate = 15200;
+    iCodec.iCNFrameSize = 0;
+    iCodec.iCodecMode = 3;
+    iCodec.iEnableDTX = 1;
+    iCodec.iFourCC = 0x31313747;
+    iCodec.iFrameSize = 0;
+    iCodec.iHwFrameTime = 20;
+    iCodec.iMaxPtime = 200;
+    iCodec.iPayloadType = 8;
+    iCodec.iPtime = 20;
+    iCodec.iRedundancyCount = 1;
+    iCodec.iRedundantPayload = 99;
+  
+    TMccCodecInfoBuffer buffer( iCodec );
+    
+    iWrite->ConfigurePayloadFormatL( buffer, *iRtpMediaClock );
+    
+    iBuff = CMMFDescriptorBuffer::NewL( 10 );
+
+    TMediaId mediaId( KUidMediaTypeAudio, 1 );
+  
+
+    iWrite->SinkPrimeL();
+    iWrite->SinkPlayL( );
+    }
+
+void UT_CIlbcPayloadFormatWrite::SetupL(  )
+    { 
+    iAlloc = EFalse;
+    
+    MAsyncEventHandler* eventHandler = NULL;
+    CMccResourcePool* mccresource = NULL;
+    iRtpMediaClock = CMccRtpMediaClock::NewL();
+     
+    iUlSink = CMccUlDataPath::NewL( eventHandler, mccresource, iMediaId ); //MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );
+    iRtpDataSinkStub = MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 );  
+    iWrite = CIlbcPayloadFormatWrite::NewL( iRtpDataSinkStub );
+    
+    iCodec.iAlgoUsed = ENoAlgoUsed;
+    iCodec.iBitrate = 15200;
+    iCodec.iCNFrameSize = 0;
+    iCodec.iCodecMode = 3;
+    iCodec.iEnableDTX = 1;
+    iCodec.iFourCC = 0x31313747;
+    iCodec.iFrameSize = 0;
+    iCodec.iHwFrameTime = 20;
+    iCodec.iMaxPtime = 200;
+    iCodec.iPayloadType = 8;
+    iCodec.iPtime = 20;
+    iCodec.iRedundancyCount = 1;
+    iCodec.iRedundantPayload = 99;
+  
+    TMccCodecInfoBuffer buffer( iCodec );
+    
+    iWrite->ConfigurePayloadFormatL( buffer, *iRtpMediaClock );
+    
+    iBuff = CMMFDescriptorBuffer::NewL( 10 );
+
+    TMediaId mediaId( KUidMediaTypeAudio, 1 );
+  
+    // Datapath calls CreateSinkBufferL
+    TBool bufferReference;
+    iBuffer = iWrite->CreateSinkBufferL( mediaId, bufferReference );
+
+    iWrite->SinkPrimeL();
+    iWrite->SinkPlayL( );
+    
+    }
+
+
+void UT_CIlbcPayloadFormatWrite::Teardown()
+    {
+    delete iUlSink;
+    delete iRtpDataSinkStub;
+    delete iWrite;
+    delete iBuff;
+    delete iRtpMediaClock;
+    
+    REComSession::FinalClose();
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_NewLL(  )
+    {
+    CIlbcPayloadFormatWrite* write = CIlbcPayloadFormatWrite::NewL( iRtpDataSinkStub );
+    delete write;
+    EUNIT_ASSERT_SPECIFIC_LEAVE( CIlbcPayloadFormatWrite* write2 = CIlbcPayloadFormatWrite::NewL( NULL ), KErrArgument );
+    }
+
+
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_EmptySourceBufferLL(  )
+    {
+    TMediaId mediaId( KUidMediaTypeAudio, 1 );
+
+    EUNIT_ASSERT_NO_LEAVE( iWrite->EmptyBufferL( iBuffer, iUlSink, mediaId ) );
+    EUNIT_ASSERT_NO_LEAVE( iWrite->EmptySourceBufferL() );
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_SourceBufferEmptiedLL(  )
+    {
+    EUNIT_ASSERT_NO_LEAVE( iWrite->EmptyBufferL( iBuffer, iUlSink, KUidMediaTypeAudio ) );
+    EUNIT_ASSERT_NO_LEAVE( iWrite->SourceBufferEmptiedL( ) );
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_SinkPrimeLL(  )
+    {
+    EUNIT_ASSERT_NO_LEAVE( iWrite->SinkPrimeL() );
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_SinkPlayLL(  )
+    {
+    iWrite->SinkPlayL();
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_SinkPauseLL(  )
+    {
+    if ( !iAlloc )
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkPauseL() );
+        }
+    else
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkPauseL() );
+        }
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_SinkStopLL(  )
+    {
+    EUNIT_ASSERT_NO_LEAVE( iWrite->SinkStopL() );
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_FrameTimeIntervalL(  )
+    {
+    iWrite->iFrameTimeInterval = 20000 *  2;  // 20k * Channels
+    TTimeIntervalMicroSeconds catchAfish;
+    TMediaId mediaIdAudio( KUidMediaTypeAudio, 1 );
+    TMediaId mediaIdVideo( KUidMediaTypeVideo, 1 );
+    
+    if ( !iAlloc )
+        {
+        catchAfish = iWrite->FrameTimeInterval ( mediaIdAudio );
+        EUNIT_ASSERT_EQUALS( catchAfish.Int64(), 40000 );
+        
+        catchAfish = iWrite->FrameTimeInterval ( mediaIdVideo );
+        EUNIT_ASSERT_EQUALS( catchAfish.Int64(), 0 );
+        }
+        
+    else
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->FrameTimeInterval ( mediaIdAudio ) );
+        EUNIT_ASSERT_NO_LEAVE( iWrite->FrameTimeInterval ( mediaIdVideo ) );
+        }
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_DurationL(  )
+    {
+    TTimeIntervalMicroSeconds catchAfish;
+    TMediaId mediaId( KUidMediaTypeAudio, 1 );
+    
+    if ( !iAlloc )
+        {
+        catchAfish = iWrite->Duration( mediaId );
+        EUNIT_ASSERT_EQUALS( catchAfish.Int64(), 0 );
+        }
+    
+    else 
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->Duration( mediaId ) );
+        }
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_CreateSinkBufferLL(  )
+    {
+    TMediaId mediaId( KUidMediaTypeAudio, 1 );
+    TMediaId mediaIdVideo( KUidMediaTypeVideo, 1 );
+    TBool reference;
+    
+    if ( !iAlloc )
+        {
+        EUNIT_ASSERT_NO_LEAVE( iBuf = iWrite->CreateSinkBufferL( mediaId, reference ) );
+        EUNIT_ASSERT_SPECIFIC_LEAVE( iBuf = iWrite->CreateSinkBufferL( mediaIdVideo, reference ), KErrNotSupported );
+        }
+    
+    else
+        {
+        EUNIT_ASSERT_SPECIFIC_LEAVE( iWrite->CreateSinkBufferL( mediaId, reference ), KErrNoMemory );
+        EUNIT_ASSERT_SPECIFIC_LEAVE( iWrite->CreateSinkBufferL( mediaIdVideo, reference ), KErrNotSupported );
+        }
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_SinkDataTypeCodeL(  )
+    {
+    TMediaId mediaId( KUidMediaTypeAudio, 1 );
+    TMediaId mediaIdVideo( KUidMediaTypeVideo, 1 );
+    
+    if ( !iAlloc )
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkDataTypeCode( mediaIdVideo ) );
+        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkDataTypeCode( mediaId ) );
+        }
+    
+    else
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkDataTypeCode( mediaIdVideo ) );
+        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkDataTypeCode( mediaId ) );
+        }
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_SetSinkDataTypeCodeL(  )
+    {
+    TFourCC fourcc;
+    TMediaId mediaId( KUidMediaTypeAudio, 1 );
+    TMediaId mediaIdVideo( KUidMediaTypeVideo, 1 );
+    
+    if ( !iAlloc )
+        {
+        fourcc = iWrite->SinkDataTypeCode( mediaId );
+        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaId ), KErrNone );
+        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaIdVideo ), KErrNotSupported );
+        fourcc = iWrite->SinkDataTypeCode( mediaIdVideo );
+        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaId ), KErrNone );
+        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaIdVideo ), KErrNotSupported );
+        }
+    
+    else
+        {
+        fourcc = iWrite->SinkDataTypeCode( mediaIdVideo );
+        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaIdVideo ), KErrNotSupported );
+        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaId ), KErrNone );
+        fourcc = iWrite->SinkDataTypeCode( mediaId  );
+        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaId ), KErrNone );
+        EUNIT_ASSERT_EQUALS( iWrite->SetSinkDataTypeCode( fourcc, mediaIdVideo ), KErrNotSupported );
+        }
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_SinkThreadLogonL(  )
+    {
+    if ( !iAlloc )
+        {
+        EUNIT_ASSERT_EQUALS( iWrite->SinkThreadLogon( *this ), KErrNone );
+        }
+    
+    else
+        {
+        EUNIT_ASSERT_EQUALS( iWrite->SinkThreadLogon( *this ), KErrNone );
+        }
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_SinkThreadLogoffL(  )
+    {
+    if ( !iAlloc )
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkThreadLogoff() );
+        }
+    
+    else
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->SinkThreadLogoff() );
+        }
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_EmptyBufferLL(  )
+    {
+    TMediaId mediaId( KUidMediaTypeAudio, 1 );
+    TMediaId mediaIdVideo( KUidMediaTypeVideo, 1 );
+    
+    if ( !iAlloc )
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->EmptyBufferL( iBuffer, iUlSink, mediaId ) );
+        EUNIT_ASSERT_SPECIFIC_LEAVE( iWrite->EmptyBufferL( iBuffer, iUlSink, mediaIdVideo ), KErrNotSupported );
+             
+        iWrite->iFrameIndex = 1;
+        EUNIT_ASSERT_NO_LEAVE( iWrite->EmptyBufferL( iBuffer, iUlSink, mediaId ) );
+        }
+    
+    else 
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->EmptyBufferL( iBuffer, iUlSink, mediaId ) );
+        EUNIT_ASSERT_SPECIFIC_LEAVE( iWrite->EmptyBufferL( iBuffer, iUlSink, mediaIdVideo ), KErrNotSupported );
+        
+        }
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_BufferEmptiedLL(  )
+    {
+    if ( !iAlloc )
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->BufferEmptiedL( iBuffer ) );
+        }
+    else
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->BufferEmptiedL( iBuffer ) );
+        }
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_SampleRateL(  )
+    {
+    TUint samplerate;
+    
+    if ( !iAlloc )
+        {
+        samplerate = iWrite->SampleRate( );
+        EUNIT_ASSERT_EQUALS( samplerate, KiLBCSampleRate );
+        }
+    
+    else
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->SampleRate( ) );
+        }
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_SetSampleRateL(  )
+    {
+    TInt rate( 8000 );
+    if ( !iAlloc )
+        {
+        EUNIT_ASSERT( iWrite->SetSampleRate( rate ) == KErrNone );
+        EUNIT_ASSERT( iWrite->SetSampleRate( rate + 1 ) == KErrNotSupported );
+        }
+    
+    else
+        {
+        EUNIT_ASSERT_NO_LEAVE( iWrite->SetSampleRate( rate ) );
+        EUNIT_ASSERT_NO_LEAVE( iWrite->SetSampleRate( rate + 1 ) );
+        }
+    }
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_DeliverPacketLL( )
+    {
+    iBuff->Data().Append( _L("1234512345") );
+     
+    EUNIT_ASSERT_NO_LEAVE( iWrite->DeliverPacketL( *iBuff ) );
+    
+    iWrite->iCNModeON = ETrue;
+    EUNIT_ASSERT_NO_LEAVE( iWrite->DeliverPacketL( *iBuff ) );    
+        
+    iBuff->Data().Append( _L("1234567891") );  
+    EUNIT_ASSERT_NO_LEAVE( iWrite->DeliverPacketL( *iBuff ) );   
+        
+    iWrite->iClip = NULL;
+    EUNIT_ASSERT_LEAVE( iWrite->DeliverPacketL( *iBuff ) );
+    
+    iWrite->iClip = iRtpDataSinkStub;
+    iWrite->iRtpDataSink = NULL;
+    EUNIT_ASSERT_LEAVE( iWrite->DeliverPacketL( *iBuff ) );  
+    }
+ 
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_ConfigurePayloadFormatLL( )
+    {
+    if ( iAlloc )
+        {
+        EUNIT_ASSERT( ETrue );
+        }
+    else
+        { 
+        TMccCodecInfo codec;
+        codec.iAlgoUsed         = ENoAlgoUsed;
+        codec.iBitrate          = 15200;
+        codec.iCNFrameSize      = 0;
+        codec.iCodecMode        = 3;
+        codec.iEnableDTX        = 1;
+        codec.iFourCC           = 0x31313747;
+        codec.iFrameSize        = 0;
+        codec.iHwFrameTime      = 20;
+        codec.iMaxPtime         = 200;
+        codec.iPayloadType      = 8;
+        codec.iPtime            = 20;
+        codec.iRedundancyCount  = 1;
+        codec.iRedundantPayload = 99;
+        codec.iComfortNoiseGenerationPt = KPayloadTypeUndefined;
+        
+        TMccCodecInfoBuffer buffer( codec );
+        EUNIT_ASSERT_NO_LEAVE( iWrite->ConfigurePayloadFormatL( buffer, *iRtpMediaClock ));
+        
+        codec.iBitrate = 10000;
+        buffer =  codec;
+        EUNIT_ASSERT_LEAVE( iWrite->ConfigurePayloadFormatL( buffer, *iRtpMediaClock  ) );     
+        
+        codec.iBitrate = 13330;
+        buffer =  codec;
+        EUNIT_ASSERT_NO_LEAVE( iWrite->ConfigurePayloadFormatL( buffer, *iRtpMediaClock  ) ); 
+        
+        // test updating of values
+        codec.iIsUpdate         = ETrue;
+        codec.iBitrate          = 15200;
+        codec.iPtime            = 40;
+        codec.iPayloadType      = 0;
+        codec.iComfortNoiseGenerationPt = 13;
+        buffer =  codec;
+        iWrite->ConfigurePayloadFormatL( buffer, *iRtpMediaClock );         
+        TMccCodecInfoBuffer buffer2( iWrite->iCInfo );
+        EUNIT_ASSERT( iWrite->iCInfo.iPtime == 40 );
+        EUNIT_ASSERT( iWrite->iCInfo.iPayloadType == 0 );
+        EUNIT_ASSERT( iWrite->iCInfo.iComfortNoiseGenerationPt == 13 );
+        
+        // test redundancy payload format usage
+        codec.iIsUpdate         = EFalse;
+        codec.iAlgoUsed         = EGenRedUsed;
+        codec.iRedundancyCount  = 1;
+        buffer = codec; 
+        CMccRtpDataSink* rtpDataSinkStub = 
+            static_cast<CMccRtpDataSink*>( MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 ) );
+        CleanupStack::PushL( rtpDataSinkStub );
+        CMccRedPayloadWrite* redEncoder = CMccRedPayloadWrite::NewL( rtpDataSinkStub );
+        CleanupStack::PushL( redEncoder );
+        CIlbcPayloadFormatWrite* write = CIlbcPayloadFormatWrite::NewL( redEncoder );
+        CleanupStack::PushL( write );
+        write->iCInfo.iHwFrameTime = 20;
+        EUNIT_ASSERT_NO_LEAVE( write->ConfigurePayloadFormatL( buffer, *iRtpMediaClock ) );
+        CleanupStack::PopAndDestroy( 3 ); 
+        }
+    }
+
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_UpdateConfigurationLL( )
+    {          
+    iCodec.iAlgoUsed = EGenRedUsed;
+    iCodec.iBitrate = 13330;
+    iCodec.iCNFrameSize = 0;
+    iCodec.iCodecMode = 3;
+    iCodec.iEnableDTX = 1;
+    iCodec.iFourCC = 0x31313747;
+    iCodec.iFrameSize = 0;
+    iCodec.iHwFrameTime = 20;
+    iCodec.iMaxPtime = 220;
+    iCodec.iPayloadType = 8;
+    iCodec.iPtime = 20;
+    iCodec.iRedundancyCount = 1;
+    iCodec.iRedundantPayload = 99;
+    
+    CMccRtpDataSink* rtpDataSinkStub = 
+        reinterpret_cast<CMccRtpDataSink*>( MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 ) );
+    CleanupStack::PushL( rtpDataSinkStub );
+    CMccRedPayloadWrite* redEncoder = CMccRedPayloadWrite::NewL( rtpDataSinkStub );
+    CleanupStack::PushL( redEncoder );
+    CIlbcPayloadFormatWrite* write2 = CIlbcPayloadFormatWrite::NewL( redEncoder );
+    CleanupStack::PushL( write2 );    
+    TMccCodecInfoBuffer buffer( iCodec );
+    EUNIT_ASSERT_NO_LEAVE( write2->ConfigurePayloadFormatL( buffer, *iRtpMediaClock ) );
+
+    write2->UpdateConfigurationL( iCodec );
+    
+    iCodec.iHwFrameTime = 0;
+    iCodec.iPtime = 30;
+    EUNIT_ASSERT_SPECIFIC_LEAVE( write2->UpdateConfigurationL( iCodec ), KErrArgument );
+    
+    CleanupStack::PopAndDestroy( 3 );
+    }  
+    
+
+void UT_CIlbcPayloadFormatWrite::UT_CIlbcPayloadFormatWrite_NumChannelsL()
+    {
+    EUNIT_ASSERT_EQUALS( iWrite->NumChannels(), 1 );
+    }  
+    
+     
+//  TEST TABLE
+
+EUNIT_BEGIN_TEST_TABLE( 
+    UT_CIlbcPayloadFormatWrite,
+    "MCC iLBC Payloadformat Unittests",
+    "UNIT" )
+    
+EUNIT_TEST(
+    "EmptySourceBufferL - test ",
+    "CIlbcPayloadFormatWrite",
+    "EmptySourceBufferL",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_EmptySourceBufferLL, Teardown)
+
+EUNIT_TEST(
+    "SourceBufferEmptiedL - test ",
+    "CIlbcPayloadFormatWrite",
+    "SourceBufferEmptiedL",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_SourceBufferEmptiedLL, Teardown)
+
+EUNIT_TEST(
+    "SinkPrimeL - test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkPrimeL",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_SinkPrimeLL, Teardown)
+
+EUNIT_TEST(
+    "SinkPlayL - test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkPlayL",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_SinkPlayLL, Teardown)
+
+EUNIT_TEST(
+    "SinkPauseL - test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkPauseL",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_SinkPauseLL, Teardown)
+
+EUNIT_TEST(
+    "SinkStopL - test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkStopL",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_SinkStopLL, Teardown)
+
+EUNIT_TEST(
+    "FrameTimeInterval - test ",
+    "CIlbcPayloadFormatWrite",
+    "FrameTimeInterval",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_FrameTimeIntervalL, Teardown)
+
+EUNIT_TEST(
+    "Duration - test ",
+    "CIlbcPayloadFormatWrite",
+    "Duration",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_DurationL, Teardown)
+
+EUNIT_TEST(
+    "CreateSinkBufferL - test ",
+    "CIlbcPayloadFormatWrite",
+    "CreateSinkBufferL",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_CreateSinkBufferLL, Teardown)
+
+EUNIT_TEST(
+    "SinkDataTypeCode - test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkDataTypeCode",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_SinkDataTypeCodeL, Teardown)
+
+EUNIT_TEST(
+    "SetSinkDataTypeCode - test ",
+    "CIlbcPayloadFormatWrite",
+    "SetSinkDataTypeCode",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_SetSinkDataTypeCodeL, Teardown)
+
+EUNIT_TEST(
+    "SinkThreadLogon - test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkThreadLogon",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_SinkThreadLogonL, Teardown)
+
+EUNIT_TEST(
+    "SinkThreadLogoff - test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkThreadLogoff",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_SinkThreadLogoffL, Teardown)
+
+EUNIT_TEST(
+    "EmptyBufferL - test ",
+    "CIlbcPayloadFormatWrite",
+    "EmptyBufferL",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_EmptyBufferLL, Teardown)
+
+EUNIT_TEST(
+    "SampleRate - test ",
+    "CIlbcPayloadFormatWrite",
+    "SampleRate",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_SampleRateL, Teardown)
+
+EUNIT_TEST(
+    "SetSampleRate - test ",
+    "CIlbcPayloadFormatWrite",
+    "SetSampleRate",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_SetSampleRateL, Teardown)
+
+EUNIT_TEST(
+    "DeliverPacketL - test ",
+    "CIlbcPayloadFormatWrite",
+    "DeliverPacketL",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_DeliverPacketLL, Teardown)  
+
+EUNIT_TEST(
+    "NumChannelsL - test ",
+    "CIlbcPayloadFormatWrite",
+    "NumChannelsL",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_NumChannelsL, Teardown)  
+  
+EUNIT_TEST(
+    "ConfigurePayloadFormatL - test ",
+    "CIlbcPayloadFormatWrite",
+    "ConfigurePayloadFormatL",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_ConfigurePayloadFormatLL, Teardown)    
+    
+EUNIT_TEST(
+    "UpdateConfigurationL - test ",
+    "CIlbcPayloadFormatWrite",
+    "UpdateConfigurationL",
+    "FUNCTIONALITY",
+    SetupL, UT_CIlbcPayloadFormatWrite_UpdateConfigurationLL, Teardown)    
+
+
+// ALLOC TESTS
+#ifdef EUNIT_ALLOC_TEST_ON
+
+EUNIT_ALLOC_TEST(
+    "EmptySourceBufferL - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "EmptySourceBufferL",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_EmptySourceBufferLL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "SourceBufferEmptiedL - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "SourceBufferEmptiedL",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_SourceBufferEmptiedLL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "SinkPrimeL - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkPrimeL",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_SinkPrimeLL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "SinkPlayL - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkPlayL",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_SinkPlayLL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "SinkPauseL - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkPauseL",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_SinkPauseLL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "SinkStopL - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkStopL",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_SinkStopLL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "FrameTimeInterval - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "FrameTimeInterval",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_FrameTimeIntervalL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "Duration - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "Duration",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_DurationL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "CreateSinkBufferL - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "CreateSinkBufferL",
+    "ERRORHANDLING",
+    Setup2AL, UT_CIlbcPayloadFormatWrite_CreateSinkBufferLL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "SinkDataTypeCode - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkDataTypeCode",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_SinkDataTypeCodeL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "SetSinkDataTypeCode - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "SetSinkDataTypeCode",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_SetSinkDataTypeCodeL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "SinkThreadLogon - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkThreadLogon",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_SinkThreadLogonL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "SinkThreadLogoff - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "SinkThreadLogoff",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_SinkThreadLogoffL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "EmptyBufferL - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "EmptyBufferL",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_EmptyBufferLL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "BufferEmptiedL - Alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "BufferEmptiedL",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_BufferEmptiedLL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "SampleRate - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "SampleRate",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_SampleRateL, Teardown)
+
+EUNIT_ALLOC_TEST(
+    "SetSampleRate - alloc test ",
+    "CIlbcPayloadFormatWrite",
+    "SetSampleRate",
+    "ERRORHANDLING",
+    SetupAL, UT_CIlbcPayloadFormatWrite_SetSampleRateL, Teardown)
+
+
+#endif
+
+EUNIT_END_TEST_TABLE
+
+//  END OF FILE