/*

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

#include "musavasettingsimp.h"

#include "musavaobserverimp.h"

#include "musavaavailabilityobserver.h"

#include "musavaavailabilityobserverimp.h"

#include "muslogger.h"

//  EXTERNAL INCLUDES

#include <EscapeUtils.h>

#include <digia/eunit/eunitmacros.h>

#include <sipstrings.h>

#include <sipstrconsts.h>

#include <stringpool.h>

#include <sipservertransaction.h>

#include <siptransactionbase.h>

#include <digia/eunit/eunitdecorators.h>

//  INTERNAL INCLUDES

#include "musavaoptionhandler.h"

#include "musavacapabilitytesthelper.h"

#include "CSipSseTestTls.h"

#include "musavaCapabilityExchange.h"

#include "musavacapabilitysipagent.h"

#include "MusAvaCapabilityQuery.h"

#include "musavaterminal.h"

#include "sipprofile.h"

#include "musavasharedobject.h"

#include "mussettingskeys.h"

#include "mussettings.h"

#include "musavasip.h"

// CONSTRUCTION

UT_CMusAvaCapabilitySipAgent* UT_CMusAvaCapabilitySipAgent::NewL()

    {

    UT_CMusAvaCapabilitySipAgent* self = UT_CMusAvaCapabilitySipAgent::NewLC(); 

    CleanupStack::Pop();

    return self;

    }

UT_CMusAvaCapabilitySipAgent* UT_CMusAvaCapabilitySipAgent::NewLC()

    {

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

    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_CMusAvaCapabilitySipAgent::~UT_CMusAvaCapabilitySipAgent()

    {

    }

// Default constructor

UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent()

    {

    }

// Second phase construct

void UT_CMusAvaCapabilitySipAgent::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CMusAvaCapabilitySipAgent::SetupL(  )

    {

    iSharedObject = CMusAvaSharedObject::GetSingletonL();

    iAvailabilityObserver = CMusAvaAvailabilityObserverImp::NewL();

    iConcreteSettings = CMusAvaSettingsImp::NewL();

    iOptionHandler = CMusAvaOptionHandler::NewL( *iAvailabilityObserver,

                                                 *iConcreteSettings );

    iExchange = iOptionHandler->iCapabilityExchange;

    iSipAgent = CMusAvaCapabilitySipAgent::NewL( *iExchange, 

                                                *iOptionHandler->iSharedObj,

                                                 iOptionHandler->iObserver);

    iCapability = iOptionHandler->iSwisCapability;

    MSIPConnectionObserver& connectionObserver = 

                            iSharedObject->MusAvaSip().ConnectionObserver();

    CSIP& sip = iSharedObject->MusAvaSip().Sip();

    iSharedObject->MusAvaSip().CreateProfileL();

    iProfile = iSharedObject->MusAvaSip().Profile();

    TUint32 iapId;

    TInt err = iProfile->GetParameter( KSIPAccessPointId, iapId );

    iSIPConnection = CSIPConnection::NewL( sip, 

                                           iapId,

                                           connectionObserver );

    iSharedObject->MusAvaSip().ConnectionL(); // Forced connection creation

    if ( !iProfile->iArray )

        {

        iProfile->iArray = new ( ELeave ) CDesC8ArrayFlat( 1 );

        iProfile->iArray->AppendL( _L8("sip:user@domain.com") );

        }

    if ( !iProfile->iRegisteredContact )

        {

        iProfile->iRegisteredContact = KRegisteredContact().AllocL();

        }

    CSipSseTestTls::OpenL();

    iStorage = CSipSseTestTls::Storage();

    iProfileId = MultimediaSharingSettings::SipProfileSettingL();

    } 

void UT_CMusAvaCapabilitySipAgent::Teardown(  )

    {

    CMusAvaSharedObject::DeleteSingleton();

    if ( iStorage )

       {

       iStorage->Clear();

       CSipSseTestTls::Close();

       iStorage = NULL;

       }

    delete iSipAgent;

    delete iOptionHandler;

    delete iConcreteSettings;

    delete iAvailabilityObserver;

    delete iSIPConnection;

    }

void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_NewLL(  )

    {

    EUNIT_ASSERT( iSipAgent );

    }

void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_ExecuteCapabilityQueryLL(  )

    {

    EUNIT_ASSERT( iSipAgent );

    EUNIT_ASSERT( iExchange->Terminals().Count() == 0 );

    TInt ret = NULL;

    TRAPD ( error, ret = iSharedObject->MusAvaSip().CreateProfileL() );

    if ( error == KErrNoMemory ) User::Leave( error );

    EUNIT_ASSERT( ret );

    MultimediaSharingSettings::SetSipProfileSettingL( 1 );

    iSipAgent->ExecuteCapabilityQueryL( *iCapability, 

                                        KCapabilityTestSIPAddressUri_B );

    EUNIT_ASSERT( iStorage->iClientRequest->Method() == 

                            SIPStrings::StringF( SipStrConsts::EOptions ) );

    EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().Content().Length() > 0 );

    EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().ContentType() );

    EUNIT_ASSERT( iStorage->iClientRequest->RemoteUri().Uri().UriDes().Compare( 

            KCapabilityTestSIPAddressUri8_B ) == 0);

    EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().UserHeaders().Count() == 6 );

    MUS_HEADER_ASSERT( iStorage->iClientRequest, 0, KCapabilityTestAcceptContactHeader );

    MUS_HEADER_ASSERT( iStorage->iClientRequest, 5, KCapabilityTestContactHeader_A1Updated );

    MUS_HEADER_ASSERT( iStorage->iClientRequest, 3, KCapabilityTestAcceptHeader );

    }

void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_IncomingRequestL(  )

    {

    CSIPServerTransaction* request = CapabilityTestHelper::OptionsRequestL( 

                                                KCapabilityTestAddress_A,

                                                KCapabilityTestAddress_B,

                                                KCapabilitySwisFeature,

                                                KCapabilitySwisFeature,

                                                KCapabilityTestAcceptHeader,

                                                KCapabilityTestTerminalID_B );

    TUint32 iapId = iSIPConnection->IapId();

    /*EUNIT_ASSERT( iSipAgent->IncomingRequest( iapId, request ) == KErrNone );

    EUNIT_ASSERT( server->iResponseToRequest == SIPStrings::StringF( SipStrConsts::EOptions ) );

    EUNIT_ASSERT( server->iClientResponse->StatusCode() == KMUSAVASIP200 );

    EUNIT_ASSERT( server->iClientResponse->MessageElements().Content().Length() > 0 );

    EUNIT_ASSERT( server->iClientResponse->MessageElements().Content().Compare( KCapabilityTestSDP ) == 0 );

    EUNIT_ASSERT( server->iClientResponse->MessageElements().UserHeaders().Count() == 1 );

    MUS_HEADER_ASSERT( server->iClientResponse, 0, KCapabilityTestContactHeader_A );

    */

    EUNIT_ASSERT( iSipAgent->IncomingRequest( iapId, request ) == KErrNotFound );

    delete request;

    EUNIT_ASSERT( !iOptionHandler->iCapabilityQueryAnswered );  

    iOptionHandler->iObserver.AvailabilityChanged(MMusAvaObserver::EMusAvaOptionHandler,

            MMusAvaObserver::EMusAvaStatusCallOnHold);

    request = CapabilityTestHelper::OptionsRequestL( 

                                                KCapabilityTestAddress_A,

                                                KCapabilityTestAddress_B,

                                                KCapabilitySwisFeature,

                                                KCapabilitySwisFeature,

                                                KCapabilityTestAcceptHeader,

                                                KCapabilityTestTerminalID_B );    

    EUNIT_ASSERT( iSipAgent->IncomingRequest( request ) == KErrNotFound );

    delete request;

    iOptionHandler->iObserver.AvailabilityChanged(MMusAvaObserver::EMusAvaOptionHandler,

                MMusAvaObserver::EMusAvaStatusOptionsNotSent);

    request = CapabilityTestHelper::OptionsRequestL( 

                                                 KCapabilityTestAddress_A,

                                                 KCapabilityTestAddress_B,

                                                 KCapabilitySwisFeature,

                                                 KCapabilitySwisFeature,

                                                 KCapabilityTestAcceptHeader,

                                                 KCapabilityTestTerminalID_B );    

    EUNIT_ASSERT( iSipAgent->IncomingRequest( request ) == KErrNone );   

    iOptionHandler->iCapabilityQueryAnswered = ETrue; 

    EUNIT_ASSERT( iOptionHandler->iCapabilityQueryAnswered );

    request = CapabilityTestHelper::OptionsRequestL( 

                                                KCapabilityTestAddress_A,

                                                KCapabilityTestAddress_B,

                                                KCapabilitySwisFeature,

                                                KCapabilitySwisFeature,

                                                KCapabilityTestAcceptHeader,

                                                KCapabilityTestTerminalID_B );

    EUNIT_ASSERT( iSipAgent->IncomingRequest( request ) == KErrNotFound ); 

    delete request;

    CSIPServerTransaction* transaction = 

                CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EInvite ) );

    iStorage->SetError( KErrGeneral );

    EUNIT_ASSERT( iSipAgent->IncomingRequest( transaction ) == KErrNone );   

    iStorage->SetError( KErrNone );

    }

