/*

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

#include "rtpstppacket.h"

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

//  INTERNAL INCLUDES

//Packet max size (defined also in RtpSession.h)

const TUint KMaxRtpPacketSize = 8192; // 65536 bits = 8192 bytes

// CONSTRUCTION

UT_CRtpStpPacket* UT_CRtpStpPacket::NewL()

    {

    UT_CRtpStpPacket* self = UT_CRtpStpPacket::NewLC();

    CleanupStack::Pop();

    return self;

    }

UT_CRtpStpPacket* UT_CRtpStpPacket::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

UT_CRtpStpPacket::~UT_CRtpStpPacket()

    {

    }

// Default constructor

UT_CRtpStpPacket::UT_CRtpStpPacket()

    {

    }

// Second phase construct

void UT_CRtpStpPacket::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CRtpStpPacket::SetupL(  )

    {

 	iRtpStpPacket = new(ELeave) CRtpStpPacket();

    iRtpStpPacket->ConstructL( KMaxRtpPacketSize, 1 );

    }

void UT_CRtpStpPacket::Teardown(  )

    {

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_CRtpStpPacketL(  )

    {

	// "CRtpUtStpPacket::TestOpenStpDll()" ) );

	// "Test description: Load RLibrary" ) );

	iRtpStpPacket->Close();

    TInt result(KErrNone);

    TPtrC16 fileName( _L16( "rtpstppacket.dll" ) );

    //Load library

    RLibrary iLibrary;

    User::LeaveIfError( iLibrary.Load( fileName ) );

    CleanupClosePushL( iLibrary );

    //Load function

    TLibraryFunction entry = iLibrary.Lookup( 1 );

    //Use function

    MRtpPacketExt* iPktExtRcv = ( MRtpPacketExt * ) entry(); //NewL()

    if( result == KErrNone && iPktExtRcv != NULL )

   	    {

	    EUNIT_ASSERT(ETrue);   

	    }

	else

	    {

	    EUNIT_ASSERT(EFalse);   

	    }

    iPktExtRcv->Close();

    //Close library

    CleanupStack::PopAndDestroy( &iLibrary );

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_ConstructLL(  )

    {

    EUNIT_ASSERT( ETrue );

    iRtpStpPacket->Close();

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_CloseL(  )

    {

    EUNIT_ASSERT( ETrue );

    iRtpStpPacket->Close();

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_RtpPacketResetL(  )

    {

     TInt result(KErrNone);

     iRtpStpPacket->Close(); 

    TPtrC16 fileName( _L16( "rtpstppacket.dll" ) );

    //Load library

    RLibrary iLibrary;

    User::LeaveIfError( iLibrary.Load( fileName ) );

    CleanupClosePushL( iLibrary );

    //Load function

    TLibraryFunction entry = iLibrary.Lookup( 1 );

    MRtpPacketExt* iPktExtRcv = ( MRtpPacketExt * ) entry(); //NewL()

    CleanupClosePushL( *iPktExtRcv );

  	iPktExtRcv->ConstructL( KMaxRtpPacketSize, 1 );

	iPktExtRcv ->RtpPacketReset();

	iPktExtRcv ->RtpPacketResetPtr();

	//TEST 1

	// "Test description: sendHeader.iChecksumInd = 0" ) );

	TRtpHeader header;

	TRtpSendHeader sendHeader= (static_cast<TRtpSendHeader&> (header));

	sendHeader.iChecksumInd = 0;

	TBuf8<15> data; 

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

    result = iPktExtRcv ->RtpPacketBuild( sendHeader, data );

    TUint8* temp =  const_cast<TUint8*>(data.Ptr());

    TInt length = data.Length();

	iPktExtRcv->SetSize(20);

	result = iPktExtRcv ->RtpPacketProcess( temp, &length  );

	//Test 2

	// "Test description: sendHeader.iChecksumInd = 1" ) );

	iPktExtRcv ->RegisterRtpObserver( *this );

	sendHeader.iChecksumInd = 1;

	//result = iPktExtRcv->RtpPacketBuild( sendHeader, data );

	iPktExtRcv->SetSize(20);

	result = iPktExtRcv ->RtpPacketProcess( temp, &length  );

	iPktExtRcv ->UnregisterRtpObserver();

    //Close library

    CleanupStack::PopAndDestroy( iPktExtRcv );

    CleanupStack::PopAndDestroy( &iLibrary );

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_RtpPacketResetPtrL(  )

    {

    EUNIT_ASSERT( ETrue );

    iRtpStpPacket->Close();

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_RtpPacketBuildL(  )

    {

    EUNIT_ASSERT( ETrue );

    iRtpStpPacket->Close();

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_RtpPacketProcessL(  )

    {

    EUNIT_ASSERT( ETrue );

    iRtpStpPacket->Close();

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_RegisterRtpObserverL(  )

    {

    EUNIT_ASSERT( ETrue );

    iRtpStpPacket->Close();

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_UnregisterRtpObserverL(  )

    {

    EUNIT_ASSERT( ETrue );

    iRtpStpPacket->Close();

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_SetSizeL(  )

    {

    	TInt result(KErrNone);

	// "Test description: Test inline functions" ) );

	iRtpStpPacket->RtpPacketReset();

	iRtpStpPacket ->RtpPacketResetPtr();

	TInt size = 150;

	iRtpStpPacket->SetSize( size );

	if( size == iRtpStpPacket->Size())

	    {

	    // "CRtpUtStpPacket::TestInlineFunctions, Size - passed" ));

	    }

	else

	    {

	    EUNIT_ASSERT(EFalse);

	    // "CRtpUtStpPacket::TestInlineFunctions, Size - passed" ));

	    }

	TUint8* dataPtr = iRtpStpPacket->Data();

	if( dataPtr != NULL )

	    {

	    // "CRtpUtStpPacket::TestInlineFunctions, TUint8* - passed" ));

	    }

    else

	    {

	    EUNIT_ASSERT(EFalse);

	    // "CRtpUtStpPacket::TestInlineFunctions, TUint8* - passed" ));

	    }

	HBufC8* bufPtr = iRtpStpPacket->GetHBuf();

    if( bufPtr != NULL )

        {

        // "CRtpUtStpPacket::TestInlineFunctions, HBufC8* - passed" ));

        }

	else

	    {

	    EUNIT_ASSERT(EFalse);

	    // "CRtpUtStpPacket::TestInlineFunctions, HBufC8* - passed" ));

	    }

	TPtrC8 ptr = iRtpStpPacket->Des();

	if( ptr.Ptr() != NULL )

        {

        // "CRtpUtStpPacket::TestInlineFunctions, TPtrC8 - passed" ));

        }

	else

	    {

	    EUNIT_ASSERT(EFalse);

	    // "CRtpUtStpPacket::TestInlineFunctions, TPtrC8 - passed" ));

	    }

	iRtpStpPacket->Close();

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_SizeL(  )

    {

    EUNIT_ASSERT( ETrue );

    iRtpStpPacket->Close();

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_DataL(  )

    {

    EUNIT_ASSERT( ETrue );

    iRtpStpPacket->Close();

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_GetHBufL(  )

    {

    EUNIT_ASSERT( ETrue );

    iRtpStpPacket->Close();

    }

void UT_CRtpStpPacket::UT_CRtpStpPacket_DesL(  )

    {

    EUNIT_ASSERT( ETrue );

    iRtpStpPacket->Close();

    }

void UT_CRtpStpPacket::RtpPacketReceived( TRtpId /*aStreamId*/, 

                                        const TRtpRecvHeader& /*aHeaderInfo*/, 

                                        const TDesC8& /*aPayloadData*/ )

	{

	}

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(

    UT_CRtpStpPacket,

    "CRtpStpPacket",

    "UNIT" )

