/*

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

//  EXTERNAL INCLUDES

#include <digia/eunit/EUnitMacros.h>

#include <sdpcodecstringpool.h>

#include <sdpdocument.h>

#include <sdpmediafield.h>

#include <sdpattributefield.h>

#include "mcemediamanager.h"

#include "mcesdpsession.h"

#include "mcesrvsource.h"

#include "mcesrvsink.h"

#include "mceaudiosdpcodec.h"

#include "sdpcodecstringconstants.h"

#include "mcemediastate.h"

#define RESET()\

    iServer->Reset()

#include "mcepreconditions.h"

#define CONSTANT( constant ) iPreconditions->constant

#define DEFINE_QOSLINES()\

    CSdpAttributeField* qos1 = NULL;\

    CSdpAttributeField* qos2 = NULL;\

    CSdpAttributeField* qos3 = NULL;\

    CSdpAttributeField* qos4 = NULL;\

    CSdpAttributeField* qos5 = NULL;\

    CSdpAttributeField* qos6 = NULL

#define CREATE_QOS4( media, line1, line2, line3, line4 )\

    qos4 = CSdpAttributeField::DecodeLC( _L8( line4 ) );\

    qos3 = CSdpAttributeField::DecodeLC( _L8( line3 ) );\

    qos2 = CSdpAttributeField::DecodeLC( _L8( line2 ) );\

    qos1 = CSdpAttributeField::DecodeLC( _L8( line1 ) );\

    media->AttributeFields().AppendL( qos1 );\

    CleanupStack::Pop( qos1 );\

    media->AttributeFields().AppendL( qos2 );\

    CleanupStack::Pop( qos2 );\

    media->AttributeFields().AppendL( qos3 );\

    CleanupStack::Pop( qos3 );\

    media->AttributeFields().AppendL( qos4 );\

    CleanupStack::Pop( qos4 );

#define CREATE_QOS5( media, line1, line2, line3, line4, line5 )\

    CREATE_QOS4( media, line1, line2, line3, line4 );\

    qos5 = CSdpAttributeField::DecodeLC( _L8( line5 ) );\

    media->AttributeFields().AppendL( qos5 );\

    CleanupStack::Pop( qos5 )

#define CREATE_QOS6( media, line1, line2, line3, line4, line5, line6 )\

    CREATE_QOS5( media, line1, line2, line3, line4, line5 );\

    qos6 = CSdpAttributeField::DecodeLC( _L8( line6 ) );\

    media->AttributeFields().AppendL( qos6 );\

    CleanupStack::Pop( qos6 )

#define ASSERT_QOS1( media, ind, attr1, line1 )\

    EUNIT_ASSERT( media->AttributeFields()[ind+0]->Attribute().DesC() == _L8( attr1 ) );\

    EUNIT_ASSERT( media->AttributeFields()[ind+0]->Value() == _L8( line1 ) )

#define ASSERT_QOS2( media, ind, attr1, line1, attr2, line2 )\

    ASSERT_QOS1( media, ind, attr1, line1 );\

    EUNIT_ASSERT( media->AttributeFields()[ind+1]->Attribute().DesC() == _L8( attr2 ) );\

    EUNIT_ASSERT( media->AttributeFields()[ind+1]->Value() == _L8( line2 ) );

#define ASSERT_QOS4( media, ind, attr1, line1, attr2, line2, attr3, line3, attr4, line4 )\

    ASSERT_QOS2( media, ind, attr1, line1, attr2, line2 );\

    EUNIT_ASSERT( media->AttributeFields()[ind+2]->Attribute().DesC() == _L8( attr3 ) );\

    EUNIT_ASSERT( media->AttributeFields()[ind+2]->Value() == _L8( line3 ) );\

    EUNIT_ASSERT( media->AttributeFields()[ind+3]->Attribute().DesC() == _L8( attr4 ) );\

    EUNIT_ASSERT( media->AttributeFields()[ind+3]->Value() == _L8( line4 ) )

#define ASSERT_QOS5( media, ind, attr1, line1, attr2, line2, attr3, line3, attr4, line4, attr5, line5 )\

    ASSERT_QOS4( media, ind, attr1, line1, attr2, line2, attr3, line3, attr4, line4 );\

    EUNIT_ASSERT( media->AttributeFields()[ind+4]->Attribute().DesC() == _L8( attr5 ) );\

    EUNIT_ASSERT( media->AttributeFields()[ind+4]->Value() == _L8( line5 ) )

#define ASSERT_QOS6( media, ind, attr1, line1, attr2, line2, attr3, line3, attr4, line4, attr5, line5, attr6, line6 )\

    ASSERT_QOS5( media, ind, attr1, line1, attr2, line2, attr3, line3, attr4, line4, attr5, line5 );\

    EUNIT_ASSERT( media->AttributeFields()[ind+5]->Attribute().DesC() == _L8( attr6 ) );\

    EUNIT_ASSERT( media->AttributeFields()[ind+5]->Value() == _L8( line6 ) )

#define ASSERT_QOS7( media, ind, attr1, line1, attr2, line2, attr3, line3, attr4, line4, attr5, line5, attr6, line6, attr7, line7 )\

    ASSERT_QOS6( media, ind, attr1, line1, attr2, line2, attr3, line3, attr4, line4, attr5, line5, attr6, line6 );\

    EUNIT_ASSERT( media->AttributeFields()[ind+6]->Attribute().DesC() == _L8( attr7 ) );\

    EUNIT_ASSERT( media->AttributeFields()[ind+6]->Value() == _L8( line7 ) )

//  INTERNAL INCLUDES

// CONSTRUCTION

UT_TMceSegmentedPreconditions* UT_TMceSegmentedPreconditions::NewL()

    {

    UT_TMceSegmentedPreconditions* self = UT_TMceSegmentedPreconditions::NewLC(); 

    CleanupStack::Pop();

    return self;

    }

UT_TMceSegmentedPreconditions* UT_TMceSegmentedPreconditions::NewLC()

    {

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

    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_TMceSegmentedPreconditions::~UT_TMceSegmentedPreconditions()

    {

    }

// Default constructor

UT_TMceSegmentedPreconditions::UT_TMceSegmentedPreconditions()

    {

    }

// Second phase construct

void UT_TMceSegmentedPreconditions::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_TMceSegmentedPreconditions::SetupL()

    {

    iServer = new (ELeave) CMceServerStub();

    iManager = CMceMediaManager::NewL( *iServer );

    iSession = MceMediaManagerTestHelper::CreateMultimediaOutSessionL();

    iSession->SetObserver( *iServer );

    iManager->CreateSessionL( *iSession );

    iPreconditions = new (ELeave) TMceSegmentedPreconditions( *(iSession->Streams()[0]) );

    iPreconditions->ConstructL();

    } 

void UT_TMceSegmentedPreconditions::Teardown()

    {

	delete iSdpDocument;

	CMceComSession::Delete( iSession, *iManager );

	delete iManager;

	iManager = NULL;

	delete iServer;

	iServer = NULL;

	delete iPreconditions;

    }

void UT_TMceSegmentedPreconditions::UT_TMceSegmentedPreconditions_DoConstructLL()

    {

    EUNIT_ASSERT( iPreconditions->iStream.Direction() == SdpCodecStringConstants::EAttributeSendrecv );

    iPreconditions->DoConstructL();

    EUNIT_ASSERT( iPreconditions->iCurrentLocalStatus == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iCurrentRemoteStatus == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iDesiredLocalSend == CONSTANT( iKAttributeMandatory ) );

    EUNIT_ASSERT( iPreconditions->iDesiredLocalRecv == CONSTANT( iKAttributeMandatory ) );

    EUNIT_ASSERT( iPreconditions->iDesiredRemoteSend == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iDesiredRemoteRecv == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iConfirmation == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iState == TMcePreconditions::ECreated );

    iPreconditions->iStream.Enable( EFalse, ETrue );

    iPreconditions->iStream.iLinkedStream->Enable( EFalse, ETrue );

    EUNIT_ASSERT( iPreconditions->iStream.Direction() == SdpCodecStringConstants::EAttributeInactive );

    iPreconditions->DoConstructL();

    EUNIT_ASSERT( iPreconditions->iCurrentLocalStatus == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iCurrentRemoteStatus == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iDesiredLocalSend == CONSTANT( iKAttributeMandatory ) );

    EUNIT_ASSERT( iPreconditions->iDesiredLocalRecv == CONSTANT( iKAttributeMandatory ) );

    EUNIT_ASSERT( iPreconditions->iDesiredRemoteSend == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iDesiredRemoteRecv == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iConfirmation == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iState == TMcePreconditions::ECreated );

    iPreconditions->iStream.Enable( ETrue, ETrue );

    iPreconditions->iStream.iLinkedStream->Enable( EFalse, ETrue );

    EUNIT_ASSERT( iPreconditions->iStream.Direction() == SdpCodecStringConstants::EAttributeRecvonly );

    iPreconditions->DoConstructL();

    EUNIT_ASSERT( iPreconditions->iCurrentLocalStatus == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iCurrentRemoteStatus == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iDesiredLocalSend == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iDesiredLocalRecv == CONSTANT( iKAttributeMandatory ) );

    EUNIT_ASSERT( iPreconditions->iDesiredRemoteSend == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iDesiredRemoteRecv == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iConfirmation == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iState == TMcePreconditions::ECreated );

    iPreconditions->iStream.Enable( EFalse, ETrue );

    iPreconditions->iStream.iLinkedStream->Enable( ETrue, ETrue );

    EUNIT_ASSERT( iPreconditions->iStream.Direction() == SdpCodecStringConstants::EAttributeSendonly );

    iPreconditions->DoConstructL();

    EUNIT_ASSERT( iPreconditions->iCurrentLocalStatus == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iCurrentRemoteStatus == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iDesiredLocalSend == CONSTANT( iKAttributeMandatory ) );

    EUNIT_ASSERT( iPreconditions->iDesiredLocalRecv == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iDesiredRemoteSend == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iDesiredRemoteRecv == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iConfirmation == CONSTANT( iKAttributeNone ) );

    EUNIT_ASSERT( iPreconditions->iState == TMcePreconditions::ECreated );

    }

void UT_TMceSegmentedPreconditions::UT_TMceSegmentedPreconditions_EncodeLL()

    {

    RStringF audio = MCE_SDP_STRING_AUDIOL();

    RStringF protocol = SDP_STRINGL( SdpCodecStringConstants::EProtocolRtpAvp );

    CSdpMediaField* audioLine = 

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

    const TInt KCases = 4;

    const TInt KVariants = 2;

    const TInt KSendRecv = 0;

    const TInt KInactive = 1;

    const TInt KSendOnly = 2;

    const TInt KRecvOnly = 3;

    const TInt KNotReserved = 0;

    const TInt KReserved = 1;

//offerer    

    iPreconditions->iStream.Session()->NegotiationState().SetRole( EMceRoleOfferer );

    for ( TInt casendx = 0;casendx < KCases ;casendx++ )

        {

        for (TInt variant = 0;variant < KVariants; variant++)

            {

            audioLine->AttributeFields().ResetAndDestroy();

            iPreconditions->iState = TMcePreconditions::ECreated;

            switch( casendx )

                {

                case KSendRecv:

                    {

                    iPreconditions->iStream.Enable( ETrue, ETrue );

                    iPreconditions->iStream.iLinkedStream->Enable( ETrue, ETrue );

                    EUNIT_ASSERT( iPreconditions->iStream.Direction() == SdpCodecStringConstants::EAttributeSendrecv );

                    break;

                    }

                case KInactive:

                    {

                    iPreconditions->iStream.Enable( EFalse, ETrue );

                    iPreconditions->iStream.iLinkedStream->Enable( EFalse, ETrue );

                    EUNIT_ASSERT( iPreconditions->iStream.Direction() == SdpCodecStringConstants::EAttributeInactive );

                    break;

                    }

                case KSendOnly:

                    {

                    iPreconditions->iStream.Enable( EFalse, ETrue );

                    iPreconditions->iStream.iLinkedStream->Enable( ETrue, ETrue );

                    EUNIT_ASSERT( iPreconditions->iStream.Direction() == SdpCodecStringConstants::EAttributeSendonly );

                    break;

                    }

                case KRecvOnly:

                    {

                    iPreconditions->iStream.Enable( ETrue, ETrue );

                    iPreconditions->iStream.iLinkedStream->Enable( EFalse, ETrue );

                    EUNIT_ASSERT( iPreconditions->iStream.Direction() == SdpCodecStringConstants::EAttributeRecvonly );

                    break;

                    }

                default:

                    {

                    EUNIT_ASSERT( EFalse );

                    break;

                    }

                }

                iPreconditions->DoConstructL();

                if ( variant == KReserved )

                    {

                    iPreconditions->Reserved();

                    }

                iPreconditions->EncodeL( *audioLine );

                switch( casendx )

                    {

                    case KSendRecv:

                        {

                        if ( variant == KNotReserved )

                            {

                            ASSERT_QOS4( audioLine, 0,

                                         "curr", "qos local none",

                                         "curr", "qos remote none",

                                         "des" , "qos mandatory local sendrecv",

                                         "des" , "qos none remote sendrecv" );

                            }

                        else if ( variant == KReserved )

                            {

                            ASSERT_QOS4( audioLine, 0,

                                         "curr", "qos local sendrecv",

                                         "curr", "qos remote none",

                                         "des" , "qos mandatory local sendrecv",

                                         "des" , "qos none remote sendrecv" );

                            }

                        break;

                        }

                    case KInactive:

                        {

                        if ( variant == KNotReserved )

                            {

                            ASSERT_QOS4( audioLine, 0,

                                         "curr", "qos local none",

                                         "curr", "qos remote none",

                                         "des" , "qos mandatory local sendrecv",

                                         "des" , "qos none remote sendrecv" );

                            }

                        else if ( variant == KReserved )

                            {

                            ASSERT_QOS4( audioLine, 0,

                                         "curr", "qos local sendrecv",

                                         "curr", "qos remote none",

                                         "des" , "qos mandatory local sendrecv",

                                         "des" , "qos none remote sendrecv" );

                            }

                        break;

                        }

                    case KSendOnly:

                        {

                        if ( variant == KNotReserved )

                            {

                            ASSERT_QOS5( audioLine, 0,

                                         "curr", "qos local none",

                                         "curr", "qos remote none",

                                         "des" , "qos mandatory local send",

                                         "des" , "qos none local recv",

                                         "des" , "qos none remote sendrecv" );

                            }

                        else if ( variant == KReserved )

                            {

                            ASSERT_QOS5( audioLine, 0,

                                         "curr", "qos local send",

                                         "curr", "qos remote none",

                                         "des" , "qos mandatory local send",

                                         "des" , "qos none local recv",

                                         "des" , "qos none remote sendrecv" );

                            }

                        break;

                        }

                    case KRecvOnly:

                        {

                        if ( variant == KNotReserved )

                            {

                            ASSERT_QOS5( audioLine, 0,

                                         "curr", "qos local none",

                                         "curr", "qos remote none",

                                         "des" , "qos none local send",

                                         "des" , "qos mandatory local recv",

                                         "des" , "qos none remote sendrecv" );

                            }

                        else if ( variant == KReserved )

                            {

                            ASSERT_QOS5( audioLine, 0,

                                         "curr", "qos local recv",

                                         "curr", "qos remote none",

                                         "des" , "qos none local send",

                                         "des" , "qos mandatory local recv",

                                         "des" , "qos none remote sendrecv" );

                            }

                        break;

                        }

                    default:

                        {

                        EUNIT_ASSERT( EFalse );

                        break;

                        }

                    }

                EUNIT_ASSERT( iPreconditions->iState == TMcePreconditions::ENegotiating );

            }

        }

//answerer

    iPreconditions->iStream.Session()->NegotiationState().SetRole( EMceRoleAnswerer );

    for ( TInt casendx = 0;casendx < KCases ;casendx++ )

        {

        for ( TInt variant = 0;variant < KVariants; variant++)

            {

            audioLine->AttributeFields().ResetAndDestroy();

            iPreconditions->iState = TMcePreconditions::ECreated;

            switch( casendx )

                {

                case KSendRecv:

                    {

                    iPreconditions->iStream.Enable( ETrue, ETrue );

                    iPreconditions->iStream.iLinkedStream->Enable( ETrue, ETrue );

                    iPreconditions->DoConstructL();

                    iPreconditions->iDesiredRemoteSend = CONSTANT( iKAttributeMandatory );

                    iPreconditions->iDesiredRemoteRecv = CONSTANT( iKAttributeMandatory );

                    if ( variant == KReserved )

                        {

                        iPreconditions->iCurrentRemoteStatus = CONSTANT( iKAttributeSendRecv );

                        }

                    EUNIT_ASSERT( iPreconditions->iStream.Direction() == SdpCodecStringConstants::EAttributeSendrecv );

                    break;

                    }

                case KInactive:

                    {

                    iPreconditions->iStream.Enable( EFalse, ETrue );

                    iPreconditions->iStream.iLinkedStream->Enable( EFalse, ETrue );

                    iPreconditions->DoConstructL();

                    iPreconditions->iDesiredRemoteSend = CONSTANT( iKAttributeMandatory );

                    iPreconditions->iDesiredRemoteRecv = CONSTANT( iKAttributeMandatory );

                    if ( variant == KReserved )

                        {

                        iPreconditions->iCurrentRemoteStatus = CONSTANT( iKAttributeSendRecv );

                        }

                    EUNIT_ASSERT( iPreconditions->iStream.Direction() == SdpCodecStringConstants::EAttributeInactive );

                    break;

                    }

                case KSendOnly:

                    {

                    iPreconditions->iStream.Enable( EFalse, ETrue );

                    iPreconditions->iStream.iLinkedStream->Enable( ETrue, ETrue );

                    iPreconditions->DoConstructL();

                    iPreconditions->iDesiredRemoteSend = CONSTANT( iKAttributeMandatory );

                    iPreconditions->iDesiredRemoteRecv = CONSTANT( iKAttributeNone );

                    if ( variant == KReserved )

                        {

                        iPreconditions->iCurrentRemoteStatus = CONSTANT( iKAttributeSend );

                        }

                    EUNIT_ASSERT( iPreconditions->iStream.Direction() == SdpCodecStringConstants::EAttributeSendonly );

                    break;

                    }

                case KRecvOnly:

                    {

                    iPreconditions->iStream.Enable( ETrue, ETrue );

                    iPreconditions->iStream.iLinkedStream->Enable( EFalse, ETrue );

                    iPreconditions->DoConstructL();

                    iPreconditions->iDesiredRemoteSend = CONSTANT( iKAttributeNone );

                    iPreconditions->iDesiredRemoteRecv = CONSTANT( iKAttributeMandatory );

                    if ( variant == KReserved )

                        {

                        iPreconditions->iCurrentRemoteStatus = CONSTANT( iKAttributeRecv );

                        }

                    EUNIT_ASSERT( iPreconditions->iStream.Direction() == SdpCodecStringConstants::EAttributeRecvonly );

                    break;

                    }

                default:

                    {

                    EUNIT_ASSERT( EFalse );

                    break;

                    }

                }

                //local is now always reserved

                iPreconditions->Reserved();

                iPreconditions->EncodeL( *audioLine );

                switch( casendx )

                    {

                    case KSendRecv:

                        {

                        if ( variant == KNotReserved )

                            {

                            //offer:

                            //a=sendrecv

                            //curr: qos local none

                            //curr: qos remote none

                            //des: qos mandatory local sendrecv

                            //des: qos none remote sendrecv

                            ASSERT_QOS5( audioLine, 0,

                                         "curr" , "qos local sendrecv",

                                         "curr" , "qos remote none",

                                         "des"  , "qos mandatory local sendrecv",

                                         "des"  , "qos mandatory remote sendrecv",

                                         "conf" , "qos remote sendrecv" );

                            EUNIT_ASSERT( iPreconditions->iState == TMcePreconditions::ENegotiating );

                            }

                        else if ( variant == KReserved )

                            {

                            //offer:

                            //a=sendrecv

                            //curr: qos local sendrecv

                            //curr: qos remote none

                            //des: qos mandatory local sendrecv

                            //des: qos none remote sendrecv

                            ASSERT_QOS4( audioLine, 0,

                                         "curr", "qos local sendrecv",