1 /*

     2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:        ?Description

    15 *

    16 */

    17 

    18 // [INCLUDE FILES] - do not remove

    19 #include <e32svr.h>

    20 #include <e32math.h>

    21 #include <StifParser.h>

    22 #include <Stiftestinterface.h>

    23 #include <SenServiceConnection.h>

    24 #include <SenServicePattern.h>

    25 #include <SenHttpTransportProperties.h>

    26 #include "SenHostletConnection.h"

    27 #include "TestConsumer.h"

    28 #include "TestHostlet.h"

    29 #include <SenFacet.h>

    30 

    31 #include <SenTransportProperties.h>

    32 #include "hostconnTester.h"

    33 

    34 // EXTERNAL DATA STRUCTURES

    35 //extern  ?external_data;

    36 

    37 // EXTERNAL FUNCTION PROTOTYPES  

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

    39 

    40 // CONSTANTS

    41 //const ?type ?constant_var = ?constant;

    42 

    43 // MACROS

    44 //#define ?macro ?macro_def

    45 

    46 // LOCAL CONSTANTS AND MACROS

    47 //const ?type ?constant_var = ?constant;

    48 //#define ?macro_name ?macro_def

    49 

    50 // MODULE DATA STRUCTURES

    51 //enum ?declaration

    52 //typedef ?declaration

    53 

    54 // LOCAL FUNCTION PROTOTYPES

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

    56 

    57 // FORWARD DECLARATIONS

    58 //class ?FORWARD_CLASSNAME;

    59 

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

    61 

    62 //Macro for Porting to STIF

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

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

    65 

    66 namespace

    67     {

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

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

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

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

    72     

    73     void threadMainL(TAny* aPtr)

    74         {

    75         TConsumerTestTask* pTask = (TConsumerTestTask*) aPtr;

    76         pTask->Execute();

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

    78         }

    79     

    80     TInt threadFunction(TAny* aPtr)

    81         {

    82         CTrapCleanup* pCleanup = CTrapCleanup::New();

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

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

    85         CActiveScheduler::Install(pScheduler);

    86 

    87         TInt leaveCode(KErrNone);

    88         TRAP(leaveCode, threadMainL(aPtr));

    89 

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

    91         delete pScheduler;

    92         delete pCleanup;

    93 

    94         return leaveCode;

    95         }

    96         

    97         

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

    99         {

   100         TName threadName(aThreadName);

   101         // Append a random number to make it unique

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

   103                 

   104 #ifdef EKA2

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

   106         return aThread.Create(threadName, // name

   107                               threadFunction,

   108                               KDefaultStackSize,

   109                               &heap,

   110                               &aTask);

   111 #else // EKA1

   112         RHeap& heap = User::Heap();

   113         return aThread.Create(threadName, // name

   114                               threadFunction,

   115                               KDefaultStackSize,

   116                               &heap,

   117                               &aTask);

   118 #endif // EKA        

   119         }      

   120     }   

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

   122 

   123 // -----------------------------------------------------------------------------

   124 // ChostconnTester::Delete

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

   126 // Called from destructor. 

   127 // -----------------------------------------------------------------------------

   128 //

   129 void ChostconnTester::Delete() 

   130     {

   131 

   132     }

   133 

   134 // -----------------------------------------------------------------------------

   135 // ChostconnTester::RunMethodL

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

   137 // -----------------------------------------------------------------------------

   138 //

   139 TInt ChostconnTester::RunMethodL( 

   140     CStifItemParser& aItem ) 

   141     {

   142 

   143     static TStifFunctionInfo const KFunctions[] =

   144         {  

   145         // Copy this line for every implemented function.

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

   147         // Second is the actual implementation member function. 

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

   149     

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

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

   152 		

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

   154 		

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

   156 		

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

   158 

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

   160 

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

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

   163 

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

   165    

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

   167 

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

   169 

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

   171     

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

   173     

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

   175 

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

   177          

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

   179    

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

   181      

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

   183 

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

   185       

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

   187 

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

   189 

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

   191     

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

   193 

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

   195 

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

   197 

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

   199 

   200 

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

   202 

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

   204 

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

   206 

   207         };

   208             const TInt count = sizeof( KFunctions ) / 

   209                         sizeof( TStifFunctionInfo );

   210 

   211     return RunInternalL( KFunctions, count, aItem );

   212     } 

   213 

   214 // -----------------------------------------------------------------------------

   215 // ChostconnTester::?member_function

   216 // ?implementation_description

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

   218 // -----------------------------------------------------------------------------

   219 //

   220 /*

   221 TInt ChostconnTester::?member_function(

   222    CItemParser& aItem )

   223    {

   224 

   225    ?code

   226 

   227    }

   228 */

   229 

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

   231 // None

   232 //  METHODS

   233 

   234 void ChostconnTester::StartActiveScheduler(TInt aNumberOfPendingOps)

   235     {

   236     iNumberOfPendingOps = aNumberOfPendingOps;

   237     CActiveScheduler::Start();

   238     }

   239        

   240 void ChostconnTester::StopActiveScheduler ()

   241     {

   242     iNumberOfPendingOps--;

   243     if ( iNumberOfPendingOps == 0 )

   244         {

   245     	CActiveScheduler::Stop();

   246         }

   247     }

   248 

   249 void TConsumerTestTask::Execute()

   250     {

   251     switch(iJob)

   252         {

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

   254             {

   255             if(ipOwner)

   256                 {

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

   258                 CleanupStack::PushL(pConsumer);

   259 

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

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

   262                 if(iFrameworkId.Length()>0)

   263                     {

   264                     pPattern->SetFrameworkIdL(iFrameworkId);

   265                     }

   266                 else

   267                     {

   268                     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);                        

   269                     }

   270                     

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

   272                 CleanupStack::PopAndDestroy(pPattern);

   273                 CleanupStack::PushL(pConnection);

   274                 

   275                 // Construct service connection by starting active scheduler..

   276                 ipOwner->StartActiveScheduler(1);

   277                 

   278                 // Check that NO HandleErrorL callback was received:

   279                 LOCAL_VOID_ASSERT( pConsumer->iErrorCode == KErrNone );

   280                 

   281                 

   282                  // Check that the Status of the ServiceConnection

   283                 // is KSenConnectionStatusReady

   284                 LOCAL_VOID_ASSERT( pConsumer->iConnectionStatus == KSenConnectionStatusReady); 

   285 

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

   287                 if(iProperties.Length()==0)

   288                     {

   289                     if(ipSoapMsg)

   290                         {

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

   292                         }

   293                     else

   294                         {

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

   296                         }

   297                     }

   298                 else

   299                     {

   300                     if(ipSoapMsg)

   301                         {

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

   303                         }

   304                     else

   305                         {

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

   307                         }

   308                     }

   309                 CleanupStack::PopAndDestroy(pConnection);

   310                 CleanupStack::PopAndDestroy(pConsumer);

   311                 }

   312            }

   313            break;

   314 

   315         case(ESubmit):

   316             {

   317             if(iProperties.Length()==0)

   318                 {

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

   320                 }

   321             else

   322                 {

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

   324                 }

   325             }

   326             break;

   327 

   328         case(EActiveSubmit):

   329             {

   330             if ( ipActive)

   331                 {

   332                 // Perform blocking (sync) submit:

   333                 if(iProperties.Length()==0)

   334                     {

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

   336                     }

   337                 else

   338                     {

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

   340                     }

   341                     

   342                 // Notify "owner" that blocking operation has completed

   343                 TRequestStatus* status = &ipActive->iStatus;

   344                 RThread owner;

   345                 owner.Open(ipActive->iOwnerThreadId);

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

   347                 }

   348             }

   349             break;

   350            

   351         }

   352     }

   353 

   354 /////////////////////////////////////////////////////////////////////////////////////////////////

   355 // HELPER CLASS for SC (active) tasks:

   356 // Public METHODS

   357 

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

   359     {

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

   361     CleanupStack::Pop();

   362     return pNew;

   363     }

   364 

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

   366     {

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

   368     CleanupStack::PushL(pNew);

   369     pNew->ConstructL(aThreadName);

   370     return pNew;

   371     }

   372 

   373 CActiveConsumerTestTask::CActiveConsumerTestTask(TConsumerTestTask& aTask, ChostconnTester& aOwner)

   374     :   CActive(EPriorityStandard), 

   375         iTask(aTask),

   376         iOwner(aOwner)

   377     {

   378     CActiveScheduler::Add(this);    

   379     }

   380 

   381 CActiveConsumerTestTask::~CActiveConsumerTestTask()

   382     {

   383     if(IsActive())

   384         {

   385         Cancel(); // issues DoCancel();

   386         }

   387     iTaskThread.Close();

   388     }

   389 

   390 void CActiveConsumerTestTask::RunL()

   391     {

   392     switch(iStatus.Int())

   393         {

   394         case(EInvokeService):

   395             {

   396             iTaskThread.Resume();

   397             }

   398             break;

   399             

   400         case(EDeliverResponse):

   401             {

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

   403             }

   404             break;

   405          /* case defaul: // unknown */

   406         }

   407     }

   408 void CActiveConsumerTestTask::DoCancel()

   409     {

   410     iOwner.StopActiveScheduler();

   411     }

   412     

   413 // Private METHODS

   414 void CActiveConsumerTestTask::ConstructL(const TDesC& aThreadName)

   415     {

   416     RThread thread;

   417     iOwnerThreadId = thread.Id(); 

   418     

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

   420     User::LeaveIfError( createThreadRetVal );

   421     SetActive();

   422     }

   423     

   424     

   425 /////////////////////////////////////////////////////////////////////////////////////////////////

   426 

   427 void  ChostconnTester::UT_CSenHostletConnection_WSI_DescribeServiceL(CSenXmlServiceDescription& aSD)

   428     {

   429     aSD.SetFrameworkIdL(KDefaultBasicWebServicesFrameworkID);

   430     aSD.SetEndPointL(KHostletEndpoint);

   431     aSD.SetContractL(KHostletContract);

   432     }

   433 

   434 void  ChostconnTester::UT_CSenHostletConnection_WSI_DescribeService_2L(CSenXmlServiceDescription& aSD)

   435     {

   436     aSD.SetFrameworkIdL(KDefaultBasicWebServicesFrameworkID);

   437     aSD.SetContractL(KHostletContract);

   438     }

   439 

   440 

   441 void ChostconnTester::UT_CSenHostletConnection_NewLL_SetStatus(ChostconnTester* apTestSuite,

   442                                                                     TInt aStatus )

   443    {

   444     switch( aStatus )

   445         {

   446         case KSenConnectionStatusReady:

   447             {

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

   449             }

   450             break;

   451         case KSenConnectionStatusNew:

   452         case KSenConnectionStatusExpired:

   453         default:            

   454             break;

   455         }

   456     }

   457 

   458 

   459 

   460 // not in use atm:

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

   462     {

   463     }

   464 

   465 //used by UT_CSenHostletConnection_Negative_ResponseCodeL

   466 //used by UT_CSenHostletConnection_Delete_HCL

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

   468     {

   469     apTestSuite->iWas_HandleErrorL_Accessed = ETrue;

   470     }

   471     

   472 //used by the UT_CSenHostletConnection_Negative_ResponseCodeL    

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

   474     {

   475     TInt alteredResponseCode = -148000;

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

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

   478     aResponse.SetResponseUtf8L(KAlteredResponse, alteredResponseCode);

   479     return KErrNone;

   480     }

   481     

   482 // not in use atm:    

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

   484     {

   485     return KErrNone;

   486     }    

   487     

   488 //used by the UT_CSenHostletConnection_DeleteSC_before_HCRespondLL method

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

   490     {

   491     apTestSuite->ipConnection->Cancel();

   492     delete apTestSuite->ipConnection;

   493     apTestSuite->ipConnection = NULL;

   494     return KErrNone;

   495     }

   496     

   497 //used by UT_CSenHostletConnection_DeleteSC_before_HCRespondLL

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

   499     {

   500 	apTestSuite->iWas_OnServiceL_Accessed = ETrue;

   501     return KErrNone;

   502     }        

   503 

   504 // used by the UT_CSenHostletConnection_RespondL_4multipleTimesL method

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

   506     {

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

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

   509 	LOCAL_ASSERT(respondRetCode == KErrNone);    

   510     LOCAL_ASSERT(respondRetCode1 == KErrAlreadyExists);

   511     return KErrNone;

   512     }

   513     

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

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

   516     {

   517     return KErrNone;

   518     }        

   519     

   520 //used by the UT_CSenHostletConnection_SC_Cancel_After_RequestL method

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

   522     {

   523 //    TInt a = aErrorCode;

   524     apTestSuite->iWas_HandleErrorL_Accessed = ETrue;

   525     }

   526 //used by the UT_CSenHostletConnection_SC_Cancel_After_RequestL method

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

   528     {

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

   530    //canceling request

   531     apTestSuite->ipConnection->CancelTransaction(apTestSuite->iTxnID);

   532     return KErrNone;

   533     }

   534 

   535 

   536 //used by the UT_CSenHostletConnection_RespondWithPropertiesL method in order to provide transport properties with the response

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

   538     {

   539     TInt txn =          apTestSuite->ipHostlet->iTxnIds.Count()-1;

   540     TPtr8 response =    apTestSuite->ipHostlet->iResponses[txn]->Des();

   541 

   542     TInt responseCode = apTestSuite->ipHostlet->iResponseCodes[txn];

   543 

   544     CSenTransportProperties* pTransportProperties = CSenTransportProperties::NewLC();

   545     _LIT8(KTestCid, "test:cid");

   546     _LIT8(KTestFile, "c:\\test.file.txt");

   547     pTransportProperties->SetFileAttachmentL( KTestCid, KTestFile );

   548     

   549     if( apTestSuite->ipHostlet->iResponseProps.Append( pTransportProperties ) )

   550         {

   551         // error:

   552         CleanupStack::PopAndDestroy(pTransportProperties);

   553         return KErrNoMemory;

   554         }

   555     else

   556         {

   557         // ok

   558         CleanupStack::Pop(pTransportProperties);

   559         aResponse.SetResponseUtf8L(response, responseCode, pTransportProperties); // by default, all requests are "accepted"

   560         return KErrNone;

   561         }

   562     }

   563 

   564 

   565 

   566 //---------------------------------------------------------------

   567 // 							Test Cases

   568 //---------------------------------------------------------------

   569 

   570 

   571 TInt ChostconnTester::UT_CSenHostletConnection_NewLL(CStifItemParser& aItem)

   572     {

   573 	 

   574     ipHostlet = CTestHostlet::NewL(this);   // uses default implementations for servicel and onservicecompletel

   575     ipConsumer = CTestConsumer::NewL(this); // uses the default implementations for setstatus, handlemessage, handleerror

   576 

   577 //    ipHostlet = CTestHostlet::NewL(this,

   578 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceL,

   579 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

   580 

   581 //    ipConsumer = CTestConsumer::NewL(this, 

   582 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleMessageL, 

   583 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleErrorL, 

   584 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_SetStatus);

   585 

   586     ipHostletConnection = CSenHostletConnection::NewL(*ipHostlet);

   587 

   588     CSenServicePattern* pPattern =

   589         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

   590     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

   591     

   592     ipConnection = CSenServiceConnection::NewL(*ipConsumer, *pPattern);

   593     CleanupStack::PopAndDestroy(pPattern);

   594     

   595     // Construct service connection

   596     StartActiveScheduler(1);

   597     

   598     _LIT8(KRequest, "<ab:Query xmlns:ab=\"urn:nokia:test:addrbook:2004-09\"><ab:QueryItem><ab:Select>/ab:Card[containts[ab:N/ab:FAMILY,\'Bob\'] or containts[ab:N/ab:GIVEN,\'Bob\'] or containts[ab:TEL,\'Bob\']]</ab:Select></ab:QueryItem></ab:Query>");

   599 

   600     TInt transactionIdOrError = ipConnection->SendL(KRequest);

   601 

   602     LOCAL_ASSERT(transactionIdOrError > KErrNone);

   603     

   604     // Invoke service  ONCE (one call to ServiceL), respond to consumer ONCE => two calls

   605     StartActiveScheduler(2);

   606 

   607     // ---- Following conditions MUST be met ----

   608 

   609     // 1. Hostlet receives request that consumer made

   610     LOCAL_ASSERT( *ipHostlet->iRequests[0] == KRequest);

   611 

   612     // 2. Consumer receives response that hostlet provided

   613     LOCAL_ASSERT( *ipConsumer->iResponses[0] == *ipHostlet->iResponses[0]);

   614     LOCAL_ASSERT( ipConsumer->iResponseCodes[0] == ipHostlet->iResponseCodes[0])

   615 

   616     // 3. Hostlet receives completion code (delivery code)

   617     LOCAL_ASSERT( ipHostlet->iTxnIds[0] == transactionIdOrError );

   618     LOCAL_ASSERT( ipHostlet->iCompletionCodes[0] == KErrNone ); // true in this "OK" -test case

   619     

   620     // --- Conditions END ---

   621     

   622     delete ipConnection;

   623     ipConnection = NULL;

   624     delete ipHostletConnection; 

   625     ipHostletConnection = NULL;

   626     delete ipHostlet;

   627     ipHostlet = NULL;

   628     delete ipConsumer;

   629     ipConsumer = NULL;

   630     

   631     return KErrNone;

   632     }

   633 

   634     

   635 TInt ChostconnTester::UT_CSenHostletConnection_NewLCL(CStifItemParser& aItem)

   636     {

   637 	 

   638     ipHostlet = CTestHostlet::NewL(this);   // uses default implementations for servicel and onservicecompletel

   639     ipConsumer = CTestConsumer::NewL(this); // uses the default implementations for setstatus, handlemessage, handleerror

   640 

   641 //    ipHostlet = CTestHostlet::NewL(this,

   642 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceL,

   643 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

   644 

   645 //    ipConsumer = CTestConsumer::NewL(this, 

   646 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleMessageL, 

   647 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleErrorL, 

   648 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_SetStatus);

   649 

   650     ipHostletConnection = CSenHostletConnection::NewLC(*ipHostlet);

   651 

   652     CSenServicePattern* pPattern =

   653         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

   654     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

   655     

   656     ipConnection = CSenServiceConnection::NewL(*ipConsumer, *pPattern);

   657     CleanupStack::PopAndDestroy(pPattern);

   658     

   659     // Construct service connection

   660     StartActiveScheduler(1);

   661     

   662     _LIT8(KRequest, "<ab:Query xmlns:ab=\"urn:nokia:test:addrbook:2004-09\"><ab:QueryItem><ab:Select>/ab:Card[containts[ab:N/ab:FAMILY,\'Bob\'] or containts[ab:N/ab:GIVEN,\'Bob\'] or containts[ab:TEL,\'Bob\']]</ab:Select></ab:QueryItem></ab:Query>");

   663 

   664     TInt transactionIdOrError = ipConnection->SendL(KRequest);

   665 

   666     LOCAL_ASSERT(transactionIdOrError > KErrNone);

   667     

   668     // Invoke service  ONCE (one call to ServiceL), respond to consumer ONCE => two calls

   669     StartActiveScheduler(2);

   670 

   671     // ---- Following conditions MUST be met ----

   672 

   673     // 1. Hostlet receives request that consumer made

   674     LOCAL_ASSERT( *ipHostlet->iRequests[0] == KRequest);

   675 

   676     // 2. Consumer receives response that hostlet provided

   677     LOCAL_ASSERT( *ipConsumer->iResponses[0] == *ipHostlet->iResponses[0]);

   678     LOCAL_ASSERT( ipConsumer->iResponseCodes[0] == ipHostlet->iResponseCodes[0])

   679 

   680     // 3. Hostlet receives completion code (delivery code)

   681     LOCAL_ASSERT( ipHostlet->iTxnIds[0] == transactionIdOrError );

   682     LOCAL_ASSERT( ipHostlet->iCompletionCodes[0] == KErrNone ); // true in this "OK" -test case

   683     

   684     // --- Conditions END ---

   685     

   686     delete ipConnection;

   687     ipConnection = NULL;

   688     CleanupStack::PopAndDestroy(ipHostletConnection);

   689     //delete ipHostletConnection; 

   690     //ipHostletConnection = NULL;

   691     delete ipHostlet;

   692     ipHostlet = NULL;

   693     delete ipConsumer;

   694     ipConsumer = NULL;

   695     

   696     return KErrNone;

   697     }

   698 TInt ChostconnTester::UT_CSenHostletConnection_IdentifierL(CStifItemParser& aItem )

   699     {

   700 	 

   701     ipHostlet = CTestHostlet::NewL(this);   // uses default implementations for servicel and onservicecompletel

   702     ipConsumer = CTestConsumer::NewL(this); // uses the default implementations for setstatus, handlemessage, handleerror

   703 

   704 //    ipHostlet = CTestHostlet::NewL(this,

   705 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceL,

   706 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

   707 

   708 //    ipConsumer = CTestConsumer::NewL(this, 

   709 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleMessageL, 

   710 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleErrorL, 

   711 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_SetStatus);

   712 

   713     ipHostletConnection = CSenHostletConnection::NewL(*ipHostlet);

   714 

   715     CSenServicePattern* pPattern =

   716         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

   717     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

   718     

   719     ipConnection = CSenServiceConnection::NewL(*ipConsumer, *pPattern);

   720     CleanupStack::PopAndDestroy(pPattern);

   721     

   722     TInt id;

   723     id = ipHostletConnection->Identifier();

   724     LOCAL_ASSERT( id  != KErrNotReady);

   725     TPtrC8 framework = ipHostlet->FrameworkId();

   726     // Construct service connection

   727     StartActiveScheduler(1);

   728     

   729     _LIT8(KRequest, "<ab:Query xmlns:ab=\"urn:nokia:test:addrbook:2004-09\"><ab:QueryItem><ab:Select>/ab:Card[containts[ab:N/ab:FAMILY,\'Bob\'] or containts[ab:N/ab:GIVEN,\'Bob\'] or containts[ab:TEL,\'Bob\']]</ab:Select></ab:QueryItem></ab:Query>");

   730 

   731     TInt transactionIdOrError = ipConnection->SendL(KRequest);

   732 

   733     LOCAL_ASSERT(transactionIdOrError > KErrNone);

   734     

   735     // Invoke service  ONCE (one call to ServiceL), respond to consumer ONCE => two calls

   736     StartActiveScheduler(2);

   737 

   738     // ---- Following conditions MUST be met ----

   739 

   740     // 1. Hostlet receives request that consumer made

   741     LOCAL_ASSERT( *ipHostlet->iRequests[0] == KRequest);

   742 

   743     // 2. Consumer receives response that hostlet provided

   744     LOCAL_ASSERT( *ipConsumer->iResponses[0] == *ipHostlet->iResponses[0]);

   745     LOCAL_ASSERT( ipConsumer->iResponseCodes[0] == ipHostlet->iResponseCodes[0])

   746 

   747     // 3. Hostlet receives completion code (delivery code)

   748     LOCAL_ASSERT( ipHostlet->iTxnIds[0] == transactionIdOrError );

   749     LOCAL_ASSERT( ipHostlet->iCompletionCodes[0] == KErrNone ); // true in this "OK" -test case

   750     

   751     // --- Conditions END ---

   752     

   753     delete ipConnection;

   754     ipConnection = NULL;

   755     delete ipHostletConnection; 

   756     ipHostletConnection = NULL;

   757     delete ipHostlet;

   758     ipHostlet = NULL;

   759     delete ipConsumer;

   760     ipConsumer = NULL;

   761     

   762     return KErrNone;

   763     }

   764 

   765 TInt ChostconnTester::UT_CSenHostletConnection_FrameworkIdL(CStifItemParser& aItem )

   766     {

   767     ipHostlet = CTestHostlet::NewL(this);   // uses default implementations for servicel and onservicecompletel

   768     ipConsumer = CTestConsumer::NewL(this); // uses the default implementations for setstatus, handlemessage, handleerror

   769 

   770 //    ipHostlet = CTestHostlet::NewL(this,

   771 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceL,

   772 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

   773 

   774 //    ipConsumer = CTestConsumer::NewL(this, 

   775 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleMessageL, 

   776 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleErrorL, 

   777 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_SetStatus);

   778 

   779     ipHostletConnection = CSenHostletConnection::NewL(*ipHostlet);

   780 

   781     CSenServicePattern* pPattern =

   782         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

   783     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

   784     

   785     ipConnection = CSenServiceConnection::NewL(*ipConsumer, *pPattern);

   786     CleanupStack::PopAndDestroy(pPattern);

   787     

   788     TInt id;

   789     id = ipHostletConnection->Identifier();

   790     LOCAL_ASSERT( id  != KErrNotReady);

   791     _LIT8(KFramework, "REST");

   792     TPtrC8 framework = ipHostlet->FrameworkId();

   793     LOCAL_ASSERT( framework == KFramework);

   794     // Construct service connection

   795     StartActiveScheduler(1);

   796     

   797     _LIT8(KRequest, "<ab:Query xmlns:ab=\"urn:nokia:test:addrbook:2004-09\"><ab:QueryItem><ab:Select>/ab:Card[containts[ab:N/ab:FAMILY,\'Bob\'] or containts[ab:N/ab:GIVEN,\'Bob\'] or containts[ab:TEL,\'Bob\']]</ab:Select></ab:QueryItem></ab:Query>");

   798 

   799     TInt transactionIdOrError = ipConnection->SendL(KRequest);

   800 

   801     LOCAL_ASSERT(transactionIdOrError > KErrNone);

   802     

   803     // Invoke service  ONCE (one call to ServiceL), respond to consumer ONCE => two calls

   804     StartActiveScheduler(2);

   805 

   806     // ---- Following conditions MUST be met ----

   807 

   808     // 1. Hostlet receives request that consumer made

   809     LOCAL_ASSERT( *ipHostlet->iRequests[0] == KRequest);

   810 

   811     // 2. Consumer receives response that hostlet provided

   812     LOCAL_ASSERT( *ipConsumer->iResponses[0] == *ipHostlet->iResponses[0]);

   813     LOCAL_ASSERT( ipConsumer->iResponseCodes[0] == ipHostlet->iResponseCodes[0])

   814 

   815     // 3. Hostlet receives completion code (delivery code)

   816     LOCAL_ASSERT( ipHostlet->iTxnIds[0] == transactionIdOrError );

   817     LOCAL_ASSERT( ipHostlet->iCompletionCodes[0] == KErrNone ); // true in this "OK" -test case

   818     

   819     // --- Conditions END ---

   820     

   821     delete ipConnection;

   822     ipConnection = NULL;

   823     delete ipHostletConnection; 

   824     ipHostletConnection = NULL;

   825     delete ipHostlet;

   826     ipHostlet = NULL;

   827     delete ipConsumer;

   828     ipConsumer = NULL;

   829     

   830     return KErrNone;

   831     }

   832 

   833 TInt ChostconnTester::UT_CSenHostletConnection_RequestUtf8L(CStifItemParser& aItem )

   834     {

   835 	 

   836     ipHostlet = CTestHostlet::NewL(this);   // uses default implementations for servicel and onservicecompletel

   837     ipConsumer = CTestConsumer::NewL(this); // uses the default implementations for setstatus, handlemessage, handleerror

   838 

   839 //    ipHostlet = CTestHostlet::NewL(this,

   840 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceL,

   841 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

   842 

   843 //    ipConsumer = CTestConsumer::NewL(this, 

   844 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleMessageL, 

   845 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleErrorL, 

   846 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_SetStatus);

   847 

   848     ipHostletConnection = CSenHostletConnection::NewL(*ipHostlet);

   849 

   850     CSenServicePattern* pPattern =

   851         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

   852     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

   853     

   854     ipConnection = CSenServiceConnection::NewL(*ipConsumer, *pPattern);

   855     CleanupStack::PopAndDestroy(pPattern);

   856     

   857     TInt id;

   858     id = ipHostletConnection->Identifier();

   859     LOCAL_ASSERT( id  != KErrNotReady);

   860     TPtrC8 request = ipHostlet->RequestUtf8();

   861     LOCAL_ASSERT( request == _L8(""));

   862     // Construct service connection

   863     StartActiveScheduler(1);

   864     

   865     _LIT8(KRequest, "<ab:Query xmlns:ab=\"urn:nokia:test:addrbook:2004-09\"><ab:QueryItem><ab:Select>/ab:Card[containts[ab:N/ab:FAMILY,\'Bob\'] or containts[ab:N/ab:GIVEN,\'Bob\'] or containts[ab:TEL,\'Bob\']]</ab:Select></ab:QueryItem></ab:Query>");

   866 

   867     TInt transactionIdOrError = ipConnection->SendL(KRequest);

   868 

   869     LOCAL_ASSERT(transactionIdOrError > KErrNone);

   870     

   871     // Invoke service  ONCE (one call to ServiceL), respond to consumer ONCE => two calls

   872     StartActiveScheduler(2);

   873 

   874     // ---- Following conditions MUST be met ----

   875 

   876     // 1. Hostlet receives request that consumer made

   877     LOCAL_ASSERT( *ipHostlet->iRequests[0] == KRequest);

   878 

   879     // 2. Consumer receives response that hostlet provided

   880     LOCAL_ASSERT( *ipConsumer->iResponses[0] == *ipHostlet->iResponses[0]);

   881     LOCAL_ASSERT( ipConsumer->iResponseCodes[0] == ipHostlet->iResponseCodes[0])

   882 

   883     // 3. Hostlet receives completion code (delivery code)

   884     LOCAL_ASSERT( ipHostlet->iTxnIds[0] == transactionIdOrError );

   885     LOCAL_ASSERT( ipHostlet->iCompletionCodes[0] == KErrNone ); // true in this "OK" -test case

   886     

   887     // --- Conditions END ---

   888     

   889     delete ipConnection;

   890     ipConnection = NULL;

   891     delete ipHostletConnection; 

   892     ipHostletConnection = NULL;

   893     delete ipHostlet;

   894     ipHostlet = NULL;

   895     delete ipConsumer;

   896     ipConsumer = NULL;

   897     

   898     return KErrNone;

   899     }

   900 

   901 TInt ChostconnTester::UT_CSenHostletConnection_ThreadIdL(CStifItemParser& aItem )

   902     {

   903 	 

   904     ipHostlet = CTestHostlet::NewL(this);   // uses default implementations for servicel and onservicecompletel

   905     ipConsumer = CTestConsumer::NewL(this); // uses the default implementations for setstatus, handlemessage, handleerror

   906 

   907 //    ipHostlet = CTestHostlet::NewL(this,

   908 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceL,

   909 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

   910 

   911 //    ipConsumer = CTestConsumer::NewL(this, 

   912 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleMessageL, 

   913 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleErrorL, 

   914 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_SetStatus);

   915 

   916     ipHostletConnection = CSenHostletConnection::NewL(*ipHostlet);

   917 

   918     CSenServicePattern* pPattern =

   919         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

   920     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

   921     

   922     ipConnection = CSenServiceConnection::NewL(*ipConsumer, *pPattern);

   923     CleanupStack::PopAndDestroy(pPattern);

   924     

   925     TInt id;

   926     id = ipHostletConnection->Identifier();

   927     LOCAL_ASSERT( id  != KErrNotReady);

   928     TPtrC threadId = ipHostlet->ThreadId();

   929     LOCAL_ASSERT( threadId == _L(""));

   930     // Construct service connection

   931     StartActiveScheduler(1);

   932     

   933     _LIT8(KRequest, "<ab:Query xmlns:ab=\"urn:nokia:test:addrbook:2004-09\"><ab:QueryItem><ab:Select>/ab:Card[containts[ab:N/ab:FAMILY,\'Bob\'] or containts[ab:N/ab:GIVEN,\'Bob\'] or containts[ab:TEL,\'Bob\']]</ab:Select></ab:QueryItem></ab:Query>");

   934 

   935     TInt transactionIdOrError = ipConnection->SendL(KRequest);

   936 

   937     LOCAL_ASSERT(transactionIdOrError > KErrNone);

   938     

   939     // Invoke service  ONCE (one call to ServiceL), respond to consumer ONCE => two calls

   940     StartActiveScheduler(2);

   941 

   942     // ---- Following conditions MUST be met ----

   943 

   944     // 1. Hostlet receives request that consumer made

   945     LOCAL_ASSERT( *ipHostlet->iRequests[0] == KRequest);

   946 

   947     // 2. Consumer receives response that hostlet provided

   948     LOCAL_ASSERT( *ipConsumer->iResponses[0] == *ipHostlet->iResponses[0]);

   949     LOCAL_ASSERT( ipConsumer->iResponseCodes[0] == ipHostlet->iResponseCodes[0])

   950 

   951     // 3. Hostlet receives completion code (delivery code)

   952     LOCAL_ASSERT( ipHostlet->iTxnIds[0] == transactionIdOrError );

   953     LOCAL_ASSERT( ipHostlet->iCompletionCodes[0] == KErrNone ); // true in this "OK" -test case

   954     

   955     // --- Conditions END ---

   956     

   957     delete ipConnection;

   958     ipConnection = NULL;

   959     delete ipHostletConnection; 

   960     ipHostletConnection = NULL;

   961     delete ipHostlet;

   962     ipHostlet = NULL;

   963     delete ipConsumer;

   964     ipConsumer = NULL;

   965     

   966     return KErrNone;

   967     }

   968 TInt ChostconnTester::UT_CSenHostletConnection_ConsumerIdL(CStifItemParser& aItem )

   969 	{

   970 	 

   971     ipHostlet = CTestHostlet::NewL(this);   // uses default implementations for servicel and onservicecompletel

   972     ipConsumer = CTestConsumer::NewL(this); // uses the default implementations for setstatus, handlemessage, handleerror

   973 

   974 //    ipHostlet = CTestHostlet::NewL(this,

   975 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceL,

   976 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

   977 

   978 //    ipConsumer = CTestConsumer::NewL(this, 

   979 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleMessageL, 

   980 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleErrorL, 

   981 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_SetStatus);

   982 

   983     ipHostletConnection = CSenHostletConnection::NewL(*ipHostlet);

   984 

   985     CSenServicePattern* pPattern =

   986         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

   987     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

   988     

   989     ipConnection = CSenServiceConnection::NewL(*ipConsumer, *pPattern);

   990     CleanupStack::PopAndDestroy(pPattern);

   991     

   992     TInt id;

   993     id = ipHostletConnection->Identifier();

   994     LOCAL_ASSERT( id  != KErrNotReady);

   995     TPtrC8 consumerId = ipHostlet->ConsumerId();

   996     LOCAL_ASSERT( consumerId == _L8(""));

   997     // Construct service connection

   998     StartActiveScheduler(1);

   999     

  1000     _LIT8(KRequest, "<ab:Query xmlns:ab=\"urn:nokia:test:addrbook:2004-09\"><ab:QueryItem><ab:Select>/ab:Card[containts[ab:N/ab:FAMILY,\'Bob\'] or containts[ab:N/ab:GIVEN,\'Bob\'] or containts[ab:TEL,\'Bob\']]</ab:Select></ab:QueryItem></ab:Query>");

  1001 

  1002     TInt transactionIdOrError = ipConnection->SendL(KRequest);

  1003 

  1004     LOCAL_ASSERT(transactionIdOrError > KErrNone);

  1005     

  1006     // Invoke service  ONCE (one call to ServiceL), respond to consumer ONCE => two calls

  1007     StartActiveScheduler(2);

  1008 

  1009     // ---- Following conditions MUST be met ----

  1010 

  1011     // 1. Hostlet receives request that consumer made

  1012     LOCAL_ASSERT( *ipHostlet->iRequests[0] == KRequest);

  1013 

  1014     // 2. Consumer receives response that hostlet provided

  1015     LOCAL_ASSERT( *ipConsumer->iResponses[0] == *ipHostlet->iResponses[0]);

  1016     LOCAL_ASSERT( ipConsumer->iResponseCodes[0] == ipHostlet->iResponseCodes[0])

  1017 

  1018     // 3. Hostlet receives completion code (delivery code)

  1019     LOCAL_ASSERT( ipHostlet->iTxnIds[0] == transactionIdOrError );

  1020     LOCAL_ASSERT( ipHostlet->iCompletionCodes[0] == KErrNone ); // true in this "OK" -test case

  1021     

  1022     // --- Conditions END ---

  1023     

  1024     delete ipConnection;

  1025     ipConnection = NULL;

  1026     delete ipHostletConnection; 

  1027     ipHostletConnection = NULL;

  1028     delete ipHostlet;

  1029     ipHostlet = NULL;

  1030     delete ipConsumer;

  1031     ipConsumer = NULL;

  1032     

  1033     return KErrNone;

  1034     }

  1035 TInt ChostconnTester::UT_CSenHostletConnection_RequestIdL(CStifItemParser& aItem )

  1036 	{

  1037 	 

  1038     ipHostlet = CTestHostlet::NewL(this);   // uses default implementations for servicel and onservicecompletel

  1039     ipConsumer = CTestConsumer::NewL(this); // uses the default implementations for setstatus, handlemessage, handleerror

  1040 

  1041 //    ipHostlet = CTestHostlet::NewL(this,

  1042 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceL,

  1043 //                                   &ChostconnTester::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

  1044 

  1045 //    ipConsumer = CTestConsumer::NewL(this, 

  1046 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleMessageL, 

  1047 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_HandleErrorL, 

  1048 //                                     &ChostconnTester::UT_CSenHostletConnection_NewLL_SetStatus);

  1049 

  1050     ipHostletConnection = CSenHostletConnection::NewL(*ipHostlet);

  1051 

  1052     CSenServicePattern* pPattern =

  1053         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

  1054     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

  1055     

  1056     ipConnection = CSenServiceConnection::NewL(*ipConsumer, *pPattern);

  1057     CleanupStack::PopAndDestroy(pPattern);

  1058     

  1059     TInt id;

  1060     id = ipHostletConnection->Identifier();

  1061     LOCAL_ASSERT( id  != KErrNotReady);

  1062     TInt requestId = ipHostlet->RequestId();

  1063     LOCAL_ASSERT( requestId == KErrNone);

  1064     // Construct service connection

  1065     StartActiveScheduler(1);

  1066     

  1067     _LIT8(KRequest, "<ab:Query xmlns:ab=\"urn:nokia:test:addrbook:2004-09\"><ab:QueryItem><ab:Select>/ab:Card[containts[ab:N/ab:FAMILY,\'Bob\'] or containts[ab:N/ab:GIVEN,\'Bob\'] or containts[ab:TEL,\'Bob\']]</ab:Select></ab:QueryItem></ab:Query>");

  1068 

  1069     TInt transactionIdOrError = ipConnection->SendL(KRequest);

  1070 

  1071     LOCAL_ASSERT(transactionIdOrError > KErrNone);

  1072     

  1073     // Invoke service  ONCE (one call to ServiceL), respond to consumer ONCE => two calls

  1074     StartActiveScheduler(2);

  1075 

  1076     // ---- Following conditions MUST be met ----

  1077 

  1078     // 1. Hostlet receives request that consumer made

  1079     LOCAL_ASSERT( *ipHostlet->iRequests[0] == KRequest);

  1080 

  1081     // 2. Consumer receives response that hostlet provided

  1082     LOCAL_ASSERT( *ipConsumer->iResponses[0] == *ipHostlet->iResponses[0]);

  1083     LOCAL_ASSERT( ipConsumer->iResponseCodes[0] == ipHostlet->iResponseCodes[0])

  1084 

  1085     // 3. Hostlet receives completion code (delivery code)

  1086     LOCAL_ASSERT( ipHostlet->iTxnIds[0] == transactionIdOrError );

  1087     LOCAL_ASSERT( ipHostlet->iCompletionCodes[0] == KErrNone ); // true in this "OK" -test case

  1088     

  1089     // --- Conditions END ---

  1090     

  1091     delete ipConnection;

  1092     ipConnection = NULL;

  1093     delete ipHostletConnection; 

  1094     ipHostletConnection = NULL;

  1095     delete ipHostlet;

  1096     ipHostlet = NULL;

  1097     delete ipConsumer;

  1098     ipConsumer = NULL;

  1099     

  1100     return KErrNone;		

  1101 	}

  1102 

  1103 

  1104 

  1105 TInt ChostconnTester::UT_CSenHostletConnection_NewLC_3InvokesL(CStifItemParser& aItem)

  1106     {

  1107 	 

  1108     // Try to send _two_ messages from ServiceConnection to HostletConnection

  1109     // and check that everything goes OK.

  1110 

  1111     _LIT8(KRequest, "<ab:Query xmlns:ab=\"urn:nokia:test:addrbook:2004-09\"><ab:QueryItem><ab:Select>/ab:Card[containts[ab:N/ab:FAMILY,\'Abel\'] or containts[ab:N/ab:GIVEN,\'Abel\'] or containts[ab:TEL,\'Abel\']]</ab:Select></ab:QueryItem></ab:Query>");

  1112     _LIT8(KRequest2, "<ab:Query xmlns:ab=\"urn:nokia:test:addrbook:2004-09\"><ab:QueryItem><ab:Select>/ab:Card[containts[ab:N/ab:FAMILY,\'Bob\'] or containts[ab:N/ab:GIVEN,\'Bob\'] or containts[ab:TEL,\'Bob\']]</ab:Select></ab:QueryItem></ab:Query>");

  1113     _LIT8(KRequest3, "<ab:Query xmlns:ab=\"urn:nokia:test:addrbook:2004-09\"><ab:QueryItem><ab:Select>/ab:Card[containts[ab:N/ab:FAMILY,\'Clarice\'] or containts[ab:N/ab:GIVEN,\'Clarice\'] or containts[ab:TEL,\'Clarice\']]</ab:Select></ab:QueryItem></ab:Query>");

  1114     

  1115     // Construct Hostlet

  1116     ipHostlet = CTestHostlet::NewL(this);   // uses default implementations for servicel and onservicecompletel

  1117     ipHostletConnection = CSenHostletConnection::NewL(*ipHostlet);

  1118 

  1119     // Construct ServiceConnection

  1120     ipConsumer = CTestConsumer::NewL(this); // uses the default implementations for setstatus, handlemessage, handleerror

  1121     CSenServicePattern* pPattern =

  1122         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

  1123     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

  1124     

  1125     ipConnection = CSenServiceConnection::NewL(*ipConsumer, *pPattern);

  1126     CleanupStack::PopAndDestroy(pPattern);

  1127     StartActiveScheduler(1);

  1128     

  1129     // Check that the Status of the ServiceConnection

  1130     // is KSenConnectionStatusReady

  1131     LOCAL_ASSERT( ipConsumer->iConnectionStatus == KSenConnectionStatusReady);

  1132     

  1133     // ServiceConnection is ready

  1134 

  1135     // => Send first request to the Hostlet