--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/rtp/rtpstack/tsrc/ut_rtpstack/src/UT_CRtpPacket.cpp Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,1106 @@
+/*
+* 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_CRtpPacket.h"
+
+// EXTERNAL INCLUDES
+#include <digia/eunit/eunitmacros.h>
+
+
+// INTERNAL INCLUDES
+#include "rtppacket.h"
+
+// Refer to RFC 1889
+// The comparison in rates between NTP timestamp and RTP timestamp.
+// A value of n means that each increment of an RTP timestamp
+// corresponds to n microseconds.
+//
+const TUint8 KRtpPayloadClockConversions[KUTRtpMaxPayloadTypes] =
+ {
+ 125, 125, 125, 125, 125, 125, 63, 125, 125, 63, // 0-9
+ 23, 23, 125, 125, 11, 125, 91, 45, 125, 0, // 10-19
+ 0, 0, 0, 0, 0, 11, 11, 0, 11, 0, // 20-29
+ 0, 11, 11, 11, 11, 0, 0, 0, 0, 0, // 30-39
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40-49
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 50-59
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60-69
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 70-79
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 80-89
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 90-99
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 100-109
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 110-119
+ 0, 0, 0, 0, 0, 0, 0, 0 // 120-127
+ };
+_LIT8(KRTPPacket1, "8001CDDD00000001DEADBEEF9206D8823BACDD");
+_LIT8(KRTPPacket2, "8101CDE000000004DEADBEEF3958B1FB3F0E");
+_LIT8(KRTPPacket3, "8101CDE000000004DEADBEEF000000003958B1FB3F0E");
+_LIT8(KRTPPacket4, "8101CDE000000004DEADBEEFFFFFFF7F3958B1FB3F0E");
+_LIT8(KRTPPacket5, "9101CDE000000004DEADBEEFFFFFFF7F3958B1FB3F0E");
+_LIT8(KRTPPacket6, "9001CDE000000004DEADBEEF");
+_LIT8(KRTPPacket7, "8A01CDE000000004DEADBEEF01010101010101010101010101010101010101010101010101010101010101010101010101010101");
+
+_LIT8(KRTCPPacket1, "80C90001DEADBEEF9E30159059A23363F0FBDB62DC85AF52875C944495C5B00280000001ABCDEF1234567890ABCDEF1234567890DFC98F01DE16DA30F20D");
+_LIT8(KRTCPPacket2, "DEADBEEF017F00003FFFFFFE9E30159059A23363F0FBDB62DC85AF52875C944495C5B00280000001ABCDEF1234567890ABCDEF1234567890DFC98F01DE16DA30F20D");
+/*
+ The RTP header has the following format:
+
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |V=2|P|X| CC |M| PT | sequence number |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | timestamp |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | synchronization source (SSRC) identifier |
+ +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+ | contributing source (CSRC) identifiers |
+ | .... |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+
+
+
+The format of an SRTP packet is illustrated in Figure 1.
+
+ 0 1 2 3
+ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+<+
+ |V=2|P|X| CC |M| PT | sequence number | |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
+ | timestamp | |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
+ | synchronization source (SSRC) identifier | |
+ +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+ |
+ | contributing source (CSRC) identifiers | |
+ | .... | |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
+ | RTP extension (OPTIONAL) | |
+ +>+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
+ | | payload ... | |
+ | | +-------------------------------+ |
+ | | | RTP padding | RTP pad count | |
+*/
+
+#define RTP_EUNIT_ASSERT_EQUALS( val1, val2 ) \
+if ( val1 == ERTCP_PACKET_ERROR ){\
+ User::Leave( KErrNoMemory );\
+ }\
+else{\
+ EUNIT_ASSERT_EQUALS( val1, val2 );\
+ }
+
+// CONSTRUCTION
+UT_CRtpPacket* UT_CRtpPacket::NewL()
+ {
+ UT_CRtpPacket* self = UT_CRtpPacket::NewLC();
+ CleanupStack::Pop();
+
+ return self;
+ }
+
+UT_CRtpPacket* UT_CRtpPacket::NewLC()
+ {
+ UT_CRtpPacket* self = new( ELeave ) UT_CRtpPacket();
+ CleanupStack::PushL( self );
+
+ self->ConstructL();
+
+ return self;
+ }
+
+// Destructor (virtual by CBase)
+UT_CRtpPacket::~UT_CRtpPacket()
+ {
+ }
+
+// Default constructor
+UT_CRtpPacket::UT_CRtpPacket()
+ {
+ }
+
+// Second phase construct
+void UT_CRtpPacket::ConstructL()
+ {
+ // The ConstructL from the base class CEUnitTestSuiteClass must be called.
+ // It generates the test case table.
+ CEUnitTestSuiteClass::ConstructL();
+ }
+
+// METHODS
+
+
+
+void UT_CRtpPacket::SetupL( )
+ {
+ for ( TUint k = 0; k < KUTRtpMaxPayloadTypes; k++ )
+ {
+ iProfileRTPTimeRates[k] = ( TUint32 ) KRtpPayloadClockConversions[k];
+ }
+
+ iPktSnd = CRtpPacket::NewL( KMaxRtpPacketSize, iProfileRTPTimeRates );
+ iPktRtcpSnd = CRtpPacket::NewL( KMaxRtcpPacketSize, iProfileRTPTimeRates );
+ //iPktSnd->SetType( ERTP );
+
+ // create test data that is 10 bytes too long than any RTP packet
+ // so that the actual length is also updated
+ iTooLongData = HBufC8::NewMaxL(KMaxRtpPacketSize + 10);
+
+
+ }
+
+void UT_CRtpPacket::Teardown( )
+ {
+ delete iPktSnd;
+ delete iPktRtcpSnd;
+ delete iTooLongData;
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_NewLL( )
+ {
+ EUNIT_ASSERT( ETrue );
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketResetL( )
+ {
+ EUNIT_ASSERT( ETrue );
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketResetPtrL( )
+ {
+ EUNIT_ASSERT( ETrue );
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketGetSSRCL( )
+ {
+ TInt result(KErrNone);
+
+ TRtpSSRC iSSRC;
+ // "Test description: --" ) );
+ // "CRtpPacket::RtpPacketProcessAppL( &streamParam, &initParam )" ));
+
+ ///////////////////////TEST CASE - ERTP///////////////////////////////////
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ iPktSnd->SetType( ERTP );
+ iSSRC = iPktSnd->RtpPacketGetSSRC();
+ ///////////////////////TEST CASE - ERTCP_HEADER//////////////////////////
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ iPktSnd->SetType( ERTCP_HEADER );
+ iSSRC = iPktSnd->RtpPacketGetSSRC();
+ ///////////////////////TEST CASE - ERTCP_SR///////////////////////////////
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ iPktSnd->SetType( ERTCP_SR );
+ iSSRC = iPktSnd->RtpPacketGetSSRC();
+ ///////////////////////TEST CASE - ERTCP_RR///////////////////////////////
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ iPktSnd->SetType( ERTCP_RR );
+ iSSRC = iPktSnd->RtpPacketGetSSRC();
+ ///////////////////////TEST CASE - ERTCP_SDES/////////////////////////////
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ iPktSnd->SetType( ERTCP_SDES );
+ iSSRC = iPktSnd->RtpPacketGetSSRC();
+ ///////////////////////TEST CASE - ERTCP_BYE//////////////////////////////
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ iPktSnd->SetType( ERTCP_BYE );
+ iSSRC = iPktSnd->RtpPacketGetSSRC();
+ ///////////////////////TEST CASE - ERTCP_APP//////////////////////////////
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ iPktSnd->SetType( ERTCP_APP );
+ iSSRC = iPktSnd->RtpPacketGetSSRC();
+ //////////////////////////////////////////////////////////////////////
+
+ ///////////////////////TEST CASE - Default//////////////////////////////
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ iPktSnd->SetType( (TRtpPacketType)-1 );
+ iSSRC = iPktSnd->RtpPacketGetSSRC();
+ //////////////////////////////////////////////////////////////////////
+
+ EUNIT_ASSERT(result == KErrNone);
+
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketGetPayloadTypeL( )
+ {
+
+ CRtpPacket* packet = CRtpPacket::NewL( 2048, iProfileRTPTimeRates );
+ TRtpPacketStreamParam aStreamParam;
+ TRtpPacketIOParam aIoParam;
+ TBuf8<10> data;
+ data.Format( _L8( "dummydata" ) );
+
+ // Set the parameters
+ aStreamParam.TRTP.SSRC = 432;
+ aStreamParam.TRTP.payload= 15;
+ aStreamParam.TRTP.seqNum = 30;
+ aStreamParam.TRTP.timeStamp = 40;
+ aIoParam.TRTP.padding = 0;
+ aIoParam.TRTP.marker = 0;
+ aIoParam.TRTP.fHeaderExtension = 0;
+ aIoParam.TRTP.numCSRC = 0;
+ aIoParam.TRTP.payloadData = const_cast<TUint8*>( data.Ptr() );
+ aIoParam.TRTP.payloadDataLen = data.Length();
+ aIoParam.TRTP.extension.type = 0;
+ aIoParam.TRTP.extension.length = 0;
+ aIoParam.TRTP.extension.data = 0;
+
+ // Build the packet
+ packet->SetType( ERTP );
+ packet->RtpPacketBuild( &aStreamParam, &aIoParam );
+ TRtpPayloadType pt= packet->RtpPacketGetPayloadType();
+ EUNIT_ASSERT(pt==15);
+
+ delete packet;
+
+
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketBuildL( )
+ {
+ TInt result(KErrNone);
+ TInt error(KErrNone);
+
+ // "Test description: build a RTP packet" ) );
+ // "CRtpPacket::RtpPacketBuildRtp( &streamParam, &initParam )" ));
+
+ ///////////////////////TEST CASE 1///////////////////////////////////
+ TRtpPacketStreamParam iStreamParam;
+ TRtpPacketIOParam iIoParam;
+ TRtpRtcpEnum eRtcpEnum(ERTCP_NO_ERROR);
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ iPktSnd->SetType( (TRtpPacketType)-1 );
+ result = iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+
+ EUNIT_ASSERT( result == ERTCP_PACKET_ERROR );
+
+
+ ///////////////////////TEST CASE 2///////////////////////////////////
+ iPktSnd->SetType( ERTP );
+
+ iStreamParam.TRTP.payload = 0;
+
+ result = iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+ eRtcpEnum = iPktSnd->RtpPacketProcessL( &iStreamParam, &iIoParam );
+
+ EUNIT_ASSERT( result == KErrNone && eRtcpEnum == ERTCP_NO_ERROR );
+
+ ////////////////////////TEST CASE 3/////////////////////////////////////////
+ /*
+ * Extension data == TRUE
+ * data length / 4 == 0
+ */
+ TBuf8<15> data;
+ data.Format( _L8( "12345678" ) );
+
+ iIoParam.TRTP.extension.data = const_cast<TUint8*>(data.Ptr());
+ iIoParam.TRTP.extension.length = data.Length();
+
+ result = iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+
+ eRtcpEnum = iPktSnd->RtpPacketProcessL( &iStreamParam, &iIoParam );
+
+ EUNIT_ASSERT( result == KErrNone && eRtcpEnum == ERTCP_NO_ERROR )
+
+ ////////////////////////TEST CASE 4/////////////////////////////////////////
+ /*
+ * data length / 4 != 0
+ */
+ data.Append( _L8( "9" ) );
+
+ iIoParam.TRTP.extension.data = const_cast<TUint8*>(data.Ptr());
+ iIoParam.TRTP.extension.length = data.Length();
+
+ result = iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+ iIoParam.TRTP.extension.data = NULL;
+ iIoParam.TRTP.extension.length = 0;
+ eRtcpEnum = iPktSnd->RtpPacketProcessL( &iStreamParam, &iIoParam );
+ if(iPktSnd->iExdataAlloc )
+ {
+ User::Free( iIoParam.TRTP.extension.data );
+ }
+ EUNIT_ASSERT( result == KErrNone && eRtcpEnum == ERTCP_NO_ERROR );
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketProcessL( )
+ {
+ TRtpRtcpEnum eRtcpEnum;
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ iPktSnd->SetType( ERTP );
+
+ TRtpPacketStreamParam iStreamParam;
+ TRtpPacketIOParam iIoParam;
+
+
+ /////////////////TEST CASE 1 (wrong version)////////////////////////////////////////
+ TUint8 version(0);
+
+ Mem::Copy(/*iPktSnd->iData*/iPktSnd->Data(), &version, 1);
+ eRtcpEnum = iPktSnd->RtpPacketProcessRtpL(&iStreamParam, &iIoParam);
+
+ EUNIT_ASSERT( eRtcpEnum == ERTCP_PACKET_ERROR )
+
+ ///////////////////////TEST CASE 2///////////////////////////////////
+ iPktSnd->RtpPacketBuildRtp(&iStreamParam, &iIoParam);
+
+ iStreamParam.TRTP.payload = 127;
+
+ iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+ eRtcpEnum = iPktSnd->RtpPacketProcessRtpL(&iStreamParam, &iIoParam);
+
+ EUNIT_ASSERT( eRtcpEnum == ERTCP_NO_ERROR )
+
+ ///////////////////////TEST CASE 3///////////////////////////////////
+ iPktSnd->RtpPacketBuildRtp(&iStreamParam, &iIoParam);
+
+ iStreamParam.TRTP.payload = 1;
+
+ iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+ eRtcpEnum = iPktSnd->RtpPacketProcessRtpL(&iStreamParam, &iIoParam);
+
+ EUNIT_ASSERT( eRtcpEnum == ERTCP_NO_ERROR )
+
+ ///////////////////////TEST CASE 4///////////////////////////////////
+ iPktSnd->RtpPacketBuildRtp(&iStreamParam, &iIoParam);
+
+ iStreamParam.TRTP.payload = ERTCP_SR;
+
+ iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+ eRtcpEnum = iPktSnd->RtpPacketProcessRtpL(&iStreamParam, &iIoParam);
+
+ EUNIT_ASSERT( eRtcpEnum == ERTCP_NO_ERROR )
+
+ ///////////////////////TEST CASE 5///////////////////////////////////
+ iPktSnd->RtpPacketBuildRtp(&iStreamParam, &iIoParam);
+
+ iStreamParam.TRTP.payload = ERTCP_RR;
+
+ iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+ eRtcpEnum = iPktSnd->RtpPacketProcessRtpL(&iStreamParam, &iIoParam);
+
+ EUNIT_ASSERT( eRtcpEnum == ERTCP_NO_ERROR )
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketProcess2L( )
+ {
+ TInt result(KErrNone);
+ TRtpRtcpEnum eRtcpEnum;
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ iPktSnd->SetType( ERTP );
+
+
+
+ TRtpPacketStreamParam iStreamParam;
+ TRtpPacketIOParam iIoParam;
+
+
+ /////////////////TEST CASE 1 (CSC number is not null)////////////////////////////////////////
+ //for the packet
+ HBufC8* rtpPacket =HBufC8::NewLC(KRTPPacket2().Length());
+ *rtpPacket=KRTPPacket2;
+ Hex(*rtpPacket);
+ TInt len= KRTPPacket2().Length();
+ rtpPacket->Des().SetLength(len/2);
+
+ iPktSnd->iData= const_cast<TUint8*>(rtpPacket->Des().Ptr());
+ //iPktSnd->SetSize(len/2);
+
+ eRtcpEnum = iPktSnd->RtpPacketProcessRtpL(&iStreamParam, &iIoParam);
+
+ EUNIT_ASSERT( eRtcpEnum == ERTCP_PACKET_ERROR )
+ CleanupStack::PopAndDestroy(rtpPacket);
+
+ ///////////////////////TEST CASE 2 (CSRC list is null)///////////////////////////////////
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+ HBufC8* rtpPacket2 =HBufC8::NewLC(KRTPPacket3().Length());
+ *rtpPacket2=KRTPPacket3;
+ Hex(*rtpPacket2);
+ TInt len2= KRTPPacket3().Length();
+ rtpPacket2->Des().SetLength(len/2);
+ iPktSnd->iData= const_cast<TUint8*>(rtpPacket2->Des().Ptr());
+ iPktSnd->SetSize(len2/2);
+ eRtcpEnum = iPktSnd->RtpPacketProcessRtpL(&iStreamParam, &iIoParam);
+ User::Free(iIoParam.TRTP.CSRCarray );
+ iIoParam.TRTP.CSRCarray = NULL;
+ EUNIT_ASSERT( eRtcpEnum == ERTCP_PACKET_ERROR )
+ CleanupStack::PopAndDestroy(rtpPacket2);
+ ///////////////////////TEST CASE 3 (CSRC list is not null)///////////////////////////////////
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+ HBufC8* rtpPacket3 =HBufC8::NewLC(KRTPPacket4().Length());
+ *rtpPacket3=KRTPPacket4;
+ Hex(*rtpPacket3);
+ TInt len3= KRTPPacket4().Length();
+ rtpPacket3->Des().SetLength(len3/2);
+ iPktSnd->iData= const_cast<TUint8*>(rtpPacket3->Des().Ptr());
+
+ iPktSnd->SetSize(len3/2);
+ eRtcpEnum = iPktSnd->RtpPacketProcessRtpL(&iStreamParam, &iIoParam);
+ User::Free(iIoParam.TRTP.CSRCarray );
+ iIoParam.TRTP.CSRCarray = NULL;
+ RTP_EUNIT_ASSERT_EQUALS(eRtcpEnum, ERTCP_NO_ERROR);
+ CleanupStack::PopAndDestroy(rtpPacket3);
+ ///////////////////////TEST CASE (CSRC listcount 10)///////////////////////////////////
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+ HBufC8* rtpPacket7 =HBufC8::NewLC(KRTPPacket7().Length());
+ *rtpPacket7=KRTPPacket7;
+ Hex(*rtpPacket7);
+ TInt len7= KRTPPacket7().Length();
+ rtpPacket7->Des().SetLength(len7/2);
+ iPktSnd->iData= const_cast<TUint8*>(rtpPacket7->Des().Ptr());
+
+ iPktSnd->SetSize(len7/2);
+ eRtcpEnum = iPktSnd->RtpPacketProcessRtpL(&iStreamParam, &iIoParam);
+
+ User::Free(iIoParam.TRTP.CSRCarray );
+ iIoParam.TRTP.CSRCarray = NULL;
+
+ RTP_EUNIT_ASSERT_EQUALS(eRtcpEnum, ERTCP_NO_ERROR);
+ CleanupStack::PopAndDestroy(rtpPacket7);
+ ///////////////////////TEST CASE 4 (header extension length not valid)///////////////////////////////////
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+ HBufC8* rtpPacket4 =HBufC8::NewLC(KRTPPacket5().Length());
+ *rtpPacket4=KRTPPacket5;
+ Hex(*rtpPacket4);
+ TInt len4= KRTPPacket5().Length();
+ rtpPacket4->Des().SetLength(len4/2);
+ iPktSnd->iData= const_cast<TUint8*>(rtpPacket4->Des().Ptr());
+
+ iPktSnd->SetSize(len4/2);
+ eRtcpEnum = iPktSnd->RtpPacketProcessRtpL(&iStreamParam, &iIoParam);
+ User::Free(iIoParam.TRTP.CSRCarray );
+ iIoParam.TRTP.CSRCarray = NULL;
+ EUNIT_ASSERT( eRtcpEnum == ERTCP_PACKET_ERROR )
+ CleanupStack::PopAndDestroy(rtpPacket4);
+
+ ///////////////////////TEST CASE 5 (header extension length is true but no header extension to read)
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+ HBufC8* rtpPacket5 =HBufC8::NewLC(KRTPPacket6().Length());
+ *rtpPacket5=KRTPPacket6;
+ Hex(*rtpPacket5);
+ TInt len5= KRTPPacket6().Length();
+ rtpPacket5->Des().SetLength(len5/2);
+ iPktSnd->iData= const_cast<TUint8*>(rtpPacket5->Des().Ptr());
+
+ iPktSnd->SetSize(len5/2);
+ eRtcpEnum = iPktSnd->RtpPacketProcessRtpL(&iStreamParam, &iIoParam);
+ User::Free(iIoParam.TRTP.CSRCarray );
+ iIoParam.TRTP.CSRCarray = NULL;
+ EUNIT_ASSERT( eRtcpEnum == ERTCP_PACKET_ERROR )
+ CleanupStack::PopAndDestroy(rtpPacket5);
+
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_RtcpPacketBuildL( )
+ {
+ TInt result(KErrNone);
+ TInt error(KErrNone);
+ TRtpRtcpEnum eRtcpEnum;
+
+
+ // "Test description: --" ) );
+ // "CRtpPacket::RtpPacketBuildRtcp( &streamParam, &initParam )" ));
+
+ ///////////////////////TEST CASE 1///////////////////////////////////
+ TRtpPacketStreamParam iStreamParam;
+ TRtpPacketIOParam iIoParam;
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ iPktSnd->SetType( ERTCP_HEADER );
+ iIoParam.TRTCP_HEADER.pt = ERTCP_SR ;
+ result = iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+ iPktSnd->RtpPacketResetPtr();
+ //Can not process rtcp packet because if it is not rtcp type rr/sr..
+ iIoParam.TRTCP_HEADER.pt = ERTCP_SR ;
+ eRtcpEnum = iPktSnd->RtpPacketProcessL( &iStreamParam, &iIoParam );
+
+ EUNIT_ASSERT(result == KErrNone && eRtcpEnum == KErrNone);
+ // "TEST CASE 1 - passed" ));
+
+ ///////////////////////TEST CASE 2////////////////////////////////////
+ iIoParam.TRTCP_HEADER.pt = ERTCP_RR;
+ iIoParam.TRTCP_HEADER.sourceCount = 0;
+
+ result = iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+ iPktSnd->RtpPacketResetPtr();
+ eRtcpEnum = iPktSnd->RtpPacketProcessL( &iStreamParam, &iIoParam );
+
+ EUNIT_ASSERT(result == KErrNone && eRtcpEnum == KErrNone);
+
+ }
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketBuildAppL()
+ {
+ TInt result(KErrNone);
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ // "Test description: --" ) );
+ // "CRtpPacket::RtpPacketBuildApp( &streamParam, &initParam )" ));
+
+ ///////////////////////TEST CASE 1///////////////////////////////////
+ TRtpPacketStreamParam iStreamParam;
+ TRtpPacketIOParam iIoParam;
+
+ iPktSnd->SetType( ERTCP_APP );
+ result = iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+ EUNIT_ASSERT(result==KErrNone);
+
+ //CRASH !!!
+ TRtpRtcpEnum eRtcpEnum = iPktSnd->RtpPacketProcessAppL(&iStreamParam, &iIoParam);
+ EUNIT_ASSERT(eRtcpEnum==ERTCP_PACKET_ERROR);
+ }
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketBuildByeL()
+ {
+ TInt result(KErrNone);
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ //Create an empty line
+ //""));
+ // "Test description: --" ) );
+ // "CRtpPacket::RtpPacketBuildBye( &streamParam, &initParam )" ));
+
+ //Add test cases
+
+ ///////////////////////TEST CASE 1///////////////////////////////////
+ TRtpPacketStreamParam streamParam;
+ TRtpPacketIOParam initParam;
+
+ iPktSnd->SetType( ERTCP_BYE );
+ result = iPktSnd->RtpPacketBuild( &streamParam, &initParam );
+ EUNIT_ASSERT(result==KErrNone);
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketBuildRRL()
+ {
+ TInt result(KErrNone);
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ //Create an empty line
+ //""));
+ // "Test description: --" ) );
+ // "CRtpPacket::RtpPacketBuildRr( &streamParam, &initParam )" ));
+
+ ///////////////////////TEST CASE 1///////////////////////////////////
+ TRtpPacketStreamParam streamParam;
+ TRtpPacketIOParam initParam;
+
+ iPktSnd->SetType( ERTCP_RR );
+ result = iPktSnd->RtpPacketBuild( &streamParam, &initParam );
+
+ ///////////////////////////////////////////////////////////////////////
+ EUNIT_ASSERT(result == KErrNone);
+ }
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketBuildSRL()
+ {
+ TInt result(KErrNone);
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ ///////////////////////TEST CASE 1///////////////////////////////////
+ TRtpPacketStreamParam iStreamParam;
+ TRtpPacketIOParam iIoParam;
+
+ iPktSnd->SetType( ERTCP_SR );
+ result = iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+
+ ///////////////////////////////////////////////////////////////////////
+ EUNIT_ASSERT(result == KErrNone);
+
+ }
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketBuildSDESL()
+ {
+ TInt result(KErrNone);
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ //Create an empty line
+ //""));
+ // "Test description: --" ) );
+ // "CRtpPacket::RtpPacketBuildSdes( &streamParam, &initParam )" ));
+
+ ///////////////////////TEST CASE 1///////////////////////////////////
+ TRtpPacketStreamParam iStreamParam;
+ TRtpPacketIOParam iIoParam;
+
+ iPktSnd->SetType( ERTCP_SDES );
+ result = iPktSnd->RtpPacketBuild( &iStreamParam, &iIoParam );
+
+ ///////////////////////////////////////////////////////////////////////
+ EUNIT_ASSERT(result == KErrNone);
+ }
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketProcessAppL()
+ {
+ TInt result(KErrNone);
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ TRtpPacketStreamParam iStreamParam;
+ TRtpPacketIOParam iIoParam;
+
+ //""));
+ // "Test description: --" ) );
+ // "CRtpPacket::RtpPacketProcessAppL( &streamParam, &initParam )" ));
+
+ ///////////////////////TEST CASE 1///////////////////////////////////
+ TRtpRtcpEnum eRtcpEnum = iPktSnd->RtpPacketProcessAppL(&iStreamParam, &iIoParam);
+ EUNIT_ASSERT(eRtcpEnum == ERTCP_PACKET_ERROR);
+
+ ///////////////////////TEST CASE 2///////////////////////////////////
+
+ HBufC8* rtcpPacket =HBufC8::NewLC(KRTCPPacket1().Length());
+ *rtcpPacket=KRTCPPacket1;
+ Hex(*rtcpPacket);
+ TInt len= KRTCPPacket1().Length();
+ rtcpPacket->Des().SetLength(len/2);
+
+ iPktSnd->iData= const_cast<TUint8*>(rtcpPacket->Des().Ptr());
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+ iPktSnd->SetSize(len/2);
+
+ iStreamParam.TRTCP_APP.totalPacketLen=len/2;
+ eRtcpEnum = iPktSnd->RtpPacketProcessAppL(&iStreamParam, &iIoParam);
+ User::Free(iIoParam.TRTCP_APP.appData);
+ RTP_EUNIT_ASSERT_EQUALS( eRtcpEnum, ERTCP_NO_ERROR )
+ CleanupStack::PopAndDestroy(rtcpPacket);
+ }
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketProcessByeL()
+ {
+ TInt result(KErrNone);
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ // "CRtpPacket::RtpPacketProcessBye( &streamParam, &initParam )" ));
+
+ ///////////////////////TEST CASE 1///////////////////////////////////
+ TRtpPacketStreamParam iStreamParam;
+ TRtpPacketIOParam iIoParam;
+
+ TRtpRtcpEnum eRtcpEnum = iPktSnd->RtpPacketProcessByeL(&iStreamParam, &iIoParam);
+ //////////////////////////////////////////////////////////////////////
+ RTP_EUNIT_ASSERT_EQUALS(eRtcpEnum, ERTCP_NO_ERROR);
+ User::Free(iIoParam.TRTCP_BYE.reason);
+ EUNIT_ASSERT(result == KErrNone);
+ }
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketProcessSRL()
+ {
+ TInt result(KErrNone);
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ //""));
+ // "Test description: --" ) );
+ // "CRtpPacket::RtpPacketProcessSr( &streamParam, &initParam )" ));
+
+ ///////////////////////TEST CASE 1///////////////////////////////////
+ TRtpPacketStreamParam iStreamParam;
+ TRtpPacketIOParam iIoParam;
+
+ TRtpRtcpEnum eRtcpEnum = iPktSnd->RtpPacketProcessSr(&iStreamParam, &iIoParam);
+ //////////////////////////////////////////////////////////////////////
+ EUNIT_ASSERT(result == KErrNone);
+ }
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketProcessRRL()
+ {
+ TInt result(KErrNone);
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ //""));
+ // "Test description: --" ) );
+ // "CRtpPacket::RtpPacketProcessRr( &streamParam, &initParam )" ));
+
+ ///////////////////////TEST CASE 1///////////////////////////////////
+ TRtpPacketStreamParam iStreamParam;
+ TRtpPacketIOParam iIoParam;
+
+ TRtpRtcpEnum eRtcpEnum = iPktSnd->RtpPacketProcessRr(&iStreamParam, &iIoParam);
+ //////////////////////////////////////////////////////////////////////
+ EUNIT_ASSERT(result == KErrNone);
+ }
+void UT_CRtpPacket::UT_CRtpPacket_RtpPacketProcessSDESL()
+ {
+ TInt result(KErrNone);
+
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+
+ //""));
+ // "Test description: --" ) );
+ // "CRtpPacket::RtpPacketProcessSdes( &streamParam, &initParam )" ));
+
+ ///////////////////////TEST CASE 1///////////////////////////////////
+ TRtpPacketStreamParam iStreamParam;
+ TRtpPacketIOParam iIoParam;
+
+ TRtpRtcpEnum eRtcpEnum = iPktSnd->RtpPacketProcessSdesL(&iStreamParam, &iIoParam);
+ //////////////////////////////////////////////////////////////////////
+ TInt index( 0 );
+ for ( index = 0; index < ERTCP_NUM_OF_SDES_ITEMS; index++ )
+ {
+ if(iIoParam.TRTCP_SDES.sdesItems[index] != NULL )
+ {
+ User::Free( iIoParam.TRTCP_SDES.sdesItems[index] );
+ iIoParam.TRTCP_SDES.sdesItems[index] = NULL;
+ }
+ iIoParam.TRTCP_SDES.sdesItemsSize[index] = 0;
+ }
+ RTP_EUNIT_ASSERT_EQUALS(eRtcpEnum, ERTCP_NO_ERROR);
+
+ ///////////////////////TEST CASE 2///////////////////////////////////
+ HBufC8* rtcpPacket2 =HBufC8::NewLC(KRTCPPacket2().Length());
+ *rtcpPacket2=KRTCPPacket2;
+ Hex(*rtcpPacket2);
+ TInt len= KRTCPPacket2().Length();
+ rtcpPacket2->Des().SetLength(len/2);
+ iPktSnd->iData= const_cast<TUint8*>(rtcpPacket2->Des().Ptr());
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+ iPktSnd->SetSize(len/2);
+
+
+ eRtcpEnum = iPktSnd->RtpPacketProcessSdesL(&iStreamParam, &iIoParam);
+
+ for ( index = 0; index < ERTCP_NUM_OF_SDES_ITEMS; index++ )
+ {
+ if(iIoParam.TRTCP_SDES.sdesItems[index] != NULL )
+ {
+ User::Free( iIoParam.TRTCP_SDES.sdesItems[index] );
+ iIoParam.TRTCP_SDES.sdesItems[index] = NULL;
+ }
+ iIoParam.TRTCP_SDES.sdesItemsSize[index] = 0;
+ }
+ CleanupStack::PopAndDestroy( rtcpPacket2 );
+
+ RTP_EUNIT_ASSERT_EQUALS(eRtcpEnum, ERTCP_NO_ERROR);
+
+ ///////////////////////TEST CASE 3///////////////////////////////////
+ HBufC8* rtcpPacket =HBufC8::NewLC(KRTCPPacket1().Length());
+ *rtcpPacket=KRTCPPacket1;
+ Hex(*rtcpPacket);
+ len= KRTCPPacket1().Length();
+ rtcpPacket->Des().SetLength(len/2);
+ iPktSnd->iData= const_cast<TUint8*>(rtcpPacket->Des().Ptr());
+ iPktSnd->RtpPacketReset();
+ iPktSnd->RtpPacketResetPtr();
+ iPktSnd->SetSize(len/2);
+
+ iStreamParam.TRTCP_APP.totalPacketLen=len/2;
+ eRtcpEnum = iPktSnd->RtpPacketProcessSdesL(&iStreamParam, &iIoParam);
+ User::Free(iIoParam.TRTCP_APP.appData);
+
+ for ( index = 0; index < ERTCP_NUM_OF_SDES_ITEMS; index++ )
+ {
+ if(iIoParam.TRTCP_SDES.sdesItems[index] != NULL )
+ {
+ User::Free( iIoParam.TRTCP_SDES.sdesItems[index] );
+ iIoParam.TRTCP_SDES.sdesItems[index] = NULL;
+ }
+ iIoParam.TRTCP_SDES.sdesItemsSize[index] = 0;
+ }
+ CleanupStack::PopAndDestroy(rtcpPacket);
+
+ RTP_EUNIT_ASSERT_EQUALS( eRtcpEnum, ERTCP_NO_ERROR )
+ }
+void UT_CRtpPacket::UT_CRtpPacket_SetSizeL( )
+ {
+ iPktSnd->SetSize( iPktSnd->Size() );
+ EUNIT_ASSERT(iPktSnd->iSize==iPktSnd->Size())
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_SetTypeL( )
+ {
+ EUNIT_ASSERT( ETrue );
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_SizeL( )
+ {
+ EUNIT_ASSERT( ETrue );
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_DataL( )
+ {
+ TUint8* iData = iPktSnd->Data();
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_GetHBufL( )
+ {
+ HBufC8* iHBufC8 = iPktSnd->GetHBuf();
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_TypeL( )
+ {
+ TRtpPacketType iPacketType = iPktSnd->Type();
+ }
+
+void UT_CRtpPacket::UT_CRtpPacket_DesL( )
+ {
+ TPtrC8 iDes = iPktSnd->Des();
+ }
+
+void UT_CRtpPacket::Hex(HBufC8& aString)
+{
+ TPtr8 ptr=aString.Des();
+ TInt length = aString.Length();
+ if (aString.Length()%2)
+ {
+ ptr.SetLength(0);
+ return;
+ }
+ TInt i;
+ for (i=0;i<aString.Length();i+=2)
+ {
+ TUint8 tmp;
+ tmp=(TUint8)(aString[i]-(aString[i]>'9'?('A'-10):'0'));
+ tmp*=16;
+ tmp|=(TUint8)(aString[i+1]-(aString[i+1]>'9'?('A'-10):'0'));
+ ptr[i/2]=tmp;
+ }
+ ptr.SetLength(aString.Length()/2);
+
+}
+
+// TEST TABLE
+
+EUNIT_BEGIN_TEST_TABLE(
+ UT_CRtpPacket,
+ "CRtpPacket",
+ "UNIT" )
+
+EUNIT_TEST(
+ "NewL - test ",
+ "CRtpPacket",
+ "NewL",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_NewLL, Teardown)
+
+EUNIT_TEST(
+ "RtpPacketReset - test ",
+ "CRtpPacket",
+ "RtpPacketReset",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketResetL, Teardown)
+
+EUNIT_TEST(
+ "RtpPacketResetPtr - test ",
+ "CRtpPacket",
+ "RtpPacketResetPtr",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketResetPtrL, Teardown)
+
+EUNIT_TEST(
+ "RtpPacketGetSSRC - test ",
+ "CRtpPacket",
+ "RtpPacketGetSSRC",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketGetSSRCL, Teardown)
+
+EUNIT_TEST(
+ "RtpPacketGetPayloadType - test ",
+ "CRtpPacket",
+ "RtpPacketGetPayloadType",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketGetPayloadTypeL, Teardown)
+
+EUNIT_TEST(
+ "RtpPacketBuild - test ",
+ "CRtpPacket",
+ "RtpPacketBuild",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketBuildL, Teardown)
+EUNIT_TEST(
+ "RtcpPacketBuild - test ",
+ "CRtpPacket",
+ "RtcpPacketBuild",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtcpPacketBuildL, Teardown)
+EUNIT_TEST(
+ "RtpPacketBuildApp - test ",
+ "CRtpPacket",
+ "RtpPacketBuildApp",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketBuildAppL, Teardown)
+EUNIT_TEST(
+ "RtpPacketProcessApp - test ",
+ "CRtpPacket",
+ "RtpPacketProcessApp",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketProcessAppL, Teardown)
+EUNIT_TEST(
+ "RtpPacketBuildBye - test ",
+ "CRtpPacket",
+ "RtpPacketBuildBye",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketBuildByeL, Teardown)
+EUNIT_TEST(
+ "RtpPacketProcessBye - test ",
+ "CRtpPacket",
+ "RtpPacketProcessBye",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketProcessByeL, Teardown)
+
+EUNIT_TEST(
+ "RtpPacketBuildSR - test ",
+ "CRtpPacket",
+ "RtpPacketBuildSR",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketBuildSRL, Teardown)
+EUNIT_TEST(
+ "RtpPacketProcessSR - test ",
+ "CRtpPacket",
+ "RtpPacketProcessSR",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketProcessSRL, Teardown)
+
+EUNIT_TEST(
+ "RtpPacketBuildRR - test ",
+ "CRtpPacket",
+ "RtpPacketBuildRR",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketBuildRRL, Teardown)
+EUNIT_TEST(
+ "RtpPacketProcessRR - test ",
+ "CRtpPacket",
+ "RtpPacketProcessRR",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketProcessRRL, Teardown)
+
+EUNIT_TEST(
+ "RtpPacketBuildApp - test ",
+ "CRtpPacket",
+ "RtpPacketBuildApp",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketBuildSDESL, Teardown)
+EUNIT_TEST(
+ "RtpPacketProcessSDES - test ",
+ "CRtpPacket",
+ "RtpPacketProcessSDES",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketProcessSDESL, Teardown)
+
+
+
+EUNIT_TEST(
+ "RtpPacketProcess - test ",
+ "CRtpPacket",
+ "RtpPacketProcess",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketProcessL, Teardown)
+
+EUNIT_TEST(
+ "SetSize - test ",
+ "CRtpPacket",
+ "SetSize",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_SetSizeL, Teardown)
+
+EUNIT_TEST(
+ "SetType - test ",
+ "CRtpPacket",
+ "SetType",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_SetTypeL, Teardown)
+
+EUNIT_TEST(
+ "Size - test ",
+ "CRtpPacket",
+ "Size",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_SizeL, Teardown)
+
+EUNIT_TEST(
+ "Data - test ",
+ "CRtpPacket",
+ "Data",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_DataL, Teardown)
+
+EUNIT_TEST(
+ "GetHBuf - test ",
+ "CRtpPacket",
+ "GetHBuf",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_GetHBufL, Teardown)
+
+EUNIT_TEST(
+ "Type - test ",
+ "CRtpPacket",
+ "Type",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_TypeL, Teardown)
+
+EUNIT_TEST(
+ "Des - test ",
+ "CRtpPacket",
+ "Des",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_DesL, Teardown)
+
+EUNIT_TEST(
+ "RtpPacketProcess2L ",
+ "CRtpPacket",
+ "RtpPacketProcess2L",
+ "FUNCTIONALITY",
+ SetupL, UT_CRtpPacket_RtpPacketProcess2L, Teardown)
+
+EUNIT_END_TEST_TABLE
+
+// END OF FILE