void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_HandleIncomingRequestLL(  )

    {

    CSIPServerTransaction* transaction = 

    CSIPServerTransaction::NewL( SIPStrings::StringF( SipStrConsts::EInvite ) );

    CleanupStack::PushL( transaction );

    transaction->iIsClientTransaction = ETrue;

    transaction->iState = CSIPTransactionBase::ETrying; 

    TUriParser8 Uri;

    User::LeaveIfError( Uri.Parse( KCapabilityTestAddress_A ) );

  	CUri8* uri = CUri8::NewLC( Uri );

    CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri ); 

    CleanupStack::Pop( uri );

    CleanupStack::PushL( requestelements );

    requestelements->SetMethodL( SIPStrings::StringF( SipStrConsts::EInvite ) );

    transaction->SetRequestElements( requestelements );

    CleanupStack::Pop( requestelements );

    iSipAgent->HandleIncomingRequestL( *transaction );

    //iSipAgent->IncomingRequest( transaction );

    EUNIT_ASSERT( iStorage->iClientResponse->ReasonPhrase() == 

                SIPStrings::StringF( SipStrConsts::EPhraseNotImplemented ) );

    EUNIT_ASSERT( iStorage->iClientResponse->StatusCode() == KMUSAVASIPNotImplemented );

    CleanupStack::PopAndDestroy( transaction );

    }

