/*

* Copyright (c) 2002-2009 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:          ?Description

*

*/

// INCLUDE FILES

#include <e32math.h>

#include "senhostletconnectionbctest.h"

#include <SenFacet.h>

//  EXTERNAL INCLUDES

#include <SenServiceConnection.h>

#include <SenServicePattern.h>

//  INTERNAL INCLUDES

#include <SenHttpTransportProperties.h>

#include "SenHostletConnection.h"

#include "testconsumer.h"

#include "testhostlet.h"

#include <SenTransportProperties.h>

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

// -----------------------------------------------------------------------------

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

//Macro for Porting to STIF

#define LOCAL_ASSERT(expression)	{if(!(expression)){return KErrArgument;}}

#define LOCAL_VOID_ASSERT(expression)	{if(!(expression)){return ;}}

namespace

    {

    _LIT8(KHostletEndpoint, "hostlet://UnitTestHostlet");

    _LIT8(KHostletEndpoint1, "hostlet://UnitTestHostlet-1");

    _LIT8(KHostletContract, "urn:nokia.com.serene:unit-test-hostlet");

    _LIT8(KHostletContract1, "urn:nokia.com.serene:unit-test-hostlet-1");  

    void threadMainL(TAny* aPtr)

        {

        TConsumerTestTask* pTask = (TConsumerTestTask*) aPtr;

        pTask->Execute();

        // Go safely out of scope (will destroy this thread)

        }

    TInt threadFunction(TAny* aPtr)

        {

        CTrapCleanup* pCleanup = CTrapCleanup::New();

        CActiveScheduler::Install(NULL); // remove one

        CActiveScheduler* pScheduler = new (ELeave) CActiveScheduler();

        CActiveScheduler::Install(pScheduler);

        TInt leaveCode(KErrNone);

        TRAP(leaveCode, threadMainL(aPtr));

        CActiveScheduler::Install(NULL); // uninstall scheduler

        delete pScheduler;

        delete pCleanup;

        return leaveCode;

        }

    TInt CreateThreadForConsumerTask(RThread& aThread, const TDesC& aThreadName, TConsumerTestTask& aTask)

        {

        TName threadName(aThreadName);

        // Append a random number to make it unique

        threadName.AppendNum(Math::Random(), EHex);

#ifdef EKA2

        RAllocator& heap = User::Allocator(); // RHeap is deprecated in EKA2

        return aThread.Create(threadName, // name

                              threadFunction,

                              KDefaultStackSize,

                              &heap,

                              &aTask);

#else // EKA1

        RHeap& heap = User::Heap();

        return aThread.Create(threadName, // name

                              threadFunction,

                              KDefaultStackSize,

                              &heap,

                              &aTask);

#endif // EKA        

        }      

    }   

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CSenServiceManagerBCTest::Case

// Returns a test case by number.

//

// This function contains an array of all available test cases 

// i.e pair of case name and test function. If case specified by parameter

// aCaseNumber is found from array, then that item is returned.

// 

// The reason for this rather complicated function is to specify all the

// test cases only in one place. It is not necessary to understand how

// function pointers to class member functions works when adding new test

// cases. See function body for instructions how to add new test case.

// -----------------------------------------------------------------------------

//

