/*

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

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

//  INTERNAL INCLUDES

#include "MCETestHelper.h"

#include "mcesipsession.h"

#include "mcesipstatemachine.h"

#include "mceservercore.h"

#include "mcecssession.h"

#include "mcecssessionimplementation.h"

#include "mcesipconnection.h"

#include "mcecomsession.h"

#include "mcestateidle.h"

#include "mceevent.h"

#include "mceserial.h"

#include "mcemediamanager.h"

#include "mcenatsipsession.h"

// CONSTRUCTION

UT_CMceStateIdle* UT_CMceStateIdle::NewL()

    {

    UT_CMceStateIdle* self = UT_CMceStateIdle::NewLC(); 

    CleanupStack::Pop();

    return self;

    }

UT_CMceStateIdle* UT_CMceStateIdle::NewLC()

    {

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

    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_CMceStateIdle::~UT_CMceStateIdle()

    {

    }

// Default constructor

UT_CMceStateIdle::UT_CMceStateIdle()

    {

    }

// Second phase construct

void UT_CMceStateIdle::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CMceStateIdle::SetupL()

    {

    CMCETls::OpenL();

    SdpCodecStringPool::OpenL();

    //TMceIds ids;

    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->NextState( KMceStateIdle );

    iState = static_cast<CMceStateIdle*>(&iSipSession->CurrentState());

    }

void UT_CMceStateIdle::Teardown()

    {

    CMCETls::Close();

	delete iSession;

    delete iServerCore;

    SdpCodecStringPool::Close();

    }

void UT_CMceStateIdle::UT_CMceStateIdle_AcceptLL()

    {

    TMceIds ids;

    CMceMsgBase* msg = NULL;

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

    EUNIT_ASSERT ( iState->AcceptL( event1 ) );

    TMceStateTransitionEvent event2( *iSipSession, EMceInvite );

    EUNIT_ASSERT ( iState->AcceptL( event2 ) );

    TMceStateTransitionEvent event3( *iSipSession, EMceMediaUpdated );

    TRAPD( e1, iState->AcceptL( event3 ) );

    EUNIT_ASSERT ( e1 == KErrTotalLossOfPrecision );

    TMceStateTransitionEvent event4( *iSipSession, EMceItcUpdate, ids, *msg );

    TRAPD( e2, iState->AcceptL( event4 ) );

    EUNIT_ASSERT ( e2 == KErrTotalLossOfPrecision );

    TMceStateTransitionEvent event5( *iSipSession, EMceCancel, KErrNotFound );

    TRAPD( e3, iState->AcceptL( event5 ) );

    EUNIT_ASSERT ( e3 == KErrTotalLossOfPrecision );

    TMceStateTransitionEvent event8( *iSipSession, EMceMediaUpdated );

    TRAPD( e6, iState->AcceptL( event8 ) );

    EUNIT_ASSERT ( e6 == KErrTotalLossOfPrecision );    

    }

void UT_CMceStateIdle::UT_CMceStateIdle_EntryLL()

    {

//Invite

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

    CleanupStack::PushL( clientSession );

    CMceMsgObject<CMceComSession>* clientSessionMsg = 

        new (ELeave) CMceMsgObject<CMceComSession>( *clientSession, EMceItcMsgTypeSession );

    CleanupStack::Pop( clientSession );

    clientSessionMsg->PushL();

    CleanupStack::PushL( clientSessionMsg );

    TMceIds ids;

    iStorage->iMediaManagerUpdateStatus = KMceAsync;

    TMceStateTransitionEvent event1( *iSipSession, EMceItcEstablishSession, ids, 

                                     *clientSessionMsg );

    iState->EntryL( event1 );

    CleanupStack::PopAndDestroy( clientSessionMsg );

    EUNIT_ASSERT ( iStorage->iMediaManagerAction == CMCETls::EUpdate );

    EUNIT_ASSERT ( iStorage->iMediaManagerSdpAction == CMCETls::ENone );

    EUNIT_ASSERT ( iSipSession->Body() == clientSession );

    EUNIT_ASSERT ( iSipSession->Body()->iSIPContent == NULL );

    EUNIT_ASSERT ( iSipSession->Offer() == NULL );

    delete iSipSession->iBody;

    iSipSession->iBody = NULL;

    clientSession = CMceComSession::NewL( CMceComSession::EOutSession );

    CleanupStack::PushL( clientSession );

    clientSessionMsg = 

        new (ELeave) CMceMsgObject<CMceComSession>( *clientSession, EMceItcMsgTypeSession );

    CleanupStack::Pop( clientSession );

    clientSessionMsg->PushL();

    CleanupStack::PushL( clientSessionMsg );

    iStorage->iMediaManagerUpdateStatus = KMceReady;

    TMceStateTransitionEvent event1_1( *iSipSession, EMceItcEstablishSession, ids, 

                                       *clientSessionMsg );

    iState->EntryL( event1_1 );

    CleanupStack::PopAndDestroy( clientSessionMsg );

    EUNIT_ASSERT ( iStorage->iMediaManagerAction == CMCETls::EUpdate );

    EUNIT_ASSERT ( iStorage->iMediaManagerSdpAction == CMCETls::EEncode );

    EUNIT_ASSERT ( iSipSession->Body() == clientSession );

    EUNIT_ASSERT ( iSipSession->Body()->iSIPContent == NULL );

    EUNIT_ASSERT ( iSipSession->Offer() != NULL );

    delete iSipSession->iOffer;

    iSipSession->iOffer = NULL;

//Invited    

    iSipSession->Body()->iType = CMceComSession::EInSession;

    RPointerArray<CSIPHeaderBase> sipHeaders;

    CSIPHeaderBase::PushLC( &sipHeaders );

    // Supported: timer 

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

	CleanupClosePushL( timerKey );

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

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

    CleanupStack::Pop( supportedHeader );

    CleanupStack::PopAndDestroy();//timerKey

    // 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 );

    iSipSession->iPendingReceivedRequests.AppendL( srvtransaction );

    CleanupStack::Pop( srvtransaction );

    TMceStateTransitionEvent event2( *iSipSession, EMceInvite );

    iState->EntryL( event2 );

    EUNIT_ASSERT ( iStorage->iMediaManagerAction == CMCETls::EUpdate );

    iStorage->iMediaManagerAction = CMCETls::ENone;

    iStorage->iMediaManagerDecodeStatus = KMceSipWarnMediaTypeNotAvailable;

    TMceStateTransitionEvent event3( *iSipSession, EMceInvite );

    iState->EntryL( event3 );

    EUNIT_ASSERT ( iStorage->iMediaManagerAction == CMCETls::ENone );

    EUNIT_ASSERT ( iStorage->iSipSentResponse->StatusCode() == KMceSipNotAcceptableHere );

    EUNIT_ASSERT ( iSipSession->Body() != NULL );

    EUNIT_ASSERT ( iSipSession->BodyCandidate() == NULL );

    EUNIT_ASSERT ( iSipSession->Body()->iType == CMceComSession::EInSession );

    EUNIT_ASSERT ( iSipSession->Body()->iSIPContent == NULL );

    TMceStateTransitionEvent event4( *iSipSession, EMceCancel );

    iState->EntryL( event4 );

    CSIPServerTransaction& request = iSipSession->Request();

    CSIPRequestElements* requestElement = const_cast<CSIPRequestElements*>(request.RequestElements());

    requestElement->MessageElements().SetContent( NULL );

    TMceStateTransitionEvent event2_2( *iSipSession, EMceInvite );

    iState->EntryL( event2_2 );

    }

void UT_CMceStateIdle::UT_CMceStateIdle_ExitLL()

    {

    TMceIds ids;

    CMceMsgBase* msg = NULL;

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

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

    event1.ParamStatus() = KMceAsync;

    iState->ExitL( event1 );

    EUNIT_ASSERT ( iSipSession->CurrentState().Id() == KMceStateClientEstablishing );

    EUNIT_ASSERT ( iSipSession->iBody->iState == CMceSession::EOffering );

    EUNIT_ASSERT ( ids.iState == CMceSession::EOffering );

    MCE_SET_STATES( iSipSession /*session*/, 

                    CMceSession::EIdle /*clientState*/, 

                    KMceStateIdle /*serverState*/ );

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

    event1_1.ParamStatus() = KMceReady;

    iState->ExitL( event1_1 );

    EUNIT_ASSERT ( iSipSession->CurrentState().Id() == KMceStateOffering );

    EUNIT_ASSERT ( iSipSession->iBody->iState == CMceSession::EOffering );

    EUNIT_ASSERT ( ids.iState == CMceSession::EOffering );

    MCE_SET_STATES( iSipSession /*session*/, 

                    CMceSession::EIdle /*clientState*/, 

                    KMceStateIdle /*serverState*/ );

    EUNIT_ASSERT ( iSipSession->CurrentState().Id() == KMceStateIdle );

    MCE_TH_SET( iSipSession->iBody, NULL );

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

    TMceStateTransitionEvent event2( *iSipSession, EMceInvite );

    iState->ExitL( event2 );

    EUNIT_ASSERT ( iSipSession->CurrentState().Id() == KMceStateServerEstablishing );

    EUNIT_ASSERT ( iSipSession->iBody->iState == CMceSession::EIncoming );

    MCE_SET_STATES( iSipSession /*session*/, 

                    CMceSession::EIdle /*clientState*/, 

                    KMceStateIdle /*serverState*/ );

    TMceStateTransitionEvent event3( *iSipSession, EMceCancel );

    iState->ExitL( event3 );

    MCE_SET_STATES( iSipSession /*session*/, 

                    CMceSession::EIdle /*clientState*/, 

                    KMceStateIdle /*serverState*/ );

    }

