1 /*

     2 * Copyright (c) 2006 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: XIMP Framework Test Code 

    15 *

    16 */

    17 

    18 #include <eunitmacros.h>

    19 #include <ecom/ecom.h>

    20 #include <badesca.h>

    21 #include <e32base.h>

    22 

    23 #include "t_sessionmng.h"

    24 #include "prfwteststatuseventlistener.h"

    25 #include "prfwtestmessaging.h"

    26 #include "prfwtestmessenger.h"

    27 #include "prfwtestcontextwrappermgr.h"

    28 #include "prfwtestcontextwrapper.h"

    29 #include "prfwtestfiletool.h"

    30 #include "userafter.h"

    31 

    32 #include "eunittools.h"

    33 #include "prfwtestrobustnesstools.h"

    34 #include "prfwtestprotocols.h"

    35 

    36 #include <ximpclient.h>

    37 #include <ximpcontext.h>

    38 #include <ximpcontextstateevent.h>

    39 #include <ximprequestcompleteevent.h>

    40 #include <ximpstatus.h>

    41 #include <ximpfeatureinfo.h>

    42 #include <ximpserviceinfo.h>

    43 

    44 

    45 

    46 

    47 

    48 

    49 

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

    51 

    52 // CONSTRUCTION

    53 T_SessionMng* T_SessionMng::NewL()

    54     {

    55     T_SessionMng* self = new( ELeave ) T_SessionMng;

    56     CleanupStack::PushL( self );

    57     self->ConstructL();

    58     CleanupStack::Pop( self );

    59 

    60     return self;

    61     }

    62 

    63 

    64 T_SessionMng::~T_SessionMng()

    65     {

    66     delete iWrapperMgr;

    67     

    68     CXIMPTestFileTool::CleanAllL();

    69     }

    70 

    71 

    72 void T_SessionMng::ConstructL()

    73     {

    74     CEUnitTestSuiteClass::ConstructL();

    75     CXIMPTestFileTool::CleanAllL();

    76     }

    77 

    78 

    79 T_SessionMng::T_SessionMng()

    80     {

    81     }

    82 

    83 

    84 

    85 // ===========================================================================

    86 // TEST CASE SETUP & TEARDOWN METHODS

    87 // ===========================================================================

    88 //

    89 

    90 void T_SessionMng::Setup_L()

    91     {

    92     PrfwTestRobustness::DoPreCleaning();

    93 

    94     // now we're using only one connection

    95     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

    96     iWrapperMgr->CreateWrapperL();

    97     }

    98 

    99 

   100 void T_SessionMng::Setup_2_L()

   101     {

   102     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   103 

   104     // two wrappers

   105     iWrapperMgr->CreateWrapperL();

   106     iWrapperMgr->CreateWrapperL();

   107     }

   108 

   109 

   110 void T_SessionMng::Setup_3_L()

   111     {

   112     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   113 

   114     // three wrappers for unbalanced bind/share unbind/unshare test

   115     iWrapperMgr->CreateWrapperL();

   116     iWrapperMgr->CreateWrapperL();

   117     iWrapperMgr->CreateWrapperL();

   118     }

   119 

   120 

   121 void T_SessionMng::Teardown()

   122     {

   123     delete iWrapperMgr;

   124     iWrapperMgr = NULL;

   125 

   126     REComSession::FinalClose();

   127 

   128     PrfwTestRobustness::DoPreCleaning();

   129     }

   130 

   131 

   132 

   133 // ===========================================================================

   134 // TEST CASE

   135 // ===========================================================================

   136 void T_SessionMng::T_Simple_Bind_Wait_Unbind_L()

   137     {

   138     EUNIT_PRINT( _L("Simple context Bind/Unbind test.") );

   139     EUNIT_PRINT( _L("Client side waits bind completion before issuing unbind.") );

   140 

   141     CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

   142     MXIMPContext* context = wrapper->GetContext();

   143     CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();

   144     CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   145 

   146     //Do bind, wait and verify events

   147     wrapper->SetupListenerL( EXIMPTestStatusEvents_BindingOk );

   148     

   149     messenger->SetPluginIndex( 0 );

   150     messenger->SetNoError();

   151 

   152     TXIMPRequestId reqId;

   153     reqId = BindContextToDefaultL( context );

   154     EUNIT_ASSERT( reqId != TXIMPRequestId::Null() );

   155 

   156     wrapper->WaitRequestAndStackEvents( reqId );

   157     wrapper->VerifyEventStackL( _L8("Binding single context: ") );

   158 

   159     messenger->AssertOpenSessionCalled( ETrue );

   160 

   161     //Verify features availability

   162     MXIMPFeatureInfo* ctxFeats = context->GetContextFeaturesLC();

   163     EUNIT_ASSERT_DESC( ctxFeats->FeatureIds().MdcaCount() > 0, "No features from context" );

   164     CleanupStack::PopAndDestroy(); //ctxFeats

   165 

   166     //Do unbind, wait and verify events

   167     wrapper->SetupListenerL( EXIMPTestStatusEvents_UnbindingOk );

   168     messenger->SetNoError();

   169     reqId = context->UnbindL();

   170     EUNIT_ASSERT( reqId != TXIMPRequestId::Null() );

   171 

   172     wrapper->WaitRequestAndStackEvents( reqId );

   173     wrapper->VerifyEventStackL( _L8("Unbinding single context: ") );

   174 

   175     messenger->AssertCloseSessionCalled( ETrue );

   176     messenger->AssertPluginDied( ETrue );

   177     }

   178 

   179 // ===========================================================================

   180 // TEST CASE

   181 // ===========================================================================

   182 void T_SessionMng::T_Settings_Bind_Wait_Unbind_L()

   183     {

   184     EUNIT_PRINT( _L("Context Bind with Settings id/Unbind test.") );

   185     EUNIT_PRINT( _L("Client side waits bind completion before issuing unbind.") );

   186 

   187     CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

   188     MXIMPContext* context = wrapper->GetContext();

   189     CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();

   190     CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   191 

   192     //Do bind, wait and verify events

   193     wrapper->SetupListenerL( EXIMPTestStatusEvents_BindingOk );

   194     

   195     messenger->SetPluginIndex( 0 );

   196     messenger->SetNoError();

   197 

   198     TXIMPRequestId reqId;

   199     TUid protocol = { K_PRFW_TST_PROTOCOL_1_IMPLEMENTATION_UID };

   200     reqId = context->BindToL( protocol, 0 );

   201     

   202     EUNIT_ASSERT( reqId != TXIMPRequestId::Null() );

   203 

   204     wrapper->WaitRequestAndStackEvents( reqId );

   205     wrapper->VerifyEventStackL( _L8("Binding single context: ") );

   206 

   207     messenger->AssertOpenSessionCalled( ETrue );

   208 

   209     //Verify features availability

   210     MXIMPFeatureInfo* ctxFeats = context->GetContextFeaturesLC();

   211     EUNIT_ASSERT_DESC( ctxFeats->FeatureIds().MdcaCount() > 0, "No features from context" );

   212     CleanupStack::PopAndDestroy(); //ctxFeats

   213 

   214     //Do unbind, wait and verify events

   215     wrapper->SetupListenerL( EXIMPTestStatusEvents_UnbindingOk );

   216     messenger->SetNoError();

   217     reqId = context->UnbindL();

   218     EUNIT_ASSERT( reqId != TXIMPRequestId::Null() );

   219 

   220     wrapper->WaitRequestAndStackEvents( reqId );

   221     wrapper->VerifyEventStackL( _L8("Unbinding single context: ") );

   222 

   223     messenger->AssertCloseSessionCalled( ETrue );

   224     messenger->AssertPluginDied( ETrue );

   225     }

   226 

   227 

   228 // ===========================================================================

   229 // TEST CASE

   230 // ===========================================================================

   231 void T_SessionMng::T_Simple_Bind_Wait_OOM_L()

   232     {

   233     EUNIT_PRINT( _L("Simple context Bind OOM test.") );

   234     EUNIT_PRINT( _L("Client side waits bind completion in alloc heaven.") );

   235 

   236     CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

   237     MXIMPContext* context = wrapper->GetContext();

   238     CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   239 

   240     //Do bind, wait and verify events

   241     wrapper->SetupListenerReqCompleteL( EXIMPTestStatusEvents_RequestOk );

   242 

   243     messenger->SetPluginIndex( 0 );

   244     messenger->SetNoError();

   245 

   246     TXIMPRequestId reqId;

   247     reqId = BindContextToDefaultL( context );

   248     EUNIT_ASSERT( reqId != TXIMPRequestId::Null() );

   249 

   250     wrapper->WaitRequestAndStackEvents( reqId );

   251     

   252     CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();    

   253     TInt reqCompleteErr = eventListener->GetReqCompletionErrL( reqId );

   254     User::LeaveIfError( reqCompleteErr );

   255     

   256     wrapper->VerifyEventStackL( _L8("Binding single context in OOM: ") );

   257     }

   258 

   259 

   260 // ===========================================================================

   261 // TEST CASE

   262 // ===========================================================================

   263 void T_SessionMng::T_Simple_Bind_Wait_Unbind_WithReqCompleteEventFilter_L()

   264     {

   265     EUNIT_PRINT( _L("Simple context Bind/Unbind test.") );

   266     EUNIT_PRINT( _L("Client side waits bind completion before issuing unbind.") );

   267     EUNIT_PRINT( _L("Client event filter accepts only request completion events") );

   268 

   269     CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

   270     MXIMPContext* context = wrapper->GetContext();

   271     CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();

   272     CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   273 

   274     //Accept only ReqComplete events

   275     wrapper->SetupListenerReqCompleteL( EXIMPTestStatusEvents_RequestOk );

   276     

   277     messenger->SetPluginIndex( 0 );

   278     messenger->SetNoError();

   279     

   280     

   281     //Do bind, wait and verify events    

   282     TXIMPRequestId reqId = BindContextToDefaultL( context );

   283 

   284     wrapper->WaitRequestAndStackEvents( reqId );

   285     wrapper->VerifyEventStackL( _L8("Binding single context, accepting only reqComplete events: ") );

   286     messenger->AssertOpenSessionCalled( ETrue );

   287     

   288 

   289     //Accept only ReqComplete events

   290     wrapper->SetupListenerReqCompleteL( EXIMPTestStatusEvents_RequestOk );

   291     messenger->SetNoError();

   292 

   293     //Do unbind, wait and verify events

   294     reqId = context->UnbindL();

   295 

   296     wrapper->WaitRequestAndStackEvents( reqId );

   297     wrapper->VerifyEventStackL( _L8("Unbinding single context, accepting only reqComplete events: ") );

   298 

   299     messenger->AssertCloseSessionCalled( ETrue );

   300     }

   301 

   302 

   303 

   304 // ===========================================================================

   305 // TEST CASE

   306 // ===========================================================================

   307 //

   308 void T_SessionMng::T_Simple_Bind_Wait_CloseHandle_L()

   309     {

   310     EUNIT_PRINT( _L("Simple context Bind/CloseHandle test.") );

   311     EUNIT_PRINT( _L("Client side waits bind completion before closing the handle.") );

   312 

   313     CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

   314     MXIMPContext* context = wrapper->GetContext();

   315     CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();

   316     CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   317 

   318     //Do bind, wait and verify events

   319     wrapper->SetupListenerL( EXIMPTestStatusEvents_BindingOk );

   320 

   321     messenger->SetPluginIndex( 0 );

   322     messenger->SetNoError();

   323 

   324     TXIMPRequestId reqId = BindContextToDefaultL( context );

   325 

   326     wrapper->WaitRequestAndStackEvents( reqId );

   327     wrapper->VerifyEventStackL( _L8("Binding single context: ") );

   328 

   329     messenger->AssertOpenSessionCalled( ETrue );

   330 

   331 

   332     //Close handle and verify events

   333     wrapper->ClearListener();    

   334     messenger->SetNoError();

   335     wrapper->DeletePresenceContext();

   336     

   337     

   338     // we give 10 sec to plugin to die

   339     CUserAfter::AfterSecondsL( 10 );

   340 

   341 

   342     messenger->AssertCloseSessionCalled( ETrue );

   343     messenger->AssertPluginDied( ETrue );

   344 

   345     wrapper->VerifyEventStackL( _L8("Closing single context handle: ") );

   346     }

   347 

   348 

   349 

   350 // ===========================================================================

   351 // TEST CASE

   352 // ===========================================================================

   353 //

   354 void T_SessionMng::T_Simple_Bind_Direct_Unbind_L()

   355     {

   356     EUNIT_PRINT( _L("Simple context Bind/Unbind test.") );

   357     EUNIT_PRINT( _L("Client side deletes context while the binding is still active.") );

   358 

   359     CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

   360     MXIMPContext* context = wrapper->GetContext();

   361     CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();

   362     CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   363 

   364     wrapper->SetupListenerL( EXIMPTestStatusEvents_BindingOk );

   365     wrapper->AppendToTraitsL( EXIMPTestStatusEvents_UnbindingOk );

   366 

   367     

   368     messenger->SetPluginIndex( 0 );

   369     messenger->SetNoError(); //For binding

   370 

   371     

   372     TXIMPRequestId bindReqId = BindContextToDefaultL( context );

   373 

   374 

   375     messenger->AssertOpenSessionCalled( ETrue );

   376 

   377     messenger->SetNoError(); // for unbinding

   378     TXIMPRequestId unbindReqId = context->UnbindL();

   379 

   380     wrapper->WaitRequestAndStackEvents( bindReqId );

   381     wrapper->WaitRequestAndStackEvents( unbindReqId );

   382 

   383     wrapper->VerifyEventStackL( _L8("Direct Bind/Unbind single context: ") );

   384 

   385     messenger->AssertCloseSessionCalled( ETrue );

   386     messenger->AssertPluginDied( ETrue );

   387     }

   388 

   389 

   390 

   391 

   392 // ===========================================================================

   393 // TEST CASE

   394 // ===========================================================================

   395 //

   396 void T_SessionMng::T_Simple_Bind_Direct_CloseHandle_L()

   397     {

   398     EUNIT_PRINT( _L("Simple context Bind/Unbind test.") );

   399     EUNIT_PRINT( _L("Client side closes context handle while the binding is still active.") );

   400 

   401     CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

   402     MXIMPContext* context = wrapper->GetContext();

   403     CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();

   404     CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   405 

   406    

   407     messenger->SetPluginIndex( 0 );

   408     messenger->SetNoError();   

   409 

   410 

   411     TXIMPRequestId reqId = BindContextToDefaultL( context );

   412 

   413     messenger->AssertOpenSessionCalled( ETrue );

   414     wrapper->DeletePresenceContext();

   415 

   416     // wait for plugin to die properly here

   417     CUserAfter::AfterSecondsL( 10 );

   418 

   419     messenger->AssertCloseSessionCalled( ETrue );

   420     messenger->AssertPluginDied( ETrue );

   421     }

   422 

   423 

   424 

   425 

   426 // ===========================================================================

   427 // TEST CASE

   428 // ===========================================================================

   429 //

   430 void T_SessionMng::T_ErrFromPlg_LeaveOnOpenSession_L()

   431     {

   432     EUNIT_PRINT( _L("Error from plug-in in bind/unbind." ) );

   433     EUNIT_PRINT( _L("Plug-in leaves from OpenSessionL()." ) );

   434 

   435 

   436     CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

   437     MXIMPContext* context = wrapper->GetContext();

   438     CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();

   439     CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   440 

   441         {

   442         wrapper->SetupListenerL( EXIMPTestStatusEvents_BindingFailKErrAbort );

   443         messenger->SetLeave( KErrAbort );

   444         messenger->SetPluginIndex( 0 );

   445         

   446         TXIMPRequestId reqId = BindContextToDefaultL( context );

   447 

   448         wrapper->WaitRequestAndStackEvents( reqId );

   449         wrapper->VerifyEventStackL( _L8("Binding single context: ") );

   450 

   451         //Verify that features are not available

   452         TRAPD( featLoadErr,

   453                 MXIMPFeatureInfo* ctxFeats = context->GetContextFeaturesLC();

   454                 CleanupStack::PopAndDestroy(); //ctxFeats

   455              );

   456         EUNIT_ASSERT_NOT_EQUALS( featLoadErr, KErrNone );

   457 

   458         // plugin should've been unloaded without calling CloseSession

   459         EUNIT_ASSERT_DESC( ! messenger->GetBoolean( EXIMPPlgTestCloseSessionCalled ), "CloseSession was called" );

   460 

   461         messenger->AssertPluginDied( ETrue );

   462         }

   463     }

   464 

   465 

   466 // ===========================================================================

   467 // TEST CASE:

   468 // ===========================================================================

   469 //

   470 void T_SessionMng::T_ErrFromPlg_ErrorResultOnOpenSession_L()

   471     {

   472     EUNIT_PRINT( _L("Error from plug-in in bind/unbind") );

   473     EUNIT_PRINT( _L("Plug-in completes OpenSessionL() with error") );

   474     EUNIT_PRINT( _L("Clint ctx can be reused for second bind.") );

   475 

   476     CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

   477     MXIMPContext* context = wrapper->GetContext();

   478     CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();

   479     CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   480 

   481         {

   482         wrapper->SetupListenerL( EXIMPTestStatusEvents_BindingFailKErrAbort );

   483 

   484         messenger->SetError( KErrAbort );

   485 

   486         messenger->SetPluginIndex( 0 );

   487 

   488         TXIMPRequestId reqId = BindContextToDefaultL( context );

   489 

   490         wrapper->WaitRequestAndStackEvents( reqId );

   491         wrapper->VerifyEventStackL( _L8("Binding single context: ") );

   492 

   493 

   494         // plugin should've been unloaded without calling CloseSession

   495         EUNIT_ASSERT_DESC( ! messenger->GetBoolean( EXIMPPlgTestCloseSessionCalled ), "CloseSession was called" );

   496         messenger->AssertPluginDied( ETrue );

   497         }

   498 

   499     

   500     //It should be possible to reuse client ctx for second bind

   501         {

   502         //Do bind, wait and verify events

   503         wrapper->SetupListenerL( EXIMPTestStatusEvents_BindingOk );

   504         

   505         messenger->SetPluginIndex( 0 );

   506         messenger->SetNoError();

   507 

   508         TXIMPRequestId reqId;

   509         reqId = BindContextToDefaultL( context );

   510         EUNIT_ASSERT( reqId != TXIMPRequestId::Null() );

   511 

   512         wrapper->WaitRequestAndStackEvents( reqId );

   513         wrapper->VerifyEventStackL( _L8("Binding single context: ") );

   514 

   515         messenger->AssertOpenSessionCalled( ETrue );

   516 

   517         //Verify features availability

   518         MXIMPFeatureInfo* ctxFeats = context->GetContextFeaturesLC();

   519         EUNIT_ASSERT_DESC( ctxFeats->FeatureIds().MdcaCount() > 0, "No features from context" );

   520         CleanupStack::PopAndDestroy(); //ctxFeats

   521 

   522         //Do unbind, wait and verify events

   523         wrapper->SetupListenerL( EXIMPTestStatusEvents_UnbindingOk );

   524         messenger->SetNoError();

   525         reqId = context->UnbindL();

   526         EUNIT_ASSERT( reqId != TXIMPRequestId::Null() );

   527 

   528         wrapper->WaitRequestAndStackEvents( reqId );

   529         wrapper->VerifyEventStackL( _L8("Unbinding single context: ") );

   530 

   531         messenger->AssertCloseSessionCalled( ETrue );

   532         messenger->AssertPluginDied( ETrue );

   533         }    

   534     }

   535 

   536 

   537 // ===========================================================================

   538 // TEST CASE:

   539 // Simple bind, bind error

   540 // ===========================================================================

   541 //

   542 void T_SessionMng::T_ErrFromPlg_InvalidReqIdOnOpenSession_L()

   543     {

   544     EUNIT_PRINT( _L("Error from plug-in in bind/unbind") );

   545     EUNIT_PRINT( _L("Plug-in completes OpenSessionL() with faulty ReqId") );

   546 

   547     CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

   548     MXIMPContext* context = wrapper->GetContext();

   549     CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();

   550     CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   551 

   552         {

   553         wrapper->SetupListenerL( EXIMPTestStatusEvents_BindingFailInvalidReqId );

   554         messenger->SetBoolean( EXIMPTestPlgBehaveInvalidReqId );

   555         messenger->SetPluginIndex( 0 );

   556         

   557         TXIMPRequestId reqId = BindContextToDefaultL( context );

   558 

   559         wrapper->WaitRequestAndStackEvents( reqId );

   560         wrapper->VerifyEventStackL( _L8("Binding single context: ") );

   561         }

   562 

   563     }

   564 

   565 

   566 

   567 // ===========================================================================

   568 // TEST CASE:

   569 // ===========================================================================

   570 //

   571 void T_SessionMng::T_ErrFromPlg_ErrorResultOnCloseSession_L()

   572     {

   573     EUNIT_PRINT( _L("Error from plug-in in bind/unbind") );

   574     EUNIT_PRINT( _L("Plug-in completes CloseSession() with error") );

   575 

   576     CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

   577     MXIMPContext* context = wrapper->GetContext();

   578     CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();

   579     CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   580 

   581     //Do bind, wait and verify events

   582     wrapper->SetupListenerL( EXIMPTestStatusEvents_BindingOk );

   583 

   584     messenger->SetNoError();

   585 

   586     messenger->SetPluginIndex( 0 );

   587     

   588     TXIMPRequestId reqId = BindContextToDefaultL( context );    

   589 

   590 

   591     wrapper->WaitRequestAndStackEvents( reqId );

   592     wrapper->VerifyEventStackL( _L8("Binding single context: ") );

   593 

   594     messenger->AssertOpenSessionCalled( ETrue );

   595 

   596     //Do unbind, wait and verify events

   597     wrapper->SetupListenerL( EXIMPTestStatusEvents_UnbindingOk );

   598 

   599     messenger->SetError( KErrCouldNotDisconnect );

   600     reqId = context->UnbindL();

   601 

   602     wrapper->WaitRequestAndStackEvents( reqId );

   603     wrapper->VerifyEventStackL( _L8("Unbinding single context: ") );

   604 

   605     messenger->AssertPluginDied( ETrue );

   606     }

   607 

   608   

   609 

   610 

   611 

   612 // ===========================================================================

   613 // TEST CASE

   614 // ===========================================================================

   615 //

   616 void T_SessionMng::T_Multi_Bind_Unbind_WithWaits_L()

   617     {

   618     EUNIT_PRINT( _L("Multiple context Bind/Unbind test.") );

   619     EUNIT_PRINT( _L("Client performs multiple bind & unbinds for a separated context sharing a connection.") );

   620 

   621     TInt ix;

   622 

   623     // bind contexts

   624     for ( ix = 0; ix < 3; ix++ )

   625         {

   626         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( ix );

   627         MXIMPContext* context = wrapper->GetContext();

   628         CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();

   629         CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   630 

   631         if ( ix == 1 )

   632             {

   633             // fail the middle one

   634             wrapper->SetupListenerL( EXIMPTestStatusEvents_BindingFailKErrAbort );

   635             messenger->SetError( KErrAbort );   // for binding

   636             }

   637         else

   638             {

   639             wrapper->SetupListenerL( EXIMPTestStatusEvents_BindingOk );

   640             messenger->SetNoError();   // for binding

   641             }

   642 

   643         messenger->SetPluginIndex( ix );

   644 

   645         TUid protocol = { K_PRFW_TST_PROTOCOL_1_IMPLEMENTATION_UID };

   646         const TDesC16& instanceId = wrapper->InstanceId();

   647         TXIMPRequestId reqId = context->BindToL( protocol,

   648                                                 _L("www.imps.no/wv"),

   649                                                 _L("user"),

   650                                                 _L("password"),

   651                                                 instanceId,

   652                                                 ix );

   653 

   654         wrapper->WaitRequestAndStackEvents( reqId );

   655 

   656         TBuf8<100> title;

   657         title.AppendFormat( _L8("Bind [%d]: "), ix );

   658         wrapper->VerifyEventStackL( title );

   659 

   660         switch ( ix )

   661             {

   662             case 0 :

   663             case 1 :

   664             case 2 :

   665                 {

   666                 messenger->AssertOpenSessionCalled( ETrue );

   667                 break;

   668                 }

   669             default :

   670                 {

   671                 break;

   672                 }

   673             }

   674     }

   675 

   676 

   677     // now context has been bound.

   678     // one has failed, but two are okay. do 3 unbinds.

   679     for( ix = 0; ix < 3; ix++ )

   680         {

   681         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( ix );

   682         MXIMPContext* context = wrapper->GetContext();

   683         CXIMPTestStatusEventListener* eventListener = wrapper->GetEventListener();

   684         CXIMPTestMessenger* messenger = wrapper->GetMessenger();

   685 

   686         if ( ix == 1 )

   687             {

   688             // the middle one has failed

   689             TRAPD( err, context->UnbindL() );

   690             EUNIT_ASSERT_EQUALS( err, KErrNotReady );

   691             }

   692 

   693         else

   694             {

   695             // we expect all unbinds to be okay from client point of view

   696             wrapper->SetupListenerL( EXIMPTestStatusEvents_UnbindingOk );

   697             messenger->SetNoError();   // For unbinding

   698 

   699             TXIMPRequestId reqId = context->UnbindL();

   700             wrapper->WaitRequestAndStackEvents( reqId );

   701 

   702             TBuf8<100> title;

   703             title.AppendFormat( _L8("Unbind [%d]: "), ix );

   704             wrapper->VerifyEventStackL( title );

   705             messenger->AssertCloseSessionCalled( ETrue );

   706             }

   707         }

   708     }

   709     

   710     

   711 TXIMPRequestId T_SessionMng::BindContextToDefaultL( MXIMPContext* aContext )

   712     {

   713     TUid protocol = { K_PRFW_TST_PROTOCOL_1_IMPLEMENTATION_UID };

   714     return aContext->BindToL( protocol,

   715                              _L("www.imps.no/wv"),

   716                              _L("user"),

   717                              _L("password"),

   718                              0 ); 

   719     }

   720 

   721 

   722 

   723 // ===========================================================================

   724 // TEST CASE TABLE

   725 // ===========================================================================

   726 //

   727 EUNIT_BEGIN_TEST_TABLE(

   728         T_SessionMng,

   729         "XIMP session management tests",

   730         "MODULE" )

   731 

   732 

   733 PRFW_NOT_DECORATED_TEST(

   734         "Simple bind wait unbind",

   735         "",

   736         "",

   737         "FUNCTIONALITY",

   738         Setup_L,

   739         T_Simple_Bind_Wait_Unbind_L,

   740         Teardown )

   741 

   742  PRFW_NOT_DECORATED_TEST(

   743         "Settings bind wait unbind",

   744         "",

   745         "",

   746         "FUNCTIONALITY",

   747         Setup_L,

   748         T_Settings_Bind_Wait_Unbind_L,

   749         Teardown )

   750 

   751 EUNIT_ALLOC_TEST(

   752         "Simple bind in OOM",

   753         "",

   754         "",

   755         "FUNCTIONALITY",

   756         Setup_L,

   757         T_Simple_Bind_Wait_OOM_L,

   758         Teardown )

   759 

   760 

   761 PRFW_NOT_DECORATED_TEST(

   762         "Simple bind wait unbind with reqComplete event filter",

   763         "",

   764         "",

   765         "FUNCTIONALITY",

   766         Setup_L,

   767         T_Simple_Bind_Wait_Unbind_WithReqCompleteEventFilter_L,

   768         Teardown )

   769 

   770 PRFW_NOT_DECORATED_TEST(

   771         "Simple bind wait close handle",

   772         "",

   773         "",

   774         "FUNCTIONALITY",

   775         Setup_L,

   776         T_Simple_Bind_Wait_CloseHandle_L,

   777         Teardown )

   778 

   779 

   780 PRFW_NOT_DECORATED_TEST(

   781         "Simple bind direct unbind",

   782         "",

   783         "",

   784         "FUNCTIONALITY",

   785         Setup_L,

   786         T_Simple_Bind_Direct_Unbind_L,

   787         Teardown )

   788 

   789 

   790 PRFW_NOT_DECORATED_TEST(

   791         "Simple bind direct close handle",

   792         "",

   793         "",

   794         "FUNCTIONALITY",

   795         Setup_L,

   796         T_Simple_Bind_Direct_CloseHandle_L,

   797         Teardown )

   798 

   799 

   800 // opensession errors

   801 PRFW_NOT_DECORATED_TEST(

   802         "ErrFromPlg leave OpenSession",

   803         "",

   804         "",

   805         "ERROHANDLING",

   806         Setup_L,

   807         T_ErrFromPlg_LeaveOnOpenSession_L,

   808         Teardown )

   809 

   810 PRFW_NOT_DECORATED_TEST(

   811         "ErrFromPlg OpenSession",

   812         "",

   813         "",

   814         "ERROHANDLING",

   815         Setup_L,

   816         T_ErrFromPlg_ErrorResultOnOpenSession_L,

   817         Teardown )

   818 

   819 

   820 

   821 PRFW_NOT_DECORATED_TEST(

   822         "ErrFromPlg Invalid ReqId",

   823         "",

   824         "",

   825         "ERROHANDLING",

   826         Setup_L,

   827         T_ErrFromPlg_InvalidReqIdOnOpenSession_L,

   828         Teardown )

   829 

   830 

   831 // closesession errors

   832 PRFW_NOT_DECORATED_TEST(

   833         "ErrFromPlg CloseSession",

   834         "",

   835         "",

   836         "ERROHANDLING",

   837         Setup_L,

   838         T_ErrFromPlg_ErrorResultOnCloseSession_L,

   839         Teardown )

   840 

   841 

   842 // multiple bind + unbind tests

   843 PRFW_NOT_DECORATED_TEST(

   844         "Multiple context Bind/Unbind test.",

   845         "",

   846         "",

   847         "ERROHANDLING",

   848         Setup_3_L,

   849         T_Multi_Bind_Unbind_WithWaits_L,

   850         Teardown )

   851 

   852 

   853 EUNIT_END_TEST_TABLE

   854 

   855 

   856 // ===========================================================================

   857 // TEST SUITE CONSTRUCTION

   858 // ===========================================================================

   859 //

   860 EXPORT_C MEUnitTest* CreateTestSuiteL()

   861     {

   862     return T_SessionMng::NewL();

   863     }

   864 

   865 

   866 // end of file

   867 

   868 

   869 

   870 

   871 

   872