--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/multimediacommscontroller/mmccrtpsourcesink/tsrc/ut_rtpsourcesink/src/UT_CMccRtpDataSource.cpp Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,1138 @@
+/*
+* 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_CMccRtpDataSource.h"
+
+// EXTERNAL INCLUDES
+#include <digia/eunit/eunitmacros.h>
+
+
+// INTERNAL INCLUDES
+#include "MccRtpDataSource.h"
+#include "MmccEvents.h"
+#include "AmrPayloadFormatRead.h"
+#include "mccrtpkeepalivecontainer.h"
+#include "mcctesteventhandler.h"
+#include <srtpcryptocontext.h>
+#include <srtpmastersalt.h>
+#include <srtpstreamin.h>
+#include "UT_CMccRtpInterface.h"
+#include "mccunittestmacros.h"
+
+// CONSTANTS
+_LIT8(KRFC3711_TestMasterKey128bits, "E1F97A0D3E018BE0D64FA32C06DE4139");
+_LIT8(KRFC3711_TestMasterSalt112bits, "0EC675AD498AFEEBB6960B3AABE6");
+_LIT8(KTestMKI128Bits, "ABCDEF1234567890ABCDEF1234567890");
+
+// CONSTRUCTION
+UT_CMccRtpDataSource* UT_CMccRtpDataSource::NewL()
+ {
+ UT_CMccRtpDataSource* self = UT_CMccRtpDataSource::NewLC();
+ CleanupStack::Pop();
+
+ return self;
+ }
+
+UT_CMccRtpDataSource* UT_CMccRtpDataSource::NewLC()
+ {
+ UT_CMccRtpDataSource* self = new( ELeave ) UT_CMccRtpDataSource();
+ CleanupStack::PushL( self );
+
+ self->ConstructL();
+
+ return self;
+ }
+
+// Destructor (virtual by CBase)
+UT_CMccRtpDataSource::~UT_CMccRtpDataSource()
+ {
+ }
+
+// Default constructor
+UT_CMccRtpDataSource::UT_CMccRtpDataSource()
+ : MDataSink( KUidMediaTypeAudio )
+ {
+ }
+
+// Second phase construct
+void UT_CMccRtpDataSource::ConstructL()
+ {
+ // The ConstructL from the base class CEUnitTestSuiteClass must be called.
+ // It generates the test case table.
+ CEUnitTestSuiteClass::ConstructL();
+ }
+
+// METHODS
+
+
+void UT_CMccRtpDataSource::SetupL()
+ {
+ iEventHandler = CMccTestEventHandler::NewL();
+ iRtpApi = CRtpAPI::NewL( *iEventHandler );
+ TUid dummyUid( TUid::Uid( 42 ) );
+ TBuf8<5> dummyBuf( _L8( "foo" ) );
+ iSource = static_cast<CMccRtpDataSource*>(
+ CMccRtpDataSource::NewSourceL( dummyUid, dummyBuf ) );
+
+ TMccRtpSourceSetting setting;
+ setting.iStandByTimerValue = 3000;
+ TMccRtpSourceSettingBuf settingBuf( setting );
+ iSource->ConstructSourceL( settingBuf );
+
+ MAsyncEventHandler* eventHandler = NULL;
+ TRtpId rtpSessionId(0);
+ iRtpKeepaliveMechanism =
+ CMccRtpKeepaliveContainer::NewL( *eventHandler,
+ *iRtpApi,
+ rtpSessionId );
+
+ }
+
+void UT_CMccRtpDataSource::Teardown()
+ {
+ delete iRtpKeepaliveMechanism;
+
+ if ( iSource )
+ {
+ delete iSource;
+ iSource = NULL;
+ }
+ if ( iSecSession)
+ {
+ delete iSecSession;
+ iSecSession = NULL;
+ }
+
+ if ( iRtpApi )
+ {
+ delete iRtpApi;
+ iRtpApi = NULL;
+ }
+
+ delete iEventHandler;
+ }
+
+
+// HELPER FUNCTIONS
+
+void UT_CMccRtpDataSource::InitializeL( TBool aCreateStream, TBool aEnableRtcp )
+ {
+ iSource->SourceThreadLogon( *iEventHandler );
+
+ RArray<TUint> payloads;
+ CleanupClosePushL( payloads );
+ payloads.AppendL( KDefaultAmrNbPT );
+ payloads.AppendL( KPcmuPayloadType );
+ iSource->RegisterPayloadTypesL( payloads );
+ CleanupStack::PopAndDestroy( &payloads );
+
+ TMccRtpSessionParams params;
+ params.iRtpAPI = iRtpApi;
+ params.iSessionId = iSession;
+ params.iEnableRTCP = aEnableRtcp;
+ params.iRtpKeepalive = iRtpKeepaliveMechanism;
+ EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );
+
+ if ( aCreateStream )
+ {
+ CreateStreamL();
+ }
+ }
+
+void UT_CMccRtpDataSource::CreateStreamL()
+ {
+ TMccCodecInfo cInfo;
+ cInfo.iType = KUidMediaTypeAudio;
+ cInfo.iFourCC = TFourCC( ' ','A','M','R' );
+ cInfo.iBitrate = 8000;
+ cInfo.iPayloadType = KDefaultAmrNbPT;
+ TMccCodecInfoBuffer cInfoBuf( cInfo );
+ EUNIT_ASSERT_NO_LEAVE( iSource->ConfigureL( cInfoBuf ) );
+ }
+
+// TEST FUNCTIONS
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_RtpPacketReceivedL()
+ {
+ TRtpId stream( 0 );
+ TRtpId wrongStream( 99 );
+ TRtpRecvHeader header;
+ TBuf8<5> data;
+ data.Format( _L8( "foo42" ) );
+ iSource->SourceThreadLogon( *iEventHandler );
+
+ CMMFBuffer* buffer = CMMFDescriptorBuffer::NewL(10);
+ CleanupStack::PushL( buffer );
+ CAmrPayloadFormatRead* amrPfRead = CAmrPayloadFormatRead::NewL( NULL );
+ CleanupStack::PushL( amrPfRead );
+
+ header.iPayloadType = KPcmuPayloadType;
+ RArray<TUint> payloads;
+ CleanupClosePushL( payloads );
+ payloads.AppendL( KDefaultAmrNbPT );
+ payloads.AppendL( KPcmuPayloadType );
+ iSource->RegisterPayloadTypesL( payloads );
+ CleanupStack::PopAndDestroy( &payloads );
+
+ // Wrong stream
+ iSource->FillBufferL( buffer, amrPfRead, TMediaId() );
+ iSource->RtpPacketReceived( wrongStream, header, data );
+
+ TMccRtpSessionParams params;
+ params.iRtpAPI = iRtpApi;
+ params.iSessionId = iSession;
+ params.iEnableRTCP = EFalse;
+ params.iRtpKeepalive = iRtpKeepaliveMechanism;
+ EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );
+
+ TMccCodecInfo cInfo;
+ cInfo.iFourCC = TFourCC( ' ','A','M','R' );
+ cInfo.iBitrate = 8000;
+ cInfo.iPayloadType = KDefaultAmrNbPT;
+ TMccCodecInfoBuffer cInfoBuf( cInfo );
+
+ EUNIT_ASSERT_NO_LEAVE( iSource->ConfigureL( cInfoBuf ) );
+ //iSource->NegotiateSourceL( *iEventHandler );
+ EUNIT_ASSERT_NO_LEAVE( iSource->NegotiateSourceL( *amrPfRead ) );
+ EUNIT_ASSERT_NO_LEAVE( iSource->SourcePrimeL() );
+ EUNIT_ASSERT_NO_LEAVE( iSource->SourcePlayL() );
+
+ stream = 2; // This is what the RtpAPI stub gives
+ header.iPayloadType = KDefaultAmrNbPT;
+
+ EUNIT_ASSERT_EQUALS( iSource->iTimeoutTime, 0 );
+ iSource->FillBufferL( buffer, amrPfRead, TMediaId() );
+ iSource->RtpPacketReceived( stream, header, data );
+ EUNIT_ASSERT_EQUALS( iSource->iTimeoutTime, 0 );
+ EUNIT_ASSERT_EQUALS( iSource->iInactivityTimerId, KMaxTUint32 );
+
+ // Inactivity timer is activated when receiving packet
+ MCC_EUNIT_ASSERT_NO_LEAVE( iSource->StartInactivityTimerL( 500000 ) );
+ iSource->RtpPacketReceived( stream, header, data );
+ EUNIT_ASSERT_EQUALS( iSource->iTimeoutTime, 500000 );
+ EUNIT_ASSERT( iSource->iInactivityTimerId != KMaxTUint32 );
+
+ // Jitter observing is active
+ iSource->iJitCalc->iMediaQualityObservingStarted = ETrue;
+ iSource->RtpPacketReceived( stream, header, data );
+
+ // Sink not ready, error ignored silently
+ iEventHandler->iLastEvent.iEventType = KMccEventNone;
+ iSource->iFillBufferRequester = NULL;
+ iSource->RtpPacketReceived( stream, header, data );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccEventNone );
+
+ // secure key expired, error ignored silently
+ iSource->iSecureKeyExpired = ETrue;
+ iSource->RtpPacketReceived( stream, header, data );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccEventNone );
+
+ CleanupStack::PopAndDestroy( amrPfRead );
+ CleanupStack::PopAndDestroy( buffer );
+ iSource->SourceThreadLogoff();
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_StartInactivityTimerLL()
+ {
+ TUint32 time( 0 );
+
+ // Invalid time
+ EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->StartInactivityTimerL( time ), KErrArgument );
+
+ time = 5000;
+
+ // Ok
+ MCC_EUNIT_ASSERT_NO_LEAVE( iSource->StartInactivityTimerL( time ) );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_StopInactivityTimerLL()
+ {
+ // No timer exists
+ EUNIT_ASSERT_NO_LEAVE( iSource->StopInactivityTimerL() );
+
+ TUint32 time( 5000 );
+ iSource->StartInactivityTimerL( time );
+
+ // OK
+ EUNIT_ASSERT_NO_LEAVE( iSource->StopInactivityTimerL() );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SendMediaSignallingLL()
+ {
+ iSource->iEnableRtcp = ETrue;
+ TMccEvent foo;
+ UT_CMccRtpInterface::CreateRtcpEvent( foo );
+
+ EUNIT_ASSERT_LEAVE( iSource->SendMediaSignallingL( foo ) );
+
+ // No RtpApi
+ foo.iEventCategory = KMccEventCategoryRtcp;
+ foo.iEventType = KMccRtcpControl;
+ TMccRtcpEventData eventData;
+ eventData.iRtcpPacketType = KRtcpRrPacket;
+ TMccRtcpEventDataPackage eventDataPkg( eventData );
+ foo.iEventData.Copy( eventDataPkg );
+ EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SendMediaSignallingL( foo ), KErrNotReady );
+
+ // Rr, stream does not exist
+ InitializeL( EFalse, ETrue );
+ EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SendMediaSignallingL( foo ), KErrNotReady );
+
+ // Stream exists
+ CreateStreamL();
+ EUNIT_ASSERT_NO_LEAVE( iSource->SendMediaSignallingL( foo ) );
+
+ // Sr
+ eventData.iRtcpPacketType = KRtcpSrPacket;
+ eventDataPkg = eventData;
+ foo.iEventData.Copy( eventDataPkg );
+ EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SendMediaSignallingL( foo ), KErrArgument );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourceDataTypeCodeL()
+ {
+ TMediaId mediaId( KUidMediaTypeVideo );
+ EUNIT_ASSERT_EQUALS( iSource->SourceDataTypeCode( mediaId ), TFourCC() );
+
+ iSource->SourceThreadLogoff();
+ TFourCC codec( ' ','A','M','R' );
+ TMediaId media2( KUidMediaTypeAudio );
+ iSource->SetSourceDataTypeCode( codec, media2 );
+
+ // The codecs SHOULD be equal
+ EUNIT_ASSERT_EQUALS( iSource->SourceDataTypeCode( media2 ), codec );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SetSourceDataTypeCodeL()
+ {
+ TFourCC codec;
+ TMediaId media( KUidMediaTypeVideo ); // wrong media type
+
+ EUNIT_ASSERT_EQUALS( iSource->SetSourceDataTypeCode( codec, media ), KErrNone );
+
+ // Set the correct media type
+ TMediaId media2( KUidMediaTypeAudio );
+ EUNIT_ASSERT_EQUALS( iSource->SetSourceDataTypeCode( codec, media2 ), KErrNone );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_BufferEmptiedLL()
+ {
+ EUNIT_ASSERT_LEAVE( iSource->BufferEmptiedL( NULL ) );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_CanCreateSourceBufferL()
+ {
+ EUNIT_ASSERT_EQUALS( iSource->CanCreateSourceBuffer(), EFalse );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_CreateSourceBufferLL()
+ {
+ TMediaId dummyId;
+ TBool dummyBool;
+ EUNIT_ASSERT_LEAVE( iSource->CreateSourceBufferL( dummyId, dummyBool ) );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourceThreadLogonL()
+ {
+ iSource->SourceThreadLogon( *iEventHandler );
+ iSource->SourceThreadLogon( *iEventHandler );
+ iSource->SourceThreadLogoff();
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourceThreadLogoffL()
+ {
+ iSource->SourceThreadLogoff();
+
+ // Reach more branches
+ TMccRtpSessionParams params;
+ params.iRtpAPI = iRtpApi;
+ params.iSessionId = iSession;
+ params.iEnableRTCP = EFalse;
+ params.iRtpKeepalive = iRtpKeepaliveMechanism;
+ EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );
+
+ TMccCodecInfo cInfo;
+ cInfo.iFourCC = TFourCC( ' ','A','M','R' );
+ cInfo.iBitrate = 8000;
+ cInfo.iPayloadType = KDefaultAmrNbPT;
+ TMccCodecInfoBuffer cInfoBuf( cInfo );
+
+ EUNIT_ASSERT_NO_LEAVE( iSource->ConfigureL( cInfoBuf ) );
+
+ MCC_EUNIT_ASSERT_EQUALS( iSource->SourceThreadLogon( *iEventHandler ), KErrNone );
+ EUNIT_ASSERT_NO_LEAVE( iSource->SourcePrimeL() );
+
+ iSource->SourceThreadLogoff();
+
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourcePrimeLL()
+ {
+ // Ok
+ TMccRtpSessionParams params;
+ params.iRtpAPI = iRtpApi;
+ params.iSessionId = iSession;
+ params.iEnableRTCP = EFalse;
+ params.iRtpKeepalive = iRtpKeepaliveMechanism;
+ EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );
+
+ TMccCodecInfo cInfo;
+ cInfo.iFourCC = TFourCC( ' ','A','M','R' );
+ cInfo.iBitrate = 8000;
+ cInfo.iPayloadType = KDefaultAmrNbPT;
+ TMccCodecInfoBuffer cInfoBuf( cInfo );
+
+ EUNIT_ASSERT_NO_LEAVE( iSource->ConfigureL( cInfoBuf ) );
+
+ MCC_EUNIT_ASSERT_EQUALS( iSource->SourceThreadLogon( *iEventHandler ), KErrNone );
+ EUNIT_ASSERT_NO_LEAVE( iSource->SourcePrimeL() );
+
+ iSource->SourceThreadLogoff();
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourcePlayLL()
+ {
+ // Not logged on
+ EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SourcePlayL(), KErrNotFound );
+
+ // Not allowed if not yet prepared
+ InitializeL();
+ EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SourcePlayL(), KErrNotReady );
+
+ // Ok when already prepared
+ iSource->iState = MMccRtpInterface::ERtpStatePrimed;
+
+ EUNIT_ASSERT_NO_LEAVE( iSource->SourcePlayL() );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccStreamStarted );
+
+ // Resuming
+ iSource->iState = MMccRtpInterface::ERtpStatePaused;
+ EUNIT_ASSERT_NO_LEAVE( iSource->SourcePlayL() );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccStreamResumed );
+ EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == EFalse )
+
+ // State downgrade is ignored
+ EUNIT_ASSERT_NO_LEAVE( iSource->SourcePrimeL() );
+ EUNIT_ASSERT( MMccRtpInterface::ERtpStatePlaying == iSource->State() );
+
+ // "Secure session"
+ iRtpKeepaliveMechanism->iStopped = ETrue;
+ TInt fakeSecSession( 3 );
+ iSource->iSecSession = reinterpret_cast<CSRTPSession*>( &fakeSecSession );
+ EUNIT_ASSERT_NO_LEAVE( iSource->SourcePlayL() );
+ EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == ETrue )
+ iSource->iSecSession = NULL;
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourcePauseLL()
+ {
+ EUNIT_ASSERT_LEAVE( iSource->SourcePauseL() );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourceStopLL()
+ {
+ EUNIT_ASSERT_NO_LEAVE( iSource->SourceStopL() );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_FillBufferLL()
+ {
+ EUNIT_ASSERT_NO_LEAVE( iSource->FillBufferL( NULL, NULL, TMediaId() ) );
+ CMMFDataBuffer* buffer = CMMFDataBuffer::NewL( 100 );
+ CleanupStack::PushL( buffer );
+ EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->FillBufferL( buffer, NULL, TMediaId() ), KErrArgument );
+ CleanupStack::PopAndDestroy( buffer );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SendRTCPReceiverReportL()
+ {
+ // No RTP API set
+ EUNIT_ASSERT_EQUALS( iSource->SendRTCPReceiverReport(), KErrNotReady );
+
+ TMccRtpSessionParams params;
+ params.iRtpAPI = iRtpApi;
+ params.iSessionId = iSession;
+ params.iEnableRTCP = EFalse;
+ params.iRtpKeepalive = iRtpKeepaliveMechanism;
+ iSource->SetSessionParamsL( params );
+
+
+ // Ok
+ iSource->iRtpStreamId = 1; // the iStreamID must not be empty
+ EUNIT_ASSERT_EQUALS( iSource->SendRTCPReceiverReport(), KErrNone );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SendRTCPSenderReportL()
+ {
+ // No RTP API set
+ EUNIT_ASSERT_EQUALS( iSource->SendRTCPSenderReport(), KErrNotReady );
+
+ TMccRtpSessionParams params;
+ params.iRtpAPI = iRtpApi;
+ params.iSessionId = iSession;
+ params.iEnableRTCP = EFalse;
+ params.iRtpKeepalive = iRtpKeepaliveMechanism;
+ iSource->SetSessionParamsL( params );
+
+ // Ok
+ iSource->iRtpStreamId = 1; // the iStreamID must not be empty
+ EUNIT_ASSERT_EQUALS( iSource->SendRTCPSenderReport(), KErrNone );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SendRTCPDataLL()
+ {
+ TBuf8<5> dummy;
+ EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SendRTCPDataL( dummy ), KErrNotSupported );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_NegotiateSourceLL()
+ {
+ // wrong codec
+ EUNIT_ASSERT_NO_LEAVE( iSource->NegotiateSourceL( *this ) );
+
+ // Reach more branches
+ TMccRtpSessionParams params;
+ params.iRtpAPI = iRtpApi;
+ params.iSessionId = iSession;
+ params.iEnableRTCP = EFalse;
+ params.iRtpKeepalive = iRtpKeepaliveMechanism;
+ EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );
+
+ TMccCodecInfo cInfo;
+ cInfo.iFourCC = TFourCC( ' ','A','M','R' );
+ cInfo.iBitrate = 8000;
+ cInfo.iPayloadType = KDefaultAmrNbPT;
+ TMccCodecInfoBuffer cInfoBuf( cInfo );
+
+ EUNIT_ASSERT_NO_LEAVE( iSource->ConfigureL( cInfoBuf ) );
+ MCC_EUNIT_ASSERT_EQUALS( iSource->SourceThreadLogon( *iEventHandler ), KErrNone );
+ EUNIT_ASSERT_NO_LEAVE( iSource->SourcePrimeL() );
+
+ EUNIT_ASSERT_NO_LEAVE( iSource->NegotiateSourceL( *this ) );
+ iSource->SourceThreadLogoff();
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_ConstructSourceLL()
+ {
+ TUid dummyUid( TUid::Uid( 42 ) );
+ TBuf8<5> dummyBuf( _L8( "foo" ) );
+ CMccRtpDataSource* source = static_cast<CMccRtpDataSource*>(
+ CMccRtpDataSource::NewSourceL( dummyUid, dummyBuf ) );
+ CleanupStack::PushL( source );
+ MCC_EUNIT_ASSERT_NO_LEAVE( source->ConstructSourceL( KNullDesC8 ) );
+ CleanupStack::PopAndDestroy( source );
+ }
+
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_ValidatePacketL()
+ {
+ TRtpId streamId( KNullId );
+ TRtpRecvHeader header;
+
+ TBuf8<5> data5;
+ TBuf8<15> data15;
+ data5.Format( _L8( "foo42" ) );
+ data15.Format( _L8( "foo42foo42foo42" ) );
+
+ // Data too big, stream ok, wrong payload type
+ EUNIT_ASSERT_LEAVE( iSource->ValidatePacketL( streamId, header, data15 ) );
+
+ // Data ok, stream ok, wrong payload type
+ EUNIT_ASSERT_LEAVE( iSource->ValidatePacketL( streamId, header, data5 ) );
+
+ header.iPayloadType = KMccPayloadTypeMax;
+
+ // header not OK
+ CMMFDataBuffer* buffer = CMMFDataBuffer::NewL(10);
+ CleanupStack::PushL( buffer );
+ iSource->iBufferToFill = buffer;
+ EUNIT_ASSERT_LEAVE( iSource->ValidatePacketL( streamId, header, data5 ) );
+
+ // Get a new source
+ //Teardown();
+ if( iRtpKeepaliveMechanism )
+ {
+ delete iRtpKeepaliveMechanism;
+ iRtpKeepaliveMechanism = NULL;
+ }
+
+ if ( iSource )
+ {
+ delete iSource;
+ iSource = NULL;
+ }
+ //SetupL();
+ TUid dummyUid( TUid::Uid( 42 ) );
+ TBuf8<5> dummyBuf( _L8( "foo" ) );
+ iSource = static_cast<CMccRtpDataSource*>(
+ CMccRtpDataSource::NewSourceL( dummyUid, dummyBuf ) );
+
+ TMccRtpSourceSetting setting;
+ setting.iStandByTimerValue = 3000;
+ TMccRtpSourceSettingBuf settingBuf( setting );
+ iSource->ConstructSourceL( settingBuf );
+
+ MAsyncEventHandler* eventHandler = NULL;
+ TRtpId rtpSessionId(0);
+ iRtpKeepaliveMechanism =
+ CMccRtpKeepaliveContainer::NewL( *eventHandler,
+ *iRtpApi,
+ rtpSessionId );
+
+ TMccRtpSessionParams params;
+ params.iRtpAPI = iRtpApi;
+ params.iSessionId = iSession;
+ params.iEnableRTCP = EFalse;
+ params.iRtpKeepalive = iRtpKeepaliveMechanism;
+ EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );
+
+ TMccCodecInfo cInfo;
+ cInfo.iFourCC = TFourCC( KMccFourCCIdG711 );
+ cInfo.iEnableDTX = ETrue;
+ TMccCodecInfoBuffer cInfoBuf( cInfo );
+ EUNIT_ASSERT_NO_LEAVE( iSource->ConfigureL( cInfoBuf ) );
+
+ header.iPayloadType = KPcmuPayloadType;
+
+ // Data ok, stream ok, payload type ok
+ CAmrPayloadFormatRead* amrPfRead = CAmrPayloadFormatRead::NewL( NULL );
+ CleanupStack::PushL( amrPfRead );
+
+ RArray<TUint> payloads;
+ CleanupClosePushL( payloads );
+ payloads.AppendL( KPcmuPayloadType );
+ iSource->RegisterPayloadTypesL( payloads );
+ iSource->FillBufferL( buffer, amrPfRead, TMediaId() );
+ EUNIT_ASSERT_NO_LEAVE( iSource->ValidatePacketL( streamId, header, data5 ) );
+ CleanupStack::PopAndDestroy( &payloads );
+ CleanupStack::PopAndDestroy( amrPfRead );
+ CleanupStack::PopAndDestroy( buffer );
+
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_CreateStreamLL()
+ {
+ TMccRtpSessionParams params;
+ params.iRtpAPI = iRtpApi;
+ params.iSessionId = iSession;
+ params.iEnableRTCP = ETrue;
+ params.iRtpKeepalive = iRtpKeepaliveMechanism;
+ EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );
+
+ TMccCodecInfo cInfo;
+ TMccCodecInfoBuffer cInfoBuf( cInfo );
+
+ EUNIT_ASSERT_NO_LEAVE( iSource->ConfigureL( cInfoBuf ) );
+
+ // Get a new Source
+ Teardown();
+ SetupL();
+
+ // This should leave because the string is too short
+ TBuf8<5> dummy;
+ dummy.Format( _L8( "foo42" ) );
+ EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );
+ EUNIT_ASSERT_LEAVE( iSource->ConfigureL( dummy ) );
+
+ // Get a new Source
+ Teardown();
+ SetupL();
+
+ TMccRtpSessionParams params2;
+ params2.iRtpAPI = iRtpApi;
+ params2.iSessionId = iSession;
+ params2.iEnableRTCP = EFalse;
+ params2.iRtpKeepalive = iRtpKeepaliveMechanism;
+ iSource->SetSessionParamsL( params2 );
+
+ TMccCodecInfo cInfo2;
+ cInfo2.iFourCC = TFourCC( KMccFourCCIdG711 );
+ cInfo2.iEnableDTX = ETrue;
+ cInfo2.iRedundantPayload = 97;
+ cInfo2.iRedundancyCount = 1;
+ cInfo2.iAlgoUsed = EGenRedUsed;
+ TMccCodecInfoBuffer cInfoBuf2( cInfo2 );
+
+ EUNIT_ASSERT_NO_LEAVE( iSource->ConfigureL( cInfoBuf2 ) );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_DoCreateSrtpStreamL()
+ {
+ // Rtp stream not created
+ iSource->iRtpStreamId = KNullId;
+ EUNIT_ASSERT_NO_LEAVE( iSource->DoCreateSrtpStreamL() );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_TestSendEventL()
+ {
+ iSource->SourceThreadLogon( *iEventHandler );
+
+ // No target payload
+ iSource->SendStreamEventToClient( KMccStreamPaused, KErrNone, KMccPTNotDefined );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccStreamPaused );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventNumData, 0 );
+
+ // Target payload
+ iSource->SendStreamEventToClient( KMccStreamResumed, KErrNone, 100 );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccStreamResumed );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventNumData, KMccPayloadSpecificEvent );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iReserved, 100 );
+
+ // No event handler
+ iSource->iEventHandler = NULL;
+ iSource->SendStreamEventToClient( KMccStreamStopped, KErrNone, KMccPTNotDefined );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccStreamResumed );
+
+ // Jitter event when no event handler
+ TMccRtpEventData eventData;
+ iSource->SendJitterEvent( eventData, KErrNone );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccStreamResumed );
+
+ // Event handler exists
+ iSource->iEventHandler = iEventHandler;
+ iSource->SendJitterEvent( eventData, KErrNone );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccMediaQualityStatus );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_StandbyL()
+ {
+ EUNIT_ASSERT_EQUALS( iSource->StandBy( EForceStandby, 100 ), KErrNotFound );
+
+ // Standby force when properly initialized
+ InitializeL();
+
+ EUNIT_ASSERT_EQUALS( iSource->iUsers.Count(), 2 );
+ EUNIT_ASSERT_EQUALS( iSource->StandBy( EForceStandby, KPcmuPayloadType ), KErrNone );
+ iSource->iState = MMccRtpInterface::ERtpStatePlaying;
+ EUNIT_ASSERT_EQUALS( iSource->StandBy( EForceStandby, KPcmuPayloadType ), KErrNone );
+ EUNIT_ASSERT( iSource->iUsers[ 0 ].iStandbyState == EInactive );
+
+ // Test activation when already inactive
+ EUNIT_ASSERT_EQUALS( iSource->StandBy( EActivateStandby, KPcmuPayloadType ), KErrNone );
+ EUNIT_ASSERT( iSource->iUsers[ 0 ].iStandbyState == EInactive );
+
+ // Test activation when activating
+ iSource->iUsers[ 0 ].iStandbyState = EActivating;
+ EUNIT_ASSERT_EQUALS( iSource->StandBy( EActivateStandby, KPcmuPayloadType ), KErrNone );
+ EUNIT_ASSERT( iSource->iUsers[ 0 ].iStandbyState == EActivating );
+
+ // Test activation when inactive
+ iSource->iUsers[ 0 ].iStandbyState = EActive;
+ EUNIT_ASSERT_EQUALS( iSource->StandBy( EActivateStandby, KPcmuPayloadType ), KErrNone );
+ EUNIT_ASSERT( iSource->iUsers[ 0 ].iStandbyState == EInactive );
+
+ // Test deactivation
+ EUNIT_ASSERT_EQUALS( iSource->StandBy( EDeactivateStandby, KPcmuPayloadType ), KErrNone );
+ EUNIT_ASSERT( iSource->iUsers[ 0 ].iStandbyState == ETurnedOff );
+
+ // Test activation when standby is turned off (timer expires)
+ iSource->iUsers[ 0 ].iTimerId = 2;
+ EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->TimerExpiredL( 2, NULL ), KErrNotSupported );
+
+ // Test timer expiration for inactivity
+ iSource->iInactivityTimerId = 3;
+ iSource->TimerExpiredL( 3, NULL );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccInactivityEvent );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourceCustomCommandL()
+ {
+ // A bit hard to test
+ EUNIT_ASSERT( ETrue );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_TestBaseClassL()
+ {
+ // Test some base class functions which are hard to test by other means
+
+ // Internal event to all clients (no users)
+ iSource->SendInternalRtpEventToAllClients(
+ iSource->iUsers, KMccRtpSourceUid, EMccInternalEventNone, KMccStreamError, 0, KErrGeneral );
+
+ // Users exist
+ InitializeL();
+
+ iSource->SendInternalRtpEventToAllClients(
+ iSource->iUsers, KMccRtpSourceUid, EMccInternalEventNone, KMccStreamError, 0, KErrGeneral );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccStreamError );
+
+ // Secure events
+ iSource->SendSecureRtpEventToClient(
+ NULL, KMccRtpSourceUid, EMccInternalEventNone, KMccStreamPaused, 0 );
+ iSource->SendSecureRtpEventToClient(
+ iEventHandler, KMccRtpSourceUid, EMccInternalEventNone, KMccStreamPaused, 0 );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccStreamPaused );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_DoStandbyDecisionL()
+ {
+ // Standby not enabled
+ iSource->DoStandByDecision( NULL );
+
+ // Standby enabled
+ InitializeL();
+ iSource->DoStandByDecision( &iSource->iUsers[ 0 ] );
+ EUNIT_ASSERT( iSource->iUsers[ 0 ].iStandbyState == EActive );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_RegisterPayloadTypesLL()
+ {
+ RArray<TUint> payloads;
+ CleanupClosePushL( payloads );
+ payloads.AppendL( KPcmuPayloadType );
+ payloads.AppendL( KDefaultAmrNbPT );
+ iSource->RegisterPayloadTypesL( payloads );
+ EUNIT_ASSERT_EQUALS( iSource->iUsers.Count(), 2 );
+
+ // Do again, multiple entries are not created
+ iSource->RegisterPayloadTypesL( payloads );
+ EUNIT_ASSERT_EQUALS( iSource->iUsers.Count(), 2 );
+
+ // Try to unregister not registered payload type
+ RArray<TUint> payloads2;
+ CleanupClosePushL( payloads2 );
+ payloads2.AppendL( KPcmaPayloadType );
+ iSource->UnRegisterPayloadTypes( payloads2 );
+ EUNIT_ASSERT_EQUALS( iSource->iUsers.Count(), 2 );
+ CleanupStack::PopAndDestroy( &payloads2 );
+
+ // Unregister registered payload types
+ iSource->UnRegisterPayloadTypes( payloads );
+ EUNIT_ASSERT_EQUALS( iSource->iUsers.Count(), 0 );
+ CleanupStack::PopAndDestroy( &payloads );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SRTPMasterKeyStaleEvent1L()
+ {
+ //SetUp SecureSession
+ TInetAddr destination;
+ destination.Input(_L("127.0.0.1") );
+ iSecSession = CSRTPSession::NewL( destination );
+
+ //Set up MCCparams
+ TMccRtpSessionParams params;
+ params.iRtpAPI = iRtpApi;
+ params.iSecSession = iSecSession;
+ params.iSessionId = iSession;
+ params.iEnableRTCP = EFalse;
+ params.iRtpKeepalive = iRtpKeepaliveMechanism;
+ EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );
+ iSource->SourceThreadLogon( *iEventHandler );
+
+ iSource->SRTPMasterKeyStaleEvent( *iSecSession );
+ EUNIT_ASSERT( iSource->iSecureKeyExpired );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccMasterKeyStaled );
+ EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SourcePlayL(), KErrGeneral );
+ }
+
+void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SRTPMasterKeyStaleEvent2L()
+ {
+ //SetUp SecureSession
+ TInetAddr destination;
+ destination.Input(_L("127.0.0.1") );
+ iSecSession = CSRTPSession::NewL( destination );
+
+ //Set up Secure Stream
+ //Secure Context
+
+ HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());
+ CleanupStack::PushL( masterKey );
+ *masterKey = KRFC3711_TestMasterKey128bits;
+
+ HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());
+ CleanupStack::PushL( masterSalt );
+ *masterSalt = KRFC3711_TestMasterSalt112bits;
+
+
+ HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());
+ CleanupStack::PushL( mki );
+ *mki = KTestMKI128Bits;
+ //Hex(*mki);
+
+ CSRTPMasterKey* mKey = CSRTPMasterKey::NewL( *masterKey, *mki );
+ CleanupStack::PushL( mKey );
+ CSRTPMasterSalt* saltKey = CSRTPMasterSalt::NewL( *masterSalt );
+ CleanupStack::PushL( saltKey );
+
+ TSrtpCryptoParams srtpParams;
+ CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(mKey, saltKey, srtpParams );
+ CleanupStack::Pop( saltKey );
+ CleanupStack::Pop( mKey );
+
+ CleanupStack::PopAndDestroy( mki );
+ CleanupStack::PopAndDestroy( masterSalt );
+ CleanupStack::PopAndDestroy( masterKey );
+
+ CleanupStack::PushL( context );
+
+ CSRTPStreamIn* srtpStream = CSRTPStreamIn::NewL( *iSecSession, context, *iSource );
+ CleanupStack::Pop( context );
+ CleanupStack::PushL( srtpStream );
+
+ //Set up MCCparams
+ TMccRtpSessionParams params;
+ params.iRtpAPI = iRtpApi;
+ params.iSecSession = iSecSession;
+ params.iSessionId = iSession;
+ params.iEnableRTCP = EFalse;
+
+ params.iRtpKeepalive = iRtpKeepaliveMechanism;
+ EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );
+ iSource->SourceThreadLogon( *iEventHandler );
+ //srtpStream is not equal
+ iSource->SRTPMasterKeyStaleEvent( *srtpStream );
+ EUNIT_ASSERT( !iSource->iSecureKeyExpired );
+ EUNIT_ASSERT_NOT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccMasterKeyStaled );
+ //srtpStream is equal
+ iSource->iSrtpStream = srtpStream;
+ iSource->SRTPMasterKeyStaleEvent( *srtpStream );
+ EUNIT_ASSERT( iSource->iSecureKeyExpired );
+ EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccMasterKeyStaled );
+ EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SourcePlayL(), KErrGeneral );
+ CleanupStack::Pop( srtpStream );
+ }
+
+// TEST TABLE
+
+EUNIT_BEGIN_TEST_TABLE(
+ UT_CMccRtpDataSource,
+ "CMccRtpDataSource",
+ "UNIT" )
+
+EUNIT_TEST(
+ "RtpPacketReceived - test ",
+ "CMccRtpDataSource",
+ "RtpPacketReceived",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_RtpPacketReceivedL, Teardown)
+
+EUNIT_TEST(
+ "StartInactivityTimerL - test ",
+ "CMccRtpDataSource",
+ "StartInactivityTimerL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_StartInactivityTimerLL, Teardown)
+
+EUNIT_TEST(
+ "StopInactivityTimerL - test ",
+ "CMccRtpDataSource",
+ "StopInactivityTimerL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_StopInactivityTimerLL, Teardown)
+
+EUNIT_TEST(
+ "SendMediaSignallingL - test ",
+ "CMccRtpDataSource",
+ "SendMediaSignallingL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SendMediaSignallingLL, Teardown)
+
+EUNIT_TEST(
+ "SourceDataTypeCode - test ",
+ "CMccRtpDataSource",
+ "SourceDataTypeCode",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SourceDataTypeCodeL, Teardown)
+
+EUNIT_TEST(
+ "SetSourceDataTypeCode - test ",
+ "CMccRtpDataSource",
+ "SetSourceDataTypeCode",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SetSourceDataTypeCodeL, Teardown)
+
+EUNIT_TEST(
+ "BufferEmptiedL - test ",
+ "CMccRtpDataSource",
+ "BufferEmptiedL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_BufferEmptiedLL, Teardown)
+
+EUNIT_TEST(
+ "CanCreateSourceBuffer - test ",
+ "CMccRtpDataSource",
+ "CanCreateSourceBuffer",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_CanCreateSourceBufferL, Teardown)
+
+EUNIT_TEST(
+ "CreateSourceBufferL - test ",
+ "CMccRtpDataSource",
+ "CreateSourceBufferL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_CreateSourceBufferLL, Teardown)
+
+EUNIT_TEST(
+ "SourceThreadLogon - test ",
+ "CMccRtpDataSource",
+ "SourceThreadLogon",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SourceThreadLogonL, Teardown)
+
+EUNIT_TEST(
+ "SourceThreadLogoff - test ",
+ "CMccRtpDataSource",
+ "SourceThreadLogoff",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SourceThreadLogoffL, Teardown)
+
+EUNIT_TEST(
+ "SourcePrimeL - test ",
+ "CMccRtpDataSource",
+ "SourcePrimeL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SourcePrimeLL, Teardown)
+
+EUNIT_TEST(
+ "SourcePlayL - test ",
+ "CMccRtpDataSource",
+ "SourcePlayL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SourcePlayLL, Teardown)
+
+EUNIT_TEST(
+ "SourcePauseL - test ",
+ "CMccRtpDataSource",
+ "SourcePauseL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SourcePauseLL, Teardown)
+
+EUNIT_TEST(
+ "SourceStopL - test ",
+ "CMccRtpDataSource",
+ "SourceStopL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SourceStopLL, Teardown)
+
+EUNIT_TEST(
+ "FillBufferL - test ",
+ "CMccRtpDataSource",
+ "FillBufferL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_FillBufferLL, Teardown)
+
+EUNIT_TEST(
+ "SendRTCPReceiverReport - test ",
+ "CMccRtpDataSource",
+ "SendRTCPReceiverReport",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SendRTCPReceiverReportL, Teardown)
+
+EUNIT_TEST(
+ "SendRTCPSenderReport - test ",
+ "CMccRtpDataSource",
+ "SendRTCPSenderReport",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SendRTCPSenderReportL, Teardown)
+
+EUNIT_TEST(
+ "SendRTCPDataL - test ",
+ "CMccRtpDataSource",
+ "SendRTCPDataL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SendRTCPDataLL, Teardown)
+
+EUNIT_TEST(
+ "NegotiateSourceL - test ",
+ "CMccRtpDataSource",
+ "NegotiateSourceL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_NegotiateSourceLL, Teardown)
+
+EUNIT_TEST(
+ "ConstructSourceL - test ",
+ "CMccRtpDataSource",
+ "ConstructSourceL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_ConstructSourceLL, Teardown)
+
+EUNIT_TEST(
+ "ValidatePacket - test ",
+ "CMccRtpDataSource",
+ "ValidatePacket",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_ValidatePacketL, Teardown)
+
+EUNIT_TEST(
+ "DoCreateSrtpStreamL - test ",
+ "CMccRtpDataSource",
+ "DoCreateSrtpStreamL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_DoCreateSrtpStreamL, Teardown)
+
+EUNIT_TEST(
+ "TestSendEvent - test ",
+ "CMccRtpDataSource",
+ "TestSendEvent",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_TestSendEventL, Teardown)
+
+EUNIT_TEST(
+ "Standby - test ",
+ "CMccRtpDataSource",
+ "Standby",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_StandbyL, Teardown)
+
+EUNIT_TEST(
+ "SourceCustomCommand - test ",
+ "CMccRtpDataSource",
+ "SourceCustomCommand",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SourceCustomCommandL, Teardown)
+
+EUNIT_TEST(
+ "DoStandbyDecision - test ",
+ "CMccRtpDataSource",
+ "DoStandbyDecision",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_DoStandbyDecisionL, Teardown)
+
+EUNIT_TEST(
+ "RegisterPayloadTypesL - test ",
+ "CMccRtpDataSource",
+ "RegisterPayloadTypesL",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_RegisterPayloadTypesLL, Teardown)
+
+EUNIT_TEST(
+ "TestBaseClass - test ",
+ "CMccRtpDataSource",
+ "TestBaseClass",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_TestBaseClassL, Teardown)
+
+EUNIT_TEST(
+ "SRTPMasterKeyStaleEvent1L - test ",
+ "CMccRtpDataSource",
+ "SRTPMasterKeyStaleEvent1L",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SRTPMasterKeyStaleEvent1L, Teardown)
+
+EUNIT_TEST(
+ "SRTPMasterKeyStaleEvent2L - test ",
+ "CMccRtpDataSource",
+ "SRTPMasterKeyStaleEvent2L",
+ "FUNCTIONALITY",
+ SetupL, UT_CMccRtpDataSource_SRTPMasterKeyStaleEvent2L, Teardown)
+
+EUNIT_END_TEST_TABLE
+
+// END OF FILE