/*

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

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

//#include "SRTPCryptoHandler.h"

#include <srtpmastersalt.h>

#include <srtpmasterkey.h>

#include "srtpcryptocontext.h"

#include "msrtprekeyingobserver.h"

#include <srtpcryptoparams.h>

#include <rtpapi.h>

#include <srtpstreamin.h>

#include "rtpmanager.h"

#include "srtpsession.h"

//  INTERNAL INCLUDES

const TUint KDefaultIap = 6;

const TUint KDefaultIap2 = 1;

const TInt KLength = 20;

_LIT8(KRFC3711_TestMasterKey128bits,    "E1F97A0D3E018BE0D64FA32C06DE4139");

_LIT8(KRFC3711_TestMasterSalt112bits,   "0EC675AD498AFEEBB6960B3AABE6");	

_LIT8(KTestMKI128Bits,      "ABCDEF1234567890ABCDEF1234567890");

#define RTP_EUNIT_ASSERT_EQUALS( val1, val2 ) \

if ( val2 != KErrNoMemory && val1 == KErrNoMemory ){\

	User::Leave( KErrNoMemory );\

	}\

else{\

	EUNIT_ASSERT_EQUALS( val1, val2 );\

	}

 #define RTP_EUNIT_ASSERT_RTP_ID_ON

 #ifdef RTP_EUNIT_ASSERT_RTP_ID_ON

 #define RTP_EUNIT_ASSERT_RTP_ID( val1 ) \

 if ( val1 == KNullId )\

    {\

    User::Leave( KErrNoMemory );\

    }

#else

#define RTP_EUNIT_ASSERT_RTP_ID( val1 )

EUNIT_ASSERT( val1 != KNullId );

#endif

_LIT8(KHello, "hello...testing");

// CONSTRUCTION

UT_CRtpAPI* UT_CRtpAPI::NewL()

    {

    UT_CRtpAPI* self = UT_CRtpAPI::NewLC();

    CleanupStack::Pop();

    return self;

    }

UT_CRtpAPI* UT_CRtpAPI::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

UT_CRtpAPI::~UT_CRtpAPI()

    {

    }

// Default constructor

UT_CRtpAPI::UT_CRtpAPI()

    {

    }

// Second phase construct

void UT_CRtpAPI::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CRtpAPI::Hex(HBufC8& aString)

{

    TPtr8 ptr=aString.Des();

    TInt length = aString.Length();

    if (aString.Length()%2)

        {

        ptr.SetLength(0);

        return;

        }

    TInt i;

    for (i=0;i<aString.Length();i+=2)

        {

        TUint8 tmp;

        tmp=(TUint8)(aString[i]-(aString[i]>'9'?('A'-10):'0'));

        tmp*=16;

        tmp|=(TUint8)(aString[i+1]-(aString[i+1]>'9'?('A'-10):'0'));

        ptr[i/2]=tmp;

        }

    ptr.SetLength(aString.Length()/2);

}

void UT_CRtpAPI::SetupL(  )

    {

	iRtpAPI = CRtpAPI::NewL( *this );

    iStpAPI = CRtpAPI::NewL( *this );

	iErr=0;

    }

void UT_CRtpAPI::Teardown(  )

    {

    iRtpAPI->Close();

    delete iRtpAPI;

    iStpAPI->Close();

    delete iStpAPI;

void UT_CRtpAPI::UT_CRtpAPI_NewLL(  )

    {

    EUNIT_ASSERT( ETrue );

    }

void UT_CRtpAPI::UT_CRtpAPI_OpenLL(  )

    {

    TInt result(KErrNone);

    TRtpSdesParams params;

    result = iRtpAPI->OpenL( params, NULL, NULL, NULL );

    EUNIT_ASSERT(result==KErrNone);

    /*if ( iRtpAPI->iManager == NULL )

        {

        EUNIT_ASSERT(iRtpAPI->iManager);

        }*/

    }