const TCaseInfo CSenHostletConnectionBCTest::Case ( 

    const TInt aCaseNumber ) const 

     {

    /**

    * To add new test cases, implement new test case function and add new 

    * line to KCases array specify the name of the case and the function 

    * doing the test case

    * In practice, do following

    * 1) Make copy of existing test case function and change its name

    *    and functionality. Note that the function must be added to 

    *    SenServiceManager_stif.cpp file and to SenServiceManager_stif.h 

    *    header file.

    *

    * 2) Add entry to following KCases array either by using:

    *

    * 2.1: FUNCENTRY or ENTRY macro

    * ENTRY macro takes two parameters: test case name and test case 

    * function name.

    *

    * FUNCENTRY macro takes only test case function name as a parameter and

    * uses that as a test case name and test case function name.

    *

    * Or

    *

    * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used

    * only with OOM (Out-Of-Memory) testing!

    *

    * OOM_ENTRY macro takes five parameters: test case name, test case 

    * function name, TBool which specifies is method supposed to be run using

    * OOM conditions, TInt value for first heap memory allocation failure and 

    * TInt value for last heap memory allocation failure.

    * 

    * OOM_FUNCENTRY macro takes test case function name as a parameter and uses

    * that as a test case name, TBool which specifies is method supposed to be

    * run using OOM conditions, TInt value for first heap memory allocation 

    * failure and TInt value for last heap memory allocation failure. 

    */ 

    static TCaseInfoInternal const KCases[] =

        {

        // To add new test cases, add new items to this array

        // NOTE: When compiled to GCCE, there must be Classname::

        // declaration in front of the method name, e.g. 

        // CSenServiceManagerBCTest::PrintTest. Otherwise the compiler

        // gives errors.

		ENTRY("NewL - CSenHostletConnectionBCTest ", CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL),

		ENTRY("NewLC - CSenHostletConnectionBCTest ", CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLCL),

		ENTRY("Identifier - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_IdentifierL), 

		ENTRY("FrameworkId - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_FrameworkIdL), 

		ENTRY("RequestUtf8 - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_RequestUtf8L), 

		ENTRY("ThreadId - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_ThreadIdL), 

		ENTRY("ConsumerId - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_ConsumerIdL), 

		ENTRY("RequestId - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_RequestIdL), 

		ENTRY("NewLC - CSenHostletConnectionBCTest ", CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLC_3InvokesL),

		ENTRY("RespondL1 - CSenHostletConnectionBCTest ", CSenHostletConnectionBCTest::UT_CSenHostletConnection_RespondL1L),

		ENTRY("RespondL2 - CSenHostletConnectionBCTest ", CSenHostletConnectionBCTest::UT_CSenHostletConnection_RespondL2L),

		ENTRY("RespondL3 - CSenHostletConnectionBCTest ", CSenHostletConnectionBCTest::UT_CSenHostletConnection_RespondL3L),

		ENTRY("RespondL negative response code - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_Negative_ResponseCodeL),

		ENTRY("RespondL self def URI - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_HC_SelfDef_URIL),

/*    

		ENTRY("RespondL delete HC after SC is created - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_Delete_HCL),

*/

		ENTRY("NewL leaves with KErrSenEndpointReserved -CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_Two_Equal_UID3L),

		ENTRY("RespondL Two HC with the same Endpoints UIDs - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_Two_Equal_EndpointsL),    

		ENTRY("RespondL Two HC Two SC diff contracts - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_Two_HC_Two_SC1L),    

		ENTRY("RespondL Two HC Two SC diff endpionts - CSenHostletConnectionBCTest",CSenHostletConnectionBCTest::UT_CSenHostletConnection_Two_HC_Two_SC2L),    

		ENTRY("RespondL Two HC Two SC diff endpionts the same contract - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_Two_HC_Two_SC3L),    

		ENTRY("RespondL Delete SC before calling HC::RespondL - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_DeleteSC_before_HCRespondLL),    

		ENTRY("RespondL Call RespondL multipe times - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_RespondL_4multipleTimesL),    

		ENTRY("RespondL SC::Cancel after request - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_SC_Cancel_After_RequestL),    

		ENTRY("RespondL Set Expose Facet - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_Set_Expose_FacetL),    

		ENTRY("HC responds with TP - ", CSenHostletConnectionBCTest::UT_CSenHostletConnection_RespondWithPropertiesL),    

		//ENTRY("New REST SC + SubmitL Test - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_CreateConnAndSubmit_Rest_MultiThreadL),    

/*

		ENTRY("New WS-I SC + SubmitL Test - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_CreateConnAndSubmit_WSI_MultiThreadL),    

		ENTRY("SendL WS-I Test - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_Send_WSIL),    

		ENTRY("Desc EP + SendL WS-I Test - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_DescEndpoint_Send_WSIL),    

*/

		ENTRY("SendL from 2 SCs to 1 HC - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_2SC1HCL), 

/*

// NOTE: following is used instead:

// --> UT_CSenHostletConnection_CreateConnAndSubmit_Rest_MultiThreadL 

		ENTRY("SubmitL (multit.), Rest Test - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_Submit_Rest_MultiThreadL),    

// NOTE: following is used instead:

// --> UT_CSenHostletConnection_CreateConnAndSubmit_Rest_MultiThreadL 

		ENTRY("SubmitL (active), Rest Test - CSenHostletConnectionBCTest", CSenHostletConnectionBCTest::UT_CSenHostletConnection_Submit_Rest_ActiveL),

*/        

	 	};

	    // Verify that case number is valid

	    if( (TUint) aCaseNumber >= sizeof( KCases ) / 

	                               sizeof( TCaseInfoInternal ) )

	        {

	        // Invalid case, construct empty object

	        TCaseInfo null( (const TText*) L"" );

	        null.iMethod = NULL;

	        null.iIsOOMTest = EFalse;

	        null.iFirstMemoryAllocation = 0;

	        null.iLastMemoryAllocation = 0;

	        return null;

	        } 

	    // Construct TCaseInfo object and return it

	    TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );

	    tmp.iMethod = KCases[ aCaseNumber ].iMethod;

	    tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;

	    tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;

	    tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;

	    return tmp;

	    }   

//  METHODS

void CSenHostletConnectionBCTest::SetupL ()

    {

    __UHEAP_MARK;

    }

void CSenHostletConnectionBCTest::Teardown ()

    {

//    User::After( 2 * 1000 * 1000 ); // temp tests

    __UHEAP_MARKEND;

    }

void CSenHostletConnectionBCTest::StartActiveScheduler(TInt aNumberOfPendingOps)

    {

    iNumberOfPendingOps = aNumberOfPendingOps;

    CActiveScheduler::Start();

    }

void CSenHostletConnectionBCTest::StopActiveScheduler ()

    {

    iNumberOfPendingOps--;

    if ( iNumberOfPendingOps == 0 )

        {

    	CActiveScheduler::Stop();

        }

    }

void TConsumerTestTask::Execute()

    {

    switch(iJob)

        {

        case(ECreateConnAndSubmit): // this is a very oddly orientated, wild case..

            {

            if(ipOwner)

                {

                CTestConsumer* pConsumer = CTestConsumer::NewL(ipOwner); // uses the default implementations for setstatus, handlemessage, handleerror

                CleanupStack::PushL(pConsumer);

                // Note, if NOT set, iEndpoint is typically KNullDesC8 (zero-lenght), which is OK, too.

                CSenServicePattern* pPattern = CSenServicePattern::NewLC(iEndpoint, KHostletContract);

                if(iFrameworkId.Length()>0)

                    {

                    pPattern->SetFrameworkIdL(iFrameworkId);

                    }

                else

                    {

                    pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);                        

                    }

                CSenServiceConnection* pConnection = CSenServiceConnection::NewL(*pConsumer, *pPattern);

                CleanupStack::PopAndDestroy(pPattern);

                CleanupStack::PushL(pConnection);

                // Construct service connection by starting active scheduler..

                ipOwner->StartActiveScheduler(1);

                // Check that NO HandleErrorL callback was received:

                LOCAL_VOID_ASSERT( pConsumer->iErrorCode == KErrNone );

                 // Check that the Status of the ServiceConnection

                // is KSenConnectionStatusReady

                LOCAL_VOID_ASSERT( pConsumer->iConnectionStatus == KSenConnectionStatusReady); 

                // execution returns here EITHER when HandleMessageL or HandleErrorL has been invoked..

                if(iProperties.Length()==0)

                    {

                    if(ipSoapMsg)

                        {

                        iStatusCode = pConnection->SubmitL(*ipSoapMsg, ipNotOwnedData);

                        }

                    else

                        {

                        iStatusCode = pConnection->SubmitL(iRequest, ipNotOwnedData);

                        }

                    }

                else

                    {

                    if(ipSoapMsg)

                        {

                        iStatusCode = pConnection->SubmitL(*ipSoapMsg, iProperties, ipNotOwnedData);

                        }

                    else

                        {

                        iStatusCode = pConnection->SubmitL(iRequest, iProperties, ipNotOwnedData);

                        }

                    }

                CleanupStack::PopAndDestroy(pConnection);

                CleanupStack::PopAndDestroy(pConsumer);

                }

           }

           break;

        case(ESubmit):

            {

            if(iProperties.Length()==0)

                {

                iStatusCode = iConnection.SubmitL(iRequest, ipNotOwnedData);

                }

            else

                {

                iStatusCode = iConnection.SubmitL(iRequest, iProperties, ipNotOwnedData);

                }

            }

            break;

        case(EActiveSubmit):

            {

            if ( ipActive)

                {

                // Perform blocking (sync) submit:

                if(iProperties.Length()==0)

                    {

                    iStatusCode = iConnection.SubmitL(iRequest, ipNotOwnedData);

                    }

                else

                    {

                    iStatusCode = iConnection.SubmitL(iRequest, iProperties, ipNotOwnedData);

                    }

                // Notify "owner" that blocking operation has completed

                TRequestStatus* status = &ipActive->iStatus;

                RThread owner;

                owner.Open(ipActive->iOwnerThreadId);

                owner.RequestComplete(status, CActiveConsumerTestTask::EDeliverResponse );

                }

            }

            break;

        }

    }

/////////////////////////////////////////////////////////////////////////////////////////////////

// HELPER CLASS for SC (active) tasks:

// Public METHODS

CActiveConsumerTestTask* CActiveConsumerTestTask::NewL(TConsumerTestTask& aTask, const TDesC& aThreadName, CSenHostletConnectionBCTest& aOwner)

    {

    CActiveConsumerTestTask* pNew = CActiveConsumerTestTask::NewLC(aTask, aThreadName, aOwner);

    CleanupStack::Pop();

    return pNew;

    }

CActiveConsumerTestTask* CActiveConsumerTestTask::NewLC(TConsumerTestTask& aTask, const TDesC& aThreadName, CSenHostletConnectionBCTest& aOwner)

    {

    CActiveConsumerTestTask* pNew = new (ELeave) CActiveConsumerTestTask(aTask, aOwner);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aThreadName);

    return pNew;

    }

CActiveConsumerTestTask::CActiveConsumerTestTask(TConsumerTestTask& aTask, CSenHostletConnectionBCTest& aOwner)

    :   CActive(EPriorityStandard), 

        iTask(aTask),

        iOwner(aOwner)

    {

    CActiveScheduler::Add(this);    

    }

CActiveConsumerTestTask::~CActiveConsumerTestTask()

    {

    if(IsActive())

        {

        Cancel(); // issues DoCancel();

        }

    iTaskThread.Close();

    }

void CActiveConsumerTestTask::RunL()

    {

    switch(iStatus.Int())

        {

        case(EInvokeService):

            {

            iTaskThread.Resume();

            }

            break;

        case(EDeliverResponse):

            {

            iOwner.StopActiveScheduler(); // submit complete..

            }

            break;

         /* case defaul: // unknown */

        }

    }

void CActiveConsumerTestTask::DoCancel()

    {

    iOwner.StopActiveScheduler();

    }

// Private METHODS

void CActiveConsumerTestTask::ConstructL(const TDesC& aThreadName)

    {

    RThread thread;

    iOwnerThreadId = thread.Id(); 

    TInt createThreadRetVal = CreateThreadForConsumerTask(iTaskThread, aThreadName, iTask);        

    User::LeaveIfError( createThreadRetVal );

    SetActive();

    }

/////////////////////////////////////////////////////////////////////////////////////////////////

void  CSenHostletConnectionBCTest::UT_CSenHostletConnection_WSI_DescribeServiceL(CSenXmlServiceDescription& aSD)

    {

    aSD.SetFrameworkIdL(KDefaultBasicWebServicesFrameworkID);

    aSD.SetEndPointL(KHostletEndpoint);

    aSD.SetContractL(KHostletContract);

    }