/*

* Copyright (c) 2008 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_tmcesecurepreconditions.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_SECLINES()\

    CSdpAttributeField* sec1 = NULL;\

    CSdpAttributeField* sec2 = NULL;\

    CSdpAttributeField* sec3 = NULL;\

    CSdpAttributeField* sec4 = NULL;\

    CSdpAttributeField* sec5 = NULL;\

    CSdpAttributeField* sec6 = NULL

#define CREATE_SEC2( media, line1, line2 )\

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

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

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

    CleanupStack::Pop( sec1 );\

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

    CleanupStack::Pop( sec2 );

#define CREATE_SEC3( media, line1, line2, line3 )\

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

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

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

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

    CleanupStack::Pop( sec1 );\

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

    CleanupStack::Pop( sec2 );\

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

    CleanupStack::Pop( sec3 );

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

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

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

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

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

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

    CleanupStack::Pop( sec1 );\

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

    CleanupStack::Pop( sec2 );\

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

    CleanupStack::Pop( sec3 );\

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

    CleanupStack::Pop( sec4 );

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

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

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

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

    CleanupStack::Pop( sec5 )

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

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

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

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

    CleanupStack::Pop( sec6 )

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

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

    EUNIT_ASSERT_EQUALS( _L8( line1 ), media->AttributeFields()[ind+0]->Value() )

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

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

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

    EUNIT_ASSERT_EQUALS( _L8( line2 ), media->AttributeFields()[ind+1]->Value() );

#define ASSERT_SEC3( media, ind, attr1, line1, attr2, line2, attr3, line3 )\

    ASSERT_SEC2( 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 ) );    

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

    ASSERT_SEC2( 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_SEC5( media, ind, attr1, line1, attr2, line2, attr3, line3, attr4, line4, attr5, line5 )\

    ASSERT_SEC4( 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_SEC6( media, ind, attr1, line1, attr2, line2, attr3, line3, attr4, line4, attr5, line5, attr6, line6 )\

    ASSERT_SEC5( 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_SEC7( media, ind, attr1, line1, attr2, line2, attr3, line3, attr4, line4, attr5, line5, attr6, line6, attr7, line7 )\

    ASSERT_SEC6( 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_TMceSecurePreconditions* UT_TMceSecurePreconditions::NewL()

    {

    UT_TMceSecurePreconditions* self = UT_TMceSecurePreconditions::NewLC(); 

    CleanupStack::Pop();

    return self;

    }

UT_TMceSecurePreconditions* UT_TMceSecurePreconditions::NewLC()

    {

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

    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_TMceSecurePreconditions::~UT_TMceSecurePreconditions()

    {

    }

// Default constructor

UT_TMceSecurePreconditions::UT_TMceSecurePreconditions()

    {

    }

// Second phase construct

void UT_TMceSecurePreconditions::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_TMceSecurePreconditions::SetupL()

    {

    iServer = new (ELeave) CMceServerStub();

    iManager = CMceMediaManager::NewL( *iServer );

    iSession = MceMediaManagerTestHelper::CreateMultimediaOutSessionL();

    iSession->SetObserver( *iServer );

    iManager->CreateSessionL( *iSession );

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

    iPreconditions->ConstructL();

    } 

void UT_TMceSecurePreconditions::Teardown()

    {

    if ( iSdpDocument )

    	{

    	delete iSdpDocument;

    	}

    iSdpDocument = NULL;

	CMceComSession::Delete( iSession, *iManager );

	delete iManager;

	iManager = NULL;

	delete iServer;

	iServer = NULL;

	delete iPreconditions;

    }

void UT_TMceSecurePreconditions::UT_TMceSecurePreconditions_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->iDesiredLocalSendRecv == CONSTANT( iKAttributeMandatory ) );

    EUNIT_ASSERT( iPreconditions->iDesiredRemoteSendRecv == 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->iDesiredLocalSendRecv == CONSTANT( iKAttributeMandatory ) );

    EUNIT_ASSERT( iPreconditions->iDesiredRemoteSendRecv == 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->iDesiredLocalSendRecv == CONSTANT( iKAttributeMandatory ) );

    EUNIT_PRINT( iPreconditions->iDesiredRemoteSendRecv.DesC() );

    EUNIT_ASSERT( iPreconditions->iDesiredRemoteSendRecv == 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->iDesiredLocalSendRecv == CONSTANT( iKAttributeMandatory ) );

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

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

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

    }

void UT_TMceSecurePreconditions::UT_TMceSecurePreconditions_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_SEC2( audioLine, 0,

                                         "curr", "sec e2e none",

                                         "des" , "sec optional e2e sendrecv");

                            }

                        else if ( variant == KReserved )

                            {

                            ASSERT_SEC2( audioLine, 0,

                                         "curr", "sec e2e sendrecv",

                                         "des" , "sec optional e2e sendrecv" );

                            }

                        break;

                        }

                    case KInactive:

                        {

                        if ( variant == KNotReserved )

                            {

                            ASSERT_SEC2( audioLine, 0,

                                         "curr", "sec e2e none",

                                         "des" , "sec optional e2e sendrecv" );

                            }

                        else if ( variant == KReserved )

                            {

                            ASSERT_SEC2( audioLine, 0,

                                         "curr", "sec e2e sendrecv",

                                         "des" , "sec optional e2e sendrecv" );

                            }

                        break;

                        }

                    case KSendOnly:

                        {

                        if ( variant == KNotReserved )

                            {

                            ASSERT_SEC2( audioLine, 0,

                                         "curr", "sec e2e none",

                                         "des" , "sec optional e2e sendrecv" );

                            }

                        else if ( variant == KReserved )

                            {

                            ASSERT_SEC2( audioLine, 0,

                                         "curr", "sec e2e sendrecv",

                                         "des" , "sec optional e2e sendrecv" );

                            }

                        break;

                        }

                    case KRecvOnly:

                        {

                        if ( variant == KNotReserved )

                            {

                            ASSERT_SEC2( audioLine, 0,

                                         "curr", "sec e2e none",

                                         "des" , "sec optional e2e sendrecv" );

                            }

                        else if ( variant == KReserved )

                            {

                            ASSERT_SEC2( audioLine, 0,

                                         "curr", "sec e2e sendrecv",

                                         "des" , "sec optional e2e 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->iDesiredRemoteSendRecv = 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->iDesiredRemoteSendRecv = 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->iDesiredRemoteSendRecv = CONSTANT( iKAttributeMandatory );

                    if ( variant == KReserved )

                        {

                        iPreconditions->iCurrentRemoteStatus = CONSTANT( iKAttributeSendRecv );

                        }

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

                    break;

                    }

                case KRecvOnly:

                    {

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

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

                    iPreconditions->DoConstructL();

                    iPreconditions->iDesiredRemoteSendRecv = CONSTANT( iKAttributeMandatory );

                    if ( variant == KReserved )

                        {

                        iPreconditions->iCurrentRemoteStatus = CONSTANT( iKAttributeSendRecv );

                        }

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

                    break;

                    }

                default:

                    {

                    EUNIT_ASSERT( EFalse );

                    break;

                    }

                }

                //local is now always reserved

                switch( casendx )

                    {

                    case KSendRecv:

                    case KSendOnly:

                    case KRecvOnly:

                        {

                        if ( variant == KNotReserved )

                            {

                            iPreconditions->Reserved();

                            iPreconditions->iCurrentLocalStatus = CONSTANT( iKAttributeNone );

			                iPreconditions->EncodeL( *audioLine );

            			    EUNIT_PRINT ( iPreconditions->iCurrentLocalStatus.DesC());

                			EUNIT_PRINT ( iPreconditions->iCurrentRemoteStatus.DesC());

                            EUNIT_PRINT( iPreconditions->iConfirmation.DesC());

                            ASSERT_SEC3( audioLine, 0,

                                         "curr" , "sec e2e recv",

                                         "des"  , "sec mandatory e2e sendrecv",

                                         "conf" , "sec e2e sendrecv" );

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

                            }

                        else if ( variant == KReserved )

                            {

                            iPreconditions->Reserved();

                			iPreconditions->EncodeL( *audioLine );

                			EUNIT_PRINT ( iPreconditions->iCurrentLocalStatus.DesC());

                			EUNIT_PRINT ( iPreconditions->iCurrentRemoteStatus.DesC());

                            ASSERT_SEC2( audioLine, 0,

                                         "curr" , "sec e2e sendrecv",

                                         "des"  , "sec mandatory e2e sendrecv" );

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

                            }