void UT_CRtpAPI::UT_CRtpAPI_StartConnectionL(  )

    {

    //Asychronize

	TInt result(KErrNone);

    TRtpSdesParams params;

    result = iRtpAPI->OpenL( params, NULL, NULL, NULL );

    EUNIT_ASSERT(result==KErrNone);

    TInt error(KErrNone);

    TRequestStatus status;

    error = iRtpAPI->StartConnection( status, KDefaultIap ); // KDefaultIap

    EUNIT_ASSERT ( error == KErrNone );

    // Cancel the start immediately

    iRtpAPI->CancelStart();

    User::WaitForRequest( status );

    // Start connection again

    error = iRtpAPI->StartConnection( status, KDefaultIap ); // KDefaultIap

    EUNIT_ASSERT ( error == KErrNone );

    // Wait until the connection is really up

    User::WaitForRequest( status );

    // Close the connection =)

    //iRtpAPI->Close();

	iRtpAPI->CancelStart();

    }

    {

    //Synchronize

    TInt result(KErrNone);

    TRtpSdesParams params;

    result = iRtpAPI->OpenL( params, NULL, NULL, NULL );

    EUNIT_ASSERT(result==KErrNone);

    TInt error( KErrNone );

	error = iRtpAPI->StartConnection( KDefaultIap2 ); // 0

    EUNIT_ASSERT( error == KErrNone );

    iRtpAPI->Close();

    }

void UT_CRtpAPI::UT_CRtpAPI_CancelStartL(  )

    {

    EUNIT_ASSERT( ETrue);

    }

void UT_CRtpAPI::UT_CRtpAPI_CloseL(  )

    {

    iRtpAPI->Close();

	iStpAPI->Close();

    EUNIT_ASSERT( iRtpAPI->iManager->iConnected == EFalse);

    }

void UT_CRtpAPI::UT_CRtpAPI_SetLocalSdesL(  )

    {

    TInt result(KErrNone);

    TRtpSdesParams params;

    result = iRtpAPI->OpenL( params, NULL, NULL, NULL );

    EUNIT_ASSERT(result==KErrNone);

    iRtpAPI->SetLocalSdes( params );

    EUNIT_ASSERT( ETrue);

    }

void UT_CRtpAPI::UT_CRtpAPI_GetLocalIPAddressLL(  )

    {

    TInt result(KErrNone);

    TRtpSdesParams params;

    result = iRtpAPI->OpenL( params, NULL, NULL, NULL );

    EUNIT_ASSERT(result==KErrNone);

    TInt error( KErrNone );

    TInetAddr addr;

	TRAP( error, addr = iRtpAPI->GetLocalIPAddressL() );

	//"Should not have found local IP when not started"

    EUNIT_ASSERT ( error == KErrNotSupported );

    //"Test description: Test getting local IP address" ) );

    // _L( "CRtpAPI::GetLocalIPAddressL()" ) );

    //Test when IAP ID<0

	TRequestStatus status;

    result = iRtpAPI->StartConnection( status, -6 ); // KDefaultIap

  	EUNIT_ASSERT ( result == KErrNone );

 // Wait until the connection is really up

    User::WaitForRequest( status );

  	TRAP( error, addr = iRtpAPI->GetLocalIPAddressL() )

    //Then test when IAP ID>0

    iRtpAPI->CancelStart();

    //result = iRtpAPI->OpenL( params, NULL, NULL, NULL );

    //EUNIT_ASSERT(result==KErrNone);

    result = iRtpAPI->StartConnection( status, KDefaultIap ); // KDefaultIap

    EUNIT_ASSERT ( result == KErrNone );

 	// Wait until the connection is really up

    User::WaitForRequest( status );

  	TRAP( error, addr = iRtpAPI->GetLocalIPAddressL() )

    if ( error != KErrNone )

        {

        EUNIT_ASSERT( EFalse);

        }

    TInetAddr compareAddr( KInetAddrAny );

    if ( addr == compareAddr )

        {

        EUNIT_ASSERT( EFalse);

        }

    }