// INVITE received for a NAT session

void UT_CMceStateIdle::UT_CMceStateIdle_ExitL_NatSessionL()

	{

	CMceSipManager& manager = iServerCore->Manager();

    TUint32 profileId = 1;

    CSIPProfile& profile = manager.ProfileL( profileId );

	// Syncronous case

	CMceNatSipSession* natSession =

		CMceNatSipSession::NewLC( *iSession,

								  iSipSession->SIPConnection(),

								  *iSipSession->iStateMachine,

								  profile,

								  NULL );

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

    TMceIds ids;

    CMceMsgBase* msg = NULL;

    CSIPServerTransaction* trx = 

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

    CleanupStack::PushL(trx);

    EUNIT_ASSERT( &natSession->Request() == NULL );

    natSession->iPendingReceivedRequests.AppendL( trx );

    CleanupStack::Pop(trx);

    EUNIT_ASSERT( &natSession->Request() == trx );

    // TODO: remove natSession->iComSession = natSession->iBody;

    natSession->iType = CMceCsSubSession::EInSession; // make this MT case

	TMceStateTransitionEvent event( *natSession, EMceInvite );

	event.ParamStatus() = KMceReady;

	iState->ExitL( event );

	EUNIT_ASSERT( natSession->CurrentState().Id() ==

				  KMceStateServerInitializing );

	// Asyncronous case

	natSession->NextState( KMceStateIdle );

    event.ParamStatus() = KMceAsync;

    iState->ExitL( event );

	EUNIT_ASSERT( natSession->CurrentState().Id() ==

				  KMceStateServerInitializing );

	// Error case

	natSession->NextState( KMceStateIdle );

    event.ParamStatus() = KErrGeneral;

    iState->ExitL( event );

	EUNIT_ASSERT( natSession->CurrentState().Id() == KMceStateTerminated );

	CleanupStack::PopAndDestroy( natSession );

	}

