1 /*

     2 * Copyright (c) 2002-2009 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 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 // INCLUDE FILES

    27 #include <e32math.h>

    28 #include "senhostletconnectionbctest.h"

    29 

    30 #include <SenFacet.h>

    31 

    32 

    33 //  EXTERNAL INCLUDES

    34 #include <SenServiceConnection.h>

    35 #include <SenServicePattern.h>

    36 

    37 

    38 

    39 //  INTERNAL INCLUDES

    40 #include <SenHttpTransportProperties.h>

    41 #include "SenHostletConnection.h"

    42 #include "testconsumer.h"

    43 #include "testhostlet.h"

    44 

    45 #include <SenTransportProperties.h>

    46 

    47 // EXTERNAL DATA STRUCTURES

    48 //extern  ?external_data;

    49 

    50 // EXTERNAL FUNCTION PROTOTYPES  

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

    52 

    53 // CONSTANTS

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

    55 

    56 // MACROS

    57 //#define ?macro ?macro_def

    58 

    59 // LOCAL CONSTANTS AND MACROS

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

    61 //#define ?macro_name ?macro_def

    62 

    63 // MODULE DATA STRUCTURES

    64 //enum ?declaration

    65 //typedef ?declaration

    66 

    67 // LOCAL FUNCTION PROTOTYPES

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

    69 

    70 // FORWARD DECLARATIONS

    71 //class ?FORWARD_CLASSNAME;

    72 

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

    74 

    75 // -----------------------------------------------------------------------------

    76 // ?function_name ?description.

    77 // ?description

    78 // Returns: ?value_1: ?description

    79 //          ?value_n: ?description_line1

    80 //                    ?description_line2

    81 // -----------------------------------------------------------------------------

    82 //

    83 /*

    84 ?type ?function_name(

    85     ?arg_type arg,  // ?description

    86     ?arg_type arg)  // ?description

    87     {

    88 

    89     ?code  // ?comment

    90 

    91     // ?comment

    92     ?code

    93     }

    94 */

    95 

    96 

    97 //Macro for Porting to STIF

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

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

   100 

   101 namespace

   102     {

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

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

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

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

   107     

   108     void threadMainL(TAny* aPtr)

   109         {

   110         TConsumerTestTask* pTask = (TConsumerTestTask*) aPtr;

   111         pTask->Execute();

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

   113         }

   114     

   115     TInt threadFunction(TAny* aPtr)

   116         {

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

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

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

   120         CActiveScheduler::Install(pScheduler);

   121 

   122         TInt leaveCode(KErrNone);

   123         TRAP(leaveCode, threadMainL(aPtr));

   124 

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

   126         delete pScheduler;

   127         delete pCleanup;

   128 

   129         return leaveCode;

   130         }

   131         

   132         

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

   134         {

   135         TName threadName(aThreadName);

   136         // Append a random number to make it unique

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

   138                 

   139 #ifdef EKA2

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

   141         return aThread.Create(threadName, // name

   142                               threadFunction,

   143                               KDefaultStackSize,

   144                               &heap,

   145                               &aTask);

   146 #else // EKA1

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

   148         return aThread.Create(threadName, // name

   149                               threadFunction,

   150                               KDefaultStackSize,

   151                               &heap,

   152                               &aTask);

   153 #endif // EKA        

   154         }      

   155     }   

   156 

   157 

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

   159 

   160 // -----------------------------------------------------------------------------

   161 // CSenServiceManagerBCTest::Case

   162 // Returns a test case by number.

   163 //

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

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

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

   167 // 

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

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

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

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

   172 // -----------------------------------------------------------------------------

   173 //

   174 const TCaseInfo CSenHostletConnectionBCTest::Case ( 

   175     const TInt aCaseNumber ) const 

   176      {

   177 

   178     /**

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

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

   181     * doing the test case

   182     * In practice, do following

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

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

   185     *    SenServiceManager_stif.cpp file and to SenServiceManager_stif.h 

   186     *    header file.

   187     *

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

   189     *

   190     * 2.1: FUNCENTRY or ENTRY macro

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

   192     * function name.

   193     *

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

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

   196     *

   197     * Or

   198     *

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

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

   201     *

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

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

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

   205     * TInt value for last heap memory allocation failure.

   206     * 

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

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

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

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

   211     */ 

   212 

   213     static TCaseInfoInternal const KCases[] =

   214         {

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

   216         

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

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

   219         // CSenServiceManagerBCTest::PrintTest. Otherwise the compiler

   220         // gives errors.

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

   222     

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

   224 		

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

   226 		

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

   228 		

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

   230 		

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

   232 

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

   234 

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

   236 

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

   238 

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

   240    

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

   242 

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

   244 

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

   246     

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

   248 /*    

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

   250 */

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

   252          

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

   254    

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

   256      

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

   258 

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

   260       

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

   262 

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

   264 

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

   266     

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

   268 

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

   270 

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

   272 /*

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

   274 

   275 

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

   277 

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

   279 */

   280 

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

   282 

   283 /*

   284 // NOTE: following is used instead:

   285 // --> UT_CSenHostletConnection_CreateConnAndSubmit_Rest_MultiThreadL 

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

   287 

   288 // NOTE: following is used instead:

   289 // --> UT_CSenHostletConnection_CreateConnAndSubmit_Rest_MultiThreadL 

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

   291 */        

   292 	 	};

   293 

   294 	    // Verify that case number is valid

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

   296 	                               sizeof( TCaseInfoInternal ) )

   297 	        {

   298 	        // Invalid case, construct empty object

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

   300 	        null.iMethod = NULL;

   301 	        null.iIsOOMTest = EFalse;

   302 	        null.iFirstMemoryAllocation = 0;

   303 	        null.iLastMemoryAllocation = 0;

   304 	        return null;

   305 	        } 

   306 

   307 	    // Construct TCaseInfo object and return it

   308 	    TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );

   309 	    tmp.iMethod = KCases[ aCaseNumber ].iMethod;

   310 	    tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;

   311 	    tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;

   312 	    tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;

   313 	    return tmp;

   314 

   315 	    }   

   316 

   317 //  METHODS

   318 

   319 void CSenHostletConnectionBCTest::SetupL ()

   320     {

   321     __UHEAP_MARK;

   322     }

   323 

   324 void CSenHostletConnectionBCTest::Teardown ()

   325     {

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

   327     __UHEAP_MARKEND;

   328     }

   329 

   330 void CSenHostletConnectionBCTest::StartActiveScheduler(TInt aNumberOfPendingOps)

   331     {

   332     iNumberOfPendingOps = aNumberOfPendingOps;

   333     CActiveScheduler::Start();

   334     }

   335        

   336 void CSenHostletConnectionBCTest::StopActiveScheduler ()

   337     {

   338     iNumberOfPendingOps--;

   339     if ( iNumberOfPendingOps == 0 )

   340         {

   341     	CActiveScheduler::Stop();

   342         }

   343     }

   344 

   345 void TConsumerTestTask::Execute()

   346     {

   347     switch(iJob)

   348         {

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

   350             {

   351             if(ipOwner)

   352                 {

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

   354                 CleanupStack::PushL(pConsumer);

   355 

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

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

   358                 if(iFrameworkId.Length()>0)

   359                     {

   360                     pPattern->SetFrameworkIdL(iFrameworkId);

   361                     }

   362                 else

   363                     {

   364                     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);                        

   365                     }

   366                     

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

   368                 CleanupStack::PopAndDestroy(pPattern);

   369                 CleanupStack::PushL(pConnection);

   370                 

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

   372                 ipOwner->StartActiveScheduler(1);

   373                 

   374                 // Check that NO HandleErrorL callback was received:

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

   376                 

   377                 

   378                  // Check that the Status of the ServiceConnection

   379                 // is KSenConnectionStatusReady

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

   381 

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

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

   384                     {

   385                     if(ipSoapMsg)

   386                         {

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

   388                         }

   389                     else

   390                         {

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

   392                         }

   393                     }

   394                 else

   395                     {

   396                     if(ipSoapMsg)

   397                         {

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

   399                         }

   400                     else

   401                         {

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

   403                         }

   404                     }

   405                 CleanupStack::PopAndDestroy(pConnection);

   406                 CleanupStack::PopAndDestroy(pConsumer);

   407                 }

   408            }

   409            break;

   410 

   411         case(ESubmit):

   412             {

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

   414                 {

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

   416                 }

   417             else

   418                 {

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

   420                 }

   421             }

   422             break;

   423 

   424         case(EActiveSubmit):

   425             {

   426             if ( ipActive)

   427                 {

   428                 // Perform blocking (sync) submit:

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

   430                     {

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

   432                     }

   433                 else

   434                     {

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

   436                     }

   437                     

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

   439                 TRequestStatus* status = &ipActive->iStatus;

   440                 RThread owner;

   441                 owner.Open(ipActive->iOwnerThreadId);

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

   443                 }

   444             }

   445             break;

   446            

   447         }

   448     }

   449 

   450 /////////////////////////////////////////////////////////////////////////////////////////////////

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

   452 // Public METHODS

   453 

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

   455     {

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

   457     CleanupStack::Pop();

   458     return pNew;

   459     }

   460 

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

   462     {

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

   464     CleanupStack::PushL(pNew);

   465     pNew->ConstructL(aThreadName);

   466     return pNew;

   467     }

   468 

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

   470     :   CActive(EPriorityStandard), 

   471         iTask(aTask),

   472         iOwner(aOwner)

   473     {

   474     CActiveScheduler::Add(this);    

   475     }

   476 

   477 CActiveConsumerTestTask::~CActiveConsumerTestTask()

   478     {

   479     if(IsActive())

   480         {

   481         Cancel(); // issues DoCancel();

   482         }

   483     iTaskThread.Close();

   484     }

   485 

   486 void CActiveConsumerTestTask::RunL()

   487     {

   488     switch(iStatus.Int())

   489         {

   490         case(EInvokeService):

   491             {

   492             iTaskThread.Resume();

   493             }

   494             break;

   495             

   496         case(EDeliverResponse):

   497             {

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

   499             }

   500             break;

   501          /* case defaul: // unknown */

   502         }

   503     }

   504 void CActiveConsumerTestTask::DoCancel()

   505     {

   506     iOwner.StopActiveScheduler();

   507     }

   508     

   509 // Private METHODS

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

   511     {

   512     RThread thread;

   513     iOwnerThreadId = thread.Id(); 

   514     

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

   516     User::LeaveIfError( createThreadRetVal );

   517     SetActive();

   518     }

   519     

   520     

   521 /////////////////////////////////////////////////////////////////////////////////////////////////

   522 

   523 void  CSenHostletConnectionBCTest::UT_CSenHostletConnection_WSI_DescribeServiceL(CSenXmlServiceDescription& aSD)

   524     {

   525     aSD.SetFrameworkIdL(KDefaultBasicWebServicesFrameworkID);

   526     aSD.SetEndPointL(KHostletEndpoint);

   527     aSD.SetContractL(KHostletContract);

   528     }

   529 

   530 void  CSenHostletConnectionBCTest::UT_CSenHostletConnection_WSI_DescribeService_2L(CSenXmlServiceDescription& aSD)

   531     {

   532     aSD.SetFrameworkIdL(KDefaultBasicWebServicesFrameworkID);

   533     aSD.SetContractL(KHostletContract);

   534     }

   535 

   536 

   537 void CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_SetStatus(CSenHostletConnectionBCTest* apTestSuite,

   538                                                                     TInt aStatus )

   539    {

   540     switch( aStatus )

   541         {

   542         case KSenConnectionStatusReady:

   543             {

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

   545             }

   546             break;

   547         case KSenConnectionStatusNew:

   548         case KSenConnectionStatusExpired:

   549         default:            

   550             break;

   551         }

   552     }

   553 

   554 

   555 

   556 // not in use atm:

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

   558     {

   559     }

   560 

   561 //used by UT_CSenHostletConnection_Negative_ResponseCodeL

   562 //used by UT_CSenHostletConnection_Delete_HCL

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

   564     {

   565     apTestSuite->iWas_HandleErrorL_Accessed = ETrue;

   566     }

   567     

   568 //used by the UT_CSenHostletConnection_Negative_ResponseCodeL    

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

   570     {

   571     TInt alteredResponseCode = -148000;

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

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

   574     aResponse.SetResponseUtf8L(KAlteredResponse, alteredResponseCode);

   575     return KErrNone;

   576     }

   577     

   578 // not in use atm:    

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

   580     {

   581     return KErrNone;

   582     }    

   583     

   584 //used by the UT_CSenHostletConnection_DeleteSC_before_HCRespondLL method

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

   586     {

   587     apTestSuite->ipConnection->Cancel();

   588     delete apTestSuite->ipConnection;

   589     apTestSuite->ipConnection = NULL;

   590     return KErrNone;

   591     }

   592     

   593 //used by UT_CSenHostletConnection_DeleteSC_before_HCRespondLL

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

   595     {

   596 	apTestSuite->iWas_OnServiceL_Accessed = ETrue;

   597     return KErrNone;

   598     }        

   599 

   600 // used by the UT_CSenHostletConnection_RespondL_4multipleTimesL method

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

   602     {

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

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

   605 	LOCAL_ASSERT(respondRetCode == KErrNone);    

   606     LOCAL_ASSERT(respondRetCode1 == KErrAlreadyExists);

   607     return KErrNone;

   608     }

   609     

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

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

   612     {

   613     return KErrNone;

   614     }        

   615     

   616 //used by the UT_CSenHostletConnection_SC_Cancel_After_RequestL method

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

   618     {

   619 //    TInt a = aErrorCode;

   620     apTestSuite->iWas_HandleErrorL_Accessed = ETrue;

   621     }

   622 //used by the UT_CSenHostletConnection_SC_Cancel_After_RequestL method

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

   624     {

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

   626    //canceling request

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

   628     return KErrNone;

   629     }

   630 

   631 

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

   633 TInt CSenHostletConnectionBCTest::UT_CSenHostletConnection_RespondWithPropertiesL_OnServiceL(CSenHostletConnectionBCTest*  apTestSuite , MSenHostletRequest&  /*aRequest*/ , MSenHostletResponse&  aResponse )

   634     {

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

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

   637 

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

   639 

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

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

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

   643     pTransportProperties->SetFileAttachmentL( KTestCid, KTestFile );

   644     

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

   646         {

   647         // error:

   648         CleanupStack::PopAndDestroy(pTransportProperties);

   649         return KErrNoMemory;

   650         }

   651     else

   652         {

   653         // ok

   654         CleanupStack::Pop(pTransportProperties);

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

   656         return KErrNone;

   657         }

   658     }

   659 

   660 

   661 

   662 //---------------------------------------------------------------

   663 // 							Test Cases

   664 //---------------------------------------------------------------

   665 

   666 

   667 TInt CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL(TTestResult& aResult)

   668     {

   669 	SetupL(); 

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

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

   672 

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

   674 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceL,

   675 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

   676 

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

   678 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleMessageL, 

   679 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleErrorL, 

   680 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_SetStatus);

   681 

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

   683 

   684     CSenServicePattern* pPattern =

   685         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

   686     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

   687     

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

   689     CleanupStack::PopAndDestroy(pPattern);

   690     

   691     // Construct service connection

   692     StartActiveScheduler(1);

   693     

   694     _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>");

   695 

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

   697 

   698     LOCAL_ASSERT(transactionIdOrError > KErrNone);

   699     

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

   701     StartActiveScheduler(2);

   702 

   703     // ---- Following conditions MUST be met ----

   704 

   705     // 1. Hostlet receives request that consumer made

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

   707 

   708     // 2. Consumer receives response that hostlet provided

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

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

   711 

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

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

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

   715     

   716     // --- Conditions END ---

   717     

   718     delete ipConnection;

   719     ipConnection = NULL;

   720     delete ipHostletConnection; 

   721     ipHostletConnection = NULL;

   722     delete ipHostlet;

   723     ipHostlet = NULL;

   724     delete ipConsumer;

   725     ipConsumer = NULL;

   726     Teardown();

   727     return KErrNone;

   728     }

   729 

   730     

   731 TInt CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLCL(TTestResult& aResult)

   732     {

   733 	SetupL(); 

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

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

   736 

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

   738 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceL,

   739 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

   740 

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

   742 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleMessageL, 

   743 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleErrorL, 

   744 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_SetStatus);

   745 

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

   747 

   748     CSenServicePattern* pPattern =

   749         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

   750     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

   751     

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

   753     CleanupStack::PopAndDestroy(pPattern);

   754     

   755     // Construct service connection

   756     StartActiveScheduler(1);

   757     

   758     _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>");

   759 

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

   761 

   762     LOCAL_ASSERT(transactionIdOrError > KErrNone);

   763     

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

   765     StartActiveScheduler(2);

   766 

   767     // ---- Following conditions MUST be met ----

   768 

   769     // 1. Hostlet receives request that consumer made

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

   771 

   772     // 2. Consumer receives response that hostlet provided

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

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

   775 

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

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

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

   779     

   780     // --- Conditions END ---

   781     

   782     delete ipConnection;

   783     ipConnection = NULL;

   784     CleanupStack::PopAndDestroy(ipHostletConnection);

   785     //delete ipHostletConnection; 

   786     //ipHostletConnection = NULL;

   787     delete ipHostlet;

   788     ipHostlet = NULL;

   789     delete ipConsumer;

   790     ipConsumer = NULL;

   791     Teardown();

   792     return KErrNone;

   793     }

   794 

   795 TInt CSenHostletConnectionBCTest::UT_CSenHostletConnection_IdentifierL(TTestResult& aResult)

   796     {

   797 	SetupL(); 

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

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

   800 

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

   802 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceL,

   803 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

   804 

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

   806 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleMessageL, 

   807 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleErrorL, 

   808 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_SetStatus);

   809 

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

   811 

   812     CSenServicePattern* pPattern =

   813         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

   814     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

   815     

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

   817     CleanupStack::PopAndDestroy(pPattern);

   818     

   819     TInt id;

   820     id = ipHostletConnection->Identifier();

   821     LOCAL_ASSERT( id  != KErrNotReady);

   822     TPtrC8 framework = ipHostlet->FrameworkId();

   823     // Construct service connection

   824     StartActiveScheduler(1);

   825     

   826     _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>");

   827 

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

   829 

   830     LOCAL_ASSERT(transactionIdOrError > KErrNone);

   831     

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

   833     StartActiveScheduler(2);

   834 

   835     // ---- Following conditions MUST be met ----

   836 

   837     // 1. Hostlet receives request that consumer made

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

   839 

   840     // 2. Consumer receives response that hostlet provided

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

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

   843 

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

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

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

   847     

   848     // --- Conditions END ---

   849     

   850     delete ipConnection;

   851     ipConnection = NULL;

   852     delete ipHostletConnection; 

   853     ipHostletConnection = NULL;

   854     delete ipHostlet;

   855     ipHostlet = NULL;

   856     delete ipConsumer;

   857     ipConsumer = NULL;

   858     Teardown();

   859     return KErrNone;

   860     }

   861 

   862 TInt CSenHostletConnectionBCTest::UT_CSenHostletConnection_FrameworkIdL(TTestResult& aResult)

   863     {

   864 	SetupL(); 

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

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

   867 

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

   869 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceL,

   870 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

   871 

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

   873 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleMessageL, 

   874 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleErrorL, 

   875 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_SetStatus);

   876 

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

   878 

   879     CSenServicePattern* pPattern =

   880         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

   881     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

   882     

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

   884     CleanupStack::PopAndDestroy(pPattern);

   885     

   886     TInt id;

   887     id = ipHostletConnection->Identifier();

   888     LOCAL_ASSERT( id  != KErrNotReady);

   889     _LIT8(KFramework, "REST");

   890     TPtrC8 framework = ipHostlet->FrameworkId();

   891     LOCAL_ASSERT( framework == KFramework);

   892     // Construct service connection

   893     StartActiveScheduler(1);

   894     

   895     _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>");

   896 

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

   898 

   899     LOCAL_ASSERT(transactionIdOrError > KErrNone);

   900     

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

   902     StartActiveScheduler(2);

   903 

   904     // ---- Following conditions MUST be met ----

   905 

   906     // 1. Hostlet receives request that consumer made

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

   908 

   909     // 2. Consumer receives response that hostlet provided

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

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

   912 

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

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

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

   916     

   917     // --- Conditions END ---

   918     

   919     delete ipConnection;

   920     ipConnection = NULL;

   921     delete ipHostletConnection; 

   922     ipHostletConnection = NULL;

   923     delete ipHostlet;

   924     ipHostlet = NULL;

   925     delete ipConsumer;

   926     ipConsumer = NULL;

   927     Teardown();

   928     return KErrNone;

   929     }

   930 

   931 TInt CSenHostletConnectionBCTest::UT_CSenHostletConnection_RequestUtf8L(TTestResult& aResult)

   932     {

   933 	SetupL(); 

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

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

   936 

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

   938 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceL,

   939 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

   940 

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

   942 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleMessageL, 

   943 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleErrorL, 

   944 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_SetStatus);

   945 

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

   947 

   948     CSenServicePattern* pPattern =

   949         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

   950     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

   951     

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

   953     CleanupStack::PopAndDestroy(pPattern);

   954     

   955     TInt id;

   956     id = ipHostletConnection->Identifier();

   957     LOCAL_ASSERT( id  != KErrNotReady);

   958     TPtrC8 request = ipHostlet->RequestUtf8();

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

   960     // Construct service connection

   961     StartActiveScheduler(1);

   962     

   963     _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>");

   964 

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

   966 

   967     LOCAL_ASSERT(transactionIdOrError > KErrNone);

   968     

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

   970     StartActiveScheduler(2);

   971 

   972     // ---- Following conditions MUST be met ----

   973 

   974     // 1. Hostlet receives request that consumer made

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

   976 

   977     // 2. Consumer receives response that hostlet provided

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

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

   980 

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

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

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

   984     

   985     // --- Conditions END ---

   986     

   987     delete ipConnection;

   988     ipConnection = NULL;

   989     delete ipHostletConnection; 

   990     ipHostletConnection = NULL;

   991     delete ipHostlet;

   992     ipHostlet = NULL;

   993     delete ipConsumer;

   994     ipConsumer = NULL;

   995     Teardown();

   996     return KErrNone;

   997     }

   998 

   999 TInt CSenHostletConnectionBCTest::UT_CSenHostletConnection_ThreadIdL(TTestResult& aResult)

  1000     {

  1001 	SetupL(); 

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

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

  1004 

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

  1006 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceL,

  1007 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

  1008 

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

  1010 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleMessageL, 

  1011 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleErrorL, 

  1012 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_SetStatus);

  1013 

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

  1015 

  1016     CSenServicePattern* pPattern =

  1017         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

  1018     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

  1019     

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

  1021     CleanupStack::PopAndDestroy(pPattern);

  1022     

  1023     TInt id;

  1024     id = ipHostletConnection->Identifier();

  1025     LOCAL_ASSERT( id  != KErrNotReady);

  1026     TPtrC threadId = ipHostlet->ThreadId();

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

  1028     // Construct service connection

  1029     StartActiveScheduler(1);

  1030     

  1031     _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>");

  1032 

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

  1034 

  1035     LOCAL_ASSERT(transactionIdOrError > KErrNone);

  1036     

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

  1038     StartActiveScheduler(2);

  1039 

  1040     // ---- Following conditions MUST be met ----

  1041 

  1042     // 1. Hostlet receives request that consumer made

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

  1044 

  1045     // 2. Consumer receives response that hostlet provided

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

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

  1048 

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

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

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

  1052     

  1053     // --- Conditions END ---

  1054     

  1055     delete ipConnection;

  1056     ipConnection = NULL;

  1057     delete ipHostletConnection; 

  1058     ipHostletConnection = NULL;

  1059     delete ipHostlet;

  1060     ipHostlet = NULL;

  1061     delete ipConsumer;

  1062     ipConsumer = NULL;

  1063     Teardown();

  1064     return KErrNone;

  1065     }

  1066 TInt CSenHostletConnectionBCTest::UT_CSenHostletConnection_ConsumerIdL(TTestResult& aResult)

  1067 	{

  1068 	SetupL(); 

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

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

  1071 

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

  1073 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceL,

  1074 //                                   &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_OnServiceCompleteL);

  1075 

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

  1077 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleMessageL, 

  1078 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_HandleErrorL, 

  1079 //                                     &CSenHostletConnectionBCTest::UT_CSenHostletConnection_NewLL_SetStatus);

  1080 

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

  1082 

  1083     CSenServicePattern* pPattern =

  1084         CSenServicePattern::NewLC(KNullDesC8, KHostletContract);

  1085     pPattern->SetFrameworkIdL(KDefaultRestServicesFrameworkID);

  1086     

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

  1088     CleanupStack::PopAndDestroy(pPattern);

  1089     

  1090     TInt id;

  1091     id = ipHostletConnection->Identifier();

  1092     LOCAL_ASSERT( id  != KErrNotReady);

  1093     TPtrC8 consumerId = ipHostlet->ConsumerId();

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

  1095     // Construct service connection

  1096     StartActiveScheduler(1);

  1097     

  1098     _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>");

  1099 

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

  1101 

  1102     LOCAL_ASSERT(transactionIdOrError > KErrNone);

  1103     

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

  1105     StartActiveScheduler(2);

  1106 

  1107     // ---- Following conditions MUST be met ----

  1108 

  1109     // 1. Hostlet receives request that consumer made

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

  1111 

  1112     // 2. Consumer receives response that hostlet provided

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

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

  1115 

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

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

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

  1119     

  1120     // --- Conditions END ---

  1121     

  1122     delete ipConnection;

  1123     ipConnection = NULL;

  1124     delete ipHostletConnection; 

  1125     ipHostletConnection = NULL;

  1126     delete ipHostlet;

  1127     ipHostlet = NULL;

  1128     delete ipConsumer;

  1129     ipConsumer = NULL;

  1130     Teardown();

  1131     return KErrNone;

  1132     }

  1133 TInt CSenHostletConnectionBCTest::UT_CSenHostletConnection_RequestIdL(TTestResult& aResult)

  1134 	{