void UT_CRtpAPI::UT_CRtpAPI_CreateSessionLL(  )

    {

    TInt result(KErrNone);

    TRtpSdesParams params;

    result = iRtpAPI->OpenL( params, NULL, NULL, NULL );

    EUNIT_ASSERT(result==KErrNone);

    TRequestStatus status;

    result = iRtpAPI->StartConnection( status, KDefaultIap ); // KDefaultIap

    RTP_EUNIT_ASSERT_EQUALS( result, KErrNone );

 // Wait until the connection is really up

    User::WaitForRequest( status );

    TCreateSessionParams sessionParams;

    sessionParams.iPriority = TCreateSessionParams::EPriorityStandard;

    sessionParams.iSocketBufSize = KSocketBufSize;

    TUint port( 5000 );

    TBool enableRtcp( EFalse );

    TRtcpParams rtcpParams;

    rtcpParams.iRtcpFraction = 0.10;

    rtcpParams.iRtcpTimeOut = 0;

    rtcpParams.iSessionBWidth = 32000;

    TRtpId error( KNullId );

    error = iRtpAPI->CreateSessionL( sessionParams,

                                    port,

                                    enableRtcp,

                                    &rtcpParams );

    RTP_EUNIT_ASSERT_RTP_ID( error );

    }

void UT_CRtpAPI::UT_CRtpAPI_CreateSessionL2L(  )

    {

    //Create SRTP Session And Stream

        HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());

    CleanupStack::PushL( masterKey );

    *masterKey = KRFC3711_TestMasterKey128bits;

    HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());

    CleanupStack::PushL( masterSalt);

	*masterSalt = KRFC3711_TestMasterSalt112bits;

	HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());

    CleanupStack::PushL( mki);

	*mki = KTestMKI128Bits;

	Hex(*mki);

	CSRTPMasterKey* mk = CSRTPMasterKey::NewL( *masterKey, *mki );

	CleanupStack::PushL( mk );

    CSRTPMasterSalt* ms = CSRTPMasterSalt::NewL( *masterSalt );

    CleanupStack::PushL( ms );

    TSrtpCryptoParams cryptoparams;

    CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(mk, ms, cryptoparams );

    CleanupStack::Pop( ms );

    CleanupStack::Pop( mk );

    CleanupStack::PopAndDestroy( mki );

    CleanupStack::PopAndDestroy( masterSalt );

    CleanupStack::PopAndDestroy( masterKey ); 

    CleanupStack::PushL( context );

    CSRTPSession* srtpSession = CSRTPSession::NewL(iDestination,

    												context,

    												*this); 

    CleanupStack::Pop( context );

    CleanupStack::PushL( srtpSession );

    //automatically added stream in the constructor												

    CSRTPStreamIn* tempStreamIn = CSRTPStreamIn::NewL(*srtpSession, (TUint)1);

    CleanupStack::PushL( tempStreamIn );

    //End of Create SRTPSession

    //Create RTPSession

    TInt result(KErrNone);

    TRtpSdesParams params;

    result = iRtpAPI->OpenL( params, NULL, NULL, NULL );

    EUNIT_ASSERT(result==KErrNone);

    TRequestStatus status;

    result = iRtpAPI->StartConnection( status, KDefaultIap ); // KDefaultIap

    EUNIT_ASSERT ( result == KErrNone );

 // Wait until the connection is really up

    User::WaitForRequest( status );

    TCreateSessionParams sessionParams;

    sessionParams.iPriority = TCreateSessionParams::EPriorityStandard;

    sessionParams.iSocketBufSize = KSocketBufSize;

    TUint port( 5000 );

    TBool enableRtcp( EFalse );

    TRtcpParams rtcpParams;

    rtcpParams.iRtcpFraction = 0.10;

    rtcpParams.iRtcpTimeOut = 0;

    rtcpParams.iSessionBWidth = 32000;

    TRtpId error( KNullId );

    error = iRtpAPI->CreateSessionL( sessionParams,

                                    port,

                                    enableRtcp,

                                    &rtcpParams,

                                    *srtpSession );

    RTP_EUNIT_ASSERT_RTP_ID( error );

    //Delete SRTPSession

    CleanupStack::PopAndDestroy( tempStreamIn );

    CleanupStack::PopAndDestroy( srtpSession );

    }    

void UT_CRtpAPI::UT_CRtpAPI_StartSessionL(  )

    {

   	TInt invalidSession( 42 );

    TInt result( KErrNone );

    result = iRtpAPI->StartSession( invalidSession );

    EUNIT_ASSERT ( result == KErrNotFound )

    // Can't verify these but they shouldn't do anything

    iRtpAPI->CloseSession( invalidSession );

    iRtpAPI->UnregisterRtpObserver( invalidSession );

    iRtpAPI->UnregisterRtcpObserver( invalidSession );

    iRtpAPI->CancelSend( invalidSession );

    }

