/*

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

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

//  INTERNAL INCLUDES

#include "MCETestHelper.h"

#include "mceactionset.h"

#include "mcesipsession.h"

#include "mceservercore.h"

#include "mcecssession.h"

#include "mcecssessionimplementation.h"

#include "mcesipconnection.h"

#include "mcecomsession.h"

#include "siprequireheader.h"

// CONSTRUCTION

UT_TMceActionSet* UT_TMceActionSet::NewL()

    {

    UT_TMceActionSet* self = UT_TMceActionSet::NewLC(); 

    CleanupStack::Pop();

    return self;

    }

UT_TMceActionSet* UT_TMceActionSet::NewLC()

    {

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

    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_TMceActionSet::~UT_TMceActionSet()

    {

    }

// Default constructor

UT_TMceActionSet::UT_TMceActionSet()

    {

    }

// Second phase construct

void UT_TMceActionSet::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_TMceActionSet::SetupL(  )

    {

    CMCETls::OpenL();

    iIds.iProfileID = 1;

    iIds.iManagerType = KMceCSSIPSession;

    iIds.iDialogType = KMceDlgTypeInvite;

    iServerCore = CMceServerCore::NewL();

    iStorage = CMCETls::Storage();

	CDesC8ArrayFlat* params = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );

	CleanupStack::PushL( params );

	params->AppendL( _L8("User <user2@host>") );

	params->AppendL( _L8("User <user@host>") );

    CMceMsgTextArray* msgParams = new (ELeave) CMceMsgTextArray( *params );

    CleanupStack::PushL( msgParams );

    iStorage->StoreL( iIds, *msgParams );

    CleanupStack::PopAndDestroy( msgParams );

    CleanupStack::PopAndDestroy( params );

    iSession = CMceCsSession::NewL( *iServerCore );

    iSession->CreateSubSessionL(iIds, RMessage2());

    iSipSession =  static_cast<CMceSipSession*>((iSession->Implementation().SubSessions())[0]);

    iSipSession->iBody = CMceComSession::NewL( CMceComSession::EInSession );

    } 

void UT_TMceActionSet::Teardown(  )

    {

    CMCETls::Close();

   	delete iSession;

    delete iServerCore;

    }

void UT_TMceActionSet::UT_TMceActionSet_UpdateBodyLL()

    {

  	MCE_DELETE( iSipSession->iBody );

  	TMceActionSet actionSet( *iSipSession );

  	CMceComSession* session = CMceComSession::NewL( CMceComSession::EOutSession );

  	CleanupStack::PushL( session );

    CMceMsgObject<CMceComSession>* msg = new (ELeave) CMceMsgObject<CMceComSession>(

        *session, EMceItcMsgTypeSession );

  	CleanupStack::PushL( msg );

  	TMceIds ids;

  	TMceStateTransitionEvent event( *iSipSession, EMceItcEstablishSession, ids, *msg );

  	// test handling of client provided aor

  	_LIT8( KMceClientProvidedAor, "alice@host");

  	session->SetOriginatorL( KMceClientProvidedAor() );

  	actionSet.UpdateBodyL( ids, *msg );

    EUNIT_ASSERT( 0 == session->iOriginator->Compare( KMceClientProvidedAor ) );

    // test aor reading from SIP profile

    session->SetOriginatorL( KNullDesC8() );

  	EUNIT_ASSERT( NULL == session->iOriginator || 

  	              0 == session->iOriginator->Length() );

  	actionSet.UpdateBodyL( ids, *msg );

  	EUNIT_ASSERT( 0 == session->iOriginator->Compare( KSIPProfileDefAOR ) );

  	CleanupStack::PopAndDestroy( msg );

    CleanupStack::Pop( session );

    }

void UT_TMceActionSet::UT_TMceActionSet_CreateBodyCandidateL()

    {

     // test the functionality of the server side session timer processing

  	TMceActionSet actionSet(*iSipSession);

  	actionSet.CreateBodyCandidateL( CMceComSession::EInSession );

  	CSIPServerTransaction* srvtransaction = 

        MCETestHelper::ServerTransactionL( SipStrConsts::EInvite, ETrue );

    CleanupStack::PushL( srvtransaction );

    iSipSession->iPendingReceivedRequests.AppendL( srvtransaction );

    CleanupStack::Pop( srvtransaction );

    delete iSipSession->iNewBodyCandidate;

    iSipSession->iNewBodyCandidate = NULL;

   	actionSet.CreateBodyCandidateL( CMceComSession::EInSession );

    }

void UT_TMceActionSet::UT_TMceActionSet_ProcessReliableResponseL()

    {

    CSIPClientTransaction* transact183 = MCETestHelper::ClientTransactionLC(

        SipStrConsts::EPhraseSessionProgress, KMceSipSessionProgress, 

        SipStrConsts::EEmpty, ETrue );

    MCETestHelper::SetResponseL( *transact183,

        KMceSipSessionProgress, SipStrConsts::EPhraseSessionProgress, 

        EFalse, ETrue, 1  );

    iSipSession->iResponse = transact183;

    CleanupStack::Pop( transact183 );

    MCETestHelper::SetResponseL( *iSipSession->iResponse, KMceSipRinging, 

        SipStrConsts::EPhraseRinging, EFalse, ETrue, 1 );

    // TMceActionSet does not anymore update SIP session's RSeq value

    TMceStateTransitionEvent event( *iSipSession, EMceProvisionalResponse );

    TMceActionSet actionSet( *iSipSession );

    EUNIT_ASSERT( ETrue == actionSet.ProcessReliableResponse( 

        *iSipSession->iResponse->ResponseElements() ) );

    EUNIT_ASSERT( ETrue == actionSet.ProcessReliableResponse( 

        *iSipSession->iResponse->ResponseElements() ) );

    TUint rseqValueOfLatestResponse 

        = MceSip::RSeq( *iSipSession->Response().ResponseElements() );

    iSipSession->SetRSeq( rseqValueOfLatestResponse );

    EUNIT_ASSERT( EFalse == actionSet.ProcessReliableResponse( 

        *iSipSession->iResponse->ResponseElements() ) );

    }

void UT_TMceActionSet::UT_TMceActionSet_ProcessSessionTimerServerL_1L(  )

    {

    // test the functionality of the server side session timer processing

  	TMceActionSet actionSet(*iSipSession);  

    RPointerArray<CSIPHeaderBase> sipHeaders; 

    CSIPHeaderBase::PushLC( &sipHeaders );

    // Supported: timer 

    RStringF timerKey = SIPStrings::Pool().OpenFStringL( KMceSipTimer() ); 

	CleanupClosePushL( timerKey );

    CSIPSupportedHeader* supportedHeader = CSIPSupportedHeader::NewL( timerKey ); 

    CleanupStack::PopAndDestroy();//timerKey

    CleanupStack::PushL( supportedHeader );

    User::LeaveIfError( sipHeaders.Append( supportedHeader ) );

    CleanupStack::Pop( supportedHeader );

    // Session-Expires: 10    

    CSIPExtensionHeader* sessionExpiresHeader = 

    						CSIPExtensionHeader::NewLC( KSessionExpires(), _L8("10") );

    User::LeaveIfError( sipHeaders.Append( sessionExpiresHeader ) );

    CleanupStack::Pop( sessionExpiresHeader );

    CSIPServerTransaction* srvtransaction = 

        MCETestHelper::ServerTransactionL( SipStrConsts::EInvite, sipHeaders, ETrue );

    CleanupStack::PopAndDestroy( &sipHeaders );

    CleanupStack::PushL( srvtransaction );

	actionSet.ProcessSessionTimerServerL( *srvtransaction );

    CMceComSession* session = iSipSession->Body();

    EUNIT_ASSERT(session->iRecipient->Des().Compare(_L8("User <user@host>")) != KErrNotFound );

    EUNIT_ASSERT(session->iOriginator->Des().Compare(_L8("User <user2@host>")) != KErrNotFound );

    EUNIT_ASSERT(session->iType == CMceComSession::EInSession );

    EUNIT_ASSERT(session->iSIPContentType->Des().Compare(_L8("application/sdp")) != KErrNotFound );

    EUNIT_ASSERT(session->iState == CMceSession::EIncoming );

    EUNIT_ASSERT(session->iTimeout == 10 );

    EUNIT_ASSERT(session->iRefresh == ETrue );

    EUNIT_ASSERT( iStorage->iSipSentResponse == NULL );

	actionSet.SendAnswerL( *srvtransaction );

    EUNIT_ASSERT( iStorage->iSipSentResponse != NULL );

	CSIPResponseElements* rspelements = iStorage->iSipSentResponse;

	CSIPMessageElements& rspmsgelements = rspelements->MessageElements();

	const RPointerArray<CSIPHeaderBase>& usrheaders = rspmsgelements.UserHeaders();

	// Session-Expires:  

    RStringF sessionexp = SIPStrings::Pool().OpenFStringL( KSessionExpires() ); 

	CleanupClosePushL( sessionexp );

	TUint count(0);

	TBool foundSupported = EFalse;

	for(int i = 0; i < usrheaders.Count(); i++)

		{

		HBufC8* value = usrheaders[i]->ToTextValueL();

		if(usrheaders[i]->Name() == SIPStrings::StringF(SipStrConsts::ESupportedHeader))

			{

			if ( value->Find( KMceSipTimer() ) != KErrNotFound )

			    {

			    foundSupported = ETrue;

			    }

			count++;

			}

		else if( usrheaders[i]->Name() == SIPStrings::StringF(SipStrConsts::ERequireHeader))

			{

			EUNIT_ASSERT(value->Find(KMceSipTimer() ) != KErrNotFound );

			count++;

			}

		else if( usrheaders[i]->Name() == sessionexp )

			{

			EUNIT_ASSERT(value->Find( _L8("10;refresher=uas")) != KErrNotFound );

			count++;

			}

		delete value;

		value = NULL;

		}

	EUNIT_ASSERT( count == 4);

    EUNIT_ASSERT( foundSupported );

    CleanupStack::PopAndDestroy(); // sessionexp

   	CleanupStack::PopAndDestroy( srvtransaction );

    }

void UT_TMceActionSet::UT_TMceActionSet_ProcessSessionTimerServerL_2L(  )

    {

    // test the functionality of the server side session timer processing

  	TMceActionSet actionSet(*iSipSession);

    RPointerArray<CSIPHeaderBase> sipHeaders; 

    CSIPHeaderBase::PushLC( &sipHeaders );

    // Supported: timer 

    RStringF timerKey = SIPStrings::Pool().OpenFStringL( KMceSipTimer() ); 

	CleanupClosePushL( timerKey );

    CSIPSupportedHeader* supportedHeader = CSIPSupportedHeader::NewL( timerKey ); 

    CleanupStack::PopAndDestroy();//timerKey

    CleanupStack::PushL( supportedHeader );

    User::LeaveIfError( sipHeaders.Append( supportedHeader ) );

    CleanupStack::Pop( supportedHeader );

    // Session-Expires: 10;refresher=uas    

    CSIPExtensionHeader* sessionExpiresHeader = 

    						CSIPExtensionHeader::NewLC( KSessionExpires(), _L8("10;refresher=uas") );

    User::LeaveIfError( sipHeaders.Append( sessionExpiresHeader ) );

    CleanupStack::Pop( sessionExpiresHeader );

    CSIPServerTransaction* srvtransaction = 

        MCETestHelper::ServerTransactionL( SipStrConsts::EInvite, sipHeaders, ETrue );

    CleanupStack::PopAndDestroy( &sipHeaders );

    CleanupStack::PushL( srvtransaction );

	actionSet.ProcessSessionTimerServerL( *srvtransaction );

    CMceComSession* session = iSipSession->Body();

    EUNIT_ASSERT(session->iTimeout == 10 );

    EUNIT_ASSERT(session->iRefresh );

    EUNIT_ASSERT( iStorage->iSipSentResponse == NULL );

    actionSet.SendAnswerL( *srvtransaction );

    EUNIT_ASSERT( iStorage->iSipSentResponse != NULL );

	CSIPResponseElements* rspelements = iStorage->iSipSentResponse;

	CSIPMessageElements& rspmsgelements = rspelements->MessageElements();

	const RPointerArray<CSIPHeaderBase>& usrheaders = rspmsgelements.UserHeaders();

	// Session-Expires:  

    RStringF sessionexp = SIPStrings::Pool().OpenFStringL( KSessionExpires() ); 

	CleanupClosePushL( sessionexp );

	TUint count(0);

	TBool foundSupported = EFalse;

	for(int i = 0; i < usrheaders.Count(); i++)

		{

		HBufC8* value = usrheaders[i]->ToTextValueL();

		if(usrheaders[i]->Name() == SIPStrings::StringF(SipStrConsts::ESupportedHeader))

			{

			if ( value->Find( KMceSipTimer() ) != KErrNotFound )

			    {

			    foundSupported = ETrue;

			    }

			count++;

			}

		else if( usrheaders[i]->Name() == SIPStrings::StringF(SipStrConsts::ERequireHeader))

			{

			EUNIT_ASSERT(value->Find(KMceSipTimer() ) != KErrNotFound );

			count++;

			}

		else if( usrheaders[i]->Name() == sessionexp )

			{

			EUNIT_ASSERT(value->Find( _L8("10;refresher=uas")) != KErrNotFound );

			count++;

			}

		delete value;

		value = NULL;

		}

	EUNIT_ASSERT( count == 4);

    EUNIT_ASSERT( foundSupported );

	CleanupStack::PopAndDestroy(); // sessionexp

   	CleanupStack::PopAndDestroy( srvtransaction );

    }

void UT_TMceActionSet::UT_TMceActionSet_ProcessSessionTimerServerL_3L(  )

    {

    // test the functionality of the server side session timer processing

  	TMceActionSet actionSet(*iSipSession);

    RPointerArray<CSIPHeaderBase> sipHeaders;

    CSIPHeaderBase::PushLC( &sipHeaders );

    // Supported: timer

    RStringF timerKey = SIPStrings::Pool().OpenFStringL( KMceSipTimer() );

	CleanupClosePushL( timerKey );

    CSIPSupportedHeader* supportedHeader = CSIPSupportedHeader::NewL( timerKey );

    CleanupStack::PopAndDestroy();//timerKey

    CleanupStack::PushL( supportedHeader );

    User::LeaveIfError( sipHeaders.Append( supportedHeader ) );

    CleanupStack::Pop( supportedHeader );

    // x: 10

    CSIPExtensionHeader* sessionExpiresHeader = 

    						CSIPExtensionHeader::NewLC( KSessionExpiresCompactForm(), _L8("10") );

    User::LeaveIfError( sipHeaders.Append( sessionExpiresHeader ) );

    CleanupStack::Pop( sessionExpiresHeader );

    CSIPServerTransaction* srvtransaction = 

        MCETestHelper::ServerTransactionL( SipStrConsts::EInvite, sipHeaders, ETrue );

    CleanupStack::PopAndDestroy( &sipHeaders );

    CleanupStack::PushL( srvtransaction );

	actionSet.ProcessSessionTimerServerL( *srvtransaction );

    CMceComSession* session = iSipSession->Body();

    EUNIT_ASSERT(session->iRecipient->Des().Compare(_L8("User <user@host>")) != KErrNotFound );

    EUNIT_ASSERT(session->iOriginator->Des().Compare(_L8("User <user2@host>")) != KErrNotFound );

    EUNIT_ASSERT(session->iType == CMceComSession::EInSession );

    EUNIT_ASSERT(session->iSIPContentType->Des().Compare(_L8("application/sdp")) != KErrNotFound );

    EUNIT_ASSERT(session->iState == CMceSession::EIncoming );

    EUNIT_ASSERT(session->iTimeout == 10 );

    EUNIT_ASSERT(session->iRefresh == ETrue );

    EUNIT_ASSERT( iStorage->iSipSentResponse == NULL );

	actionSet.SendAnswerL( *srvtransaction );

    EUNIT_ASSERT( iStorage->iSipSentResponse != NULL );

	CSIPResponseElements* rspelements = iStorage->iSipSentResponse;

	CSIPMessageElements& rspmsgelements = rspelements->MessageElements();

	const RPointerArray<CSIPHeaderBase>& usrheaders = rspmsgelements.UserHeaders();

	// Session-Expires:

    RStringF sessionexp = SIPStrings::Pool().OpenFStringL( KSessionExpires() );

	CleanupClosePushL( sessionexp );

	TUint count(0);

	TBool foundSupported = EFalse;

	for(int i = 0; i < usrheaders.Count(); i++)

		{

		HBufC8* value = usrheaders[i]->ToTextValueL();

		if(usrheaders[i]->Name() == SIPStrings::StringF(SipStrConsts::ESupportedHeader))

			{

			if ( value->Find( KMceSipTimer() ) != KErrNotFound )

			    {

			    foundSupported = ETrue;

			    }

			count++;

			}

		else if( usrheaders[i]->Name() == SIPStrings::StringF(SipStrConsts::ERequireHeader))

			{

			EUNIT_ASSERT(value->Find(KMceSipTimer() ) != KErrNotFound );

			count++;

			}

		else if( usrheaders[i]->Name() == sessionexp )

			{

			EUNIT_ASSERT(value->Find( _L8("10;refresher=uas")) != KErrNotFound );

			count++;

			}

		delete value;

		value = NULL;

		}

	EUNIT_ASSERT( count == 4);

    EUNIT_ASSERT( foundSupported );

    CleanupStack::PopAndDestroy(); // sessionexp

   	CleanupStack::PopAndDestroy( srvtransaction );

    }

void UT_TMceActionSet::UT_TMceActionSet_ProcessSessionTimerClientL_1L(  )

    {

    // test the functionality of the client side session timer processing

    TMceActionSet actionSet(*iSipSession);

    RPointerArray<CSIPHeaderBase> sipHeaders; 

    CSIPHeaderBase::PushLC( &sipHeaders );

    // Supported: timer 

    RStringF timerKey = SIPStrings::Pool().OpenFStringL( KMceSipTimer() ); 

	CleanupClosePushL( timerKey );

    CSIPSupportedHeader* supportedHeader = CSIPSupportedHeader::NewL( timerKey ); 

    CleanupStack::PushL( supportedHeader );

    User::LeaveIfError( sipHeaders.Append( supportedHeader ) );

    CleanupStack::Pop( supportedHeader );

    // Session-Expires: 100;refresher=uac    

    CSIPExtensionHeader* sessionExpiresHeader = 

    						CSIPExtensionHeader::NewLC( KSessionExpires(), _L8("100;refresher=uac") );

    User::LeaveIfError( sipHeaders.Append( sessionExpiresHeader ) );

    CleanupStack::Pop( sessionExpiresHeader );

    CSIPClientTransaction* cltransaction = 

        MCETestHelper::ClientTransactionLC( SipStrConsts::EInvite, sipHeaders, KMceSipOK, SipStrConsts::EPhraseOk, ETrue );

    actionSet.ProcessSessionTimerClientL( *cltransaction );

    CleanupStack::PopAndDestroy( cltransaction );

    CMceComSession* session = iSipSession->Body();

    EUNIT_ASSERT( !session->iRefresh );

    // Require: timer

    CSIPRequireHeader* requireHeader = 

    						CSIPRequireHeader::NewLC( timerKey  );

    User::LeaveIfError( sipHeaders.Append( requireHeader ) );

    CleanupStack::Pop( requireHeader );

    CSIPSupportedHeader* supportedHeader2 = CSIPSupportedHeader::NewL( timerKey ); 

    CleanupStack::PushL( supportedHeader2 );

    User::LeaveIfError( sipHeaders.Append( supportedHeader2 ) );

    CleanupStack::Pop( supportedHeader2 );

    // Session-Expires: 100;refresher=uac    

    CSIPExtensionHeader* sessionExpiresHeader2 = 

    						CSIPExtensionHeader::NewLC( KSessionExpires(), _L8("100;refresher=uac") );

    User::LeaveIfError( sipHeaders.Append( sessionExpiresHeader2 ) );

    CleanupStack::Pop( sessionExpiresHeader2 );

    CSIPClientTransaction* cltransaction2 = 

        MCETestHelper::ClientTransactionLC( SipStrConsts::EInvite, sipHeaders, KMceSipOK, SipStrConsts::EPhraseOk, ETrue );

    actionSet.ProcessSessionTimerClientL( *cltransaction2 );

    CleanupStack::PopAndDestroy( cltransaction2 );

    EUNIT_ASSERT( session->iTimeout == 100 );

    EUNIT_ASSERT( session->iRefresh );

    // Require: timer

    CSIPRequireHeader* requireHeader2 = 

    						CSIPRequireHeader::NewLC( timerKey  );

    User::LeaveIfError( sipHeaders.Append( requireHeader2 ) );

    CleanupStack::Pop( requireHeader2 );

    CSIPSupportedHeader* supportedHeader3 = CSIPSupportedHeader::NewL( timerKey ); 

    CleanupStack::PushL( supportedHeader3 );

    User::LeaveIfError( sipHeaders.Append( supportedHeader3 ) );

    CleanupStack::Pop( supportedHeader3 );

    // Session-Expires: 100 <- Failure case