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

//  EXTERNAL INCLUDES
#include <digia/eunit/EUnitMacros.h>
#include "rtpheader.h"

// CONSTANTS

const TInt KMaxQueueSize = 30; // KMccMaxSendQueueSize
const TUint32 KTestRtpSendTimeoutLongMillisecs = 600; // KMccRtpSendTimeoutLongMillisecs

//  INTERNAL INCLUDES


UT_CMccRtpSender* UT_CMccRtpSender::NewL()
    {
    UT_CMccRtpSender* self = UT_CMccRtpSender::NewLC(); 
    CleanupStack::Pop();

    return self;
    }

UT_CMccRtpSender* UT_CMccRtpSender::NewLC()
    {
    UT_CMccRtpSender* self = new( ELeave ) UT_CMccRtpSender();
    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;
    }
    
UT_CMccRtpSender::UT_CMccRtpSender()
    {
    }

// Destructor (virtual by CBase)
UT_CMccRtpSender::~UT_CMccRtpSender()
    {
    }

// Second phase construct
void UT_CMccRtpSender::ConstructL()
    {
    // The ConstructL from the base class CEUnitTestSuiteClass must be called.
    // It generates the test case table.
    CEUnitTestSuiteClass::ConstructL();
    }

//  METHODS
void UT_CMccRtpSender::SetupL(  )
    {
    iLastError = KErrNone;
    iRtpApi = CRtpAPI::NewL( *this );
    iSender = CMccRtpSender::NewL( *this, *iRtpApi, 1, ETrue );
    } 

void UT_CMccRtpSender::Teardown(  )
    {
    delete iSender;
    iSender = NULL;
    delete iRtpApi;
    iRtpApi = NULL;
    }


void UT_CMccRtpSender::ErrorNotify( TInt /*aErrCode*/ )
    {
    }

void UT_CMccRtpSender::SendErrorOccured( TInt aError )
    {
    iLastError = aError;
    }
    
// TEST FUNCTIONs

void UT_CMccRtpSender::UT_CMccRtpSender_SendRtpPacketTest()
    {
    _LIT8( KMccRtpSenderTestData, "testadata" );
    TRtpId streamId( 2 );
    TRtpSendHeader sendHeader;
    TInt timestamp = 1000;
    sendHeader.iTimestamp = timestamp;
    sendHeader.iMarker = 1;
    TUint16 seqNum( 10 );
    
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 1 );
    EUNIT_ASSERT( iSender->iSendQueue[ 0 ]->RtpStreamId() == streamId );
    EUNIT_ASSERT( iSender->iSendQueue[ 0 ]->RtpHeader().iTimestamp == timestamp );
    EUNIT_ASSERT( iSender->iSendQueue[ 0 ]->DataPtr() == KMccRtpSenderTestData );
    
    // Send is active, make queue full
    
    for ( TInt i = 1; i < KMaxQueueSize; i++ )
        {
        iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
        EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), i + 1 );
        }
    
    // As queue is full, packet is discarded
    TInt queueSize = iSender->iSendQueue.Count();
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), queueSize );
    
    // Sending completes successfully
    iSender->Cancel();
    iSender->RunL();
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), queueSize - 1 );
    EUNIT_ASSERT_EQUALS( iLastError, KErrNone );
     
    // Sending of next packet fails
    iSender->Cancel();
    iSender->iStatus = KErrGeneral;
    iSender->RunL();
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), queueSize - 2 );
    EUNIT_ASSERT_EQUALS( iLastError, KErrGeneral );
    }

