/*

* 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());