// Pull mode INVITE received for a NAT session

void UT_CMceStateIdle::UT_CMceStateIdle_ExitL_NatSession1L()

	{

	CMceSipManager& manager = iServerCore->Manager();

    TUint32 profileId = 1;

    CSIPProfile& profile = manager.ProfileL( profileId );

	// Syncronous case

	CMceNatSipSession* natSession =

		CMceNatSipSession::NewLC( *iSession,

								  iSipSession->SIPConnection(),

								  *iSipSession->iStateMachine,

								  profile,

								  NULL );

	TMceStateTransitionEvent event( *natSession, EMceInvite );

	event.ParamStatus() = KMceReady;

	iState->ExitL( event );

	EUNIT_ASSERT( natSession->CurrentState().Id() ==

				  KMceStateServerEstablishing );

	// Error case

	natSession->NextState( KMceStateIdle );

    event.ParamStatus() = KErrGeneral;

    iState->ExitL( event );

	EUNIT_ASSERT( natSession->CurrentState().Id() == KMceStateTerminated );

	CleanupStack::PopAndDestroy( natSession );

	}

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE( 

    UT_CMceStateIdle,

    "UT_CMceStateIdle",

    "UNIT" )

EUNIT_TEST(

    "AcceptL - test ",

    "CMceStateIdle",

    "AcceptL",

    "FUNCTIONALITY",

    SetupL, UT_CMceStateIdle_AcceptLL, Teardown)

EUNIT_TEST(

    "EntryL - test ",

    "CMceStateIdle",

    "EntryL",

    "FUNCTIONALITY",

    SetupL, UT_CMceStateIdle_EntryLL, Teardown)

EUNIT_TEST(

    "ExitL - test ",

    "CMceStateIdle",

    "ExitL",

    "FUNCTIONALITY",

    SetupL, UT_CMceStateIdle_ExitLL, Teardown)

EUNIT_TEST(

    "ExitL - NAT session",

    "CMceStateIdle",

    "ExitL",

    "FUNCTIONALITY",

    SetupL, UT_CMceStateIdle_ExitL_NatSessionL, Teardown)

EUNIT_TEST(

    "ExitL - NAT Pull Mode",

    "CMceStateIdle",

    "ExitL",

    "FUNCTIONALITY",

    SetupL, UT_CMceStateIdle_ExitL_NatSession1L, Teardown)

EUNIT_END_TEST_TABLE

//  END OF FILE