void UT_CMccRtpSender::UT_CMccRtpSender_SendDataLL()
    {
    _LIT8( KMccRtpSenderTestData, "testadata" );
    TRtpId sessionId( 1 );
    TBool useRtpSocket( EFalse );
    iSender->SendDataL( sessionId, useRtpSocket, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 1 );
    EUNIT_ASSERT( iSender->iSendQueue[ 0 ]->RtpStreamId() == KNullId );
    EUNIT_ASSERT( iSender->iSendQueue[ 0 ]->SessionId() == sessionId );
    EUNIT_ASSERT( iSender->iSendQueue[ 0 ]->DataPtr() == KMccRtpSenderTestData );
    
    // Send is active, make queue full
    for ( TInt i = 1; i < KMaxQueueSize; i++ )
        {
        iSender->SendDataL( sessionId, useRtpSocket, KMccRtpSenderTestData );
        EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), i + 1 );
        }
    
    // As queue is full, packet is discarded
    TInt queueSize = iSender->iSendQueue.Count();
    EUNIT_ASSERT_LEAVE( 
        iSender->SendDataL( sessionId, useRtpSocket, KMccRtpSenderTestData ) );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), queueSize );
    
    // Sending completes successfully
    iSender->Cancel();
    iSender->RunL();
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), queueSize - 1 );
    EUNIT_ASSERT_EQUALS( iLastError, KErrNone );
    
    // Sending of next packet fails
    iSender->Cancel();
    iSender->iStatus = KErrGeneral;
    iSender->RunL();
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), queueSize - 2 );
    EUNIT_ASSERT_EQUALS( iLastError, KErrGeneral );    
    }

void UT_CMccRtpSender::UT_CMccRtpSender_ClearTest()
    {
    _LIT8( KMccRtpSenderTestData, "testadata" );
    TRtpId streamId( 2 );
    TRtpSendHeader sendHeader;
    TInt timestamp = 1000;
    sendHeader.iTimestamp = timestamp;
    TUint16 seqNum( 10 );
    
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 1 );
    
    iSender->Clear();
    
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 0 );
    }    

void UT_CMccRtpSender::UT_CMccRtpSender_SendingTimeoutTest()
    {
    _LIT8( KMccRtpSenderTestData, "testadata" );
    TRtpId streamId( 2 );
    TRtpSendHeader sendHeader;
    TInt timestamp = 1000;
    sendHeader.iTimestamp = timestamp;
    TUint16 seqNum( 10 );
    
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 1 );
    
    iSender->TimerExpiredL( 0, NULL );
    
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 0 );
    }  

void UT_CMccRtpSender::UT_CMccRtpSender_MarkerBasedClearingTest()
    {
    // Set to short timeout mode
    iSender->iTimeoutTimeMilliseconds = KTestRtpSendTimeoutLongMillisecs;
    
    _LIT8( KMccRtpSenderTestData, "testadata" );
    TRtpId streamId( 2 );
    TRtpSendHeader sendHeader;
    TInt timestamp = 1000;
    sendHeader.iTimestamp = timestamp;
    TUint16 seqNum( 10 );
    sendHeader.iMarker = 0;
    
    // Timeout occurs when sending zero marker packet and there's already the full
    // frame in the queue
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 1 );
    
    seqNum++;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 2 );
    
    seqNum++;
    sendHeader.iMarker = 1;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 3 );
    
    iSender->TimerExpiredL( 0, NULL );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 0 );
    
    // Timeout occurs when sending marker packet
    seqNum++;
    sendHeader.iMarker = 1;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 1 );
    
    seqNum++;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 2 );
    
    iSender->TimerExpiredL( 0, NULL );
    
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 1 );
    
    seqNum++;
    sendHeader.iMarker = 0;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 2 );
    
    iSender->TimerExpiredL( 0, NULL );
    
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 1 );
    
    // Timeout occurs when sending zero marker packet and there's no full frame
    // in the queue
    seqNum++;
    sendHeader.iMarker = 0;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 2 );
    
    iSender->TimerExpiredL( 0, NULL );
    
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 0 );
    EUNIT_ASSERT( iSender->iDiscarding == ETrue );
    
    // Next packets are discarded because of that
    seqNum++;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 0 );
    EUNIT_ASSERT( iSender->iDiscarding == ETrue );
    
    seqNum++;
    sendHeader.iMarker = 1;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 0 );
    EUNIT_ASSERT( iSender->iDiscarding == EFalse );
    
    // Buffer is full and dropped frame is zero marker frame and there's some
    // packets of same frame in the queue
    for ( TInt i = 0; i < KMaxQueueSize; i++ )
        {
        seqNum++;
        sendHeader.iMarker = 1;
        iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
        EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), i + 1 );
        }
    
    iSender->iSendQueue[ KMaxQueueSize - 1 ]->iRtpHeader.iMarker = 0;
    iSender->iSendQueue[ KMaxQueueSize - 2 ]->iRtpHeader.iMarker = 0;
    
    seqNum++;
    sendHeader.iMarker = 0;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), KMaxQueueSize - 2 );
    EUNIT_ASSERT( iSender->iDiscarding == ETrue );
    iSender->iDiscarding = EFalse;
    
    // Buffer is full and dropped frame is zero marker frame but there's no other packets
    // of the same frame in the queue
    seqNum++;
    sendHeader.iMarker = 1;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    seqNum++;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    seqNum++;
    sendHeader.iMarker = 0;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), KMaxQueueSize );
    EUNIT_ASSERT( iSender->iDiscarding == ETrue );
    iSender->iDiscarding = EFalse;
    
    // Buffer is full and dropped frame is marker frame but there's no other packets
    // of the same frame in the queue 
    seqNum++;
    sendHeader.iMarker = 1;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), KMaxQueueSize );
    EUNIT_ASSERT( iSender->iDiscarding == EFalse );
    
    // Buffer is full and dropped frame is marker frame and there's some other packets
    // of the same frame in the queue 
    iSender->iSendQueue[ KMaxQueueSize - 1 ]->iRtpHeader.iMarker = 0;
    seqNum++;
    sendHeader.iMarker = 1;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), KMaxQueueSize - 1 );
    EUNIT_ASSERT( iSender->iDiscarding == EFalse );
    }