EUNIT_TEST(

    "CRtpStpPacket - test ",

    "CRtpStpPacket",

    "CRtpStpPacket",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_CRtpStpPacketL, Teardown)

EUNIT_TEST(

    "ConstructL - test ",

    "CRtpStpPacket",

    "ConstructL",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_ConstructLL, Teardown)

EUNIT_TEST(

    "Close - test ",

    "CRtpStpPacket",

    "Close",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_CloseL, Teardown)

EUNIT_TEST(

    "RtpPacketReset - test ",

    "CRtpStpPacket",

    "RtpPacketReset",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_RtpPacketResetL, Teardown)

EUNIT_TEST(

    "RtpPacketResetPtr - test ",

    "CRtpStpPacket",

    "RtpPacketResetPtr",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_RtpPacketResetPtrL, Teardown)

EUNIT_TEST(

    "RtpPacketBuild - test ",

    "CRtpStpPacket",

    "RtpPacketBuild",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_RtpPacketBuildL, Teardown)

EUNIT_TEST(

    "RtpPacketProcess - test ",

    "CRtpStpPacket",

    "RtpPacketProcess",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_RtpPacketProcessL, Teardown)

EUNIT_TEST(

    "RegisterRtpObserver - test ",

    "CRtpStpPacket",

    "RegisterRtpObserver",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_RegisterRtpObserverL, Teardown)

EUNIT_TEST(

    "UnregisterRtpObserver - test ",

    "CRtpStpPacket",

    "UnregisterRtpObserver",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_UnregisterRtpObserverL, Teardown)

EUNIT_TEST(

    "SetSize - test ",

    "CRtpStpPacket",

    "SetSize",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_SetSizeL, Teardown)

EUNIT_TEST(

    "Size - test ",

    "CRtpStpPacket",

    "Size",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_SizeL, Teardown)

EUNIT_TEST(

    "Data - test ",

    "CRtpStpPacket",

    "Data",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_DataL, Teardown)

EUNIT_TEST(

    "GetHBuf - test ",

    "CRtpStpPacket",

    "GetHBuf",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_GetHBufL, Teardown)

EUNIT_TEST(

    "Des - test ",

    "CRtpStpPacket",

    "Des",

    "FUNCTIONALITY",

    SetupL, UT_CRtpStpPacket_DesL, Teardown)

EUNIT_END_TEST_TABLE

//  END OF FILE