multimediacommscontroller/mmccrtpsourcesink/tsrc/ut_rtpsourcesink/src/UT_CMccRtpDataSink.cpp
changeset 0 1bce908db942
child 32 f2ed1fc4c163
equal deleted inserted replaced
-1:000000000000 0:1bce908db942
       
     1 /*
       
     2 * Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 
       
    21 //  CLASS HEADER
       
    22 #include "UT_CMccRtpDataSink.h"
       
    23 
       
    24 //  EXTERNAL INCLUDES
       
    25 #include <digia/eunit/EUnitMacros.h>
       
    26 #include <mmf/server/mmfbuffer.h>
       
    27 
       
    28 
       
    29 
       
    30 
       
    31 //  INTERNAL INCLUDES
       
    32 #include "rtpheader.h"
       
    33 #include "MccRtpDataSink.h"
       
    34 #include <mmf/server/mmfdatasink.h>
       
    35 #include <mmf/common/mmfcontrollerframework.h>
       
    36 #include "MmccEvents.h"
       
    37 #include "MccInternalCodecs.h"
       
    38 #include <mmf/server/mmfvideoframebuffer.h>
       
    39 #include "mccrtpkeepalivecontainer.h"
       
    40 #include "amrpayloadformatwrite.h"
       
    41 #include <srtpcryptocontext.h>
       
    42 #include <srtpmastersalt.h>
       
    43 #include <srtpstreamout.h>
       
    44 #include "mccunittestmacros.h"
       
    45 
       
    46 
       
    47 #define MCCEVENTDATAPCKG_TO_RTCPEVENTDATAPCKG( event )\
       
    48     *reinterpret_cast<TMccRtcpEventDataPackage*>( &event.iEventData )
       
    49 
       
    50 // CONSTANTS
       
    51 const TUint8 KPayloadType( 96 );
       
    52 _LIT8(KRFC3711_TestMasterKey128bits,    "E1F97A0D3E018BE0D64FA32C06DE4139");
       
    53 _LIT8(KRFC3711_TestMasterSalt112bits,   "0EC675AD498AFEEBB6960B3AABE6");	
       
    54 _LIT8(KTestMKI128Bits,      "ABCDEF1234567890ABCDEF1234567890");
       
    55 
       
    56 
       
    57 // CONSTRUCTION
       
    58 UT_CMccRtpDataSink* UT_CMccRtpDataSink::NewL()
       
    59     {
       
    60     UT_CMccRtpDataSink* self = UT_CMccRtpDataSink::NewLC(); 
       
    61     CleanupStack::Pop();
       
    62 
       
    63     return self;
       
    64     }
       
    65 
       
    66 UT_CMccRtpDataSink* UT_CMccRtpDataSink::NewLC()
       
    67     {
       
    68     UT_CMccRtpDataSink* self = new( ELeave ) UT_CMccRtpDataSink();
       
    69     CleanupStack::PushL( self );
       
    70 
       
    71 	self->ConstructL(); 
       
    72 
       
    73     return self;
       
    74     }
       
    75 
       
    76 // Destructor (virtual by CBase)
       
    77 UT_CMccRtpDataSink::~UT_CMccRtpDataSink()
       
    78     {
       
    79     }
       
    80 
       
    81 // Default constructor
       
    82 UT_CMccRtpDataSink::UT_CMccRtpDataSink()
       
    83     : iSession( 1 )
       
    84     {
       
    85     }
       
    86 
       
    87 // Second phase construct
       
    88 void UT_CMccRtpDataSink::ConstructL()
       
    89     {
       
    90     // The ConstructL from the base class CEUnitTestSuiteClass must be called.
       
    91     // It generates the test case table.
       
    92     CEUnitTestSuiteClass::ConstructL();
       
    93     }
       
    94 
       
    95 //  METHODS
       
    96 
       
    97 // From MRtpErrNotify
       
    98 void UT_CMccRtpDataSink::ErrorNotify( TInt /*aErrCode*/ )
       
    99     {
       
   100     }
       
   101 
       
   102 
       
   103 void UT_CMccRtpDataSink::SetupL()
       
   104     {
       
   105     iRtpApi = CRtpAPI::NewL( *this );
       
   106     TUid dummyUid( TUid::Uid( 42 ) ); 
       
   107     TBuf8<5> dummyBuf( _L8( "foo" ) );
       
   108     iSink = static_cast<CMccRtpDataSink*>(
       
   109         CMccRtpDataSink::NewSinkL( dummyUid, dummyBuf ) );
       
   110     
       
   111     MAsyncEventHandler* eventHandler = NULL;
       
   112     TRtpId rtpSessionId(0);
       
   113     iRtpKeepaliveMechanism = 
       
   114         CMccRtpKeepaliveContainer::NewL( *eventHandler, 
       
   115                                          *iRtpApi, 
       
   116                                          rtpSessionId ); 
       
   117                                          
       
   118     } 
       
   119 
       
   120 void UT_CMccRtpDataSink::Teardown()
       
   121     {
       
   122     delete iRtpKeepaliveMechanism;
       
   123     
       
   124     if ( iSink )
       
   125         {
       
   126         delete iSink;
       
   127         iSink = NULL;
       
   128         }
       
   129     if ( iSecSession)
       
   130     	{
       
   131     	delete iSecSession;
       
   132 		iSecSession = NULL;
       
   133     	}    
       
   134     if ( iRtpApi )
       
   135         {
       
   136         delete iRtpApi;
       
   137         iRtpApi = NULL;
       
   138         }
       
   139     }
       
   140 
       
   141 // HELPERS
       
   142 //
       
   143 
       
   144 void UT_CMccRtpDataSink::InitializeStreamL()
       
   145     {
       
   146     iSink->SinkThreadLogon( *this );
       
   147     iSink->SetCurrentUser( this );
       
   148     TMccRtpSessionParams params;
       
   149     params.iRtpAPI = iRtpApi;
       
   150     params.iSessionId = iSession;
       
   151     params.iEnableRTCP = ETrue;
       
   152     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   153 
       
   154     iSink->SetSessionParamsL( params );
       
   155 
       
   156     TMccCodecInfo cInfo;
       
   157     TMccCodecInfoBuffer cInfoBuf( cInfo );
       
   158     
       
   159     MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) );
       
   160     }
       
   161 
       
   162 
       
   163 // TEST FUNCTIONS
       
   164 //
       
   165 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_MuteL()
       
   166     {
       
   167     const TUint8 KDtmfPayloadType( 98 );
       
   168     TRtpSendHeader header;
       
   169     header.iPayloadType = KDtmfPayloadType;
       
   170     iSink->iState = MMccRtpInterface::ERtpStatePlaying;
       
   171     iSink->Mute( ETrue, KDtmfPayloadType );
       
   172     EUNIT_ASSERT( ETrue == iSink->SendingAllowed( header ) );
       
   173     
       
   174     header.iPayloadType = 0;
       
   175     EUNIT_ASSERT( EFalse == iSink->SendingAllowed( header ) );
       
   176     
       
   177     iSink->Mute( EFalse, KDtmfPayloadType );
       
   178     EUNIT_ASSERT( ETrue == iSink->SendingAllowed( header ) );
       
   179     }
       
   180 
       
   181 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SendMediaSignallingLL()
       
   182     {
       
   183     TMccEvent wrongEvent;
       
   184     wrongEvent.iEventCategory = KMccEventCategoryDtmf;
       
   185     // Wrong type of signal
       
   186     EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( wrongEvent ) );
       
   187 
       
   188     TMccEvent event;
       
   189     event.iEventCategory = KMccEventCategoryRtcp;
       
   190     event.iEventType = KMccRtcpControl;
       
   191     
       
   192     TMccRtcpEventData data;
       
   193     TMccRtcpEventDataPackage dataPackage( data );
       
   194     event.iEventData.Copy( dataPackage );
       
   195     
       
   196     // No RTP API set
       
   197     EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( event ) );
       
   198 
       
   199     TMccRtpSessionParams params;
       
   200     params.iRtpAPI = iRtpApi;
       
   201     params.iSessionId = iSession;
       
   202     params.iEnableRTCP = EFalse;
       
   203     params.iRtpKeepalive= iRtpKeepaliveMechanism;
       
   204     EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) );
       
   205 
       
   206     // RTCP not enabled
       
   207     EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( event ) );
       
   208 
       
   209     params.iEnableRTCP = ETrue;
       
   210     EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) );
       
   211 
       
   212     // Wrong packet type
       
   213     EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( event ) );
       
   214     
       
   215     // Streams and RTP sender not constructed
       
   216     data.iRtcpPacketType = KRtcpAnyPacket;
       
   217     EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( event ) );
       
   218     
       
   219     TMccCodecInfo cInfo;
       
   220     TMccCodecInfoBuffer cInfoBuf( cInfo );
       
   221     MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) );
       
   222     MCC_EUNIT_ASSERT_EQUALS( iSink->SinkThreadLogon( *this ), KErrNone );
       
   223     iSink->SetCurrentUser( this );
       
   224     EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() );
       
   225 
       
   226     TMccRtcpEventDataPackage& eventDataPackage = MCCEVENTDATAPCKG_TO_RTCPEVENTDATAPCKG( event );
       
   227     TMccRtcpEventData eventData;
       
   228     eventData.iRtcpPacketType = KRtcpSdesPacket;
       
   229     eventDataPackage = TMccRtcpEventDataPackage( eventData );
       
   230 
       
   231     // No RTCP data, but does not leave because empty TRtpSdesParams
       
   232     // will be constructed from zero length RTCP data
       
   233     EUNIT_ASSERT_NO_LEAVE( iSink->SendMediaSignallingL( event ) );
       
   234     
       
   235     TRtpSdesParams sdesParams;
       
   236     TPckgBuf<TRtpSdesParams> sdesPackage( sdesParams );
       
   237     
       
   238     eventData.iRtcpPacketData.Copy( sdesPackage );
       
   239     eventDataPackage = TMccRtcpEventDataPackage( eventData );
       
   240     
       
   241     EUNIT_ASSERT_NO_LEAVE( iSink->SendMediaSignallingL( event ) );
       
   242 
       
   243     TBuf<5> reason( _L( "foo" ) );
       
   244     eventData.iRtcpPacketType = KRtcpByePacket;
       
   245     eventData.iRtcpPacketData.Copy( reason );
       
   246     eventDataPackage = TMccRtcpEventDataPackage( eventData );
       
   247     EUNIT_ASSERT_NO_LEAVE( iSink->SendMediaSignallingL( event ) );
       
   248 
       
   249     TRtcpApp app;
       
   250     eventData.iRtcpPacketType = KRtcpAppPacket;
       
   251     TPckgBuf<TRtcpApp> appPackage( app );
       
   252     eventData.iRtcpPacketData.Copy( appPackage );
       
   253     eventDataPackage = TMccRtcpEventDataPackage( eventData );
       
   254     
       
   255     EUNIT_ASSERT_NO_LEAVE( iSink->SendMediaSignallingL( event ) );
       
   256 
       
   257     }
       
   258 
       
   259 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_EmptyBufferLL()
       
   260     {
       
   261     EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( NULL, NULL, TMediaId() ) );
       
   262     }
       
   263 
       
   264 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkThreadLogonL()
       
   265     {
       
   266     MCC_EUNIT_ASSERT_EQUALS( iSink->SinkThreadLogon( *this ), KErrNone );
       
   267     iSink->SetCurrentUser( this );
       
   268     }
       
   269 
       
   270 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkThreadLogoffL()
       
   271     {
       
   272     iSink->SinkThreadLogoff();
       
   273 
       
   274     TMccRtpSessionParams params;
       
   275     params.iRtpAPI = iRtpApi;
       
   276     params.iSessionId = iSession;
       
   277     params.iEnableRTCP = ETrue;
       
   278     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   279     EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) );
       
   280     iSink->SinkThreadLogoff();
       
   281     
       
   282     // Reach more branches
       
   283     TUint8 redPt( 97 );
       
   284     TMccCodecInfo cInfo;
       
   285     cInfo.iRedundancyCount = 1;
       
   286     cInfo.iRedundantPayload = redPt;
       
   287     TMccCodecInfoBuffer cInfoBuf( cInfo );
       
   288     
       
   289     MCC_EUNIT_ASSERT_EQUALS( iSink->SinkThreadLogon( *this ), KErrNone );
       
   290     iSink->SetCurrentUser( this );
       
   291     EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) );
       
   292     MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) );
       
   293     EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() );
       
   294     iSink->SinkThreadLogoff();
       
   295     }
       
   296 
       
   297 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkDataTypeCodeL()
       
   298     {
       
   299     TMediaId mediaId( KUidMediaTypeMidi );
       
   300     EUNIT_ASSERT_EQUALS( iSink->SinkDataTypeCode( mediaId ), TFourCC() );
       
   301 
       
   302     iSink->SinkThreadLogoff();
       
   303     TFourCC codec( ' ','A','M','R' );
       
   304     TMediaId media2( KUidMediaTypeAudio );
       
   305     iSink->SetSinkDataTypeCode( codec, media2 );
       
   306 
       
   307     // The codecs SHOULD be equal
       
   308     EUNIT_ASSERT_EQUALS( iSink->SinkDataTypeCode( media2 ), codec );
       
   309     
       
   310     TFourCC codec2( ' H','2','6','3' );
       
   311     TMediaId media3( KUidMediaTypeVideo );
       
   312     iSink->SetSinkDataTypeCode( codec2, media3 );
       
   313 
       
   314     // The codecs SHOULD be equal
       
   315     EUNIT_ASSERT_EQUALS( iSink->SinkDataTypeCode( media3 ), codec2 );
       
   316     }
       
   317 
       
   318 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SetSinkDataTypeCodeL()
       
   319     {
       
   320     TFourCC codec;
       
   321     TMediaId media( KUidMediaTypeMidi ); // wrong media type
       
   322     EUNIT_ASSERT_EQUALS( iSink->SetSinkDataTypeCode( codec, media ), KErrNotSupported );
       
   323 
       
   324     // Set the correct media type
       
   325     TMediaId media2( KUidMediaTypeAudio );
       
   326     EUNIT_ASSERT_EQUALS( iSink->SetSinkDataTypeCode( codec, media2 ), KErrNone );
       
   327     TMediaId media3( KUidMediaTypeVideo );
       
   328     EUNIT_ASSERT_EQUALS( iSink->SetSinkDataTypeCode( codec, media3 ), KErrNone );
       
   329     }
       
   330 
       
   331 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_BufferFilledLL()
       
   332     {
       
   333     EUNIT_ASSERT_LEAVE( iSink->BufferFilledL( NULL ) );
       
   334     }
       
   335 
       
   336 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_CanCreateSinkBufferL()
       
   337     {
       
   338     EUNIT_ASSERT_EQUALS( iSink->CanCreateSinkBuffer(), EFalse );
       
   339     }
       
   340 
       
   341 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_CreateSinkBufferLL()
       
   342     {
       
   343     TBool dummy;
       
   344     EUNIT_ASSERT_LEAVE( iSink->CreateSinkBufferL( TMediaId(), dummy ) );
       
   345     }
       
   346 
       
   347 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkPrimeLL()
       
   348     {
       
   349     // Set wrong state
       
   350     iSink->SinkThreadLogoff();
       
   351     EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() );
       
   352 
       
   353     // Set correct state
       
   354     iSink->SinkThreadLogon( *this );
       
   355     iSink->SetCurrentUser( this );
       
   356     EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() );
       
   357 
       
   358     TMccRtpSessionParams params;
       
   359     params.iRtpAPI = iRtpApi;
       
   360     params.iSessionId = iSession;
       
   361     params.iEnableRTCP = ETrue;
       
   362     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   363     iSink->SetSessionParamsL( params );
       
   364     EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() );
       
   365 
       
   366     TMccCodecInfo cInfo;
       
   367     TMccCodecInfoBuffer cInfoBuf( cInfo );
       
   368     
       
   369     MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) );
       
   370     EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() );
       
   371     EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == EFalse );
       
   372   
       
   373     // "Secure session"
       
   374     iRtpKeepaliveMechanism->iStopped = ETrue;
       
   375     TInt fakeSecSession( 3 );
       
   376     iSink->iSecSession = reinterpret_cast<CSRTPSession*>( &fakeSecSession );
       
   377     EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() );
       
   378     EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == ETrue )
       
   379     iSink->iSecSession = NULL;
       
   380     }
       
   381 
       
   382 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkPlayLL()
       
   383     {
       
   384     // Wrong state
       
   385     EUNIT_ASSERT_LEAVE( iSink->SinkPlayL() );
       
   386 
       
   387     // Do it right
       
   388     InitializeStreamL();
       
   389     
       
   390     iSink->SinkPrimeL();
       
   391     EUNIT_ASSERT_NO_LEAVE( iSink->SinkPlayL() );
       
   392     
       
   393     // State downgrade is ignored
       
   394     EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() );
       
   395     EUNIT_ASSERT( MMccRtpInterface::ERtpStatePlaying == iSink->State() );
       
   396     }
       
   397 
       
   398 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkPauseLL()
       
   399     {
       
   400     // Wrong state
       
   401     EUNIT_ASSERT_LEAVE( iSink->SinkPauseL() );
       
   402 
       
   403     // Do it right
       
   404     InitializeStreamL();
       
   405 
       
   406     iSink->SinkPrimeL();
       
   407     iSink->SinkPlayL();
       
   408     EUNIT_ASSERT_NO_LEAVE( iSink->SinkPauseL() );
       
   409     }
       
   410 
       
   411 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkStopLL()
       
   412     {
       
   413     // Do it right
       
   414     InitializeStreamL();
       
   415 
       
   416     iSink->SinkPrimeL();
       
   417     iSink->SinkPlayL();
       
   418     EUNIT_ASSERT_NO_LEAVE( iSink->SinkStopL() );
       
   419     }
       
   420 
       
   421 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_EmptyBufferL_2L()
       
   422     {
       
   423     CMMFBuffer* buf( NULL );
       
   424     TMediaId mediaId;
       
   425     TRtpSendHeader header;
       
   426     
       
   427     
       
   428     InitializeStreamL();
       
   429     
       
   430     //initial srtp realted
       
   431     iRtpKeepaliveMechanism->iStopped = ETrue;
       
   432     TInt fakeSecSession( 3 );
       
   433     iSink->iSecSession = reinterpret_cast<CSRTPSession*>( &fakeSecSession );
       
   434     iSink->iSecureKeyExpired = ETrue;
       
   435     iSink->iState = MMccRtpInterface::ERtpStatePlaying;
       
   436     EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == ETrue )
       
   437     
       
   438     //null buffer
       
   439     EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );
       
   440 
       
   441     // Try different buffer types, null source
       
   442     CMMFDataBuffer* dataBuf = CMMFDataBuffer::NewL();
       
   443     EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );
       
   444     delete dataBuf;
       
   445 
       
   446     TBuf8<5> foo;
       
   447     foo.Format( _L8( "foo42" ) );
       
   448     TUint8* fooPtr = const_cast<TUint8*>( foo.Ptr() );
       
   449     TPtr8 ptr( fooPtr, foo.Length() ) ;
       
   450     CMMFPtrBuffer* ptrBuf = CMMFPtrBuffer::NewL( ptr );
       
   451     EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );
       
   452     delete ptrBuf;
       
   453 
       
   454     CMMFYUVBuffer* yuvBuf = CMMFYUVBuffer::NewL();
       
   455     EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->EmptyBufferL( yuvBuf, NULL, mediaId, header ), KErrNotSupported );
       
   456     delete yuvBuf;
       
   457 
       
   458     // packet drop because of secure keyStream not playing
       
   459     CAmrPayloadFormatWrite* source = CAmrPayloadFormatWrite::NewL( iSink );
       
   460     CleanupStack::PushL( source );
       
   461     CMMFDataBuffer* dataBuf2 = CMMFDataBuffer::NewL();
       
   462     CleanupStack::PushL( dataBuf2 );
       
   463     EUNIT_ASSERT_NO_LEAVE( iSink->EmptyBufferL( dataBuf2, source, mediaId, header ) );
       
   464     
       
   465     // Stream playing
       
   466     iSink->SinkPrimeL();
       
   467     //becuase of secure key packet drop
       
   468     EUNIT_ASSERT_SPECIFIC_LEAVE(iSink->SinkPlayL(), KErrGeneral );
       
   469     iSink->iSecureKeyExpired = EFalse;
       
   470     iSink->SinkPlayL();
       
   471     //packet drop because of secure stream not there
       
   472     EUNIT_ASSERT_NO_LEAVE( iSink->EmptyBufferL( dataBuf2, source, mediaId, header ) );
       
   473     CleanupStack::PopAndDestroy( dataBuf2 );
       
   474     CleanupStack::PopAndDestroy( source );
       
   475     iSink->iSecSession = NULL;
       
   476     
       
   477     }
       
   478 
       
   479 
       
   480 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_EmptyBufferL_1L()
       
   481     {
       
   482     CMMFBuffer* buf( NULL );
       
   483     TMediaId mediaId;
       
   484     TRtpSendHeader header;
       
   485     
       
   486     // No stream
       
   487     EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );
       
   488 
       
   489     // NULL buffer
       
   490     InitializeStreamL();
       
   491     EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );
       
   492 
       
   493     // Try different buffer types, null source
       
   494     CMMFDataBuffer* dataBuf = CMMFDataBuffer::NewL();
       
   495     EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );
       
   496     delete dataBuf;
       
   497 
       
   498     TBuf8<5> foo;
       
   499     foo.Format( _L8( "foo42" ) );
       
   500     TUint8* fooPtr = const_cast<TUint8*>( foo.Ptr() );
       
   501     TPtr8 ptr( fooPtr, foo.Length() ) ;
       
   502     CMMFPtrBuffer* ptrBuf = CMMFPtrBuffer::NewL( ptr );
       
   503     EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );
       
   504     delete ptrBuf;
       
   505 
       
   506     CMMFYUVBuffer* yuvBuf = CMMFYUVBuffer::NewL();
       
   507     EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->EmptyBufferL( yuvBuf, NULL, mediaId, header ), KErrNotSupported );
       
   508     delete yuvBuf;
       
   509 
       
   510     // Stream not playing
       
   511     CAmrPayloadFormatWrite* source = CAmrPayloadFormatWrite::NewL( iSink );
       
   512     CleanupStack::PushL( source );
       
   513     CMMFDataBuffer* dataBuf2 = CMMFDataBuffer::NewL();
       
   514     CleanupStack::PushL( dataBuf2 );
       
   515     EUNIT_ASSERT_NO_LEAVE( iSink->EmptyBufferL( dataBuf2, source, mediaId, header ) );
       
   516     
       
   517     // Stream playing
       
   518     iSink->SinkPrimeL();
       
   519     iSink->SinkPlayL();
       
   520     MCC_EUNIT_ASSERT_NO_LEAVE( iSink->EmptyBufferL( dataBuf2, source, mediaId, header ) );
       
   521     CleanupStack::PopAndDestroy( dataBuf2 );
       
   522     CleanupStack::PopAndDestroy( source );
       
   523     
       
   524     // TBD: test also scenario where failure occurs in rtp packet sending
       
   525     }
       
   526 
       
   527 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SendRTCPReceiverReportL()
       
   528     {
       
   529     // No RTP API set
       
   530     EUNIT_ASSERT_EQUALS( iSink->SendRTCPReceiverReport(), KErrNotReady );
       
   531 
       
   532     TMccRtpSessionParams params;
       
   533     params.iRtpAPI = iRtpApi;
       
   534     params.iSessionId = iSession;
       
   535     params.iEnableRTCP = ETrue;      
       
   536     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   537 
       
   538     iSink->SetSessionParamsL( params );
       
   539 
       
   540     EUNIT_ASSERT_NO_LEAVE( iSink->SendRTCPReceiverReport() );
       
   541     }
       
   542 
       
   543 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SendRTCPSenderReportL()
       
   544     {
       
   545     // No RTP API set
       
   546     EUNIT_ASSERT_EQUALS( iSink->SendRTCPSenderReport(), KErrNotReady );
       
   547 
       
   548     TMccRtpSessionParams params;
       
   549     params.iRtpAPI = iRtpApi;
       
   550     params.iSessionId = iSession;
       
   551     params.iEnableRTCP = ETrue;
       
   552     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   553 
       
   554     iSink->SetSessionParamsL( params );
       
   555     EUNIT_ASSERT_NO_LEAVE( iSink->SendRTCPSenderReport() );
       
   556     }
       
   557 
       
   558 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SendRTCPDataLL()
       
   559     {
       
   560     TBuf8<5> data;
       
   561     data.Format( _L8( "foo42" ) );
       
   562     
       
   563     // No RTP API set
       
   564     EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->SendRTCPDataL( data ), KErrNotReady );
       
   565     
       
   566     TMccRtpSessionParams params;
       
   567     params.iRtpAPI = iRtpApi;
       
   568     params.iSessionId = iSession;
       
   569     params.iEnableRTCP = ETrue;
       
   570     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   571     EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) );
       
   572     
       
   573     // No RTP sender constructed
       
   574     EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->SendRTCPDataL( data ), KErrNotReady );
       
   575     
       
   576     // RTP sender constructed
       
   577     iSink->DoCreateStreamL();
       
   578     iSink->SendRTCPDataL( data );
       
   579     }
       
   580 
       
   581 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_ConstructSinkLL()
       
   582     {
       
   583     TBuf8<5> data;
       
   584     data.Format( _L8( "foo42" ) );
       
   585 
       
   586     // Can't have init data
       
   587     EUNIT_ASSERT_LEAVE( iSink->ConstructSinkL( data ) );
       
   588 
       
   589     EUNIT_ASSERT_NO_LEAVE( iSink->ConstructSinkL( KNullDesC8 ) );
       
   590     }
       
   591 
       
   592 
       
   593 // FUNCTIONS INHERITED FROM CMccRtpInterface
       
   594 
       
   595 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_PrepareLL()
       
   596     {
       
   597     TFourCC codec( ' ','A','M','R' );
       
   598 
       
   599     // No session exists
       
   600     EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() );
       
   601     
       
   602     iSink->SinkThreadLogon( *this );
       
   603     iSink->SetCurrentUser( this );
       
   604     TMccRtpSessionParams params;
       
   605     params.iRtpAPI = iRtpApi;
       
   606     params.iSessionId = iSession;
       
   607     params.iEnableRTCP = ETrue;
       
   608     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   609 
       
   610     iSink->SetSessionParamsL( params );
       
   611 
       
   612     // No stream exists
       
   613     EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() );
       
   614 
       
   615     TMccCodecInfo cInfo;
       
   616     TMccCodecInfoBuffer cInfoBuf( cInfo );
       
   617     
       
   618     MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) );
       
   619     EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() ); 
       
   620 
       
   621     // Create a comfort noise stream
       
   622     //codec = KMccFourCCIdG711;
       
   623     //EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() );
       
   624     }
       
   625 
       
   626 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_CreateStreamLL()
       
   627     {
       
   628     iSink->SinkThreadLogon( *this );
       
   629     iSink->SetCurrentUser( this );
       
   630     TMccRtpSessionParams params;
       
   631     params.iRtpAPI = iRtpApi;
       
   632     params.iSessionId = iSession;
       
   633     params.iEnableRTCP = ETrue;
       
   634     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   635 
       
   636     iSink->SetSessionParamsL( params );
       
   637 
       
   638     TMccCodecInfo cInfo;
       
   639     TMccCodecInfoBuffer cInfoBuf( cInfo );
       
   640     
       
   641     MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) );
       
   642 
       
   643     // This should leave because the string is too short
       
   644     TBuf8<5> dummy;
       
   645     dummy.Format( _L8( "foo42" ) );
       
   646     EUNIT_ASSERT_LEAVE( iSink->ConfigureL( dummy ) );
       
   647 
       
   648     // Get a new sink
       
   649     //Teardown();
       
   650     if( iRtpKeepaliveMechanism )
       
   651     	{
       
   652     	delete iRtpKeepaliveMechanism;
       
   653     	iRtpKeepaliveMechanism = NULL;
       
   654     	}
       
   655     
       
   656     if ( iSink )
       
   657         {
       
   658         delete iSink;
       
   659         iSink = NULL;
       
   660         }
       
   661         
       
   662     //SetupL();
       
   663     TUid dummyUid( TUid::Uid( 42 ) ); 
       
   664     TBuf8<5> dummyBuf( _L8( "foo" ) );
       
   665     iSink = static_cast<CMccRtpDataSink*>(
       
   666         CMccRtpDataSink::NewSinkL( dummyUid, dummyBuf ) );
       
   667 
       
   668 	MAsyncEventHandler* eventHandler = NULL;
       
   669     TRtpId rtpSessionId(0);
       
   670     iRtpKeepaliveMechanism = 
       
   671         CMccRtpKeepaliveContainer::NewL( *eventHandler, 
       
   672                                          *iRtpApi, 
       
   673                                          rtpSessionId );
       
   674 
       
   675     iSink->SinkThreadLogon( *this );
       
   676     iSink->SetCurrentUser( this );
       
   677     TMccRtpSessionParams params2;
       
   678     params2.iRtpAPI = iRtpApi;
       
   679     params2.iSessionId = iSession;
       
   680     params2.iEnableRTCP = ETrue;
       
   681     params2.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   682 
       
   683     iSink->SetSessionParamsL( params2 );
       
   684     
       
   685     TMccCodecInfo cInfo2;
       
   686     cInfo2.iFourCC = TFourCC( KMccFourCCIdG711 );
       
   687     cInfo2.iEnableDTX = ETrue;
       
   688     cInfo2.iRedundantPayload = 97;
       
   689     cInfo2.iRedundancyCount = 1;
       
   690     cInfo2.iAlgoUsed = EGenRedUsed;
       
   691     TMccCodecInfoBuffer cInfoBuf2( cInfo2 );
       
   692 
       
   693     EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf2 ) );
       
   694     }
       
   695 
       
   696 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_RemoveStreamLL()
       
   697     {
       
   698 /*
       
   699     // No RTP API set
       
   700     EUNIT_ASSERT_LEAVE( iSink->RemoveStreamL( 42 ) );
       
   701 
       
   702     // Do it right
       
   703     iSink->SinkThreadLogon( *this );
       
   704     iSink->SetCurrentUser( this );
       
   705     TMccRtpSessionParams params;
       
   706     params.iRtpAPI = iRtpApi;
       
   707     params.iSessionId = iSession;
       
   708     params.iEnableRTCP = ETrue;
       
   709     params.iEventHandler = this;
       
   710     iSink->SetSessionParamsL( params );
       
   711 
       
   712     TMccRtpStreamParams strParams;
       
   713     strParams.iPayloadType = 96;
       
   714     strParams.iCodec = TFourCC( ' ','A','M','R' );
       
   715     strParams.iSampleRate = 8000;
       
   716     strParams.iEnableVAD = EFalse;
       
   717     TRtpSSRC ssrc( 5 );
       
   718     strParams.iSSRC = &ssrc;
       
   719 
       
   720     TUint32 stream( iSink->CreateStreamL( strParams ) );
       
   721 
       
   722     EUNIT_ASSERT_NO_LEAVE( iSink->RemoveStreamL( stream ) );
       
   723 */
       
   724     }
       
   725 
       
   726 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_PlayStreamLL()
       
   727     {
       
   728     // No stream
       
   729     EUNIT_ASSERT_LEAVE( iSink->SinkPlayL() );
       
   730 
       
   731     iSink->SinkThreadLogon( *this );
       
   732     iSink->SetCurrentUser( this );
       
   733     TMccRtpSessionParams params;
       
   734     params.iRtpAPI = iRtpApi;
       
   735     params.iSessionId = iSession;
       
   736     params.iEnableRTCP = ETrue;
       
   737     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   738 
       
   739     iSink->SetSessionParamsL( params );
       
   740     
       
   741     TMccCodecInfo cInfo;
       
   742     TMccCodecInfoBuffer cInfoBuf( cInfo );
       
   743     
       
   744     MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) );
       
   745 
       
   746     // Wrong state
       
   747     EUNIT_ASSERT_LEAVE( iSink->SinkPlayL() );
       
   748 
       
   749     iSink->SinkPrimeL();
       
   750 
       
   751     // Ok
       
   752     EUNIT_ASSERT_NO_LEAVE( iSink->SinkPlayL() );
       
   753     }
       
   754 
       
   755 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_PauseStreamLL()
       
   756     {
       
   757     // No stream
       
   758     EUNIT_ASSERT_LEAVE( iSink->SinkPauseL() );
       
   759 
       
   760     iSink->SinkThreadLogon( *this );
       
   761     iSink->SetCurrentUser( this );
       
   762     TMccRtpSessionParams params;
       
   763     params.iRtpAPI = iRtpApi;
       
   764     params.iSessionId = iSession;
       
   765     params.iEnableRTCP = ETrue;
       
   766     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   767 
       
   768     iSink->SetSessionParamsL( params );
       
   769     
       
   770     TMccCodecInfo cInfo;
       
   771     TMccCodecInfoBuffer cInfoBuf( cInfo );
       
   772     
       
   773     MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) );
       
   774 
       
   775     // Wrong state
       
   776     EUNIT_ASSERT_LEAVE( iSink->SinkPauseL() );
       
   777 
       
   778     iSink->SinkPrimeL();
       
   779     iSink->SinkPlayL();
       
   780 
       
   781     // Ok
       
   782     EUNIT_ASSERT_NO_LEAVE( iSink->SinkPauseL() );
       
   783     }
       
   784 
       
   785 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_StopStreamLL()
       
   786     {
       
   787     iSink->SinkThreadLogon( *this );
       
   788     iSink->SetCurrentUser( this );
       
   789     TMccRtpSessionParams params;
       
   790     params.iRtpAPI = iRtpApi;
       
   791     params.iSessionId = iSession;
       
   792     params.iEnableRTCP = ETrue;
       
   793     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   794 
       
   795     iSink->SetSessionParamsL( params );
       
   796     
       
   797     TMccCodecInfo cInfo;
       
   798     TMccCodecInfoBuffer cInfoBuf( cInfo );
       
   799     
       
   800     MCC_EUNIT_ASSERT_NO_LEAVE( iSink->ConfigureL( cInfoBuf ) );
       
   801     iSink->SinkPrimeL();
       
   802     iSink->SinkPlayL();
       
   803 
       
   804     // Ok
       
   805     EUNIT_ASSERT_NO_LEAVE( iSink->SinkStopL() );
       
   806     }
       
   807 
       
   808 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_StartInactivityTimerLL()
       
   809     {
       
   810     TUint32 dummyTime( 0 );
       
   811     EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->StartInactivityTimerL( dummyTime ),
       
   812                                  KErrNotSupported );
       
   813     }
       
   814 
       
   815 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_StopInactivityTimerLL()
       
   816     {
       
   817     EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->StopInactivityTimerL(),
       
   818                                  KErrNotSupported );
       
   819     }
       
   820 
       
   821 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SetSessionParamsLL()
       
   822     {
       
   823     TMccRtpSessionParams params;
       
   824     params.iRtpAPI = iRtpApi;
       
   825     params.iSessionId = iSession;
       
   826     params.iEnableRTCP = ETrue;
       
   827     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   828 
       
   829     EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) );
       
   830     }
       
   831 
       
   832 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SRTPMasterKeyStaleEvent1L()
       
   833 	{
       
   834 	//SetUp SecureSession
       
   835 	TInetAddr destination; 
       
   836 	destination.Input(_L("127.0.0.1") );
       
   837 	iSecSession = CSRTPSession::NewL( destination );
       
   838 	
       
   839 	//Set up MCCparams
       
   840 	TMccRtpSessionParams params;
       
   841     params.iRtpAPI = iRtpApi;
       
   842     params.iSecSession = iSecSession;
       
   843     params.iSessionId = iSession;
       
   844     params.iEnableRTCP = EFalse;
       
   845     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   846     EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) );
       
   847     iSink->SinkThreadLogon( *this );
       
   848     iSink->SetCurrentUser( this);
       
   849     
       
   850 	iSink->SRTPMasterKeyStaleEvent( *iSecSession );
       
   851 	EUNIT_ASSERT( iSink->iSecureKeyExpired );
       
   852 	EUNIT_ASSERT_EQUALS( iEventType, KMccMasterKeyStaled );
       
   853     EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->SinkPlayL(), KErrGeneral );
       
   854     }
       
   855     
       
   856 void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SRTPMasterKeyStaleEvent2L()
       
   857 	{
       
   858 	this->iEventType = KErrNone;
       
   859 	//SetUp SecureSession
       
   860 	TInetAddr destination; 
       
   861 	destination.Input(_L("127.0.0.1") );
       
   862 	iSecSession = CSRTPSession::NewL( destination );
       
   863 	
       
   864 	//Set up Secure Stream
       
   865 	//Secure Context
       
   866 	
       
   867 	 HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
       
   868     CleanupStack::PushL( masterKey );
       
   869     *masterKey = KRFC3711_TestMasterKey128bits;
       
   870 	
       
   871     
       
   872     
       
   873     HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
       
   874     CleanupStack::PushL( masterSalt);
       
   875 	*masterSalt = KRFC3711_TestMasterSalt112bits;
       
   876 	
       
   877 	
       
   878 	HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
       
   879     CleanupStack::PushL( mki);
       
   880 	*mki = KTestMKI128Bits;
       
   881 	//Hex(*mki);
       
   882 	
       
   883 	CSRTPMasterKey* mKey = CSRTPMasterKey::NewL( *masterKey, *mki );
       
   884 	CleanupStack::PushL( mKey );
       
   885     CSRTPMasterSalt* saltKey = CSRTPMasterSalt::NewL( *masterSalt );
       
   886     CleanupStack::PushL( saltKey );
       
   887     
       
   888     TSrtpCryptoParams srtpParams;
       
   889     CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(mKey, saltKey, srtpParams );
       
   890     CleanupStack::Pop( saltKey );
       
   891     CleanupStack::Pop( mKey );
       
   892 
       
   893     CleanupStack::PopAndDestroy( mki );
       
   894     CleanupStack::PopAndDestroy( masterSalt );
       
   895     CleanupStack::PopAndDestroy( masterKey ); 
       
   896     
       
   897     CleanupStack::PushL( context );
       
   898 	
       
   899 	CSRTPStreamOut* srtpStream = CSRTPStreamOut::NewL( *iSecSession, iSink->GetSSRC(), context, *iSink );
       
   900 	CleanupStack::Pop( context );
       
   901 	CleanupStack::PushL( srtpStream );
       
   902 	
       
   903 	//Set up MCCparams
       
   904 	TMccRtpSessionParams params;
       
   905     params.iRtpAPI = iRtpApi;
       
   906     params.iSecSession = iSecSession;
       
   907     params.iSessionId = iSession;
       
   908     params.iEnableRTCP = EFalse;
       
   909     
       
   910     params.iRtpKeepalive = iRtpKeepaliveMechanism;
       
   911     EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) );
       
   912     iSink->SinkThreadLogon( *this );
       
   913     iSink->SetCurrentUser( this);
       
   914     
       
   915     //srtpStream is not equal
       
   916 	iSink->SRTPMasterKeyStaleEvent( *srtpStream );
       
   917 	EUNIT_ASSERT( !iSink->iSecureKeyExpired );
       
   918 	EUNIT_ASSERT_NOT_EQUALS( this->iEventType, KMccMasterKeyStaled );
       
   919     //srtpStream is equal
       
   920     iSink->iSrtpStream = srtpStream;
       
   921     iSink->SRTPMasterKeyStaleEvent( *srtpStream );
       
   922 	EUNIT_ASSERT( iSink->iSecureKeyExpired );
       
   923 	EUNIT_ASSERT_EQUALS( iEventType, KMccMasterKeyStaled );
       
   924   	EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->SinkPlayL(), KErrGeneral );
       
   925   	CleanupStack::Pop( srtpStream );
       
   926     }	
       
   927 	
       
   928 //  TEST TABLE
       
   929 
       
   930 EUNIT_BEGIN_TEST_TABLE( 
       
   931     UT_CMccRtpDataSink,
       
   932     "MccRtpDataSink",
       
   933     "UNIT" )
       
   934 
       
   935 EUNIT_TEST(
       
   936     "MuteL - test ",
       
   937     "CMccRtpDataSink",
       
   938     "MuteL",
       
   939     "FUNCTIONALITY",
       
   940     SetupL, UT_CMccRtpDataSink_MuteL, Teardown)
       
   941 
       
   942 EUNIT_TEST(
       
   943     "SendMediaSignallingL - test ",
       
   944     "CMccRtpDataSink",
       
   945     "SendMediaSignallingL",
       
   946     "FUNCTIONALITY",
       
   947     SetupL, UT_CMccRtpDataSink_SendMediaSignallingLL, Teardown)
       
   948 
       
   949 EUNIT_TEST(
       
   950     "EmptyBufferL - test ",
       
   951     "CMccRtpDataSink",
       
   952     "EmptyBufferL",
       
   953     "FUNCTIONALITY",
       
   954     SetupL, UT_CMccRtpDataSink_EmptyBufferLL, Teardown)
       
   955 
       
   956 EUNIT_TEST(
       
   957     "SinkThreadLogon - test ",
       
   958     "CMccRtpDataSink",
       
   959     "SinkThreadLogon",
       
   960     "FUNCTIONALITY",
       
   961     SetupL, UT_CMccRtpDataSink_SinkThreadLogonL, Teardown)
       
   962 
       
   963 EUNIT_TEST(
       
   964     "SinkThreadLogoff - test ",
       
   965     "CMccRtpDataSink",
       
   966     "SinkThreadLogoff",
       
   967     "FUNCTIONALITY",
       
   968     SetupL, UT_CMccRtpDataSink_SinkThreadLogoffL, Teardown)
       
   969 
       
   970 EUNIT_TEST(
       
   971     "SinkDataTypeCode - test ",
       
   972     "CMccRtpDataSink",
       
   973     "SinkDataTypeCode",
       
   974     "FUNCTIONALITY",
       
   975     SetupL, UT_CMccRtpDataSink_SinkDataTypeCodeL, Teardown)
       
   976 
       
   977 EUNIT_TEST(
       
   978     "SetSinkDataTypeCode - test ",
       
   979     "CMccRtpDataSink",
       
   980     "SetSinkDataTypeCode",
       
   981     "FUNCTIONALITY",
       
   982     SetupL, UT_CMccRtpDataSink_SetSinkDataTypeCodeL, Teardown)
       
   983 
       
   984 EUNIT_TEST(
       
   985     "BufferFilledL - test ",
       
   986     "CMccRtpDataSink",
       
   987     "BufferFilledL",
       
   988     "FUNCTIONALITY",
       
   989     SetupL, UT_CMccRtpDataSink_BufferFilledLL, Teardown)
       
   990 
       
   991 EUNIT_TEST(
       
   992     "CanCreateSinkBuffer - test ",
       
   993     "CMccRtpDataSink",
       
   994     "CanCreateSinkBuffer",
       
   995     "FUNCTIONALITY",
       
   996     SetupL, UT_CMccRtpDataSink_CanCreateSinkBufferL, Teardown)
       
   997 
       
   998 EUNIT_TEST(
       
   999     "CreateSinkBufferL - test ",
       
  1000     "CMccRtpDataSink",
       
  1001     "CreateSinkBufferL",
       
  1002     "FUNCTIONALITY",
       
  1003     SetupL, UT_CMccRtpDataSink_CreateSinkBufferLL, Teardown)
       
  1004 
       
  1005 EUNIT_TEST(
       
  1006     "SinkPrimeL - test ",
       
  1007     "CMccRtpDataSink",
       
  1008     "SinkPrimeL",
       
  1009     "FUNCTIONALITY",
       
  1010     SetupL, UT_CMccRtpDataSink_SinkPrimeLL, Teardown)
       
  1011 
       
  1012 EUNIT_TEST(
       
  1013     "SinkPlayL - test ",
       
  1014     "CMccRtpDataSink",
       
  1015     "SinkPlayL",
       
  1016     "FUNCTIONALITY",
       
  1017     SetupL, UT_CMccRtpDataSink_SinkPlayLL, Teardown)
       
  1018 
       
  1019 EUNIT_TEST(
       
  1020     "SinkPauseL - test ",
       
  1021     "CMccRtpDataSink",
       
  1022     "SinkPauseL",
       
  1023     "FUNCTIONALITY",
       
  1024     SetupL, UT_CMccRtpDataSink_SinkPauseLL, Teardown)
       
  1025 
       
  1026 EUNIT_TEST(
       
  1027     "SinkStopL - test ",
       
  1028     "CMccRtpDataSink",
       
  1029     "SinkStopL",
       
  1030     "FUNCTIONALITY",
       
  1031     SetupL, UT_CMccRtpDataSink_SinkStopLL, Teardown)
       
  1032 
       
  1033 EUNIT_TEST(
       
  1034     "EmptyBufferL - test ",
       
  1035     "CMccRtpDataSink",
       
  1036     "EmptyBufferL",
       
  1037     "FUNCTIONALITY",
       
  1038     SetupL, UT_CMccRtpDataSink_EmptyBufferL_1L, Teardown)
       
  1039 
       
  1040 EUNIT_TEST(
       
  1041     "EmptyBuffer2L - test ",
       
  1042     "CMccRtpDataSink",
       
  1043     "EmptyBuffer2L",
       
  1044     "FUNCTIONALITY",
       
  1045     SetupL, UT_CMccRtpDataSink_EmptyBufferL_2L, Teardown)
       
  1046 
       
  1047 EUNIT_TEST(
       
  1048     "SendRTCPReceiverReport - test ",
       
  1049     "CMccRtpDataSink",
       
  1050     "SendRTCPReceiverReport",
       
  1051     "FUNCTIONALITY",
       
  1052     SetupL, UT_CMccRtpDataSink_SendRTCPReceiverReportL, Teardown)
       
  1053 
       
  1054 EUNIT_TEST(
       
  1055     "SendRTCPSenderReport - test ",
       
  1056     "CMccRtpDataSink",
       
  1057     "SendRTCPSenderReport",
       
  1058     "FUNCTIONALITY",
       
  1059     SetupL, UT_CMccRtpDataSink_SendRTCPSenderReportL, Teardown)
       
  1060 
       
  1061 EUNIT_TEST(
       
  1062     "SendRTCPDataL - test ",
       
  1063     "CMccRtpDataSink",
       
  1064     "SendRTCPDataL",
       
  1065     "FUNCTIONALITY",
       
  1066     SetupL, UT_CMccRtpDataSink_SendRTCPDataLL, Teardown)
       
  1067 
       
  1068 EUNIT_TEST(
       
  1069     "ConstructSinkL - test ",
       
  1070     "CMccRtpDataSink",
       
  1071     "ConstructSinkL",
       
  1072     "FUNCTIONALITY",
       
  1073     SetupL, UT_CMccRtpDataSink_ConstructSinkLL, Teardown)
       
  1074 
       
  1075 
       
  1076 // FUNCTIONS INHERITED FROM CMccRtpInterface
       
  1077 
       
  1078 EUNIT_TEST(
       
  1079     "PrepareL - test ",
       
  1080     "CMccRtpInterface",
       
  1081     "PrepareL",
       
  1082     "FUNCTIONALITY",
       
  1083     SetupL, UT_CMccRtpDataSink_PrepareLL, Teardown)
       
  1084 
       
  1085 EUNIT_TEST(
       
  1086     "CreateStreamL - test ",
       
  1087     "CMccRtpInterface",
       
  1088     "CreateStreamL",
       
  1089     "FUNCTIONALITY",
       
  1090     SetupL, UT_CMccRtpDataSink_CreateStreamLL, Teardown)
       
  1091 
       
  1092 EUNIT_TEST(
       
  1093     "RemoveStreamL - test ",
       
  1094     "CMccRtpInterface",
       
  1095     "RemoveStreamL",
       
  1096     "FUNCTIONALITY",
       
  1097     SetupL, UT_CMccRtpDataSink_RemoveStreamLL, Teardown)
       
  1098 
       
  1099 EUNIT_TEST(
       
  1100     "PlayStreamL - test ",
       
  1101     "CMccRtpInterface",
       
  1102     "PlayStreamL",
       
  1103     "FUNCTIONALITY",
       
  1104     SetupL, UT_CMccRtpDataSink_PlayStreamLL, Teardown)
       
  1105 
       
  1106 EUNIT_TEST(
       
  1107     "PauseStreamL - test ",
       
  1108     "CMccRtpInterface",
       
  1109     "PauseStreamL",
       
  1110     "FUNCTIONALITY",
       
  1111     SetupL, UT_CMccRtpDataSink_PauseStreamLL, Teardown)
       
  1112 
       
  1113 EUNIT_TEST(
       
  1114     "StopStreamL - test ",
       
  1115     "CMccRtpInterface",
       
  1116     "StopStreamL",
       
  1117     "FUNCTIONALITY",
       
  1118     SetupL, UT_CMccRtpDataSink_StopStreamLL, Teardown)
       
  1119 
       
  1120 EUNIT_TEST(
       
  1121     "StartInactivityTimerL - test ",
       
  1122     "CMccRtpInterface",
       
  1123     "StartInactivityTimerL",
       
  1124     "FUNCTIONALITY",
       
  1125     SetupL, UT_CMccRtpDataSink_StartInactivityTimerLL, Teardown)
       
  1126 
       
  1127 EUNIT_TEST(
       
  1128     "StopInactivityTimerL - test ",
       
  1129     "CMccRtpInterface",
       
  1130     "StopInactivityTimerL",
       
  1131     "FUNCTIONALITY",
       
  1132     SetupL, UT_CMccRtpDataSink_StopInactivityTimerLL, Teardown)
       
  1133 
       
  1134 EUNIT_TEST(
       
  1135     "SetSessionParamsL - test ",
       
  1136     "CMccRtpInterface",
       
  1137     "SetSessionParamsL",
       
  1138     "FUNCTIONALITY",
       
  1139     SetupL, UT_CMccRtpDataSink_SetSessionParamsLL, Teardown)
       
  1140 
       
  1141 EUNIT_TEST(
       
  1142     "SRTPMasterKeyStaleEvent1L - test ",
       
  1143     "CMccRtpDataSink",
       
  1144     "SRTPMasterKeyStaleEvent1L",
       
  1145     "FUNCTIONALITY",
       
  1146     SetupL, UT_CMccRtpDataSink_SRTPMasterKeyStaleEvent1L, Teardown)
       
  1147 
       
  1148 EUNIT_TEST(
       
  1149     "SRTPMasterKeyStaleEvent2L - test ",
       
  1150     "CMccRtpDataSink",
       
  1151     "SRTPMasterKeyStaleEvent2L",
       
  1152     "FUNCTIONALITY",
       
  1153     SetupL, UT_CMccRtpDataSink_SRTPMasterKeyStaleEvent2L, Teardown)
       
  1154     
       
  1155 EUNIT_END_TEST_TABLE
       
  1156 
       
  1157 //  END OF FILE