/*

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

//  EXTERNAL INCLUDES

#include <digia/eunit/EUnitMacros.h>

#include <mmf/server/mmfbuffer.h>

//  INTERNAL INCLUDES

#include "rtpheader.h"

#include "MccRtpDataSink.h"

#include <mmf/server/mmfdatasink.h>

#include <mmf/common/mmfcontrollerframework.h>

#include "MmccEvents.h"

#include "MccInternalCodecs.h"

#include <mmf/server/mmfvideoframebuffer.h>

#include "mccrtpkeepalivecontainer.h"

#include "amrpayloadformatwrite.h"

#include <srtpcryptocontext.h>

#include <srtpmastersalt.h>

#include <srtpstreamout.h>

#include "mccunittestmacros.h"

#define MCCEVENTDATAPCKG_TO_RTCPEVENTDATAPCKG( event )\

    *reinterpret_cast<TMccRtcpEventDataPackage*>( &event.iEventData )

// CONSTANTS

const TUint8 KPayloadType( 96 );

_LIT8(KRFC3711_TestMasterKey128bits,    "E1F97A0D3E018BE0D64FA32C06DE4139");

_LIT8(KRFC3711_TestMasterSalt112bits,   "0EC675AD498AFEEBB6960B3AABE6");	

_LIT8(KTestMKI128Bits,      "ABCDEF1234567890ABCDEF1234567890");

// CONSTRUCTION

UT_CMccRtpDataSink* UT_CMccRtpDataSink::NewL()

    {

    UT_CMccRtpDataSink* self = UT_CMccRtpDataSink::NewLC(); 

    CleanupStack::Pop();

    return self;

    }

UT_CMccRtpDataSink* UT_CMccRtpDataSink::NewLC()

    {

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

    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_CMccRtpDataSink::~UT_CMccRtpDataSink()

    {

    }

// Default constructor

UT_CMccRtpDataSink::UT_CMccRtpDataSink()

    : iSession( 1 )

    {

    }

// Second phase construct

void UT_CMccRtpDataSink::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

// From MRtpErrNotify

void UT_CMccRtpDataSink::ErrorNotify( TInt /*aErrCode*/ )

    {

    }

void UT_CMccRtpDataSink::SetupL()

    {

    iRtpApi = CRtpAPI::NewL( *this );

    TUid dummyUid( TUid::Uid( 42 ) ); 

    TBuf8<5> dummyBuf( _L8( "foo" ) );

    iSink = static_cast<CMccRtpDataSink*>(

        CMccRtpDataSink::NewSinkL( dummyUid, dummyBuf ) );

    MAsyncEventHandler* eventHandler = NULL;

    TRtpId rtpSessionId(0);

    iRtpKeepaliveMechanism = 

        CMccRtpKeepaliveContainer::NewL( *eventHandler, 

                                         *iRtpApi, 

                                         rtpSessionId ); 

    } 

void UT_CMccRtpDataSink::Teardown()

    {

    delete iRtpKeepaliveMechanism;

    if ( iSink )

        {

        delete iSink;

        iSink = NULL;

        }

    if ( iSecSession)

    	{

    	delete iSecSession;

		iSecSession = NULL;

    	}    

    if ( iRtpApi )

        {

        delete iRtpApi;

        iRtpApi = NULL;

        }

    }

// HELPERS

//

void UT_CMccRtpDataSink::InitializeStreamL()

    {

    iSink->SinkThreadLogon( *this );

    iSink->SetCurrentUser( this );

    TMccRtpSessionParams params;

    params.iRtpAPI = iRtpApi;

    params.iSessionId = iSession;

    params.iEnableRTCP = ETrue;

    params.iRtpKeepalive = iRtpKeepaliveMechanism;

    iSink->SetSessionParamsL( params );

    TMccCodecInfo cInfo;

    TMccCodecInfoBuffer cInfoBuf( cInfo );

    }

// TEST FUNCTIONS

