/*
* 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;
    
	iPktSnd = NULL;
	iPktRtcpSnd = NULL;
	iTooLongData = NULL;
	
	}

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