void UT_CRtpAPI::UT_CRtpAPI_CloseSessionL(  )

    {

    EUNIT_ASSERT( ETrue );//See above test case

    }

void UT_CRtpAPI::UT_CRtpAPI_TestStartSession2L(  )

    {

    //Create SRTP Session And Stream

        HBufC8* masterKey = HBufC8::NewL(KRFC3711_TestMasterKey128bits().Length());

    CleanupStack::PushL( masterKey );

    *masterKey = KRFC3711_TestMasterKey128bits;

    HBufC8* masterSalt =HBufC8::NewL(KRFC3711_TestMasterSalt112bits().Length());

    CleanupStack::PushL( masterSalt);

	*masterSalt = KRFC3711_TestMasterSalt112bits;

	HBufC8* mki =HBufC8::NewL(KTestMKI128Bits().Length());

    CleanupStack::PushL( mki);

	*mki = KTestMKI128Bits;

	Hex(*mki);

	CSRTPMasterKey* mk = CSRTPMasterKey::NewL( *masterKey, *mki );

	CleanupStack::PushL( mk );

    CSRTPMasterSalt* ms = CSRTPMasterSalt::NewL( *masterSalt );

    CleanupStack::PushL( ms );

    TSrtpCryptoParams cryptoparams;

    CSRTPCryptoContext* context = CSRTPCryptoContext::NewL(mk, ms, cryptoparams );

    CleanupStack::Pop( ms );

    CleanupStack::Pop( mk );

    CleanupStack::PopAndDestroy( mki );

    CleanupStack::PopAndDestroy( masterSalt );

    CleanupStack::PopAndDestroy( masterKey ); 

    CleanupStack::PushL( context );

    CSRTPSession* srtpSession = CSRTPSession::NewL(iDestination,

    												context,

    												*this); 

    CleanupStack::Pop( context );

    CleanupStack::PushL( srtpSession );

    //automatically added stream in the constructor												

    CSRTPStreamIn* tempStreamIn = CSRTPStreamIn::NewL(*srtpSession, (TUint)1);

    CleanupStack::PushL( tempStreamIn );

    //End of Create SRTPSession

    //Create RTPSession

    TInt result(KErrNone);

    TRtpSdesParams params;

    result = iRtpAPI->OpenL( params, NULL, NULL, NULL );

    EUNIT_ASSERT(result==KErrNone);

    TRequestStatus status;

    result = iRtpAPI->StartConnection( status, KDefaultIap ); // KDefaultIap

    RTP_EUNIT_ASSERT_EQUALS ( result, KErrNone );

 // Wait until the connection is really up

    User::WaitForRequest( status );

    TCreateSessionParams sessionParams;

    sessionParams.iPriority = TCreateSessionParams::EPriorityStandard;

    sessionParams.iSocketBufSize = KSocketBufSize;

    TUint port( 5000 );

    TBool enableRtcp( EFalse );

    TRtcpParams rtcpParams;

    rtcpParams.iRtcpFraction = 0.10;

    rtcpParams.iRtcpTimeOut = 0;

    rtcpParams.iSessionBWidth = 32000;

    TRtpId sessionId( KNullId );

    TRtpId error( KNullId );

    sessionId = iRtpAPI->CreateSessionL( sessionParams,

                                    port,

                                    enableRtcp,

                                    &rtcpParams,

                                    *srtpSession );

    RTP_EUNIT_ASSERT_RTP_ID( sessionId );

    TRcvStreamParams recvparams;

    recvparams.iPayloadType = 0;

    TRtpId streamId( 1 );

    TRtpSSRC ssrc( 0 );

    TInt err( KErrNone );

    err = iRtpAPI->CreateReceiveStreamL( sessionId /*session id*/, recvparams );

    result = iRtpAPI->StartSession( sessionId );//error is sessionID

    CRtpSession* session = iRtpAPI->iManager->GetSession( sessionId);

    session->OnRtpReceivedL();

    iRtpAPI->CloseSession( error );

    iRtpAPI->UnregisterRtpObserver( error );

    iRtpAPI->UnregisterRtcpObserver( error);

    iRtpAPI->CancelSend( error );

    //Delete SRTPSession

    CleanupStack::PopAndDestroy( tempStreamIn );

    CleanupStack::PopAndDestroy( srtpSession );

    }