//

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_MuteL()

    {

    const TUint8 KDtmfPayloadType( 98 );

    TRtpSendHeader header;

    header.iPayloadType = KDtmfPayloadType;

    iSink->iState = MMccRtpInterface::ERtpStatePlaying;

    iSink->Mute( ETrue, KDtmfPayloadType );

    EUNIT_ASSERT( ETrue == iSink->SendingAllowed( header ) );

    header.iPayloadType = 0;

    EUNIT_ASSERT( EFalse == iSink->SendingAllowed( header ) );

    iSink->Mute( EFalse, KDtmfPayloadType );

    EUNIT_ASSERT( ETrue == iSink->SendingAllowed( header ) );

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SendMediaSignallingLL()

    {

    TMccEvent wrongEvent;

    wrongEvent.iEventCategory = KMccEventCategoryDtmf;

    // Wrong type of signal

    EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( wrongEvent ) );

    TMccEvent event;

    event.iEventCategory = KMccEventCategoryRtcp;

    event.iEventType = KMccRtcpControl;

    TMccRtcpEventData data;

    TMccRtcpEventDataPackage dataPackage( data );

    event.iEventData.Copy( dataPackage );

    // No RTP API set

    EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( event ) );

    TMccRtpSessionParams params;

    params.iRtpAPI = iRtpApi;

    params.iSessionId = iSession;

    params.iEnableRTCP = EFalse;

    params.iRtpKeepalive= iRtpKeepaliveMechanism;

    EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) );

    // RTCP not enabled

    EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( event ) );

    params.iEnableRTCP = ETrue;

    EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) );

    // Wrong packet type

    EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( event ) );

    // Streams and RTP sender not constructed

    data.iRtcpPacketType = KRtcpAnyPacket;

    EUNIT_ASSERT_LEAVE( iSink->SendMediaSignallingL( event ) );

    TMccCodecInfo cInfo;

    TMccCodecInfoBuffer cInfoBuf( cInfo );

    MCC_EUNIT_ASSERT_EQUALS( iSink->SinkThreadLogon( *this ), KErrNone );

    iSink->SetCurrentUser( this );

    EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() );

    TMccRtcpEventDataPackage& eventDataPackage = MCCEVENTDATAPCKG_TO_RTCPEVENTDATAPCKG( event );

    TMccRtcpEventData eventData;

    eventData.iRtcpPacketType = KRtcpSdesPacket;

    eventDataPackage = TMccRtcpEventDataPackage( eventData );

    // No RTCP data, but does not leave because empty TRtpSdesParams

    // will be constructed from zero length RTCP data

    EUNIT_ASSERT_NO_LEAVE( iSink->SendMediaSignallingL( event ) );

    TRtpSdesParams sdesParams;

    TPckgBuf<TRtpSdesParams> sdesPackage( sdesParams );

    eventData.iRtcpPacketData.Copy( sdesPackage );

    eventDataPackage = TMccRtcpEventDataPackage( eventData );

    EUNIT_ASSERT_NO_LEAVE( iSink->SendMediaSignallingL( event ) );

    TBuf<5> reason( _L( "foo" ) );

    eventData.iRtcpPacketType = KRtcpByePacket;

    eventData.iRtcpPacketData.Copy( reason );

    eventDataPackage = TMccRtcpEventDataPackage( eventData );

    EUNIT_ASSERT_NO_LEAVE( iSink->SendMediaSignallingL( event ) );

    TRtcpApp app;

    eventData.iRtcpPacketType = KRtcpAppPacket;

    TPckgBuf<TRtcpApp> appPackage( app );

    eventData.iRtcpPacketData.Copy( appPackage );

    eventDataPackage = TMccRtcpEventDataPackage( eventData );

    EUNIT_ASSERT_NO_LEAVE( iSink->SendMediaSignallingL( event ) );

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_EmptyBufferLL()

    {

    EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( NULL, NULL, TMediaId() ) );

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkThreadLogonL()

    {

    MCC_EUNIT_ASSERT_EQUALS( iSink->SinkThreadLogon( *this ), KErrNone );

    iSink->SetCurrentUser( this );

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkThreadLogoffL()

    {

    iSink->SinkThreadLogoff();

    TMccRtpSessionParams params;

    params.iRtpAPI = iRtpApi;

    params.iSessionId = iSession;

    params.iEnableRTCP = ETrue;

    params.iRtpKeepalive = iRtpKeepaliveMechanism;

    EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) );

    iSink->SinkThreadLogoff();

    // Reach more branches

    TUint8 redPt( 97 );

    TMccCodecInfo cInfo;

    cInfo.iRedundancyCount = 1;

    cInfo.iRedundantPayload = redPt;

    TMccCodecInfoBuffer cInfoBuf( cInfo );

    MCC_EUNIT_ASSERT_EQUALS( iSink->SinkThreadLogon( *this ), KErrNone );

    iSink->SetCurrentUser( this );

    EUNIT_ASSERT_NO_LEAVE( iSink->SetSessionParamsL( params ) );

    EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() );

    iSink->SinkThreadLogoff();

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkDataTypeCodeL()

    {

    TMediaId mediaId( KUidMediaTypeMidi );

    EUNIT_ASSERT_EQUALS( iSink->SinkDataTypeCode( mediaId ), TFourCC() );

    iSink->SinkThreadLogoff();

    TFourCC codec( ' ','A','M','R' );

    TMediaId media2( KUidMediaTypeAudio );

    iSink->SetSinkDataTypeCode( codec, media2 );

    // The codecs SHOULD be equal

    EUNIT_ASSERT_EQUALS( iSink->SinkDataTypeCode( media2 ), codec );

    TFourCC codec2( ' H','2','6','3' );

    TMediaId media3( KUidMediaTypeVideo );

    iSink->SetSinkDataTypeCode( codec2, media3 );

    // The codecs SHOULD be equal

    EUNIT_ASSERT_EQUALS( iSink->SinkDataTypeCode( media3 ), codec2 );

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SetSinkDataTypeCodeL()

    {

    TFourCC codec;

    TMediaId media( KUidMediaTypeMidi ); // wrong media type

    EUNIT_ASSERT_EQUALS( iSink->SetSinkDataTypeCode( codec, media ), KErrNotSupported );

    // Set the correct media type

    TMediaId media2( KUidMediaTypeAudio );

    EUNIT_ASSERT_EQUALS( iSink->SetSinkDataTypeCode( codec, media2 ), KErrNone );

    TMediaId media3( KUidMediaTypeVideo );

    EUNIT_ASSERT_EQUALS( iSink->SetSinkDataTypeCode( codec, media3 ), KErrNone );

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_BufferFilledLL()

    {

    EUNIT_ASSERT_LEAVE( iSink->BufferFilledL( NULL ) );

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_CanCreateSinkBufferL()

    {

    EUNIT_ASSERT_EQUALS( iSink->CanCreateSinkBuffer(), EFalse );

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_CreateSinkBufferLL()

    {

    TBool dummy;

    EUNIT_ASSERT_LEAVE( iSink->CreateSinkBufferL( TMediaId(), dummy ) );

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkPrimeLL()

    {

    // Set wrong state

    iSink->SinkThreadLogoff();

    EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() );

    // Set correct state

    iSink->SinkThreadLogon( *this );

    iSink->SetCurrentUser( this );

    EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() );

    TMccRtpSessionParams params;

    params.iRtpAPI = iRtpApi;

    params.iSessionId = iSession;

    params.iEnableRTCP = ETrue;

    params.iRtpKeepalive = iRtpKeepaliveMechanism;

    iSink->SetSessionParamsL( params );

    EUNIT_ASSERT_LEAVE( iSink->SinkPrimeL() );

    TMccCodecInfo cInfo;

    TMccCodecInfoBuffer cInfoBuf( cInfo );

    EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() );

    EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == EFalse );

    // "Secure session"

    iRtpKeepaliveMechanism->iStopped = ETrue;

    TInt fakeSecSession( 3 );

    iSink->iSecSession = reinterpret_cast<CSRTPSession*>( &fakeSecSession );

    EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() );

    EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == ETrue )

    iSink->iSecSession = NULL;

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkPlayLL()

    {

    // Wrong state

    EUNIT_ASSERT_LEAVE( iSink->SinkPlayL() );

    // Do it right

    InitializeStreamL();

    iSink->SinkPrimeL();

    EUNIT_ASSERT_NO_LEAVE( iSink->SinkPlayL() );

    // State downgrade is ignored

    EUNIT_ASSERT_NO_LEAVE( iSink->SinkPrimeL() );

    EUNIT_ASSERT( MMccRtpInterface::ERtpStatePlaying == iSink->State() );

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkPauseLL()

    {

    // Wrong state

    EUNIT_ASSERT_LEAVE( iSink->SinkPauseL() );

    // Do it right

    InitializeStreamL();

    iSink->SinkPrimeL();

    iSink->SinkPlayL();

    EUNIT_ASSERT_NO_LEAVE( iSink->SinkPauseL() );

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SinkStopLL()

    {

    // Do it right

    InitializeStreamL();

    iSink->SinkPrimeL();

    iSink->SinkPlayL();

    EUNIT_ASSERT_NO_LEAVE( iSink->SinkStopL() );

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_EmptyBufferL_2L()

    {

    CMMFBuffer* buf( NULL );

    TMediaId mediaId;

    TRtpSendHeader header;

    InitializeStreamL();

    //initial srtp realted

    iRtpKeepaliveMechanism->iStopped = ETrue;

    TInt fakeSecSession( 3 );

    iSink->iSecSession = reinterpret_cast<CSRTPSession*>( &fakeSecSession );

    iSink->iSecureKeyExpired = ETrue;

    iSink->iState = MMccRtpInterface::ERtpStatePlaying;

    EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == ETrue )

    //null buffer

    EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );

    // Try different buffer types, null source

    CMMFDataBuffer* dataBuf = CMMFDataBuffer::NewL();

    EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );

    delete dataBuf;

    TBuf8<5> foo;

    foo.Format( _L8( "foo42" ) );

    TUint8* fooPtr = const_cast<TUint8*>( foo.Ptr() );

    TPtr8 ptr( fooPtr, foo.Length() ) ;

    CMMFPtrBuffer* ptrBuf = CMMFPtrBuffer::NewL( ptr );

    EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );

    delete ptrBuf;

    CMMFYUVBuffer* yuvBuf = CMMFYUVBuffer::NewL();

    EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->EmptyBufferL( yuvBuf, NULL, mediaId, header ), KErrNotSupported );

    delete yuvBuf;

    // packet drop because of secure keyStream not playing

    CAmrPayloadFormatWrite* source = CAmrPayloadFormatWrite::NewL( iSink );

    CleanupStack::PushL( source );

    CMMFDataBuffer* dataBuf2 = CMMFDataBuffer::NewL();

    CleanupStack::PushL( dataBuf2 );

    EUNIT_ASSERT_NO_LEAVE( iSink->EmptyBufferL( dataBuf2, source, mediaId, header ) );

    // Stream playing

    iSink->SinkPrimeL();

    //becuase of secure key packet drop

    EUNIT_ASSERT_SPECIFIC_LEAVE(iSink->SinkPlayL(), KErrGeneral );

    iSink->iSecureKeyExpired = EFalse;

    iSink->SinkPlayL();

    //packet drop because of secure stream not there

    EUNIT_ASSERT_NO_LEAVE( iSink->EmptyBufferL( dataBuf2, source, mediaId, header ) );

    CleanupStack::PopAndDestroy( dataBuf2 );

    CleanupStack::PopAndDestroy( source );

    iSink->iSecSession = NULL;

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_EmptyBufferL_1L()

    {

    CMMFBuffer* buf( NULL );

    TMediaId mediaId;

    TRtpSendHeader header;

    // No stream

    EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );

    // NULL buffer

    InitializeStreamL();

    EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );

    // Try different buffer types, null source

    CMMFDataBuffer* dataBuf = CMMFDataBuffer::NewL();

    EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );

    delete dataBuf;

    TBuf8<5> foo;

    foo.Format( _L8( "foo42" ) );

    TUint8* fooPtr = const_cast<TUint8*>( foo.Ptr() );

    TPtr8 ptr( fooPtr, foo.Length() ) ;

    CMMFPtrBuffer* ptrBuf = CMMFPtrBuffer::NewL( ptr );

    EUNIT_ASSERT_LEAVE( iSink->EmptyBufferL( buf, NULL, mediaId, header ) );

    delete ptrBuf;

    CMMFYUVBuffer* yuvBuf = CMMFYUVBuffer::NewL();

    EUNIT_ASSERT_SPECIFIC_LEAVE( iSink->EmptyBufferL( yuvBuf, NULL, mediaId, header ), KErrNotSupported );

    delete yuvBuf;

    // Stream not playing

    CAmrPayloadFormatWrite* source = CAmrPayloadFormatWrite::NewL( iSink );

    CleanupStack::PushL( source );

    CMMFDataBuffer* dataBuf2 = CMMFDataBuffer::NewL();

    CleanupStack::PushL( dataBuf2 );

    EUNIT_ASSERT_NO_LEAVE( iSink->EmptyBufferL( dataBuf2, source, mediaId, header ) );

    // Stream playing

    iSink->SinkPrimeL();

    iSink->SinkPlayL();

    MCC_EUNIT_ASSERT_NO_LEAVE( iSink->EmptyBufferL( dataBuf2, source, mediaId, header ) );

    CleanupStack::PopAndDestroy( dataBuf2 );

    CleanupStack::PopAndDestroy( source );

    // TBD: test also scenario where failure occurs in rtp packet sending

    }

void UT_CMccRtpDataSink::UT_CMccRtpDataSink_SendRTCPReceiverReportL()