/*

* Copyright (c) 2002 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] - do not remove

#include <e32svr.h>

#include <e32math.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include <SenServiceConnection.h>

#include <SenServicePattern.h>

#include <SenHttpTransportProperties.h>

#include "SenHostletConnection.h"

#include "TestConsumer.h"

#include "TestHostlet.h"

#include <SenFacet.h>

#include <SenTransportProperties.h>

#include "hostconnTester.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 ===============================

//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 ===============================

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

// ChostconnTester::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void ChostconnTester::Delete() 

    {

    }

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

// ChostconnTester::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt ChostconnTester::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function. 

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

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

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

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

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

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

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

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

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

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

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

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

		ENTRY("RespondL_negative_response_code-ChostconnTester", ChostconnTester::UT_CSenHostletConnection_Negative_ResponseCodeL),

		ENTRY("RespondL_self_def_URI-ChostconnTester", ChostconnTester::UT_CSenHostletConnection_HC_SelfDef_URIL),

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

		ENTRY("NewL_leaves_with_KErrSenEndpointReserved-ChostconnTester", ChostconnTester::UT_CSenHostletConnection_Two_Equal_UID3L),

		ENTRY("RespondL_Two_HC_with_the_same_Endpoints_UIDs-ChostconnTester", ChostconnTester::UT_CSenHostletConnection_Two_Equal_EndpointsL),    

		ENTRY("RespondL_Two_HC_Two_SC_diff_contracts-ChostconnTester", ChostconnTester::UT_CSenHostletConnection_Two_HC_Two_SC1L),    

		ENTRY("RespondL_Two_HC_Two_SC_diff_endpionts-ChostconnTester",ChostconnTester::UT_CSenHostletConnection_Two_HC_Two_SC2L),    

		ENTRY("RespondL_Two_HC_Two_SC_diff_endpionts_the_same_contract-ChostconnTester", ChostconnTester::UT_CSenHostletConnection_Two_HC_Two_SC3L),    

		ENTRY("RespondL_Delete_SC_before_calling_HC::RespondL-ChostconnTester", ChostconnTester::UT_CSenHostletConnection_DeleteSC_before_HCRespondLL),    

		ENTRY("RespondL_Call_RespondL_multipe_times-ChostconnTester", ChostconnTester::UT_CSenHostletConnection_RespondL_4multipleTimesL),    

		ENTRY("RespondL_SC::Cancel_after_request-ChostconnTester", ChostconnTester::UT_CSenHostletConnection_SC_Cancel_After_RequestL),    

		ENTRY("RespondL_Set_Expose_Facet-ChostconnTester", ChostconnTester::UT_CSenHostletConnection_Set_Expose_FacetL),    

		ENTRY("HC_responds_with_TP-ChostconnTester", ChostconnTester::UT_CSenHostletConnection_RespondWithPropertiesL),    

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

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

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

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

		ENTRY("SendL_from_2_SCs_to_1_HC-ChostconnTester", ChostconnTester::UT_CSenHostletConnection_2SC1HCL)

        };

            const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    } 

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

// ChostconnTester::?member_function

// ?implementation_description

// (other items were commented in a header).

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

//

/*

TInt ChostconnTester::?member_function(

   CItemParser& aItem )

   {

   ?code

   }

*/

// ========================== OTHER EXPORTED FUNCTIONS =========================

// None

//  METHODS

void ChostconnTester::StartActiveScheduler(TInt aNumberOfPendingOps)

    {

    iNumberOfPendingOps = aNumberOfPendingOps;

    CActiveScheduler::Start();

    }

void ChostconnTester::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, ChostconnTester& aOwner)

    {

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

    CleanupStack::Pop();

    return pNew;

    }

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

    {

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

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aThreadName);

    return pNew;

    }

