/*

* 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_CRtpStream.h"

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

//  INTERNAL INCLUDES

#include "rtpstream.h"

const TUint8 KRtpPayloadClockConversions[KRtpMaxPayloadTypes] =

    {

    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

    };

const TInt KExtType( 2 );

const TInt KExtLength( 4 );

_LIT8( KExtData, "extD\0" );

_LIT8(KRTPPacket, "8180CDE000000004DEADBEEFFFFFFF7F3958B1FB3F0E");

// CONSTRUCTION

UT_CRtpStream* UT_CRtpStream::NewL()

    {

    UT_CRtpStream* self = UT_CRtpStream::NewLC();

    CleanupStack::Pop();

    return self;

    }

UT_CRtpStream* UT_CRtpStream::NewLC()

    {

    UT_CRtpStream* self = new( ELeave ) UT_CRtpStream();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

UT_CRtpStream::~UT_CRtpStream()

    {

    }

// Default constructor

UT_CRtpStream::UT_CRtpStream()

    {

    }

// Second phase construct

void UT_CRtpStream::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CRtpStream::SetupL(  )

    {

   TRtpPayloadType payloadType( 0 );

    for ( TUint k = 0; k < KRtpMaxPayloadTypes; k++ )

        {

        iProfileRTPTimeRates[k] = ( TUint32 ) KRtpPayloadClockConversions[k];

        }

    iObs = this;

    iRecvStream = CRtpRecvStream::NewL( payloadType,

                                        1, // sessionId

                                        2, // rcvstreamid

                                        &iObs,

                                        this,

                                        iProfileRTPTimeRates,

                                        this );

    iTranStream = CRtpTranStream::NewL( payloadType,

                                        1, // sessionId

                                        3, // transtreamid

                                        1000, // SSRC

                                        this,

                                        iProfileRTPTimeRates );

    iExpectingExtensionPacket = EFalse;

    }

void UT_CRtpStream::Teardown(  )

    {

    delete iRecvStream;

    delete iTranStream;

    }

void UT_CRtpStream::UT_CRtpStream_ResetStreamStatL(  )

    {

   // RECEIVE STREAM

    // "Test description: Test the reset of statistics" ) );

    // "CRtpRecvStream::ResetStreamStat()" ) );

    // Create some arbitrary data

    iRecvStream->iNumReceivedPackets = 45;

    iRecvStream->iNumWrapAround = 3;

    iRecvStream->iSyncJitter.iLastPacketR = 45;

    iRecvStream->iSyncJitter.iLastPacketS = 45;

    iRecvStream->iSyncJitter.iJitterTime = 45;

    iRecvStream->iSyncJitter.iWaitTime = 45;

    iRecvStream->iRtcpStats.iRtcpReceiverStats.iFractionLost = 45;

    iRecvStream->iRtcpStats.iRtcpReceiverStats.iCumNumPacketsLost = 45;

    iRecvStream->iRtcpStats.iRtcpReceiverStats.iSeqNumReceived = 45;

    iRecvStream->iRtcpStats.iRtcpReceiverStats.iArrivalJitter = 45;

    iRecvStream->iRtcpStats.iRtcpReceiverStats.iRoundTripDelay = 45;

    iRecvStream->iRtcpStats.iRtcpReceiverStats.iBandwidth = 45;

    iRecvStream->iRtcpStats.iRtcpReceiverStats.iTxBandwidth = 45;

    iRecvStream->iRtcpStats.iRtcpReceiverStats.iChannelBufferSize = 45;

    // Do the reset

    iRecvStream->ResetStreamStat();

    // Check the results

    if ( iRecvStream->iNumReceivedPackets != 0 ||

         iRecvStream->iNumWrapAround != 0 ||

         iRecvStream->iSyncJitter.iLastPacketR != 0 ||

         iRecvStream->iSyncJitter.iLastPacketS != 0 ||

         iRecvStream->iSyncJitter.iJitterTime != 0 ||

         iRecvStream->iSyncJitter.iWaitTime != 0 ||

         iRecvStream->iRtcpStats.iRtcpReceiverStats.iFractionLost != 0 ||

         iRecvStream->iRtcpStats.iRtcpReceiverStats.iCumNumPacketsLost != 0 ||

         iRecvStream->iRtcpStats.iRtcpReceiverStats.iSeqNumReceived != 0 ||

         iRecvStream->iRtcpStats.iRtcpReceiverStats.iArrivalJitter != 0 ||

         iRecvStream->iRtcpStats.iRtcpReceiverStats.iRoundTripDelay != 0 ||

         iRecvStream->iRtcpStats.iRtcpReceiverStats.iChannelBufferSize != 0 ||

         // maintain the bandwidth information

         iRecvStream->iRtcpStats.iRtcpReceiverStats.iBandwidth != 45 ||

         iRecvStream->iRtcpStats.iRtcpReceiverStats.iTxBandwidth != 45 )

        {

        // "Values incorrectly reset" ) );

        // "CRtpRecvStream:ResetStreamStat() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else         

        {

        EUNIT_ASSERT(ETrue);

        }

    // TRANSMIT STREAM

    // "Test description: Test the reset of statistics" ) );

    // "CRtpTranStream::ResetStreamStat()" ) );

    // Create some arbitrary data

    iTranStream->iRtcpStats.iRtcpSenderStats.iNumPacketsSent = 1;

    iTranStream->iRtcpStats.iRtcpSenderStats.iCumNumOctetsSent = 2;

    iTranStream->iRtcpStats.iRtcpSenderStats.iNTPTimeStampSec = 3;

    iTranStream->iRtcpStats.iRtcpSenderStats.iNTPTimeStampFrac = 4;

    iTranStream->iRtcpStats.iRtcpSenderStats.iTimeStamp = 5;

    iTranStream->iFlagSentRTPPackets = 6;

    iTranStream->iFSentRtcpReport = 7;

    iTranStream->iCumNumOctetsSent = 8;

    iTranStream->iCumNumOctetsSent_last = 9;

    iTranStream->iPreviousTime = 10;

    iTranStream->iPreviousRemoteSN = 11;

    iTranStream->iRemoteBandwidth = 13;

    iTranStream->iSeqNumCycles = 14;

    iTranStream->iSN_size[0] = 15;

    iTranStream->iSN_size[1] = 16;

    // Do the reset

    iTranStream->ResetStreamStat();

    // Check the results

    if ( iTranStream->iFlagSentRTPPackets != 0 ||

         iTranStream->iFSentRtcpReport != 0 ||

         iTranStream->iCumNumOctetsSent != 0 ||

         iTranStream->iCumNumOctetsSent_last != 0 ||

         iTranStream->iPreviousTime != 0 ||

         iTranStream->iPreviousRemoteSN != 0 ||

         iTranStream->iSeqNumCycles != 0 ||

         iTranStream->iSN_size[0] != 0 ||

         iTranStream->iSN_size[1] != 0 ||

         iTranStream->iRtcpStats.iRtcpSenderStats.iNumPacketsSent != 0 ||

         iTranStream->iRtcpStats.iRtcpSenderStats.iCumNumOctetsSent != 0 ||

         iTranStream->iRtcpStats.iRtcpSenderStats.iNTPTimeStampSec != 0 ||

         iTranStream->iRtcpStats.iRtcpSenderStats.iNTPTimeStampFrac != 0 ||

         iTranStream->iRtcpStats.iRtcpSenderStats.iTimeStamp != 0 ||

         // Preserve bandwidth information

         iTranStream->iRemoteBandwidth != 13 )

        {

        // "Values incorrectly reset" ) );

        // "CRtpTranStream:ResetStreamStat() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else         

        {

        EUNIT_ASSERT(ETrue);

        }

    }

void UT_CRtpStream::UT_CRtpStream_FirstPkgL(  )

    {

    // THESE ARE THE GETTERS AND SETTERS OF CRtpStream, THE BASE CLASS

    // "Test description: Testing getters and setters" ) );

    // "CRtpStream::SetFirstPkg( TBool )" ) );

    // Store the previous value

    TBool tempBool( iRecvStream->iFlagFirstPkg );

    // Initialise it

    iRecvStream->iFlagFirstPkg = EFalse;

    // Use the function

    iRecvStream->SetFirstPkg( ETrue );

    // Run the test

    if ( iRecvStream->iFlagFirstPkg == EFalse )

        {

        // "Setter did not update member value" ) );

        // "CRtpStream::SetFirstPkg() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else

        {

        EUNIT_ASSERT(ETrue);

        }

    // "CRtpStream::FirstPkg()" ) );

    // Set it

    iRecvStream->iFlagFirstPkg = ETrue;

    // Run the test

    if ( !iRecvStream->FirstPkg() )

        {

        // "Invalid return value" ) );

        // "CRtpStream::FirstPkg() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else

        {

       	EUNIT_ASSERT(ETrue);

        }

    // Restore the previous value

    iRecvStream->iFlagFirstPkg = tempBool;

    ///////////////////////////////////////////////////////////

    // "CRtpStream::SetLocalSSRC( TRtpSSRC )" ) );

    // Store the previous value

    TRtpSSRC tempSSRC( iRecvStream->iLocalSSRC );

    // Initialise it

    iRecvStream->iLocalSSRC = 12;

    // Use the function

    iRecvStream->SetLocalSSRC( 13 );

    // Run the test

    if ( iRecvStream->iLocalSSRC != 13 )

        {

        // "Setter did not update member value" ) );

        // "CRtpStream::SetLocalSSRC() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else

        {

        EUNIT_ASSERT(ETrue);

        }

    // "CRtpStream::GetLocalSSRC()" ) );

    // Initialise it

    iRecvStream->iLocalSSRC = 14;

    // Run the test

    if ( iRecvStream->GetLocalSSRC() != 14 )

        {

        // "Invalid return value" ) );

        // "CRtpStream::GetLocalSSRC() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else

        {

        EUNIT_ASSERT(ETrue);

        }

    // Restore the previous value

    iRecvStream->iLocalSSRC = tempSSRC;

    ///////////////////////////////////////////////////////////

    // "CRtpStream::GetStreamID()" ) );

    // Store the previous value

    TRtpId tempId( iRecvStream->iStreamId );

    // Initialise it

    iRecvStream->iStreamId = 20;

    // Run the test

    if ( iRecvStream->GetStreamID() != 20 )

        {

        // "Invalid return value" ) );

        // "CRtpStream::GetStreamID() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else

        {

        EUNIT_ASSERT(ETrue);

        }

    // Restore the previous value

    iRecvStream->iStreamId = tempId;

    ///////////////////////////////////////////////////////////

    // "CRtpStream::RtcpStats( TRtcpStats )" ) );

    // Store the previous value

    TRtcpStats tempStats( iRecvStream->iRtcpStats );

    TRtcpStats stats;

    TRtcpReceiverStats recvStats;

    TRtcpSenderStats sendStats;

    recvStats.iArrivalJitter = 1;

    recvStats.iBandwidth = 2;

    recvStats.iChannelBufferSize = 3;

    recvStats.iCumNumPacketsLost = 4;

    recvStats.iFractionLost = 5;

    recvStats.iRoundTripDelay = 6;

    recvStats.iSeqNumReceived = 7;

    recvStats.iSSRC = 8;

    recvStats.iTxBandwidth = 9;

    sendStats.iCumNumOctetsSent = 10;

    sendStats.iNTPTimeStampFrac = 11;

    sendStats.iNTPTimeStampSec = 12;

    sendStats.iNumPacketsSent = 13;

    sendStats.iSSRC = 14;

    sendStats.iTimeStamp = 15;

    stats.iRtcpReceiverStats = recvStats;

    stats.iRtcpSenderStats = sendStats;

    // Set the stats

    iRecvStream->iRtcpStats = stats;

    // Get the stats (function under test)

    TRtcpStats compareStats;

    iRecvStream->RtcpStats( compareStats );

    // Compare

    if ( compareStats.iRtcpReceiverStats.iArrivalJitter != stats.iRtcpReceiverStats.iArrivalJitter ||

         compareStats.iRtcpReceiverStats.iBandwidth != stats.iRtcpReceiverStats.iBandwidth ||

         compareStats.iRtcpReceiverStats.iChannelBufferSize != stats.iRtcpReceiverStats.iChannelBufferSize ||

         compareStats.iRtcpReceiverStats.iCumNumPacketsLost != stats.iRtcpReceiverStats.iCumNumPacketsLost ||

         compareStats.iRtcpReceiverStats.iFractionLost != stats.iRtcpReceiverStats.iFractionLost ||

         compareStats.iRtcpReceiverStats.iRoundTripDelay != stats.iRtcpReceiverStats.iRoundTripDelay ||

         compareStats.iRtcpReceiverStats.iSeqNumReceived != stats.iRtcpReceiverStats.iSeqNumReceived ||

         compareStats.iRtcpReceiverStats.iSSRC != stats.iRtcpReceiverStats.iSSRC ||

         compareStats.iRtcpReceiverStats.iTxBandwidth != stats.iRtcpReceiverStats.iTxBandwidth ||

         compareStats.iRtcpSenderStats.iCumNumOctetsSent != stats.iRtcpSenderStats.iCumNumOctetsSent ||

         compareStats.iRtcpSenderStats.iNTPTimeStampFrac != stats.iRtcpSenderStats.iNTPTimeStampFrac ||

         compareStats.iRtcpSenderStats.iNTPTimeStampSec != stats.iRtcpSenderStats.iNTPTimeStampSec ||

         compareStats.iRtcpSenderStats.iNumPacketsSent != stats.iRtcpSenderStats.iNumPacketsSent ||

         compareStats.iRtcpSenderStats.iSSRC != stats.iRtcpSenderStats.iSSRC ||

         compareStats.iRtcpSenderStats.iTimeStamp != stats.iRtcpSenderStats.iTimeStamp )

        {

        // "Invalid return value" ) );

        // "CRtpStream::RtcpStats() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else

        {

        EUNIT_ASSERT(ETrue);

        }

    ///////////////////////////////////////////////////////////

    // THESE ARE THE GETTERS AND SETTERS OF CRtpRecvStream

    // "CRtpRecvStream::SetReceivedRTPPackets( TRtpSSRC )" ) );

    // Store the previous value

    TBool tempFlag( iRecvStream->iFlagReceivedRTPPackets );

    // Initialise it

    iRecvStream->iFlagReceivedRTPPackets = EFalse;

    // Use the function

    iRecvStream->SetReceivedRTPPackets( ETrue );

    // Run the test

    if ( !iRecvStream->iFlagReceivedRTPPackets )

        {

        // "Setter did not update member value" ) );

        // "CRtpRecvStream::SetReceivedRTPPackets() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else

        {

        EUNIT_ASSERT(ETrue);

        }

    // "CRtpRecvStream::ReceivedRTPPackets()" ) );

    // Initialise it

    iRecvStream->iFlagReceivedRTPPackets = ETrue;

    // Run the test

    if ( !iRecvStream->ReceivedRTPPackets() )

        {

        // "Invalid return value" ) );

        // "CRtpRecvStream::ReceivedRTPPackets() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else

        {

        // "CRtpRecvStream::ReceivedRTPPackets() - passed" ) );

        }

    // Restore the previous value

    iRecvStream->iFlagReceivedRTPPackets = tempFlag;

    ///////////////////////////////////////////////////////////

    // THESE ARE THE GETTERS AND SETTERS OF CRtpTranStream

    // "CRtpTranStream::SetSentRTPPackets( TBool )" ) );

    // Store the previous value

    tempFlag = iTranStream->iFlagSentRTPPackets;

    // Initialise it

    iTranStream->iFlagSentRTPPackets = EFalse;

    // Use the function

    iTranStream->SetSentRTPPackets( ETrue );

    // Run the test

    if ( !iTranStream->iFlagSentRTPPackets )

        {

        // "Setter did not update member value" ) );

        // "CRtpTranStream::SetSentRTPPackets() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else

        {

        EUNIT_ASSERT(ETrue);

        }

    // "CRtpTranStream::SentRTPPackets()" ) );

    // Initialise it

    iTranStream->iFlagSentRTPPackets = ETrue;

    // Run the test

    if ( !iTranStream->SentRTPPackets() )

        {

        // "Invalid return value" ) );

        // "CRtpTranStream::SentRTPPackets() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else

        {

        EUNIT_ASSERT(ETrue);

        }

    // Restore the previous value

    iTranStream->iFlagSentRTPPackets = tempFlag;

    // "CRtpTranStream::SetRtcpReportFlag( TBool )" ) );

    // Store the previous value

    tempFlag = iTranStream->iFSentRtcpReport;

    // Initialise it

    iTranStream->iFSentRtcpReport = EFalse;

    // Use the function

    iTranStream->SetRtcpReportFlag();

    // Run the test

    if ( !iTranStream->iFSentRtcpReport )

        {

        // "Setter did not update member value" ) );

        // "CRtpTranStream::SetRtcpReportFlag() - FAILED" ) );

        EUNIT_ASSERT(EFalse);

        }

    else

        {

        // "CRtpTranStream::SetRtcpReportFlag() - passed" ) );

        }

    // "CRtpTranStream::ResetRtcpReportFlag()" ) );