void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_IncomingResponseL(  )

    {

    CMusAvaCapabilityQuery* query = NULL;

    MultimediaSharingSettings::SetOperatorVariantSettingL( 

                                        MusSettingsKeys::EStandard );

//init

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

        {

        query = CMusAvaCapabilityQuery::NewL( *iCapability,

                                            *iSIPConnection,

                                            *iProfile,

                                            KCapabilityTestSIPAddressUri_B );

        CleanupStack::PushL( query );

        EUNIT_ASSERT( query->Result() ==  KCapabilityQueryNotReady );

        EUNIT_ASSERT( query->State() == CMusAvaCapabilityQueryBase::ECapabilityQueryCreated );

        EUNIT_ASSERT( !query->iTimer );

        EUNIT_ASSERT( !query->iTrx );

        EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

        if ( i == 0 )

            {

            EUNIT_ASSERT( query->Terminal().Id().Length() == 0 );

            }

        else

            {

            EUNIT_ASSERT( query->Terminal().Id().Length() > 0 );

            EUNIT_ASSERT( query->Terminal().Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

            }

        EUNIT_ASSERT( !query->Terminal().RequestedQuery() );

        EUNIT_ASSERT( !query->Terminal().IsDiscovered() );

        // Since several queries cannot be executed, we delete the old one... 

        delete query->iTerminal->iQuery;

        query->iTerminal->iQuery = NULL;

        // ...before execution

        query->Terminal().ExecuteQueryL( query );

        CleanupStack::Pop( query );

        EUNIT_ASSERT( query->Terminal().iQuery == query );

        EUNIT_ASSERT( query->Result() ==  KCapabilityQueryNotReady );

        EUNIT_ASSERT( query->State() == CMusAvaCapabilityQueryBase::ECapabilityQueryExecuting );

        EUNIT_ASSERT( !query->iTimer );

        EUNIT_ASSERT( query->iTrx );

        EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

        if ( i == 0 )

            {

            EUNIT_ASSERT( query->Terminal().Id().Length() == 0 );

            }

        else

            {

            EUNIT_ASSERT( query->Terminal().Id().Length() > 0 );

            EUNIT_ASSERT( query->Terminal().Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

            }

        HBufC* uri16 = EscapeUtils::ConvertToUnicodeFromUtf8L( query->Terminal().Uri() );

        EUNIT_ASSERT( uri16->Compare( KCapabilityTestSIPAddressUri_B ) == 0 );

        delete uri16;

        uri16 = NULL;

        EUNIT_ASSERT( !query->Terminal().RequestedQuery() );

        EUNIT_ASSERT( !query->Terminal().IsDiscovered() );

        EUNIT_ASSERT( iStorage->iClientRequest->Method() == SIPStrings::StringF( SipStrConsts::EOptions ) );

        EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().Content().Length() > 0 );

        EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().ContentType() );

        EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().UserHeaders().Count() == 6 );

        MUS_HEADER_ASSERT( iStorage->iClientRequest, 0, KCapabilityTestAcceptContactHeader );

        MUS_HEADER_ASSERT( iStorage->iClientRequest, 5, KCapabilityTestContactHeader_A1Updated );

        MUS_HEADER_ASSERT( iStorage->iClientRequest, 3, KCapabilityTestAcceptHeader );

    //set response

        //    GSMA     Cingular

        if ( i == 0 || i == 3 )//200 OK FT

            {

            CapabilityTestHelper::SetResponseL( *query->iTrx, KMUSAVASIP200, SipStrConsts::EPhraseOk,

                                          KCapabilityTestAddress_B,

                                          KCapabilitySwisFeature,

                                          KCapabilityTestTerminalID_B,

                                          KPAssertedIdentity_B,

                                          KCapabilityTestSDP );

            }

        //         GSMA     Cingular

        else if ( i == 1 || i == 4 )//200 OK NO FT

            {

            CapabilityTestHelper::SetResponseL( *query->iTrx, KMUSAVASIP200, SipStrConsts::EPhraseOk,

                                          KCapabilityTestAddress_B,

                                          KNullDesC8,

                                          KCapabilityTestTerminalID_B,

                                          KPAssertedIdentity_B,

                                          KCapabilityTestSDP );

            }

        else if ( i == 2 )//GSMA & 404

            {

            CapabilityTestHelper::SetResponseL( *query->iTrx, KMUSAVASIPNotFound, SipStrConsts::EPhraseNotFound,

                                          KCapabilityTestAddress_B,

                                          KNullDesC8,

                                          KNullDesC8,

                                          KNullDesC8,

                                          KNullDesC8 );

            }

        if ( i == 4 )

            {

            EUNIT_ASSERT( 

                MultimediaSharingSettings::OperatorVariantSettingL() ==

                                                MusSettingsKeys::EStandard );

                // set cingular variant key on

            MultimediaSharingSettings::SetOperatorVariantSettingL( 

                                        MusSettingsKeys::EOperatorSpecific );

            EUNIT_ASSERT( MultimediaSharingSettings::OperatorVariantSettingL()

                        == MusSettingsKeys::EOperatorSpecific );

            }

        iSipAgent->IncomingResponse( *query->iTrx );

        EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

        TInt count = 0;

        EUNIT_GET_ALLOC_DECORATOR_FAILCOUNT( count );

        if ( count == 0 )

            {

            EUNIT_ASSERT( query->Terminal().Id().Length() > 0 );

            EUNIT_ASSERT( query->Terminal().Id().Compare( KCapabilityTestTerminalID_B ) == 0 );

            uri16 = EscapeUtils::ConvertToUnicodeFromUtf8L( query->Terminal().Uri() );

            //EUNIT_ASSERT( uri16->Compare( iOptionHandler->SipAddressProposal() ) == 0 );

            delete uri16;

            uri16 = NULL;

            EUNIT_ASSERT( !query->Terminal().RequestedQuery() );

            if ( i == 0 || i == 3 )//200 OK FT

                {

                EUNIT_ASSERT( 

                    MultimediaSharingSettings::OperatorVariantSettingL() ==

                                                MusSettingsKeys::EStandard );

                EUNIT_ASSERT( query->Terminal().iQuery->State() == CMusAvaCapabilityQueryBase::ECapabilityQueryCompleted );

                EUNIT_ASSERT( query->Terminal().IsDiscovered() );

                EUNIT_ASSERT( !query->Retrying() );

                EUNIT_ASSERT( query->iTimer == NULL );

                }

            else if ( i == 1 )//GSMA & 200 OK NO FT

                {

                EUNIT_ASSERT( 

                    MultimediaSharingSettings::OperatorVariantSettingL() ==

                                                MusSettingsKeys::EStandard );

                EUNIT_ASSERT( query->Terminal().iQuery == query );

                EUNIT_ASSERT( query->Terminal().iQuery->Result() == KCapabilityCapabilitesNotFound );

                EUNIT_ASSERT( query->Terminal().IsDiscovered() );

                EUNIT_ASSERT( !query->Retrying() );

                EUNIT_ASSERT( query->iTimer == NULL );

                }

            else if ( i == 4 )//( not yet Cingular) & 200 OK NO FT

                {

                EUNIT_ASSERT( MultimediaSharingSettings::OperatorVariantSettingL()

                        == MusSettingsKeys::EOperatorSpecific );

                MultimediaSharingSettings::SetOperatorVariantSettingL( 

                                        MusSettingsKeys::EStandard );

                EUNIT_ASSERT( query->Terminal().iQuery == query );

                EUNIT_ASSERT( query->Terminal().iQuery->Result() == KCapabilityCapabilitesNotFound );

                EUNIT_ASSERT( query->Terminal().IsDiscovered() );

                EUNIT_ASSERT( !query->Retrying() );

                EUNIT_ASSERT( query->iTimer == NULL );

                }

            else if ( i == 2 )  //GSMA & 404

                {

                EUNIT_ASSERT( 

                    MultimediaSharingSettings::OperatorVariantSettingL() ==

                                                    MusSettingsKeys::EStandard );

                EUNIT_ASSERT( !query->Terminal().iQuery == NULL );

                EUNIT_ASSERT( !query->Terminal().IsDiscovered() );

                EUNIT_ASSERT( query->Retrying() );

                EUNIT_ASSERT( query->iTimer != NULL );

                query->OnExpiredL( KErrNone );

                EUNIT_ASSERT( iStorage->iClientRequest->Method() == SIPStrings::StringF( SipStrConsts::EOptions ) );

                EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().Content().Length() > 0 );

                EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().ContentType() );

                EUNIT_ASSERT( iStorage->iClientRequest->MessageElements().UserHeaders().Count() == 6 );

                MUS_HEADER_ASSERT( iStorage->iClientRequest, 0, KCapabilityTestAcceptContactHeader );

                MUS_HEADER_ASSERT( iStorage->iClientRequest, 5, KCapabilityTestContactHeader_A1Updated );

                MUS_HEADER_ASSERT( iStorage->iClientRequest, 3, KCapabilityTestAcceptHeader );

                CapabilityTestHelper::SetResponseL( *query->iTrx, KMUSAVASIPNotFound, SipStrConsts::EPhraseNotFound,

                                          KCapabilityTestAddress_B,

                                          KNullDesC8,

                                          KNullDesC8,

                                          KNullDesC8,

                                          KNullDesC8 );

                //iExchange->AnswerToQueryReceived( *query->iTrx );

                iSipAgent->IncomingResponse( *query->iTrx );

                EUNIT_ASSERT( query->Terminal().iQuery == query );

                EUNIT_ASSERT( query->Terminal().iQuery->Result() == KCapabilityCapabilitesNotFound );

                EUNIT_ASSERT( query->Terminal().IsDiscovered() );

                EUNIT_ASSERT( !query->Retrying() );

                EUNIT_ASSERT( query->iTimer == NULL );

                }

            }

        else

            {

            break;    

            }

        }

    }