CActiveConsumerTestTask::CActiveConsumerTestTask(TConsumerTestTask& aTask, ChostconnTester& 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  ChostconnTester::UT_CSenHostletConnection_WSI_DescribeServiceL(CSenXmlServiceDescription& aSD)

    {

    aSD.SetFrameworkIdL(KDefaultBasicWebServicesFrameworkID);

    aSD.SetEndPointL(KHostletEndpoint);

    aSD.SetContractL(KHostletContract);

    }

void  ChostconnTester::UT_CSenHostletConnection_WSI_DescribeService_2L(CSenXmlServiceDescription& aSD)

    {

    aSD.SetFrameworkIdL(KDefaultBasicWebServicesFrameworkID);

    aSD.SetContractL(KHostletContract);

    }

void ChostconnTester::UT_CSenHostletConnection_NewLL_SetStatus(ChostconnTester* apTestSuite,

                                                                    TInt aStatus )

   {

    switch( aStatus )

        {

        case KSenConnectionStatusReady:

            {

            apTestSuite->StopActiveScheduler(); // otherwise failed SC construction is reported via HandleErrorL(!)

            }

            break;

        case KSenConnectionStatusNew:

        case KSenConnectionStatusExpired:

        default:            

            break;

        }

    }

// not in use atm:

void ChostconnTester::UT_CSenHostletConnection_NewLL_HandleMessageL(ChostconnTester* /* apTestSuite */, const TDesC8& /* aMessage*/ )

    {

    }

//used by UT_CSenHostletConnection_Negative_ResponseCodeL

//used by UT_CSenHostletConnection_Delete_HCL

void ChostconnTester::UT_CSenHostletConnection_NewLL_HandleErrorL(ChostconnTester* apTestSuite, const TInt  /*aErrorCode*/ , const TDesC8& /* aMessage */)

    {

    apTestSuite->iWas_HandleErrorL_Accessed = ETrue;

    }

//used by the UT_CSenHostletConnection_Negative_ResponseCodeL    

TInt ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceL(ChostconnTester*  apTestSuite , MSenHostletRequest&  /*aRequest*/ , MSenHostletResponse&  aResponse )

    {

    TInt alteredResponseCode = -148000;

    _LIT8(KAlteredResponse, "<Response><ReplyMessage>Response Altered in UT_CSenHostletConnection_NewLL_OnServiceL.</ReplyMessage><Request>%S</Request></Response>");

    apTestSuite->ipHostlet->iResponseCodes[apTestSuite->ipHostlet->iTxnIds.Count()-1] = alteredResponseCode;

    aResponse.SetResponseUtf8L(KAlteredResponse, alteredResponseCode);

    return KErrNone;

    }

// not in use atm:    

TInt ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceCompleteL(ChostconnTester* /* apTestSuite */, const TInt /* aTxnId */, TInt /* aCompletionCode */, const TDesC8& /* aDesc */ )

    {

    return KErrNone;

    }    

//used by the UT_CSenHostletConnection_DeleteSC_before_HCRespondLL method

TInt ChostconnTester::UT_CSenHostletConnection_NewLL_OnService1L(ChostconnTester*  apTestSuite , MSenHostletRequest&  /*aRequest*/ , MSenHostletResponse&  /*aResponse*/ )

    {

    apTestSuite->ipConnection->Cancel();

    delete apTestSuite->ipConnection;

    apTestSuite->ipConnection = NULL;

    return KErrNone;

    }

//used by UT_CSenHostletConnection_DeleteSC_before_HCRespondLL

TInt ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceComplete1L(ChostconnTester* apTestSuite, const TInt /* aTxnId */, TInt /*aCompletionCode*/ , const TDesC8& /* aDesc */ )

    {

	apTestSuite->iWas_OnServiceL_Accessed = ETrue;

    return KErrNone;

    }        

// used by the UT_CSenHostletConnection_RespondL_4multipleTimesL method

TInt ChostconnTester::UT_CSenHostletConnection_NewLL_OnService2L(ChostconnTester*  apTestSuite , MSenHostletRequest&  /*aRequest*/ , MSenHostletResponse&  aResponse )

    {

    TInt respondRetCode = apTestSuite->ipHostletConnection->RespondL(aResponse);

    TInt respondRetCode1 = apTestSuite->ipHostletConnection->RespondL(aResponse);

	LOCAL_ASSERT(respondRetCode == KErrNone);    

    LOCAL_ASSERT(respondRetCode1 == KErrAlreadyExists);

    return KErrNone;

    }

// to be used (currently does nothing) by the UT_CSenHostletConnection_RespondL_4multipleTimesL method    

TInt ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceComplete2L(ChostconnTester* /* apTestSuite */, const TInt /* aTxnId */, TInt /*aCompletionCode*/ , const TDesC8& /* aDesc */ )

    {

    return KErrNone;

    }        

//used by the UT_CSenHostletConnection_SC_Cancel_After_RequestL method

void ChostconnTester::UT_CSenHostletConnection_NewLL_HandleError1L(ChostconnTester* apTestSuite, const TInt  /* aErrorCode */, const TDesC8& /* aMessage */)

    {

//    TInt a = aErrorCode;

    apTestSuite->iWas_HandleErrorL_Accessed = ETrue;

    }

//used by the UT_CSenHostletConnection_SC_Cancel_After_RequestL method

TInt ChostconnTester::UT_CSenHostletConnection_NewLL_OnService3L(ChostconnTester*  apTestSuite , MSenHostletRequest&  /*aRequest*/ , MSenHostletResponse&  /*aResponse*/ )

    {

   // apTestSuite->ipConnection->Cancel();