/*

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

//  EXTERNAL INCLUDES

#include <digia/eunit/EUnitMacros.h>

#include <mmf/common/mmfbase.h>

#include <mmf/common/mmfcontrollerframeworkbase.h>

#include <ecom/ecom.h>

//  INTERNAL INCLUDES

#include "MccSymSubthreadClient.h"

#include "MmccEvents.h"

#include "mcccodecconfigurator.h"

#include "Mcctesteventhandler.h"

#include "MccRtpDataSink.h"

#include "MccRtpDataSource.h"

#include "mccresourcepool_stub.h"

#include "mccrtpmediaclock.h"

#include "Mccrtpmanager.h"

#include "mmcccryptocontext.h"

#include "mmccsecureinterface.h"

#include "mccunittestmacros.h"

// MACROS

#define MCC_TEST_GET_RTP_API_SOCKET_SIZE( a ) \

iClient->iRtpmanager->iRtpApi->CustomCommandSync( 4, KNullDesC8, KNullDesC8, a )

#define MCC_TEST_GET_RTP_API_SECURE( a ) \

iClient->iRtpmanager->iRtpApi->CustomCommandSync( 3, KNullDesC8, KNullDesC8, a )

// CONSTANTS

const TUint KUT_CMccSymSubthreadClientDataSourceType( 42 );

const TUint KUT_CMccSymSubthreadClientDataSinkType( 43 );

const TInt KAmrNbBitrate122 = 12200;

const TInt KAmrNbBitrate475 = 4750;

const TUid KRtpDataSource = { KImplUidRtpDataSource }; 

const TUid KRtpDataSink = { KImplUidRtpDataSink };

// CONSTRUCTION

UT_CMccSymSubthreadClient* UT_CMccSymSubthreadClient::NewL()

    {

    UT_CMccSymSubthreadClient* self = UT_CMccSymSubthreadClient::NewLC();

    CleanupStack::Pop();

    return self;

    }

UT_CMccSymSubthreadClient* UT_CMccSymSubthreadClient::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

UT_CMccSymSubthreadClient::~UT_CMccSymSubthreadClient()

    {

    }

// Default constructor

UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient() :

    iClient( NULL ),

  //  iSourceStub( NULL ),

  //  iSink( NULL ),

    iStreamId( 42 )

    {

    }

// Second phase construct

void UT_CMccSymSubthreadClient::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CMccSymSubthreadClient::SetupL()

    {

    iResources = CMccResourcePoolStub::NewL();

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

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

    iHandler = CMccTestEventHandler::NewL();

    iSourceStub = static_cast< CMccRtpDataSource* >( MDataSource::NewSourceL( KRtpDataSource, KNullDesC8 ) );

    iSinkStub = static_cast< CMccRtpDataSink* >(MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 ));

    iClient = CMccSymSubthreadClient::NewL( iHandler, iResources, KMccLinkGeneral, iMccSessionId );

    }

void UT_CMccSymSubthreadClient::Teardown()

    {

    if ( iClient )

        {

        delete iClient;

        }

    if ( iSinkStub )

        {

        delete iSinkStub;

        }   

    if ( iSourceStub )

        {

        delete iSourceStub;

        }

    if (iHandler)

    	{

    	delete iHandler;

    	}

    delete iResources;

    REComSession::FinalClose();

    }

void UT_CMccSymSubthreadClient::Setup2L()

    {

    iResources = CMccResourcePoolStub::NewL();

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

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

    iHandler = CMccTestEventHandler::NewL();

    TPckgBuf<TInt> params( 30000 );

    iSourceStub = MDataSource::NewSourceL( KRtpDataSource, params );

    iSinkStub = MDataSink::NewSinkL( KUidMmfAudioOutput, KNullDesC8 );

    iClient = CMccSymSubthreadClient::NewL( iHandler, iResources, KMccLinkGeneral, iMccSessionId );

    iRtpMediaClock = CMccRtpMediaClock::NewL();

    // Create session

    TUint port( 5000 );

    TUint iap( -1 );

    TBool enableRTCP( ETrue );

    TInt ipTos( 0 );

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->CreateRtpSessionL( port, enableRTCP, ipTos, *iRtpMediaClock ) );

    // Create stream, add sink & source

    TUint8 payloadType( 96 );

    TFourCC fourCC( KMccFourCCIdAMRNB );

    TMMFPrioritySettings prioritySettings;

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->OpenL( payloadType,

                                    fourCC,

                                    iSourceStub, 

                                    iSinkStub,

                                    iStreamId,

                                    prioritySettings ) );

    TMccCodecInfo cInfo;

    cInfo.iFourCC = TFourCC( KMccFourCCIdAMRNB );

    cInfo.iBitrate = KAmrNbBitrate122;

    cInfo.iHwFrameTime = 20;

    cInfo.iFrameSize = 32;

    cInfo.iPtime = 20;

    cInfo.iMaxPtime = 400; // recommended "limit" 200ms

    cInfo.iJitterBufBufferLength = 100;

    cInfo.iPayloadType = KMinDynamicPT;

    cInfo.iCodecMode = EBandwidthEfficient;

    cInfo.iPayloadFormatEncoder = KImplUidAmrPayloadFormatEncode;

    cInfo.iPayloadFormatDecoder = KImplUidAmrPayloadFormatDecode;

    _LIT8( KFmtp, "octet-align=0" );

    TBuf8<13> buf( KFmtp() );

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->SetCodecInformationL( iStreamId, cInfo, buf ) );

    }

void UT_CMccSymSubthreadClient::Teardown2()

    {

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->CloseL() );

    if ( iClient )

        {

        delete iClient;

        }

    if ( iSinkStub )

        {

        delete iSinkStub;

        iSinkStub = NULL;

        }

    if ( iSourceStub )

        {

        delete iSourceStub;

        iSourceStub = NULL;

        }

    if (iHandler)

    	{

    	delete iHandler;

    	}

    delete iRtpMediaClock;	

    delete iResources;

    REComSession::FinalClose();

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_HandleEventL()

    {

    TMccInternalEvent internalEvent;

    iClient->SendEventToClient( internalEvent );

    TMccEvent event;

    iClient->DoMccEvent( event, internalEvent );

    EUNIT_ASSERT( event.iEventCategory == KMccEventCategoryStream );

    EUNIT_ASSERT( event.iEventType == KMccStreamMMFEvent );

    // TMccEvent missing from TMccInternalEvent

    internalEvent.iEventType = KMccRtpSinkUid;

    internalEvent.iInternalEventType = EMccInternalRtpSinkError;

    iClient->SendEventToClient( internalEvent );

    // TMccEvent included in TMccInternalEvent

    TMccEvent event2;

    event2.iEventCategory = KMccEventCategoryStream;

    event2.iEventType = KMccRtcpReceived;

    event2.iEventData.Copy( _L8("foofoo") );

    internalEvent.iMccEvent = &event2;

    iClient->SendEventToClient( internalEvent );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_DoMccEvent()

    {

    TMccEvent mccevent;

    TMccInternalEvent internalEvent;

    internalEvent.iErrorCode = KErrGeneral;

    iClient->DoMccEvent( mccevent, internalEvent );

    EUNIT_ASSERT( mccevent.iEventCategory == KMccEventCategoryStream );

    EUNIT_ASSERT( mccevent.iEventType == KMccStreamMMFEvent );

    EUNIT_ASSERT( mccevent.iErrorCode == KErrGeneral );

    EUNIT_ASSERT( mccevent.iLinkId == iClient->iLinkId );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_SendEventToClientL()

    {

    TMccInternalEvent internalEvent;

    internalEvent.iEventType = KMccAmrFormatterUid;

    internalEvent.iInternalEventType = EMccInternalAmrEventCmr;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    TMccEvent event;

    event.iEventType = KMccRtcpReceived;

    internalEvent.iMccEvent = &event;

    TMccAmrEventData eventdata;

    eventdata.iModeRequestBitrate = KAmrNbBitrate475;

    TMccAmrEventDataPackage eventdataPkg(eventdata);

    event.iEventData = eventdataPkg;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    TMccRtcpEventData eventData;

    eventData.iRtcpPacketType = KRtcpByePacket;

    TUint port( 5000 );

    TUint iap( -1 );

    TBool enableRTCP( ETrue );

    TInt ipTos( 0 );

    TUint8 payloadType( 96 );

    TFourCC fourCC( KMccFourCCIdAMRNB );

    TMMFPrioritySettings prioritySettings;

    // Create a stream so that there is something to close

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->CreateRtpSessionL( port, enableRTCP, ipTos, *iRtpMediaClock ) );

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->OpenL( payloadType,

                                    fourCC,

                                    iSourceStub, 

                                    iSinkStub,

                                    iStreamId,

                                    prioritySettings ) );

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KMccAmrFormatterUid;

    internalEvent.iInternalEventType = EMccInternalAmrEventCmr;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    eventdata.iModeRequestBitrate = KAmrNbBitrate475;

    eventdataPkg = eventdata;

    event.iEventData = eventdataPkg;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    eventdata.iModeRequestBitrate = 0;

    eventdataPkg = eventdata;

    event.iEventData = eventdataPkg;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    eventData.iRtcpPacketType = KRtcpByePacket;

    eventdataPkg = eventdata;

    event.iEventData = eventdataPkg;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KUidMediaTypeAudio; 

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KUidMediaTypeVideo;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KMccFileSinkUid;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KMccFileSourceUid;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KMccRtpSourceUid;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KMccRtpSinkUid;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KMccVideoSourceUid;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KMccVideoSinkUid;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KMccJitterBufferUid;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KMccMultiplexerUid;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KMccDtmfFormatterUid;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KMccAnySourceUid;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    internalEvent.iEventType = KMccAnySinkUid;

    EUNIT_ASSERT( iClient->SendEventToClient( internalEvent ) == KErrNone );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_OpenLL()

    {

    TUint port( 5000 );

    TUint iap( -1 );

    TBool enableRTCP( ETrue );

    TInt ipTos( 0 );

    TUint8 payloadType( 96 );

    TFourCC fourCC( KMccFourCCIdAMRNB );

    TMMFPrioritySettings prioritySettings;

    // No session    

    EUNIT_ASSERT_LEAVE( iClient->OpenL( payloadType,

                                    fourCC,

                                    iSourceStub, 

                                    iSinkStub,

                                    iStreamId,

                                    prioritySettings ) );

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->CreateRtpSessionL( port, enableRTCP, ipTos, *iRtpMediaClock ) );

    // KErrAlreadyExists

    EUNIT_ASSERT_LEAVE( iClient->CreateRtpSessionL( port, enableRTCP, ipTos, *iRtpMediaClock ) );

    // NULL parameter    

    EUNIT_ASSERT_LEAVE( iClient->OpenL( payloadType,

                                    fourCC,

                                    iSourceStub, 

                                    NULL,

                                    iStreamId,

                                    prioritySettings ) );

    // NULL parameter    

    EUNIT_ASSERT_LEAVE( iClient->OpenL( payloadType,

                                    fourCC,

                                    NULL, 

                                    iSinkStub,

                                    iStreamId,

                                    prioritySettings ) );

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->OpenL( payloadType,

                                    fourCC,

                                    iSourceStub, 

                                    iSinkStub,

                                    iStreamId,

                                    prioritySettings ) );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_SetBalanceLL()

    {

    TInt left( 50 );

    TInt right( 50 );

    // No stream

    EUNIT_ASSERT_LEAVE( iClient->SetBalanceL( iStreamId, left, right ) );

    //Teardown();

    //MCC_EUNIT_ASSERT_NO_LEAVE( Setup2L() );

    //MCC_EUNIT_ASSERT_NO_LEAVE( iClient->SetBalanceL( iStreamId, left, right ) );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_GetBalanceLL()

    {

    TInt left( 0 );

    TInt right( 0 );

    // No stream

    EUNIT_ASSERT_LEAVE( iClient->GetBalanceL( iStreamId, left, right ) );

    //Teardown();

    //MCC_EUNIT_ASSERT_NO_LEAVE( Setup2L() );

    //MCC_EUNIT_ASSERT_NO_LEAVE( iClient->GetBalanceL( iStreamId, left, right ) );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_PrepareLL()

    {

    // KErrNotReady

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iClient->PrepareL( iStreamId, 0 ), KErrNotFound );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_PrepareL2L()

    {                                       

    MCC_EUNIT_ASSERT_NO_LEAVE(iClient->PrepareL( iStreamId, 0 ) );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_PlayLL()

    {

    // KErrNotReady

    EUNIT_ASSERT_LEAVE( iClient->PlayL( iStreamId, 0, EFalse, ETrue ) );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_PlayL2L()

    {

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->PrepareL( iStreamId, 0) );

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->PlayL( iStreamId, 0, EFalse, ETrue ) );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_StopLL()

    {

    // KErrNotReady

    EUNIT_ASSERT_LEAVE( iClient->StopL( iStreamId, 0 ) );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_StopL2L()

    {

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->PrepareL( iStreamId, 0 ) );

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->PlayL( iStreamId, 0, EFalse, EFalse ) );

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->StopL( iStreamId, 0 ) );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_PauseLL()

    {

    // KErrNotReady

    EUNIT_ASSERT_LEAVE( iClient->PauseL( iStreamId, 0, ETrue ) );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_ResumeLL()

    {

    // KErrNotReady

    EUNIT_ASSERT_LEAVE( iClient->ResumeL( iStreamId, 0, ETrue ) );

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_ResumeL2L()

    {/*

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->PrepareL( iStreamId, 0 ) );

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->PlayL( iStreamId, 0, EFalse, EFalse ) );

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->PauseL( iStreamId, 0, EFalse ) );

    MCC_EUNIT_ASSERT_NO_LEAVE( iClient->ResumeL( iStreamId, 0, ETrue ) );

    */

    }

void UT_CMccSymSubthreadClient::UT_CMccSymSubthreadClient_CloseLL()

    {

    // KErrNotReady

    EUNIT_ASSERT_LEAVE( iClient->CloseL( iStreamId ) );

    TUint port( 5000 );

    TUint iap( -1 );

    TBool enableRTCP( ETrue );

    TInt ipTos( 0 );

    TUint8 payloadType( 96 );

    TFourCC fourCC( KMccFourCCIdAMRNB );