/*

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

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

//  INTERNAL INCLUDES

#include "MccRtpDataSource.h"

#include "MmccEvents.h"

#include "AmrPayloadFormatRead.h"

#include "mccrtpkeepalivecontainer.h"

#include "mcctesteventhandler.h"

#include <srtpcryptocontext.h>

#include <srtpmastersalt.h>

#include <srtpstreamin.h>

#include "UT_CMccRtpInterface.h"

#include "mccunittestmacros.h"

// CONSTANTS

_LIT8(KRFC3711_TestMasterKey128bits,    "E1F97A0D3E018BE0D64FA32C06DE4139");

_LIT8(KRFC3711_TestMasterSalt112bits,   "0EC675AD498AFEEBB6960B3AABE6");	

_LIT8(KTestMKI128Bits,      "ABCDEF1234567890ABCDEF1234567890");

// CONSTRUCTION

UT_CMccRtpDataSource* UT_CMccRtpDataSource::NewL()

    {

    UT_CMccRtpDataSource* self = UT_CMccRtpDataSource::NewLC(); 

    CleanupStack::Pop();

    return self;

    }

UT_CMccRtpDataSource* UT_CMccRtpDataSource::NewLC()

    {

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

    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_CMccRtpDataSource::~UT_CMccRtpDataSource()

    {

    }

// Default constructor

UT_CMccRtpDataSource::UT_CMccRtpDataSource()

    : MDataSink( KUidMediaTypeAudio )

    {

    }

// Second phase construct

void UT_CMccRtpDataSource::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CMccRtpDataSource::SetupL()

    {

    iEventHandler = CMccTestEventHandler::NewL();

    iRtpApi = CRtpAPI::NewL( *iEventHandler );

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

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

    iSource = static_cast<CMccRtpDataSource*>(

        CMccRtpDataSource::NewSourceL( dummyUid, dummyBuf ) );

    TMccRtpSourceSetting setting;

    setting.iStandByTimerValue = 3000;   

    TMccRtpSourceSettingBuf settingBuf( setting );

    iSource->ConstructSourceL( settingBuf );

    MAsyncEventHandler* eventHandler = NULL;

    TRtpId rtpSessionId(0);

    iRtpKeepaliveMechanism = 

        CMccRtpKeepaliveContainer::NewL( *eventHandler, 

                                         *iRtpApi, 

                                         rtpSessionId ); 

    } 

void UT_CMccRtpDataSource::Teardown()

    {

    delete iRtpKeepaliveMechanism;

    if ( iSource )

        {

        delete iSource;

        iSource = NULL;

        }

    if ( iSecSession)

    	{

    	delete iSecSession;

		iSecSession = NULL;

    	}

    if ( iRtpApi )

        {

        delete iRtpApi;

        iRtpApi = NULL;

        }

    delete iEventHandler;

    }

// HELPER FUNCTIONS

void UT_CMccRtpDataSource::InitializeL( TBool aCreateStream, TBool aEnableRtcp )

    {

    iSource->SourceThreadLogon( *iEventHandler );

    RArray<TUint> payloads;

    CleanupClosePushL( payloads );

    payloads.AppendL( KDefaultAmrNbPT );

    payloads.AppendL( KPcmuPayloadType );

    iSource->RegisterPayloadTypesL( payloads );

    CleanupStack::PopAndDestroy( &payloads );

    TMccRtpSessionParams params;

    params.iRtpAPI = iRtpApi;

    params.iSessionId = iSession;

    params.iEnableRTCP = aEnableRtcp;

    params.iRtpKeepalive = iRtpKeepaliveMechanism;

    EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );

    if ( aCreateStream )

        {

        CreateStreamL();

        }

    }

void UT_CMccRtpDataSource::CreateStreamL()

    {

    TMccCodecInfo cInfo;

    cInfo.iType = KUidMediaTypeAudio;

    cInfo.iFourCC = TFourCC( ' ','A','M','R' );

    cInfo.iBitrate = 8000;

    cInfo.iPayloadType = KDefaultAmrNbPT;

    TMccCodecInfoBuffer cInfoBuf( cInfo );

    }

// TEST FUNCTIONS

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_RtpPacketReceivedL()

    {

    TRtpId stream( 0 );

    TRtpId wrongStream( 99 );

    TRtpRecvHeader header;

    TBuf8<5> data;

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

    iSource->SourceThreadLogon( *iEventHandler );

    CMMFBuffer* buffer = CMMFDescriptorBuffer::NewL(10);

    CleanupStack::PushL( buffer );    

    CAmrPayloadFormatRead* amrPfRead = CAmrPayloadFormatRead::NewL( NULL );

    CleanupStack::PushL( amrPfRead );

    header.iPayloadType = KPcmuPayloadType;    

    RArray<TUint> payloads;

    CleanupClosePushL( payloads );

    payloads.AppendL( KDefaultAmrNbPT );

    payloads.AppendL( KPcmuPayloadType );

    iSource->RegisterPayloadTypesL( payloads );

    CleanupStack::PopAndDestroy( &payloads );

    // Wrong stream

    iSource->FillBufferL( buffer, amrPfRead, TMediaId() );

    iSource->RtpPacketReceived( wrongStream, header, data );

    TMccRtpSessionParams params;

    params.iRtpAPI = iRtpApi;

    params.iSessionId = iSession;

    params.iEnableRTCP = EFalse;

    params.iRtpKeepalive = iRtpKeepaliveMechanism;

    EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );

    TMccCodecInfo cInfo;

    cInfo.iFourCC = TFourCC( ' ','A','M','R' );

    cInfo.iBitrate = 8000;

    cInfo.iPayloadType = KDefaultAmrNbPT;

    TMccCodecInfoBuffer cInfoBuf( cInfo );

    //iSource->NegotiateSourceL( *iEventHandler );

    EUNIT_ASSERT_NO_LEAVE( iSource->NegotiateSourceL( *amrPfRead ) );

    EUNIT_ASSERT_NO_LEAVE( iSource->SourcePrimeL() );

    EUNIT_ASSERT_NO_LEAVE( iSource->SourcePlayL() );

    stream = 2; // This is what the RtpAPI stub gives

    header.iPayloadType = KDefaultAmrNbPT;

    EUNIT_ASSERT_EQUALS( iSource->iTimeoutTime, 0 );

    iSource->FillBufferL( buffer, amrPfRead, TMediaId() );

    iSource->RtpPacketReceived( stream, header, data );

    EUNIT_ASSERT_EQUALS( iSource->iTimeoutTime, 0 );

    EUNIT_ASSERT_EQUALS( iSource->iInactivityTimerId, KMaxTUint32 );

    // Inactivity timer is activated when receiving packet

    MCC_EUNIT_ASSERT_NO_LEAVE( iSource->StartInactivityTimerL( 500000 ) );

    iSource->RtpPacketReceived( stream, header, data );

    EUNIT_ASSERT_EQUALS( iSource->iTimeoutTime, 500000 );

    EUNIT_ASSERT( iSource->iInactivityTimerId != KMaxTUint32 );

    // Jitter observing is active

    iSource->iJitCalc->iMediaQualityObservingStarted = ETrue;

    iSource->RtpPacketReceived( stream, header, data );

    // Sink not ready, error ignored silently

    iEventHandler->iLastEvent.iEventType = KMccEventNone;

    iSource->iFillBufferRequester = NULL;

    iSource->RtpPacketReceived( stream, header, data );

    EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccEventNone );

    // secure key expired, error ignored silently

    iSource->iSecureKeyExpired = ETrue;

    iSource->RtpPacketReceived( stream, header, data );

    EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccEventNone );

    CleanupStack::PopAndDestroy( amrPfRead );

    CleanupStack::PopAndDestroy( buffer );

    iSource->SourceThreadLogoff();

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_StartInactivityTimerLL()

    {

    TUint32 time( 0 );

    // Invalid time

    EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->StartInactivityTimerL( time ), KErrArgument );

    time = 5000;

    // Ok

    MCC_EUNIT_ASSERT_NO_LEAVE( iSource->StartInactivityTimerL( time ) );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_StopInactivityTimerLL()

    {

    // No timer exists

    EUNIT_ASSERT_NO_LEAVE( iSource->StopInactivityTimerL() );

    TUint32 time( 5000 );

    iSource->StartInactivityTimerL( time );

    // OK

    EUNIT_ASSERT_NO_LEAVE( iSource->StopInactivityTimerL() );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SendMediaSignallingLL()

    {

    iSource->iEnableRtcp = ETrue;

    TMccEvent foo;

    UT_CMccRtpInterface::CreateRtcpEvent( foo );

    EUNIT_ASSERT_LEAVE( iSource->SendMediaSignallingL( foo ) );

    // No RtpApi

    foo.iEventCategory = KMccEventCategoryRtcp;

    foo.iEventType = KMccRtcpControl;

    TMccRtcpEventData eventData;

    eventData.iRtcpPacketType = KRtcpRrPacket;

    TMccRtcpEventDataPackage eventDataPkg( eventData );

    foo.iEventData.Copy( eventDataPkg );

    EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SendMediaSignallingL( foo ), KErrNotReady );

    // Rr, stream does not exist

    InitializeL( EFalse, ETrue );

    EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SendMediaSignallingL( foo ), KErrNotReady );

    // Stream exists

    CreateStreamL();

    EUNIT_ASSERT_NO_LEAVE( iSource->SendMediaSignallingL( foo ) );

    // Sr

    eventData.iRtcpPacketType = KRtcpSrPacket;

    eventDataPkg = eventData;

    foo.iEventData.Copy( eventDataPkg );

    EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SendMediaSignallingL( foo ), KErrArgument );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourceDataTypeCodeL()

    {

    TMediaId mediaId( KUidMediaTypeVideo );

    EUNIT_ASSERT_EQUALS( iSource->SourceDataTypeCode( mediaId ), TFourCC() );

    iSource->SourceThreadLogoff();

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

    TMediaId media2( KUidMediaTypeAudio );

    iSource->SetSourceDataTypeCode( codec, media2 );

    // The codecs SHOULD be equal

    EUNIT_ASSERT_EQUALS( iSource->SourceDataTypeCode( media2 ), codec );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SetSourceDataTypeCodeL()

    {

    TFourCC codec;

    TMediaId media( KUidMediaTypeVideo ); // wrong media type

    EUNIT_ASSERT_EQUALS( iSource->SetSourceDataTypeCode( codec, media ), KErrNone );

    // Set the correct media type

    TMediaId media2( KUidMediaTypeAudio );

    EUNIT_ASSERT_EQUALS( iSource->SetSourceDataTypeCode( codec, media2 ), KErrNone );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_BufferEmptiedLL()

    {

    EUNIT_ASSERT_LEAVE( iSource->BufferEmptiedL( NULL ) );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_CanCreateSourceBufferL()

    {

    EUNIT_ASSERT_EQUALS( iSource->CanCreateSourceBuffer(), EFalse );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_CreateSourceBufferLL()

    {

    TMediaId dummyId;

    TBool dummyBool;

    EUNIT_ASSERT_LEAVE( iSource->CreateSourceBufferL( dummyId, dummyBool ) );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourceThreadLogonL()

    {

    iSource->SourceThreadLogon( *iEventHandler );

    iSource->SourceThreadLogon( *iEventHandler );

    iSource->SourceThreadLogoff();

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourceThreadLogoffL()

    {

    iSource->SourceThreadLogoff();

    // Reach more branches

    TMccRtpSessionParams params;

    params.iRtpAPI = iRtpApi;

    params.iSessionId = iSession;

    params.iEnableRTCP = EFalse;

    params.iRtpKeepalive = iRtpKeepaliveMechanism;

    EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );

    TMccCodecInfo cInfo;

    cInfo.iFourCC = TFourCC( ' ','A','M','R' );

    cInfo.iBitrate = 8000;

    cInfo.iPayloadType = KDefaultAmrNbPT;

    TMccCodecInfoBuffer cInfoBuf( cInfo );

    MCC_EUNIT_ASSERT_EQUALS( iSource->SourceThreadLogon( *iEventHandler ), KErrNone );

    EUNIT_ASSERT_NO_LEAVE( iSource->SourcePrimeL() );

    iSource->SourceThreadLogoff();

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourcePrimeLL()

    {

    // Ok

    TMccRtpSessionParams params;

    params.iRtpAPI = iRtpApi;

    params.iSessionId = iSession;

    params.iEnableRTCP = EFalse;

    params.iRtpKeepalive = iRtpKeepaliveMechanism;

    EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );

    TMccCodecInfo cInfo;

    cInfo.iFourCC = TFourCC( ' ','A','M','R' );

    cInfo.iBitrate = 8000;

    cInfo.iPayloadType = KDefaultAmrNbPT;

    TMccCodecInfoBuffer cInfoBuf( cInfo );

    MCC_EUNIT_ASSERT_EQUALS( iSource->SourceThreadLogon( *iEventHandler ), KErrNone );

    EUNIT_ASSERT_NO_LEAVE( iSource->SourcePrimeL() );

    iSource->SourceThreadLogoff();

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourcePlayLL()

    {

    // Not logged on

    EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SourcePlayL(), KErrNotFound );

    // Not allowed if not yet prepared

    InitializeL();

    EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SourcePlayL(), KErrNotReady );

    // Ok when already prepared

    iSource->iState = MMccRtpInterface::ERtpStatePrimed;

    EUNIT_ASSERT_NO_LEAVE( iSource->SourcePlayL() );

    EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccStreamStarted );

    // Resuming

    iSource->iState = MMccRtpInterface::ERtpStatePaused; 

    EUNIT_ASSERT_NO_LEAVE( iSource->SourcePlayL() );

    EUNIT_ASSERT_EQUALS( iEventHandler->iLastEvent.iEventType, KMccStreamResumed );

    EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == EFalse )

    // State downgrade is ignored

    EUNIT_ASSERT_NO_LEAVE( iSource->SourcePrimeL() );

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

    // "Secure session"

    iRtpKeepaliveMechanism->iStopped = ETrue;

    TInt fakeSecSession( 3 );

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

    EUNIT_ASSERT_NO_LEAVE( iSource->SourcePlayL() );

    EUNIT_ASSERT( iRtpKeepaliveMechanism->iStopped == ETrue )

    iSource->iSecSession = NULL;

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourcePauseLL()

    {

    EUNIT_ASSERT_LEAVE( iSource->SourcePauseL() );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SourceStopLL()

    {

    EUNIT_ASSERT_NO_LEAVE( iSource->SourceStopL() );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_FillBufferLL()

    {

    EUNIT_ASSERT_NO_LEAVE( iSource->FillBufferL( NULL, NULL, TMediaId() ) );

    CMMFDataBuffer* buffer = CMMFDataBuffer::NewL( 100 );

    CleanupStack::PushL( buffer );

    EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->FillBufferL( buffer, NULL, TMediaId() ), KErrArgument );

    CleanupStack::PopAndDestroy( buffer );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SendRTCPReceiverReportL()

    {

    // No RTP API set

    EUNIT_ASSERT_EQUALS( iSource->SendRTCPReceiverReport(), KErrNotReady );

    TMccRtpSessionParams params;

    params.iRtpAPI = iRtpApi;

    params.iSessionId = iSession;

    params.iEnableRTCP = EFalse;

    params.iRtpKeepalive = iRtpKeepaliveMechanism;

    iSource->SetSessionParamsL( params );

    // Ok

    iSource->iRtpStreamId = 1; // the iStreamID must not be empty

    EUNIT_ASSERT_EQUALS( iSource->SendRTCPReceiverReport(), KErrNone );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SendRTCPSenderReportL()

    {

    // No RTP API set

    EUNIT_ASSERT_EQUALS( iSource->SendRTCPSenderReport(), KErrNotReady );

    TMccRtpSessionParams params;

    params.iRtpAPI = iRtpApi;

    params.iSessionId = iSession;

    params.iEnableRTCP = EFalse;

    params.iRtpKeepalive = iRtpKeepaliveMechanism;

    iSource->SetSessionParamsL( params );

    // Ok

    iSource->iRtpStreamId = 1; // the iStreamID must not be empty

    EUNIT_ASSERT_EQUALS( iSource->SendRTCPSenderReport(), KErrNone );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_SendRTCPDataLL()

    {

    TBuf8<5> dummy;

    EUNIT_ASSERT_SPECIFIC_LEAVE( iSource->SendRTCPDataL( dummy ), KErrNotSupported );

    }

void UT_CMccRtpDataSource::UT_CMccRtpDataSource_NegotiateSourceLL()

    {

    // wrong codec

    EUNIT_ASSERT_NO_LEAVE( iSource->NegotiateSourceL( *this ) );

    // Reach more branches

    TMccRtpSessionParams params;

    params.iRtpAPI = iRtpApi;

    params.iSessionId = iSession;

    params.iEnableRTCP = EFalse;

    params.iRtpKeepalive = iRtpKeepaliveMechanism;

    EUNIT_ASSERT_NO_LEAVE( iSource->SetSessionParamsL( params ) );

    TMccCodecInfo cInfo;

    cInfo.iFourCC = TFourCC( ' ','A','M','R' );

    cInfo.iBitrate = 8000;

    cInfo.iPayloadType = KDefaultAmrNbPT;

    TMccCodecInfoBuffer cInfoBuf( cInfo );

    MCC_EUNIT_ASSERT_EQUALS( iSource->SourceThreadLogon( *iEventHandler ), KErrNone );

    EUNIT_ASSERT_NO_LEAVE( iSource->SourcePrimeL() );