void UT_CMusAvaCapabilitySipAgent::UT_CMusAvaCapabilitySipAgent_ErrorOccuredL(  )

    {

    CMusAvaCapabilityQuery* query = NULL;

    query = CMusAvaCapabilityQuery::NewL( *iCapability,

                                            *iSIPConnection,

                                            *iProfile,

                                            KCapabilityTestSIPAddressUri_B );

    CleanupStack::PushL( query );

    EUNIT_ASSERT( query->Result() ==  KCapabilityQueryNotReady );

    EUNIT_ASSERT( query->State() == 

                    CMusAvaCapabilityQueryBase::ECapabilityQueryCreated );

    EUNIT_ASSERT( !query->iTimer );

    EUNIT_ASSERT( !query->iTrx );

    EUNIT_ASSERT( iExchange->Terminals().Count() == 1 );

    EUNIT_ASSERT( query->Terminal().Id().Length() == 0 );

    EUNIT_ASSERT( !query->Terminal().RequestedQuery() );

    EUNIT_ASSERT( !query->Terminal().IsDiscovered() );

    query->Terminal().ExecuteQueryL( query );

    CleanupStack::Pop( query );

    EUNIT_ASSERT( query->Terminal().iQuery == query );

    EUNIT_ASSERT( query->Result() ==  KCapabilityQueryNotReady );

    EUNIT_ASSERT( query->State() ==