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:

    15 *

    16 */

    17 

    18 

    19 #include "eunittools.h"

    20 

    21 #include <eunitmacros.h>

    22 #include <ecom/ecom.h>

    23 #include <badesca.h>

    24 

    25 #include <ximpbase.h>

    26 #include <ximpclient.h>

    27 #include <ximpcontext.h>

    28 #include <ximpcontextstateevent.h>

    29 #include <ximprequestcompleteevent.h>

    30 #include <ximpstatus.h>

    31 #include <presencefeatures.h>

    32 #include <presencewatching.h>

    33 #include <presencepublishing.h>

    34 #include <presentitypresenceevent.h>

    35 #include <ximpobjectfactory.h>

    36 

    37 #include "t_presencewatching.h"

    38 #include "prfwteststatuseventlistener.h"

    39 #include "prfwtestmessaging.h"

    40 #include "prfwtestmessenger.h"

    41 #include "prfwtestcontextwrappermgr.h"

    42 #include "prfwtestcontextwrapper.h"

    43 

    44 #include "presenceinfoimp.h"

    45 #include "presenceinfofilterimp.h"

    46 #include "prfwtestpresencedatautils.h"

    47 #include "ximpidentityimp.h"

    48 #include "presentitygroupmemberinfoimp.h"

    49 #include "ximpobjecthelpers.h"

    50 #include "prfwtestfilesrvmsg.h"

    51 #include "prfwtestwaithelper.h"

    52 

    53 #include "prfwtestrobustnesstools.h"

    54 #include "presenceinfofieldimp.h"

    55 #include "presenceinfofieldcollectionimp.h"

    56 #include "presenceinfofieldvaluetextimp.h"

    57 #include "personpresenceinfoimp.h"

    58 

    59 #include <presencecachereader.h>

    60 

    61 // For the protocol UID

    62 #include "prfwtestprotocols.h"

    63 

    64 

    65 _LIT8( KPrefix1, "PreA_" );

    66 _LIT8( KPrefix2, "PreB_" );

    67 _LIT8( KPrefix3, "PreC_" );

    68 _LIT8( KPrefix4, "PreD_" );

    69 

    70 _LIT( KIdentity, "TestId@hello.world" );

    71 _LIT8( KIdentity8, "TestId@hello.world" );

    72 

    73 _LIT( KText, "Hello World" );

    74 

    75 

    76 const TUid KTestProtocolUid = { K_PRFW_TST_PROTOCOL_1_IMPLEMENTATION_UID };  // hardcoded...

    77 

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

    79 

    80 // CONSTRUCTION

    81 T_PresenceWatching* T_PresenceWatching::NewL()

    82     {

    83     T_PresenceWatching* self = new( ELeave ) T_PresenceWatching;

    84     CleanupStack::PushL( self );

    85     self->ConstructL();

    86     CleanupStack::Pop( self );

    87 

    88     return self;

    89     }

    90 

    91 

    92 T_PresenceWatching::~T_PresenceWatching()

    93     {

    94     }

    95 

    96 

    97 void T_PresenceWatching::ConstructL()

    98     {

    99     CEUnitTestSuiteClass::ConstructL();

   100     }

   101 

   102 

   103 T_PresenceWatching::T_PresenceWatching()

   104     {

   105     }

   106 

   107 

   108 

   109 // ===========================================================================

   110 // TEST CASE SETUP & TEARDOWN METHODS

   111 // ===========================================================================

   112 //

   113 

   114 void T_PresenceWatching::Setup_L()

   115     {

   116     __UHEAP_MARK;

   117     PrfwTestRobustness::DoPreCleaning();

   118 

   119     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   120     iWrapperMgr->CreateWrapperL();

   121     

   122     iMPresenceCacheReader = MPresenceCacheReader::NewL();

   123     }

   124 

   125 void T_PresenceWatching::SetupMultiple_L()

   126     {

   127     PrfwTestRobustness::DoPreCleaning();

   128 

   129     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   130     iWrapperMgr->CreateWrapperL();

   131     iWrapperMgr->CreateWrapperL();

   132     iWrapperMgr->CreateWrapperL();

   133     }

   134 

   135 

   136 void T_PresenceWatching::BindL()

   137     {

   138     CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 );

   139 

   140     wrapper0->BindL( 0 );

   141     }

   142 

   143 void T_PresenceWatching::BindAllL()

   144     {

   145     for( TInt a = 0; a < iWrapperMgr->WrapperCount(); ++a )

   146         {

   147         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

   148         wrapper->BindL( 0 );

   149         }

   150     }

   151 

   152 

   153 void T_PresenceWatching::Teardown()

   154     {

   155     delete iWrapperMgr;

   156     iWrapperMgr = NULL;

   157     

   158     delete iMPresenceCacheReader;

   159 

   160     REComSession::FinalClose();

   161 

   162     PrfwTestRobustness::DoPreCleaning();

   163     __UHEAP_MARKEND;

   164     }

   165 

   166 void T_PresenceWatching::UnbindL()

   167     {

   168     // Do unbind

   169     CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 );

   170     wrapper0->UnbindL();

   171     }

   172 

   173 void T_PresenceWatching::UnbindAllL()

   174     {

   175     for( TInt a = 0; a < iWrapperMgr->WrapperCount(); ++a )

   176         {

   177         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

   178         wrapper->UnbindL();

   179         }

   180     }

   181 

   182 

   183 // ===========================================================================

   184 // TEST CASES for presentity presence subscription

   185 // ===========================================================================

   186 

   187 // Single client, empty filter

   188 void T_PresenceWatching::T_SubscribePresentityPresence_Single_L()

   189     {

   190     EUNIT_PRINT( _L("Single presentity subscription") );

   191 

   192 // BIND AND SETUP

   193 

   194     BindL();

   195 

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

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

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

   199 

   200     // Tell the protocol it should act normally

   201     messenger->SetNoError();

   202 

   203     // Get the interfaces

   204     MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   205     MPresenceWatching& presWatch = presFeat->PresenceWatching();

   206 

   207 // SUBSCRIBE

   208     // Setup status event listener for RequestComplete

   209     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   210 

   211     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

   212     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   213     

   214     // register interest

   215     TXIMPRequestId reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

   216 

   217     // Wait for events on the request

   218     wrapper->WaitRequestAndStackEvents( reqId );

   219     wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

   220     // verify that UpdateInterest was called

   221     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, "SubscribePresentityPresenceL was not called", ETrue, NULL );

   222 

   223 

   224 // REFRESH

   225     // Setup status event listener for RequestComplete

   226     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   227     messenger->SetValueFor( EXIMPPlgTestSubscribePresentityPresesenceCalled, 0 );

   228 

   229     // register interest

   230     reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

   231 

   232     // Wait for events on the request

   233     wrapper->WaitRequestAndStackEvents( reqId );

   234     wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

   235     

   236     // Wait for event because refresh happened

   237     SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_HandlePresentityPresencePending );

   238     // Wait for events

   239     wrapper->WaitAnyEvent();

   240     wrapper->VerifyEventStackL( _L8("Handle presence watcher list. Wrong event occurred.") );

   241     

   242     // verify that UpdateInterest was called

   243     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, 

   244                  "SubscribePresentityPresenceL was not called", EFalse,

   245                  "SubscribePresentityPresenceL was called" );

   246 

   247 // UNSUBSCRIBE

   248 

   249     // Setup status event listener for RequestComplete

   250     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk ); // allow events after reqcomplete

   251 

   252     // register interest

   253     reqId = presWatch.UnsubscribePresentityPresenceL( *identity );

   254 

   255     // Wait for events on the request

   256     wrapper->WaitRequestAndStackEvents( reqId );

   257     wrapper->VerifyEventStackL( _L8("UnSubscribing presentity presence, complete with error: ") );

   258     // verify that UpdateInterest was called

   259     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityPresesenceCalled, "UnsubscribePresentityPresenceL was not called", ETrue, NULL );

   260 

   261 // UNBIND    

   262 

   263     CleanupStack::PopAndDestroy( pif );

   264     CleanupStack::PopAndDestroy( identity );

   265     

   266     UnbindL();

   267     }

   268 

   269 // Single client, empty filter, presence cache checking

   270 void T_PresenceWatching::T_SubscribeHandlePresentityPresence_Single_L()

   271     {

   272     EUNIT_PRINT( _L("Single presentity subscription") );

   273 

   274 // BIND AND SETUP

   275 

   276     BindL();

   277 

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

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

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

   281 

   282     // Tell the protocol it should act normally

   283     messenger->SetNoError();

   284 

   285     // Get the interfaces

   286     MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   287     MPresenceWatching& presWatch = presFeat->PresenceWatching();

   288 

   289 // SUBSCRIBE

   290     // Setup status event listener for RequestComplete

   291     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   292 

   293     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KIdentity8 );

   294     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   295     

   296     // register interest

   297     TXIMPRequestId reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

   298 

   299     // Wait for events on the request

   300     wrapper->WaitRequestAndStackEvents( reqId );

   301     wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

   302     // verify that UpdateInterest was called

   303     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, "SubscribePresentityPresenceL was not called", ETrue, NULL );

   304 

   305 // SEND DATA

   306     

   307     // Create some meaningful data

   308     CPresenceInfoImp* presenceInfo = CPresenceInfoImp::NewLC();

   309 

   310     MPresenceInfoFieldValueText* value = CPresenceInfoFieldValueTextImp::NewLC();

   311     value->SetTextValueL(KText);

   312     

   313     MPresenceInfoField* infoField = CPresenceInfoFieldImp::NewLC();

   314     infoField->SetFieldTypeL(NPresenceInfo::NFieldType::KStatusMessage);

   315     infoField->SetFieldValue(value);    

   316     

   317     MPersonPresenceInfo* personPres = CPersonPresenceInfoImp::NewLC();

   318     MPresenceInfoFieldCollection& fieldCol = personPres->Fields();

   319     fieldCol.AddOrReplaceFieldL(infoField);

   320     TInt fieldCount= fieldCol.FieldCount();

   321         

   322     presenceInfo->SetPersonPresenceL(personPres);

   323     CleanupStack::Pop(3); // value, infoField, personPres

   324     

   325     // Pack the data for FileTool

   326     HBufC8* packedInfo = TXIMPObjectPacker< CPresenceInfoImp >::PackL( *presenceInfo );

   327     CleanupStack::PushL( packedInfo );

   328     HBufC8* packedId = TXIMPObjectPacker< CXIMPIdentityImp >::PackL( *identity );

   329     CleanupStack::PushL( packedId );

   330     RPointerArray< HBufC8 > bufferArray;

   331     CleanupClosePushL( bufferArray );

   332     bufferArray.AppendL( packedId );

   333     bufferArray.AppendL( packedInfo );

   334     HBufC8* packedBufferArray = TXIMPHBuf8Packer::PackArrayL( bufferArray );

   335     CleanupStack::PopAndDestroy( 3, packedInfo ); // packedId, packedInfo, bufferArray

   336     CleanupStack::PushL( packedBufferArray );

   337     

   338     // Use filetool to send it for plugin.

   339     CXIMPTestFileSrvMsg* srvMsg = CXIMPTestFileSrvMsg::NewL( CXIMPTestFileSrvMsg::ETestSrvMsgPresentityPresence, 

   340                                                              *packedBufferArray );

   341     CleanupStack::PopAndDestroy( packedBufferArray );

   342     CleanupStack::PushL( srvMsg );

   343     wrapper->FileTool().SrvMsgStoreL( srvMsg );

   344     CleanupStack::PopAndDestroy( srvMsg );

   345     

   346     // Wait for event

   347     SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_HandlePresentityPresence );

   348 

   349     // Wait for events

   350     wrapper->WaitAnyEvent();

   351     wrapper->VerifyEventStackL( _L8("Handle presentity presence. Wrong event occurred.") );

   352     

   353     // Verify the cache

   354     MPresenceInfo* presInfoRead = iMPresenceCacheReader->PresenceInfoLC(*identity);

   355 

   356     CPresenceInfoImp* readInfo = 

   357         TXIMPGetImpClassOrPanic<CPresenceInfoImp>::From(*presInfoRead);    

   358 

   359 

   360     EUNIT_ASSERT( presenceInfo->EqualsContent(*readInfo) );

   361     

   362     CleanupStack::PopAndDestroy( 2 ); // readInfo, presenceInfo

   363             

   364         

   365 // UNSUBSCRIBE

   366 

   367     // Setup status event listener for RequestComplete

   368     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk ); // allow events after reqcomplete

   369 

   370     // unsubscribe

   371     reqId = presWatch.UnsubscribePresentityPresenceL( *identity );

   372 

   373     // Wait for events on the request

   374     wrapper->WaitRequestAndStackEvents( reqId );

   375     wrapper->VerifyEventStackL( _L8("UnSubscribing presentity presence, complete with error: ") );

   376     // verify that UpdateInterest was called

   377     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityPresesenceCalled, "UnsubscribePresentityPresenceL was not called", ETrue, NULL );

   378 

   379 // UNBIND    

   380 

   381     CleanupStack::PopAndDestroy( pif );

   382     CleanupStack::PopAndDestroy( identity );

   383     

   384     UnbindL();

   385     }

   386 

   387 

   388 // Single client, empty filter

   389 void T_PresenceWatching::T_SubscribePresentityPresenceChangeId_Single_L()

   390     {

   391     EUNIT_PRINT( _L("Single presentity subscription") );

   392 

   393 // BIND AND SETUP

   394 

   395     BindL();

   396 

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

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

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

   400 

   401     // Tell the protocol it should act normally

   402     messenger->SetNoError();

   403 

   404     // Get the interfaces

   405     MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   406     MPresenceWatching& presWatch = presFeat->PresenceWatching();

   407 

   408 // ID CHANGE REQUEST TO ADAPTATION

   409 

   410     MXIMPIdentity* identityParam = context->ObjectFactory().NewIdentityLC();

   411     identityParam->SetIdentityL( KIdentity );

   412     

   413     CXIMPIdentityImp* identityParamImp =

   414              ( CXIMPIdentityImp* ) identityParam->GetInterface(

   415                                         CXIMPIdentityImp::KClassId,

   416                                         MXIMPBase::EPanicIfUnknown );

   417     HBufC8* packedId = TXIMPObjectPacker< CXIMPIdentityImp >::PackL( *identityParamImp );

   418     CleanupStack::PopAndDestroy(); // identityParam

   419     CleanupStack::PushL( packedId );

   420     CXIMPTestFileSrvMsg* srvMsg = CXIMPTestFileSrvMsg::NewL( CXIMPTestFileSrvMsg::ETestSrvMsgReqParamIdentity, 

   421                                                              *packedId );

   422     CleanupStack::PopAndDestroy( packedId );

   423     CleanupStack::PushL( srvMsg );

   424     wrapper->FileTool().SrvMsgStoreL( srvMsg );

   425     CleanupStack::PopAndDestroy( srvMsg );

   426 

   427     // Wait for server to handle srvmsg.

   428     CXIMPTestWaitHelper* wait = CXIMPTestWaitHelper::NewL();

   429     CleanupStack::PushL( wait );

   430     wait->WaitForL( 2 );

   431     CleanupStack::PopAndDestroy( wait );

   432 

   433 // SUBSCRIBE

   434     // Setup status event listener for RequestComplete

   435     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   436 

   437     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

   438     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   439     

   440     // register interest

   441     TXIMPRequestId reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

   442 

   443     // Wait for events on the request

   444     wrapper->WaitRequestAndStackEvents( reqId );

   445     wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

   446     // verify that UpdateInterest was called

   447     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, "SubscribePresentityPresenceL was not called", ETrue, NULL );

   448 

   449 // UNBIND    

   450 

   451     CleanupStack::PopAndDestroy( pif );

   452     CleanupStack::PopAndDestroy( identity );

   453     

   454     UnbindL();

   455     }

   456 

   457 

   458 void T_PresenceWatching::T_UnsubscribeNotSubscribedPresentityPresence_Single_L()

   459     {

   460     EUNIT_PRINT( _L("Unsubscribe not subscribed presentity presence") );

   461 

   462 // BIND AND SETUP

   463 

   464     BindL();

   465 

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

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

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

   469 

   470     // Tell the protocol it should act normally

   471     messenger->SetNoError();

   472 

   473     // Get the interfaces

   474     MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   475     MPresenceWatching& presWatch = presFeat->PresenceWatching();

   476     

   477     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

   478     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   479     

   480 // UNSUBSCRIBE

   481 

   482     // Setup status event listener for RequestComplete

   483     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk ); // allow events after reqcomplete

   484 

   485     // register interest

   486     TXIMPRequestId reqId = presWatch.UnsubscribePresentityPresenceL( *identity );

   487 

   488     // Wait for events on the request

   489     wrapper->WaitRequestAndStackEvents( reqId );

   490     wrapper->VerifyEventStackL( _L8("UnSubscribing presentity presence, complete with error: ") );

   491 

   492     // verify that UpdateInterest was called

   493     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityPresesenceCalled, "UnsubscribePresentityPresenceL was not called", EFalse, 

   494                                                                                 "UnsbuscribePresentityPresenceL was called." );

   495 

   496 // UNBIND    

   497 

   498     CleanupStack::PopAndDestroy( pif );

   499     CleanupStack::PopAndDestroy( identity );

   500     

   501     UnbindL();

   502     }

   503 

   504 void T_PresenceWatching::T_UnsubscribeNotSubscribedPresentityPresence_Multiple_L()

   505     {

   506     EUNIT_PRINT( _L("Multiple client filter registration") );

   507 

   508     BindAllL();

   509 

   510     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

   511     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   512 

   513     TInt countOfWrappers = iWrapperMgr->WrapperCount();

   514     for( TInt a = countOfWrappers - 1; a >= 1 ; --a ) // Don't subscribe the first one.

   515         {

   516         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

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

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

   519 

   520         // Tell the protocol it should act normally

   521         messenger->SetNoError();

   522 

   523         // Get the interfaces

   524         MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   525         MPresenceWatching& presWatch = presFeat->PresenceWatching();

   526 

   527         // Setup status event listener for RequestComplete

   528         SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   529 

   530         // register interest

   531         TXIMPRequestId reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

   532 

   533         // Wait for events on the request

   534         wrapper->WaitRequestAndStackEvents( reqId );

   535         // verify that UpdateInterest was called

   536         COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, 

   537             "SubscribePresentityPresenceL was not called",

   538             ( a > 1 ) ? ETrue : EFalse,

   539             "SubscribePresentityPresenceL was called" );

   540         }

   541 

   542     for( TInt a = 0; a < countOfWrappers; ++a ) // Try to unsubscribe first one first.

   543         {

   544         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

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

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

   547 

   548         // Get the interfaces

   549         MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   550         MPresenceWatching& presWatch = presFeat->PresenceWatching();

   551         

   552         // Setup status event listener for RequestComplete

   553         SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk ); // allow events after reqcomplete

   554 

   555         // register interest

   556         TXIMPRequestId reqId = presWatch.UnsubscribePresentityPresenceL( *identity );

   557 

   558         // Wait for events on the request

   559         wrapper->WaitRequestAndStackEvents( reqId );

   560         wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

   561         // verify that UpdateInterest was called

   562         COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityPresesenceCalled, 

   563             "UnsubscribePresentityPresenceL was not called",

   564             ( a < 2 ) ? EFalse : ETrue,

   565             "UnsubscribePresentityPresenceL was called" );

   566         }

   567     

   568     CleanupStack::PopAndDestroy( pif );

   569     CleanupStack::PopAndDestroy( identity );

   570         

   571     UnbindAllL();    

   572     }

   573 

   574 

   575 void T_PresenceWatching::T_ErrFromPlg_LeaveOnSubscribePresentityPresence_L()

   576     {

   577     EUNIT_PRINT( _L("Error from plug-in in presentity presence subscribe") );

   578     EUNIT_PRINT( _L("Plug-in leaves from SubscribePresence().") );

   579 

   580 // BIND AND SETUP

   581 

   582     BindL();

   583 

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

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

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

   587 

   588     messenger->SetLeave( KErrAbort );

   589 

   590     // Get the interfaces

   591     MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   592     MPresenceWatching& presWatch = presFeat->PresenceWatching();

   593     

   594 // SUBSCRIBE

   595 

   596     // Setup status event listener for RequestComplete

   597     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_PresentitySubscribeFailKErrAbort );

   598 

   599     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

   600     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   601     

   602     // register interest

   603     TXIMPRequestId reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

   604 

   605     // Wait for events on the request

   606     wrapper->WaitRequestAndStackEvents( reqId );

   607     wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

   608     // verify that UpdateInterest was called

   609     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, "SubscribePresentityPresenceL was not called", EFalse, "SubscribePresentityPresenceL was called" );

   610     

   611 // UNBIND

   612 

   613     CleanupStack::PopAndDestroy( pif );

   614     CleanupStack::PopAndDestroy( identity );

   615 

   616     messenger->SetLeave( KErrNone );

   617 

   618     UnbindL();

   619     }

   620 

   621 

   622 void T_PresenceWatching::T_ErrFromPlg_LeaveOnUnsubscribePresentityPresence_L()

   623     {

   624     EUNIT_PRINT( _L("Error from plug-in in presentity presence subscribe") );

   625     EUNIT_PRINT( _L("Plug-in leaves from SubscribePresence().") );

   626 

   627 // BIND AND SETUP

   628 

   629     BindL();

   630 

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

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

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

   634 

   635     // Get the interfaces

   636     MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   637     MPresenceWatching& presWatch = presFeat->PresenceWatching();

   638 

   639 // SUBSCRIBE

   640 

   641     // Setup status event listener for RequestComplete

   642     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   643 

   644     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

   645     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   646     

   647     // register interest

   648     TXIMPRequestId reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

   649 

   650     // Wait for events on the request

   651     wrapper->WaitRequestAndStackEvents( reqId );

   652     wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

   653     // verify that UpdateInterest was called

   654     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, "SubscribePresentityPresenceL was not called", ETrue, NULL );

   655 

   656 // UNSUBSCRIBE

   657 

   658     messenger->SetLeave( KErrAbort );

   659 

   660     // Setup status event listener for RequestComplete

   661     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_PresentitySubscribeFailKErrAbort ); // allow events after reqcomplete

   662 

   663     // register interest

   664     reqId = presWatch.UnsubscribePresentityPresenceL( *identity );

   665 

   666     // Wait for events on the request

   667     wrapper->WaitRequestAndStackEvents( reqId );

   668     wrapper->VerifyEventStackL( _L8("UnSubscribing presentity presence, complete with error: ") );

   669 

   670     // verify that UpdateInterest was called

   671     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityPresesenceCalled, "UnsubscribePresentityPresenceL was not called", EFalse, 

   672                                                                                 "UnsbuscribePresentityPresenceL was called." );

   673     

   674 // UNBIND

   675 

   676     CleanupStack::PopAndDestroy( pif );

   677     CleanupStack::PopAndDestroy( identity );

   678 

   679     messenger->SetLeave( KErrNone );

   680 

   681     UnbindL();

   682     }

   683 

   684 

   685 // Multiple client, empty filter

   686 void T_PresenceWatching::T_SubscribePresentityPresence_Multiple_L()

   687     {

   688     EUNIT_PRINT( _L("Multiple client filter registration") );

   689 

   690     BindAllL();

   691 

   692     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

   693     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   694 

   695     TInt countOfWrappers = iWrapperMgr->WrapperCount();

   696     for( TInt a = 0; a < countOfWrappers; ++a )

   697         {

   698         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

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

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

   701 

   702         // Tell the protocol it should act normally

   703         messenger->SetNoError();

   704 

   705         // Get the interfaces

   706         MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   707         MPresenceWatching& presWatch = presFeat->PresenceWatching();

   708 

   709         // Setup status event listener for RequestComplete

   710         SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   711 

   712         // register interest

   713         TXIMPRequestId reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

   714 

   715         // Wait for events on the request

   716         wrapper->WaitRequestAndStackEvents( reqId );

   717         // verify that UpdateInterest was called

   718         COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, 

   719             "SubscribePresentityPresenceL was not called",

   720             ( a == 0 ) ? ETrue : EFalse,

   721             "SubscribePresentityPresenceL was called" );

   722         }

   723         

   724     for( TInt a = 0; a < countOfWrappers; ++a )

   725         {

   726         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

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

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

   729         

   730         // Get the interfaces

   731         MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   732         MPresenceWatching& presWatch = presFeat->PresenceWatching();

   733                 

   734         // Setup status event listener for RequestComplete

   735         SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   736         messenger->SetValueFor( EXIMPPlgTestSubscribePresentityPresesenceCalled, 0 );

   737 

   738         // register interest

   739         TXIMPRequestId reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

   740 

   741         // Wait for events on the request

   742         wrapper->WaitRequestAndStackEvents( reqId );

   743         wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

   744 

   745         // Wait for event because refresh happened

   746         SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_HandlePresentityPresencePending );

   747         // Wait for events

   748         wrapper->WaitAnyEvent();

   749         wrapper->VerifyEventStackL( _L8("Handle presence watcher list. Wrong event occurred.") );

   750 

   751         // verify that UpdateInterest was called

   752         COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, 

   753                      "SubscribePresentityPresenceL was not called", EFalse,

   754                      "SubscribePresentityPresenceL was called" );

   755         }

   756         

   757         

   758     for( TInt a = 0; a < countOfWrappers; ++a )

   759         {

   760         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

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

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

   763         

   764         // Get the interfaces

   765         MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   766         MPresenceWatching& presWatch = presFeat->PresenceWatching();

   767 

   768         // Setup status event listener for RequestComplete

   769         SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk ); // allow events after reqcomplete

   770 

   771         // register interest

   772         TXIMPRequestId reqId = presWatch.UnsubscribePresentityPresenceL( *identity );

   773 

   774         // Wait for events on the request

   775         wrapper->WaitRequestAndStackEvents( reqId );

   776         wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

   777         // verify that UpdateInterest was called

   778         COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityPresesenceCalled, 

   779             "UnsubscribePresentityPresenceL was not called",

   780             ( a < 2 ) ? EFalse : ETrue,

   781             "UnsubscribePresentityPresenceL was called" );

   782         }

   783     

   784     CleanupStack::PopAndDestroy( pif );

   785     CleanupStack::PopAndDestroy( identity );

   786     

   787     

   788     UnbindAllL();

   789     }

   790 

   791 

   792 // ===========================================================================

   793 // TEST CASES for presentity group members presence subscription

   794 // ===========================================================================

   795 

   796 // Single client, empty filter

   797 void T_PresenceWatching::T_SubscribePresentityGroupMembersPresence_Single_L()

   798     {

   799     EUNIT_PRINT( _L("Single presentity group members subscription") );

   800 

   801     BindL();

   802 

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

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

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

   806 

   807     // Tell the protocol it should act normally

   808     messenger->SetNoError();

   809 

   810     // Get the interfaces

   811     MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   812     MPresenceWatching& presWatch = presFeat->PresenceWatching();

   813     // Setup status event listener for RequestComplete

   814     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   815 

   816     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

   817     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   818 

   819 // SUBSCRIBE

   820 

   821     // register interest

   822     TXIMPRequestId reqId = presWatch.SubscribePresentityGroupMembersPresenceL( *identity, *pif );

   823 

   824     // Wait for events on the request

   825     wrapper->WaitRequestAndStackEvents( reqId );

   826     // verify that UpdateInterest was called

   827     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityGroupMembersPresesenceCalled, "SubscribePresentityGroupMembersPresenceL was not called", ETrue, NULL );

   828 

   829 // REFRESH

   830 

   831     // Setup status event listener for RequestComplete

   832     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   833     messenger->SetValueFor( EXIMPPlgTestSubscribePresentityGroupMembersPresesenceCalled, 0 );

   834 

   835     // register interest

   836     reqId = presWatch.SubscribePresentityGroupMembersPresenceL( *identity, *pif );

   837 

   838     // Wait for events on the request

   839     wrapper->WaitRequestAndStackEvents( reqId );

   840     // verify that UpdateInterest was called

   841     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityGroupMembersPresesenceCalled, 

   842                  "SubscribePresentityPresenceL was not called", EFalse,

   843                  "SubscribePresentityPresenceL was called" );

   844 

   845 // UNSUBSCRIBE

   846 

   847     // Setup status event listener for RequestComplete

   848     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk ); // allow events after reqcomplete

   849 

   850 

   851     // register interest

   852     reqId = presWatch.UnsubscribePresentityGroupMembersPresenceL( *identity );

   853 

   854     // Wait for events on the request

   855     wrapper->WaitRequestAndStackEvents( reqId );

   856     wrapper->VerifyEventStackL( _L8("Subscribing presentity group members presence, complete with error: ") );

   857     // verify that UpdateInterest was called

   858     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityGroupMembersPresesenceCalled, "UnsubscribePresentityGroupMembersPresenceL was not called", ETrue, NULL );

   859 

   860     

   861     CleanupStack::PopAndDestroy( pif );

   862     CleanupStack::PopAndDestroy( identity );

   863     

   864     UnbindL();

   865     }

   866 

   867 void T_PresenceWatching::T_UnsubscribeNotSubscribedPresentityGroupMembersPresence_Single_L()

   868     {

   869     EUNIT_PRINT( _L("Unsubscribe not subscribed presentity group members presence") );

   870 

   871 // BIND AND SETUP

   872 

   873     BindL();

   874 

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

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

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

   878 

   879     // Tell the protocol it should act normally

   880     messenger->SetNoError();

   881 

   882     // Get the interfaces

   883     MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   884     MPresenceWatching& presWatch = presFeat->PresenceWatching();    

   885     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

   886     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   887     

   888 // UNSUBSCRIBE

   889 

   890     // Setup status event listener for RequestComplete

   891     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk ); // allow events after reqcomplete

   892 

   893     // register interest

   894     TXIMPRequestId reqId = presWatch.UnsubscribePresentityGroupMembersPresenceL( *identity );

   895 

   896     // Wait for events on the request

   897     wrapper->WaitRequestAndStackEvents( reqId );

   898     wrapper->VerifyEventStackL( _L8("UnSubscribing presentity presence, complete with error: ") );

   899 

   900     // verify that UpdateInterest was called

   901     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityGroupMembersPresesenceCalled, "UnsubscribePresentityGroupMembersPresenceL was not called", EFalse, 

   902                                                                                             "UnsubscribePresentityGroupMembersPresenceL was called." );

   903 

   904 // UNBIND    

   905 

   906     CleanupStack::PopAndDestroy( pif );

   907     CleanupStack::PopAndDestroy( identity );

   908     

   909     UnbindL();

   910     }

   911 

   912 

   913 void T_PresenceWatching::T_UnsubscribeNotSubscribedPresentityGroupMembersPresence_Multiple_L()

   914     {

   915     EUNIT_PRINT( _L("Multiple client filter registration") );

   916 

   917     BindAllL();

   918 

   919     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

   920     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   921 

   922     TInt countOfWrappers = iWrapperMgr->WrapperCount();

   923     for( TInt a = countOfWrappers - 1; a >= 1; --a )

   924         {

   925         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

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

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

   928 

   929         // Tell the protocol it should act normally

   930         messenger->SetNoError();

   931 

   932         // Get the interfaces

   933         MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   934         MPresenceWatching& presWatch = presFeat->PresenceWatching();

   935     

   936         // Setup status event listener for RequestComplete

   937         SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   938 

   939         // register interest

   940         TXIMPRequestId reqId = presWatch.SubscribePresentityGroupMembersPresenceL( *identity, *pif );

   941 

   942         // Wait for events on the request

   943         wrapper->WaitRequestAndStackEvents( reqId );

   944         // verify that UpdateInterest was called

   945         COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityGroupMembersPresesenceCalled,

   946             "SubscribePresentityPresenceL was not called",

   947             ( a > 1 ) ? ETrue : EFalse,

   948             "SubscribePresentityPresenceL was called" );

   949         }

   950         

   951     for( TInt a = 0; a < countOfWrappers; ++a )

   952         {

   953         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

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

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

   956 

   957         // Get the interfaces

   958         MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

   959         MPresenceWatching& presWatch = presFeat->PresenceWatching();

   960     

   961         // Setup status event listener for RequestComplete

   962         SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk ); // allow events after reqcomplete

   963 

   964         // register interest

   965         TXIMPRequestId reqId = presWatch.UnsubscribePresentityGroupMembersPresenceL( *identity );

   966 

   967         // Wait for events on the request

   968         wrapper->WaitRequestAndStackEvents( reqId );

   969         wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

   970         // verify that UpdateInterest was called

   971         COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityGroupMembersPresesenceCalled, 

   972             "UnsubscribePresentityPresenceL was not called",

   973             ( a < 2 ) ? EFalse : ETrue,

   974             "UnsubscribePresentityPresenceL was called" );

   975         }

   976     

   977     CleanupStack::PopAndDestroy( pif );

   978     CleanupStack::PopAndDestroy( identity );

   979         

   980     UnbindAllL();    

   981     }

   982 

   983 

   984 

   985 // Multiple client, empty filter

   986 void T_PresenceWatching::T_SubscribeGroupMembersPresence_Multiple_L()

   987     {

   988     EUNIT_PRINT( _L("Multiple client filter registration") );

   989 

   990     BindAllL();

   991 

   992     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

   993     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   994 

   995     TInt countOfWrappers = iWrapperMgr->WrapperCount();

   996     for( TInt a = 0; a < countOfWrappers; ++a )

   997         {

   998         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

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

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

  1001 

  1002         // Tell the protocol it should act normally

  1003         messenger->SetNoError();

  1004 

  1005         // Get the interfaces

  1006         MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

  1007         MPresenceWatching& presWatch = presFeat->PresenceWatching();

  1008 

  1009         // Setup status event listener for RequestComplete

  1010         SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

  1011 

  1012         // register interest

  1013         TXIMPRequestId reqId = presWatch.SubscribePresentityGroupMembersPresenceL( *identity, *pif );

  1014 

  1015         // Wait for events on the request

  1016         wrapper->WaitRequestAndStackEvents( reqId );

  1017         // verify that UpdateInterest was called

  1018         COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityGroupMembersPresesenceCalled, 

  1019             "SubscribePresentityPresenceL was not called",

  1020             ( a == 0 ) ? ETrue : EFalse,

  1021             "SubscribePresentityPresenceL was called" );

  1022         }

  1023         

  1024     for( TInt a = 0; a < countOfWrappers; ++a )

  1025         {

  1026         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

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

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

  1029         

  1030         // Get the interfaces

  1031         MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

  1032         MPresenceWatching& presWatch = presFeat->PresenceWatching();  

  1033                       

  1034         // Setup status event listener for RequestComplete

  1035         SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

  1036         messenger->SetValueFor( EXIMPPlgTestSubscribePresentityGroupMembersPresesenceCalled, 0 );

  1037 

  1038         // register interest

  1039         TXIMPRequestId reqId = presWatch.SubscribePresentityGroupMembersPresenceL( *identity, *pif );

  1040 

  1041         // Wait for events on the request

  1042         wrapper->WaitRequestAndStackEvents( reqId );

  1043         wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

  1044 

  1045         // verify that UpdateInterest was called

  1046         COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityGroupMembersPresesenceCalled, 

  1047                      "SubscribePresentityPresenceL was not called", EFalse,

  1048                      "SubscribePresentityPresenceL was called" );

  1049         }

  1050         

  1051         

  1052     for( TInt a = 0; a < countOfWrappers; ++a )

  1053         {

  1054         CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

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

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

  1057     

  1058         // Get the interfaces

  1059         MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

  1060         MPresenceWatching& presWatch = presFeat->PresenceWatching();

  1061     

  1062         // Setup status event listener for RequestComplete

  1063         SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk ); // allow events after reqcomplete

  1064 

  1065         // register interest

  1066         TXIMPRequestId reqId = presWatch.UnsubscribePresentityGroupMembersPresenceL( *identity );

  1067 

  1068         // Wait for events on the request

  1069         wrapper->WaitRequestAndStackEvents( reqId );

  1070         wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

  1071         // verify that UpdateInterest was called

  1072         COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityGroupMembersPresesenceCalled, 

  1073             "UnsubscribePresentityPresenceL was not called",

  1074             ( a < 2 ) ? EFalse : ETrue,

  1075             "UnsubscribePresentityPresenceL was called" );

  1076         }

  1077     

  1078     CleanupStack::PopAndDestroy( pif );

  1079     CleanupStack::PopAndDestroy( identity );

  1080     

  1081     

  1082     UnbindAllL();

  1083     }

  1084 

  1085 

  1086 void T_PresenceWatching::T_ErrFromPlg_LeaveOnSubscribePresentityGroupMembersPresence_L()

  1087     {

  1088     EUNIT_PRINT( _L("Error from plug-in in presentity group members presence subscribe") );

  1089     EUNIT_PRINT( _L("Plug-in leaves from SubscribeGroupMembersPresence().") );

  1090 

  1091 // BIND AND SETUP

  1092 

  1093     BindL();

  1094 

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

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

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

  1098 

  1099     messenger->SetLeave( KErrAbort );

  1100 

  1101     // Get the interfaces

  1102     MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

  1103     MPresenceWatching& presWatch = presFeat->PresenceWatching();

  1104 

  1105 // SUBSCRIBE

  1106 

  1107     // Setup status event listener for RequestComplete

  1108     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_PresentitySubscribeFailKErrAbort );

  1109 

  1110     CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

  1111     CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

  1112     

  1113     // register interest

  1114     TXIMPRequestId reqId = presWatch.SubscribePresentityGroupMembersPresenceL( *identity, *pif );

  1115 

  1116     // Wait for events on the request

  1117     wrapper->WaitRequestAndStackEvents( reqId );

  1118     wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

  1119     // verify that UpdateInterest was called

  1120     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityGroupMembersPresesenceCalled, "SubscribePresentityPresenceL was not called", EFalse, "SubscribePresentityPresenceL was called" );

  1121     

  1122 // UNBIND

  1123 

  1124     CleanupStack::PopAndDestroy( pif );

  1125     CleanupStack::PopAndDestroy( identity );

  1126 

  1127     messenger->SetLeave( KErrNone );

  1128 

  1129     UnbindL();

  1130     }

  1131 

  1132 

  1133 void T_PresenceWatching::T_ErrFromPlg_LeaveOnUnsubscribePresentityGroupMembersPresence_L()

  1134     {