void UT_CMccRtpSender::UT_CMccRtpSender_MarkerBasedClearingTest2()
    {
    // Set to long timeout mode
    iSender->iTimeoutTimeMilliseconds = KTestRtpSendTimeoutLongMillisecs + 200;
    
    _LIT8( KMccRtpSenderTestData, "testadata" );
    TRtpId streamId( 2 );
    TRtpSendHeader sendHeader;
    TInt timestamp = 1000;
    sendHeader.iTimestamp = timestamp;
    TUint16 seqNum( 10 );
    sendHeader.iMarker = 0;
    
    // Timeout occurs when there's already several packets in queue
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 1 );
    
    seqNum++;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 2 );
    
    seqNum++;
    sendHeader.iMarker = 1;
    iSender->SendRtpPacketL( streamId, sendHeader, KMccRtpSenderTestData );
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 3 );
    
    iSender->TimerExpiredL( 0, NULL );
    
    EUNIT_ASSERT_EQUALS( iSender->iSendQueue.Count(), 0 );
    }
        
//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE( 
    UT_CMccRtpSender,
    "CMccRtpSender test",
    "UNIT" )

EUNIT_TEST(
    "SendRtpPacketL - test ",
    "CMccRtpSender",
    "SendRtpPacketL",
    "FUNCTIONALITY",
    SetupL, UT_CMccRtpSender_SendRtpPacketTest, Teardown )

EUNIT_TEST(
    "SendDataL - test ",
    "CMccRtpSender",
    "SendDataL",
    "FUNCTIONALITY",
    SetupL, UT_CMccRtpSender_SendDataLL, Teardown )
    
EUNIT_TEST(
    "Clear - test ",
    "CMccRtpSender",
    "Clear",
    "FUNCTIONALITY",
    SetupL, UT_CMccRtpSender_ClearTest, Teardown )
    
EUNIT_TEST(
    "Timeout - test ",
    "CMccRtpSender",
    "Timeout",
    "FUNCTIONALITY",
    SetupL, UT_CMccRtpSender_SendingTimeoutTest, Teardown )
    
EUNIT_TEST(
    "MarkerBasedClearing - test ",
    "CMccRtpSender",
    "MarkerBasedClearing",
    "FUNCTIONALITY",
    SetupL, UT_CMccRtpSender_MarkerBasedClearingTest, Teardown )

EUNIT_TEST(
    "MarkerBasedClearing 2 - test ",
    "CMccRtpSender",
    "MarkerBasedClearing 2",
    "FUNCTIONALITY",
    SetupL, UT_CMccRtpSender_MarkerBasedClearingTest2, Teardown )
            
EUNIT_END_TEST_TABLE

//  END OF FILE