/*

* Copyright (c) 2006 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_cmcesdpcodec.h"

//  EXTERNAL INCLUDES

#include <digia/eunit/EUnitMacros.h>

#include "mcemediamanager.h"

#define RESET()\

    iServer->Reset()

#include <sdpcodecstringpool.h>

#include <sdpcodecstringconstants.h>

#include <sdpmediafield.h>

#include <sdpfmtattributefield.h>

#include <sdprtpmapvalue.h>

#include <sdpattributefield.h>

#include "mceaudiosdpcodec.h"

#include "mcevideosdpcodec.h"

#include "cleanupresetanddestroy.h"

#include "mmcccodecinformation.h"

//  INTERNAL INCLUDES

// CONSTRUCTION

UT_CMceSdpCodec* UT_CMceSdpCodec::NewL()

    {

    UT_CMceSdpCodec* self = UT_CMceSdpCodec::NewLC(); 

    CleanupStack::Pop();

    return self;

    }

UT_CMceSdpCodec* UT_CMceSdpCodec::NewLC()

    {

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

    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_CMceSdpCodec::~UT_CMceSdpCodec()

    {

    }

// Default constructor

UT_CMceSdpCodec::UT_CMceSdpCodec()

    {

    }

// Second phase construct

void UT_CMceSdpCodec::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CMceSdpCodec::SetupL()

    {

    iServer = new (ELeave) CMceServerStub();

    iManager = CMceMediaManager::NewL( *iServer );

    iSession = MceMediaManagerTestHelper::CreateMultimediaOutSessionL();

    iSdpCodec = CMceAudioSdpCodec::NewL();

    } 

void UT_CMceSdpCodec::Teardown()

    {

	CMceComSession::Delete( iSession, *iManager );

	delete iManager;

	iManager = NULL;

	delete iServer;

	iServer = NULL;

	delete iSdpCodec;

	iSdpCodec = NULL;

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_MediaL()

    {

    RStringF audio = MCE_SDP_STRING_AUDIOL();

    EUNIT_ASSERT( iSdpCodec->iMedia == audio );

    RStringF media = iSdpCodec->Media();

    EUNIT_ASSERT( media == audio );

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_DecodesL()

    {

    RStringF video = MCE_SDP_STRING_VIDEOL();

    RStringF audio = MCE_SDP_STRING_AUDIOL();

    RStringF protocol = SDP_STRINGL( SdpCodecStringConstants::EProtocolRtpAvp );

    CSdpMediaField* audioLine = 

        CSdpMediaField::NewLC( audio, 5005, protocol, _L8("0") );

    CSdpMediaField* videoLine = 

        CSdpMediaField::NewLC( video, 5005, protocol, _L8("0") );

    EUNIT_ASSERT( iSdpCodec->Decodes( *audioLine ) );

    EUNIT_ASSERT( !iSdpCodec->Decodes( *videoLine ) );

    CleanupStack::PopAndDestroy( videoLine );

    CleanupStack::PopAndDestroy( audioLine );

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_AddCapabilityLL()

    {

    EUNIT_ASSERT( iSdpCodec->iCapabilities->Count() == 0 );

    iSdpCodec->AddCapabilityL( KMceSDPNameAMR );

    EUNIT_ASSERT( iSdpCodec->iCapabilities->Count() == 1 );

    iSdpCodec->AddCapabilityL( KMceSDPNamePCMU );

    EUNIT_ASSERT( iSdpCodec->iCapabilities->Count() == 2 );

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_IsSupportedL()

    {

    EUNIT_ASSERT( iSdpCodec->iCapabilities->Count() == 0 );

    EUNIT_ASSERT( !iSdpCodec->IsSupported( KMceSDPNameAMR ) );

    iSdpCodec->AddCapabilityL( KMceSDPNameAMR );

    EUNIT_ASSERT( iSdpCodec->iCapabilities->Count() == 1 );

    iSdpCodec->AddCapabilityL( KMceSDPNamePCMU );

    EUNIT_ASSERT( iSdpCodec->iCapabilities->Count() == 2 );

    EUNIT_ASSERT( iSdpCodec->IsSupported( KMceSDPNameAMR ) );

    EUNIT_ASSERT( iSdpCodec->IsSupported( KMceSDPNamePCMU ) );

    EUNIT_ASSERT( !iSdpCodec->IsSupported( KMceSDPNamePCMA ) );

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_PrepareForEncodeLL()

    {

    RStringF audio = MCE_SDP_STRING_AUDIOL();

    RStringF protocol = SDP_STRINGL( SdpCodecStringConstants::EProtocolRtpAvp );

    CSdpMediaField* audioLine = 

        CSdpMediaField::NewLC( audio, 5005, protocol, _L8("0") );

    RStringF rtpmapStr = SDP_STRINGL( SdpCodecStringConstants::EAttributeRtpmap );

    MCE_DEFINE_DECSTR( payload, 96 );

    TSdpRtpmapValue rtpmapValue = TSdpRtpmapValue::DecodeL( _L8("AMR/8000") );

    HBufC8* rtpmapBuf = rtpmapValue.EncodeL();

    CleanupStack::PushL( rtpmapBuf );

    CSdpFmtAttributeField* rtpmapAttribute = 

        CSdpFmtAttributeField::NewL( rtpmapStr, payload, *rtpmapBuf );

    CleanupStack::PopAndDestroy( rtpmapBuf ); 

    CleanupStack::PushL( rtpmapAttribute ); 

    audioLine->FormatAttributeFields().AppendL( rtpmapAttribute );

    CleanupStack::Pop( rtpmapAttribute ); 

    EUNIT_ASSERT( audioLine->FormatAttributeFields().Count() == 1 );

    iSdpCodec->PrepareForEncodeL( *iSession->Streams()[0], *audioLine );

    EUNIT_ASSERT( audioLine->FormatAttributeFields().Count() == 0 );

    RStringF empty = SdpCodecStringPool::StringPoolL().OpenFStringL( KNullDesC8 );

    CleanupClosePushL( empty );

    audioLine->SetMediaL( empty );

    EUNIT_ASSERT_LEAVE( iSdpCodec->PrepareForEncodeL( *iSession->Streams()[0], *audioLine  ) );

    CleanupStack::PopAndDestroy(); //empty

    CleanupStack::PopAndDestroy( audioLine );

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_EncodeRtpMapFieldsLL()

    {

    CSdpFmtAttributeField* rtpmap = NULL;

    rtpmap = iSdpCodec->EncodeRtpMapFieldsL( 96, _L8("AMR"), 8000, KNullDesC8 );

    EUNIT_ASSERT( rtpmap );

    EUNIT_ASSERT( rtpmap->Value() == _L8("AMR/8000") );

    CleanupStack::PushL( rtpmap );

    CleanupStack::PopAndDestroy( rtpmap );

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_DirectionL()

    {

    _LIT8( KAttrValue, "120");

    RStringF audio = MCE_SDP_STRING_AUDIOL();

    RStringF protocol = SDP_STRINGL( SdpCodecStringConstants::EProtocolRtpAvp );

    CSdpAttributeField* direction = NULL;

    RPointerArray<CSdpAttributeField> sessionAttributes;

    MceCleanupResetAndDestroyPushL( sessionAttributes );

    CSdpMediaField* audioLine = 

        CSdpMediaField::NewLC( audio, 5005, protocol, _L8("0") );

    EUNIT_ASSERT( iSdpCodec->Direction( *audioLine, sessionAttributes ) == KErrNotFound );

    for( TInt i = 0; i < 10; i++ )

        {

        if ( i == 0 || i == 5 )

            {

            direction = CSdpAttributeField::NewLC( SDP_STRINGL( SdpCodecStringConstants::EAttributeSendonly ), KNullDesC8 );

            }

        else if ( i == 1 || i == 6 )

            {

            direction = CSdpAttributeField::NewLC( SDP_STRINGL( SdpCodecStringConstants::EAttributeRecvonly ), KNullDesC8 );

            }

        else if ( i == 2 || i == 7 )

            {

            direction = CSdpAttributeField::NewLC( SDP_STRINGL( SdpCodecStringConstants::EAttributeInactive ), KNullDesC8 );

            }

        else if ( i == 3 || i == 8 )

            {

            direction = CSdpAttributeField::NewLC( SDP_STRINGL( SdpCodecStringConstants::EAttributeSendrecv ), KNullDesC8 );

            }

        else if ( i == 4 || i == 9 )

            {

            //wrong

            direction = CSdpAttributeField::NewLC( SDP_STRINGL( SdpCodecStringConstants::EAttributePtime ), KAttrValue );

            }

        if ( i < 5 )

            {

            audioLine->AttributeFields().AppendL( direction );

            CleanupStack::Pop( direction );

            }

        else

            {

            sessionAttributes.AppendL( direction );

            CleanupStack::Pop( direction );

            }

        if ( i == 0 || i == 5 )

            {

            EUNIT_ASSERT( iSdpCodec->Direction( *audioLine, sessionAttributes ) == SdpCodecStringConstants::EAttributeSendonly );

            }

        else if ( i == 1 || i == 6 )

            {

            EUNIT_ASSERT( iSdpCodec->Direction( *audioLine, sessionAttributes ) == SdpCodecStringConstants::EAttributeRecvonly );

            }

        else if ( i == 2 || i == 7 )

            {

            EUNIT_ASSERT( iSdpCodec->Direction( *audioLine, sessionAttributes ) == SdpCodecStringConstants::EAttributeInactive );

            }

        else if ( i == 3 || i == 8 )

            {

            EUNIT_ASSERT( iSdpCodec->Direction( *audioLine, sessionAttributes ) == SdpCodecStringConstants::EAttributeSendrecv );

            }

        else if ( i == 4 || i == 9 )

            {

            EUNIT_ASSERT( iSdpCodec->Direction( *audioLine, sessionAttributes ) == KErrNotFound );

            }

        audioLine->AttributeFields().ResetAndDestroy();

        sessionAttributes.ResetAndDestroy();

        }

    CleanupStack::PopAndDestroy( audioLine );

    CleanupStack::PopAndDestroy();//sessionAttributes

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_ConvertDesToUintLL()

    {

    EUNIT_ASSERT( CMceSdpCodec::ConvertDesToUintL( _L8("10") ) == 10 );

    EUNIT_ASSERT_LEAVE( CMceSdpCodec::ConvertDesToUintL( _L8("Yada, Yada") ) );

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_ConvertDesToIntLL()

    {

    EUNIT_ASSERT( CMceSdpCodec::ConvertDesToIntL( _L8("10") ) == 10 );

    EUNIT_ASSERT_LEAVE( CMceSdpCodec::ConvertDesToIntL( _L8("Yada, Yada") ) );

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_ConvertTRealToDesLCL()

    {

    TReal real = 10.2304;

    HBufC8* realDes = NULL;

    realDes = CMceSdpCodec::ConvertTRealToDesLC( real );

    EUNIT_ASSERT( *realDes == _L8("10.2304") );

    CleanupStack::PopAndDestroy( realDes );

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_ConvertDesToRealLL()

    {

    EUNIT_ASSERT( CMceSdpCodec::ConvertDesToRealL( _L8("10.2304") ) == 10.2304 );

    EUNIT_ASSERT_LEAVE( CMceSdpCodec::ConvertDesToRealL( _L8("Yada, Yada") ) );

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_IsPayloadTypeSupportedL()

    {

	EUNIT_ASSERT(iSdpCodec->IsPayloadTypeSupported(KMceSDPNameAMR, KDefaultAmrNbPT)==EFalse);

    iSdpCodec->AddCapabilityL(KMceSDPNameAMR);

    iSdpCodec->AddCapabilityPayloadTypeL(KDefaultAmrNbPT);

    EUNIT_ASSERT(iSdpCodec->IsPayloadTypeSupported(KMceSDPNameAMR, KDefaultAmrNbPT)==ETrue);

    }

void UT_CMceSdpCodec::UT_CMceSdpCodec_AddCapabilityPayloadTypeLL()

    {

    iSdpCodec->AddCapabilityPayloadTypeL(KDefaultAmrNbPT);

    EUNIT_ASSERT(iSdpCodec->iCapabilitiesPT.Count() > 0 );

    }

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE( 

    UT_CMceSdpCodec,

    "CMceSdpCodec tests",

    "UNIT" )

EUNIT_TEST (

    "Media test",

    "CMceSdpCodec",

    "Media",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_MediaL, Teardown)

EUNIT_TEST (

    "Decodes test",

    "CMceSdpCodec",

    "Decodes",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_DecodesL, Teardown)

EUNIT_TEST (

    "AddCapabilityL test",

    "CMceSdpCodec",

    "AddCapabilityL",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_AddCapabilityLL, Teardown)

EUNIT_TEST (

    "IsSupported test",

    "CMceSdpCodec",

    "IsSupported",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_IsSupportedL, Teardown)

EUNIT_TEST (

    "PrepareForEncodeL test",

    "CMceSdpCodec",

    "PrepareForEncodeL",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_PrepareForEncodeLL, Teardown)

EUNIT_TEST (

    "EncodeRtpMapFieldsL test",

    "CMceSdpCodec",

    "EncodeRtpMapFieldsL",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_EncodeRtpMapFieldsLL, Teardown)

EUNIT_TEST (

    "Direction test",

    "CMceSdpCodec",

    "Direction",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_DirectionL, Teardown)

EUNIT_TEST (

    "ConvertDesToUintL test",

    "CMceSdpCodec",

    "ConvertDesToUintL",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_ConvertDesToUintLL, Teardown)

EUNIT_TEST (

    "ConvertDesToIntL test",

    "CMceSdpCodec",

    "ConvertDesToIntL",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_ConvertDesToIntLL, Teardown)

EUNIT_TEST (

    "ConvertTRealToDesLC test",

    "CMceSdpCodec",

    "ConvertTRealToDesLC",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_ConvertTRealToDesLCL, Teardown)

EUNIT_TEST (

    "ConvertDesToRealL test",

    "CMceSdpCodec",

    "ConvertDesToRealL",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_ConvertDesToRealLL, Teardown)

EUNIT_TEST (

    "IsPayloadTypeSupported test",

    "CMceSdpCodec",

    "IsPayloadTypeSupported",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_IsPayloadTypeSupportedL, Teardown)

EUNIT_TEST (

    "AddCapabilityPayloadType test",

    "CMceSdpCodec",

    "AddCapabilityPayloadType",

    "FUNCTIONALITY",

    SetupL, UT_CMceSdpCodec_AddCapabilityPayloadTypeLL, Teardown)

EUNIT_END_TEST_TABLE

//  END OF FILE