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 <presencefeatures.h>

    28 #include <presencepublishing.h>

    29 #include <ximpdatasubscriptionstate.h>

    30 #include <presentitygroups.h>

    31 #include <ximpobjectfactory.h>

    32 #include <presencewatching.h>

    33 #include <presenceobjectfactory.h>

    34 #include <ximpcontext.h>

    35 #include <ximpcontextstateevent.h>

    36 #include <ximprequestcompleteevent.h>

    37 #include <ximpstatus.h>

    38 #include <presentitypresenceevent.h>

    39 #include "prfwtestpresencedatautils.h"

    40 

    41 

    42 

    43 #include "t_presencewatcherlistmngt.h"

    44 

    45 // watcher list related includes

    46 #include "presencewatcherinfoimp.h"

    47 #include "presencewatcherlisteventimp.h"

    48 

    49 // other data model includes

    50 #include "ximpidentityimp.h"

    51 #include "ximpdatasubscriptionstateimp.h"

    52 #include "presentitygroupmemberinfoimp.h"

    53 #include "presenceinfofilterimp.h"

    54 

    55 // utils includes

    56 #include "ximpobjecthelpers.h"

    57 

    58 #include "ximprequestcompleteeventimp.h"

    59 

    60 // testing tool includes

    61 #include "prfwtestmessaging.h"

    62 #include "prfwtestmessenger.h"

    63 #include "prfwtestcontextwrappermgr.h"

    64 #include "prfwtestcontextwrapper.h"

    65 #include "prfwtestwaithelper.h"

    66 

    67 #include "prfwtestfilesrvmsg.h"

    68 #include "prfwtestfiletool.h"

    69 #include "prfwtestlistener.h"

    70 

    71 #include "prfwtestrobustnesstools.h"

    72 

    73 

    74 

    75 

    76 

    77 /*#include "presenceinfoimp.h"

    78 #include "presenceinfofilterimp.h"

    79 #include "prfwtestpresencedatautils.h"

    80 #include "ximpidentityimp.h"

    81 #include "presentitygroupmemberinfoimp.h"

    82 #include "ximpobjecthelpers.h"

    83 #include "prfwtestfilesrvmsg.h"

    84 #include "prfwtestwaithelper.h"*/

    85 

    86 _LIT8( KPrefix1, "PreA_" );

    87 _LIT8( KPrefix2, "PreB_" );

    88 _LIT8( KPrefix3, "PreC_" );

    89 _LIT8( KPrefix4, "PreD_" );

    90 

    91 // ============================ MEMBER FUNCTIONS ===============================

    92 

    93 // CONSTRUCTION

    94 T_PresenceWatcherListManagement* T_PresenceWatcherListManagement::NewL()

    95     {

    96     T_PresenceWatcherListManagement* self = new( ELeave ) T_PresenceWatcherListManagement;

    97     CleanupStack::PushL( self );

    98     self->ConstructL();

    99     CleanupStack::Pop( self );

   100 

   101     return self;

   102     }

   103 

   104 

   105 T_PresenceWatcherListManagement::~T_PresenceWatcherListManagement()

   106     {

   107     }

   108 

   109 

   110 void T_PresenceWatcherListManagement::ConstructL()

   111     {

   112     CEUnitTestSuiteClass::ConstructL();

   113     }

   114 

   115 

   116 T_PresenceWatcherListManagement::T_PresenceWatcherListManagement()

   117     {

   118     }

   119 

   120 

   121 

   122 // ===========================================================================

   123 // TEST CASE SETUP & TEARDOWN METHODS

   124 // ===========================================================================

   125 //

   126 

   127 void T_PresenceWatcherListManagement::Setup_L()

   128     {

   129         

   130     __UHEAP_MARK;

   131     PrfwTestRobustness::DoPreCleaning();

   132 

   133     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   134     iWrapperMgr->CreateWrapperL();

   135     }

   136 

   137 void T_PresenceWatcherListManagement::SetupMultiple_L()

   138     {

   139     __UHEAP_MARK;

   140     PrfwTestRobustness::DoPreCleaning();

   141 

   142     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   143     iWrapperMgr->CreateWrapperL();

   144     iWrapperMgr->CreateWrapperL();

   145     iWrapperMgr->CreateWrapperL();

   146     }

   147 

   148 

   149 void T_PresenceWatcherListManagement::BindL()

   150     {

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

   152 

   153     wrapper0->BindL( 0 );

   154     }

   155 

   156 void T_PresenceWatcherListManagement::BindAllL()

   157     {

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

   159         {

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

   161         wrapper->BindL( 0 );

   162         }

   163     }

   164 

   165 

   166 void T_PresenceWatcherListManagement::Teardown()

   167     {

   168     delete iWrapperMgr;

   169     iWrapperMgr = NULL;

   170 

   171     REComSession::FinalClose();

   172 

   173     PrfwTestRobustness::DoPreCleaning();

   174         

   175     __UHEAP_MARKEND;

   176     }

   177 

   178 void T_PresenceWatcherListManagement::UnbindL()

   179     {

   180     // Do unbind

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

   182     wrapper0->UnbindL();

   183     }

   184 

   185 void T_PresenceWatcherListManagement::UnbindAllL()

   186     {

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

   188         {

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

   190         wrapper->UnbindL();

   191         }

   192     }

   193 

   194 

   195 // ===========================================================================

   196 // TEST CASES for presentity presence subscription

   197 // ===========================================================================

   198 // Check that this don't leak memory

   199 void T_PresenceWatcherListManagement::T_BindUnbind_L()

   200     {

   201     BindL();

   202     UnbindL();

   203     }

   204 // ---------------------------------------------------------------------------

   205 // ---------------------------------------------------------------------------

   206 // Subscribe, unsubscribe - Single client

   207 void T_PresenceWatcherListManagement::T_SubscribePresenceWatcherList_Single_L()

   208     {

   209 

   210     EUNIT_PRINT( _L("Single client presence watcher list subscription") );

   211 

   212     BindL();

   213 

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

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

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

   217 

   218     CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

   219     CleanupStack::PushL( listener2 );

   220 

   221     // Tell the protocol it should act normally

   222     messenger->SetNoError();

   223 

   224     // Get the interfaces

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

   226     MPresencePublishing& presPub = presFeat->PresencePublishing();

   227 

   228     //-------------------------------------------------

   229     // subscribe

   230 

   231     // Setup status event listener for RequestComplete

   232     // ---------------------------------------------

   233     listener2->Reset();

   234 

   235     // normal request complete

   236     TXIMPRequestId reqIdDummy;  // not checked

   237     CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   238     listener2->ExpectL( evReqComplete );

   239     CleanupStack::Pop( evReqComplete );

   240 

   241 

   242     // Subscribe

   243     TXIMPRequestId reqId = presPub.SubscribePresenceWatcherListL();

   244 

   245     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribe failed" );

   246 

   247     // verify that SubscribePresenceWatcherListL was called

   248     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceWatcherListCalled, "SubscribePresenceWatcherListL was not called", ETrue, NULL );

   249 

   250     //-------------------------------------------------

   251     // refresh subscribe

   252 

   253     // Setup status event listener for RequestComplete

   254     listener2->Reset();

   255 

   256     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   257     listener2->ExpectL( evReqComplete );

   258     CleanupStack::Pop( evReqComplete );

   259 

   260     RPrWatLstInfoImpArray* currentList(NULL);

   261     CPresenceWatcherListEventImp* event = CreateWatcherListEventLCX(

   262         KNullDesC, KNullDesC,

   263         MXIMPDataSubscriptionState::ESubscriptionActive,

   264         MXIMPDataSubscriptionState::EDataUnavailable,

   265         ETestPWlCurrent, currentList);

   266     listener2->ExpectL( event );

   267     CleanupStack::Pop(); //event 3 to go.

   268     // ---------------------------------------------

   269 

   270     // Subscribe second time

   271     reqId = presPub.SubscribePresenceWatcherListL();

   272 

   273     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Refresh failed" );

   274     CleanupStack::PopAndDestroy( 3 ); // rest of the items.

   275 

   276     // verify that SubscribePresenceWatcherListL was called

   277     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceWatcherListCalled, "SubscribePresenceWatcherListL was not called", ETrue, NULL );

   278 

   279 

   280     //-------------------------------------------------

   281     // unsubscribe

   282 

   283     // Setup status event listener for RequestComplete

   284     listener2->Reset();

   285 

   286     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   287     listener2->ExpectL( evReqComplete );

   288     CleanupStack::Pop( evReqComplete );

   289 

   290     // register interest

   291     reqId = presPub.UnsubscribePresenceWatcherListL();

   292 

   293     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe failed" );

   294 

   295     // verify that UnsubscribePresenceWatcherListL was called

   296     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled, "UnsubscribePresenceWatcherListL was not called", ETrue, NULL );

   297 

   298     //-------------------------------------------------

   299     // unsubscribe nonsubscribed

   300 

   301     // Setup status event listener for RequestComplete

   302     listener2->Reset();

   303 

   304     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   305     listener2->ExpectL( evReqComplete );

   306     CleanupStack::Pop( evReqComplete );

   307 

   308     // register interest

   309     reqId = presPub.UnsubscribePresenceWatcherListL();

   310 

   311     // Wait for events on the request

   312     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe failed" );

   313 

   314     // verify that UpdateInterest was called

   315     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled, "UnsubscribePresenceWatcherListL was not called", ETrue, NULL );

   316 

   317 

   318 

   319     listener2->SetEventSourceL( NULL );

   320 

   321     UnbindL();

   322 

   323     CleanupStack::PopAndDestroy( listener2 );

   324     }

   325 

   326 // ---------------------------------------------------------------------------

   327 // ---------------------------------------------------------------------------

   328 // Subscribe, Unsubscribe - Multiple clients

   329 void T_PresenceWatcherListManagement::T_SubscribePresenceWatcherList_Multiple_L()

   330     {

   331     EUNIT_PRINT( _L("Multiple client presence watcher list subscription") );

   332 

   333     BindAllL();

   334 

   335     TInt countOfWrappers = iWrapperMgr->WrapperCount();

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

   337         {

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

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

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

   341 

   342         // Tell the protocol it should act normally

   343         messenger->SetNoError();

   344 

   345         CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

   346         CleanupStack::PushL( listener2 );

   347 

   348         // Get the interfaces

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

   350         MPresencePublishing& presPub = presFeat->PresencePublishing();

   351 

   352         // Setup status event listener for RequestComplete

   353         listener2->Reset();

   354 

   355         TXIMPRequestId reqIdDummy;  // not checked

   356         CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   357         listener2->ExpectL( evReqComplete );

   358         CleanupStack::Pop( evReqComplete );

   359 

   360         // Subscribe

   361         TXIMPRequestId reqId = presPub.SubscribePresenceWatcherListL();

   362 

   363         // Wait for events on the request

   364         EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribe failed" );

   365 

   366         // verify that SubscribePresenceWatcherListL was called

   367         COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceWatcherListCalled, "SubscribePresenceWatcherListL was not called", ETrue, NULL );

   368 

   369         CleanupStack::PopAndDestroy( listener2 );

   370         }

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

   372         {

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

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

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

   376 

   377         CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

   378         CleanupStack::PushL( listener2 );

   379 

   380         // Get the interfaces

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

   382         MPresencePublishing& presPub = presFeat->PresencePublishing();

   383 

   384         // Setup status event listener for RequestComplete

   385         listener2->Reset();

   386 

   387         TXIMPRequestId reqIdDummy;  // not checked

   388         CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   389         listener2->ExpectL( evReqComplete );

   390         CleanupStack::Pop( evReqComplete );

   391 

   392         // Unsubscribe

   393         TXIMPRequestId reqId = presPub.UnsubscribePresenceWatcherListL();

   394 

   395         // Wait for events on the request

   396         EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe failed" );

   397 

   398         // verify that unsubscribe was called

   399         COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled,

   400             "UnsubscribePresenceWatcherListL was not called",

   401             ( a < 2 ) ? EFalse : ETrue,

   402             "UnsubscribePresenceWatcherListL was called" );

   403 

   404         CleanupStack::PopAndDestroy( listener2 );

   405         }

   406 

   407     UnbindAllL();

   408     }

   409 

   410 // ---------------------------------------------------------------------------

   411 // ---------------------------------------------------------------------------

   412 void T_PresenceWatcherListManagement::SubscribeL()

   413     {

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

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

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

   417 

   418     // Get the interfaces

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

   420     MPresencePublishing& presPub = presFeat->PresencePublishing();

   421 

   422     CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

   423     CleanupStack::PushL( listener2 );

   424 

   425     // Setup status event listener for RequestComplete

   426     listener2->Reset();

   427 

   428     TXIMPRequestId reqIdDummy;  // not checked

   429     CXIMPRequestCompleteEventImp* evReqComplete =

   430                     CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   431     listener2->ExpectL( evReqComplete );

   432     CleanupStack::Pop( evReqComplete );

   433 

   434     // subscribe

   435     TXIMPRequestId reqId = presPub.SubscribePresenceWatcherListL();

   436 

   437     // Wait for events on the request

   438     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribe failed" );

   439 

   440     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceWatcherListCalled, "SubscribeWatcherListL was not called", ETrue, NULL );

   441 

   442     CleanupStack::PopAndDestroy( listener2 );

   443     }

   444 

   445 // ---------------------------------------------------------------------------

   446 // ---------------------------------------------------------------------------

   447 void T_PresenceWatcherListManagement::UnsubscribeL()

   448     {

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

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

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

   452 

   453     // Get the interfaces

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

   455     MPresencePublishing& presPub = presFeat->PresencePublishing();

   456 

   457     // Setup status event listener for RequestComplete

   458     CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

   459     CleanupStack::PushL( listener2 );

   460 

   461     // Setup status event listener for RequestComplete

   462     listener2->Reset();

   463 

   464     TXIMPRequestId reqIdDummy;  // not checked

   465     CXIMPRequestCompleteEventImp* evReqComplete =

   466                     CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   467     listener2->ExpectL( evReqComplete );

   468     CleanupStack::Pop( evReqComplete );

   469 

   470     // unsubscribe

   471     TXIMPRequestId reqId = presPub.UnsubscribePresenceWatcherListL();

   472 

   473     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsbscribe failed" );

   474 

   475     // verify that UnsubscribeWatcherListL was called

   476     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled, "UnsubscribeWatcherListL was not called", ETrue, NULL );

   477 

   478     CleanupStack::PopAndDestroy( listener2 );

   479 

   480     }

   481 

   482 // ---------------------------------------------------------------------------

   483 // ---------------------------------------------------------------------------

   484 void T_PresenceWatcherListManagement::T_HandlePresenceWatcherList_L()

   485     {

   486     EUNIT_PRINT( _L("Handle presence watcher list.") );

   487 

   488     BindL();

   489     SubscribeL();

   490 

   491     // ------------------------------------------------------

   492     // some startup stuff

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

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

   495 

   496     CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

   497     CleanupStack::PushL( listener2 );

   498     // ------------------------------------------------------

   499 

   500     // Tell the protocol it should act normally

   501     wrapper->GetMessenger()->SetNoError();

   502 

   503     // ------------------------------------------------------

   504     // 1. Create faked server message about watcher list (empty)

   505     SendSrvMsgL( CXIMPTestFileSrvMsg::ETestSrvMsgPresenceWatcherList );

   506 

   507     // ------------------------------------------------------

   508     // expect empty MPresencewatcherList event.

   509 

   510     RPrWatLstInfoImpArray* currentList(NULL);

   511     CPresenceWatcherListEventImp* event = CreateWatcherListEventLCX(

   512             KNullDesC, KNullDesC,

   513         MXIMPDataSubscriptionState::ESubscriptionActive,

   514         MXIMPDataSubscriptionState::EDataAvailable,

   515         ETestPWlCurrent, currentList);

   516 

   517     listener2->ExpectL( event );

   518     CleanupStack::Pop( event ); // 3 more items in cleanupstack

   519 

   520     //Waqas: Fixed task Ticket#22

   521     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceWatcherListL failed" );

   522     CleanupStack::PopAndDestroy( 3 ); // lists

   523     // ------------------------------------------------------

   524 

   525 

   526     // ------------------------------------------------------

   527     // 2. Create faked server message about watcher list (new)

   528     listener2->Reset();

   529 

   530     _LIT16( KWatcherUri1,      "http://carpe.diem.com" );

   531     _LIT16( KWatcherDispName1, "DispnameA, LoremI" );

   532 

   533     SendSrvMsgL( KWatcherUri1,

   534                  KWatcherDispName1,

   535                  CXIMPTestFileSrvMsg::ETestSrvMsgPresenceWatcherList );

   536 

   537     // ------------------------------------------------------

   538     // MPresencewatcherList event.

   539 

   540     currentList = NULL; // previous one was destroyed

   541     //Now create the actual event

   542     event = CreateWatcherListEventLCX(  // previous event was destroyed

   543             KWatcherUri1, KWatcherDispName1,

   544         MXIMPDataSubscriptionState::ESubscriptionActive,

   545         MXIMPDataSubscriptionState::EDataAvailable,

   546         ETestPWlNew, currentList);

   547     

   548 

   549     listener2->ExpectL( event );

   550     CleanupStack::Pop( event ); // 3 more items in cleanupstack

   551 

   552     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceWatcherListL failed" );

   553     CleanupStack::PopAndDestroy( 3 ); // lists

   554 

   555 

   556     // ------------------------------------------------------

   557     // 3. Create faked server message about watcher list (disappeared)

   558     listener2->Reset();

   559 

   560     SendSrvMsgL( CXIMPTestFileSrvMsg::ETestSrvMsgPresenceWatcherList );

   561     // ------------------------------------------------------

   562     // MPresencewatcherList event.

   563 

   564     CXIMPIdentityImp* idForEvent = CXIMPIdentityImp::NewLC( KWatcherUri1 );

   565     // we need to create current list to give to the event

   566     currentList = new ( ELeave ) RPrWatLstInfoImpArray; // previous is destroyed

   567     CleanupDeletePushL( currentList );

   568             // create the group info

   569     CPresenceWatcherInfoImp* watcherInfoForEvent = 

   570                             CPresenceWatcherInfoImp::NewLC( (MPresenceWatcherInfo::TWatcherType)0, *idForEvent, KWatcherDispName1);

   571     currentList->AppendL( watcherInfoForEvent );

   572     CleanupStack::Pop( watcherInfoForEvent );

   573     CleanupStack::Pop( currentList );

   574     CleanupStack::PopAndDestroy( idForEvent );    

   575 

   576 

   577     //Now create the actual event

   578     event = CreateWatcherListEventLCX(

   579             KWatcherUri1, KWatcherDispName1,

   580         MXIMPDataSubscriptionState::ESubscriptionActive,

   581         MXIMPDataSubscriptionState::EDataAvailable,

   582         ETestPWlDisappeared, currentList);

   583 

   584     listener2->ExpectL( event );

   585     CleanupStack::Pop( event ); // 3 more items in cleanupstack

   586 

   587     //Waqas: Fixed task Ticket#22

   588     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceWatcherListL failed" );

   589 

   590     CleanupStack::PopAndDestroy( 3 ); // lists

   591 

   592 

   593     // clean it up

   594     UnsubscribeL();

   595     

   596     /* TODO later on better time.

   597     // ------------------------------------------------------

   598     // 4. Create faked server message about watcher list (no subscribers to list)

   599     //    Make sure no event is 

   600     listener2->Reset();

   601     

   602     event = CreateWatcherListEventLCX(

   603             KNullDesC, KNullDesC,

   604             ETestPWlEmpty );

   605 

   606     //EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceWatcherListL failed" );

   607 

   608     */

   609     CleanupStack::PopAndDestroy( listener2 );

   610     

   611     UnbindL();

   612     }

   613 

   614 ////////////////////////////////////////////////////

   615 //// INTIA CASE 

   616 ////////////////////////////////////////////////////

   617 void T_PresenceWatcherListManagement::T_IndiaCase_L()

   618     {

   619 

   620     EUNIT_PRINT( _L("Presence notification subscribed list, Intia") );

   621    

   622 

   623     BindL();

   624 

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

   626     MXIMPContext* presenceCtx = wrapper->GetContext();

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

   628 

   629     CXIMPTestListener* ctxObserver = CXIMPTestListener::NewL( presenceCtx );

   630     CleanupStack::PushL( ctxObserver );  // << ctxObserver

   631   

   632 

   633     // Tell the protocol it should act normally

   634     messenger->SetNoError();

   635 

   636        // Get the interfaces

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

   638     MPresencePublishing& presPub = presFeat->PresencePublishing();

   639     MPresentityGroups& presGroups = presFeat->PresentityGroups();    

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

   641     

   642     MXIMPObjectFactory& objFactory = presenceCtx->ObjectFactory();

   643     

   644     _LIT( KGroupId, "rakesh.harsh/Friends" );

   645     _LIT( KGroupDisplayName, "my_friend" );

   646     _LIT( KMemberId1, "user1" );

   647     _LIT( KMember1DisplayName, "user1DisplayName" );

   648     _LIT( KMemberId2, "user2" );

   649     _LIT( KMember2DisplayName, "user2DisplayName" );

   650     

   651     

   652     // Create test variables

   653     MXIMPIdentity* testGroupId = objFactory.NewIdentityLC();   // << testGroupId

   654     testGroupId->SetIdentityL( KGroupId ); 

   655         

   656     MXIMPIdentity* member1 = objFactory.NewIdentityLC(); // << member1

   657     member1->SetIdentityL( KMemberId1 );

   658     

   659     MXIMPIdentity* member2 = objFactory.NewIdentityLC(); // << member2

   660     member2->SetIdentityL( KMemberId2 );

   661     

   662     //////////////////////////////////////////////////////////////////////////

   663     // SUBSCRIBE PRESENTITY GROUP LIST

   664     //////////////////////////////////////////////////////////////////////////

   665     

   666     // Setup status event listener for RequestComplete

   667     TXIMPRequestId reqId;  

   668     ctxObserver->Reset();

   669     CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );// << evReqComplete

   670     ctxObserver->ExpectL( evReqComplete );

   671     CleanupStack::Pop( evReqComplete ); // >> evReqComplete 

   672     

   673     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   674     

   675     // subscribe PresentityGroupList

   676     reqId = presGroups.SubscribePresentityGroupListL();

   677     

   678     // Wait for events on the request

   679     wrapper->WaitRequestAndStackEvents( reqId );

   680     wrapper->VerifyEventStackL( _L8("Subscribing presentity group list, complete with error: ") );

   681     

   682     // verify that SubscribePresentityGroupListL was called

   683     messenger->AssertSubscribePresentityGroupListCalled( ETrue );

   684     

   685     

   686     // get list request

   687 /*    TXIMPRequestId req = presGroups.SubscribePresentityGroupListL(); 

   688     ctxObserver->WaitOpToCompleteL( req );

   689 

   690     CUserAfter::AfterL( 1000000 );

   691 */

   692     

   693     //////////////////////////////////////////////////////////////////////////

   694     // SUBSCRIBE PRESENTITY GROUP CONTENT

   695     //////////////////////////////////////////////////////////////////////////    

   696 

   697     // Setup status event listener for RequestComplete

   698     ctxObserver->Reset();

   699     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   700     ctxObserver->ExpectL( evReqComplete );

   701     CleanupStack::Pop( evReqComplete );

   702     SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );

   703             

   704     // subscribe group content

   705     reqId = presGroups.SubscribePresentityGroupContentL( *testGroupId );

   706     

   707     // Wait for events on the request

   708     wrapper->WaitRequestAndStackEvents( reqId );

   709     wrapper->VerifyEventStackL( _L8("Subscribe presentity group content, complete with error: ") );

   710 

   711     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityGroupContentCalled, "SubscribeGroupContentL was not called", ETrue, NULL );

   712     

   713 /*    TInt count = ctxObserver->gidcount;

   714     // List manage request

   715      for(TInt i = 0; i<count;i++)

   716      { 

   717       //get the content of the lists

   718        MXIMPIdentity*   tgid = objFactory.NewIdentityLC();

   719      tgid->SetIdentityL( ctxObserver->gid[i] ); 

   720     // tgid->SetIdentityL( _L("rakesh.harsh/basu2@nokia.com") );

   721       

   722       TXIMPRequestId  req = presGroups.SubscribePresentityGroupContentL( *tgid );

   723     

   724       ctxObserver->WaitOpToCompleteL( req );

   725     

   726       CleanupStack::PopAndDestroy( 1 ); //  tgid

   727      }  */

   728      

   729     //////////////////////////////////////////////////////////////////////////

   730     // CREATE PRESENTITY GROUP

   731     /////////////////////////////////////////////////////////////////////////

   732     

   733     // Setup status event listener for RequestComplete

   734     // This will also produce HandlePresentityGroupListEvent, since the

   735     // the group is subscribed 

   736     ctxObserver->Reset();

   737     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   738     ctxObserver->ExpectL( evReqComplete );

   739     CleanupStack::Pop( evReqComplete );//TODO???

   740 

   741     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   742 

   743     // Create group

   744     reqId = presGroups.CreatePresentityGroupL( *testGroupId, KGroupDisplayName );

   745     

   746     // Wait for events on the request

   747     wrapper->WaitRequestAndStackEvents( reqId );

   748     wrapper->VerifyEventStackL( _L8("CreatePresentityGroupL failed, complete with error: ") );

   749     

   750     // verify that SubscribePresentityGroupListL was called

   751     messenger->AssertCreatePresentityGroupCalled( ETrue );

   752 

   753     

   754                    

   755     // first make a test group in our roster

   756  /*   MXIMPIdentity* newGroupId = objFactory.NewIdentityLC();//1

   757     newGroupId->SetIdentityL( _L("rakesh.harsh/Friends") );

   758 

   759     req = presGroups.CreatePresentityGroupL( *newGroupId,_L("my_friend") );

   760     // wait completion

   761     ctxObserver->WaitOpToCompleteL( req );

   762       

   763     CUserAfter::AfterL( 1000000 );*/

   764     

   765     //////////////////////////////////////////////////////////////////////////

   766     // ADD PRESENTITY GROUP MEMBER

   767     ////////////////////////////////////////////////////////////////////////// 

   768     

   769     // Setup event listener for RequestComplete

   770     ctxObserver->Reset();

   771     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); // << evReqComplete

   772 

   773     // group id

   774     CXIMPIdentityImp* grid = CXIMPIdentityImp::NewLC( testGroupId->Identity() ); // << grid

   775     evReqComplete->AppendParamL( grid );

   776     CleanupStack::Pop(); // >> grid

   777 

   778     // id for member info

   779     CXIMPIdentityImp* miId = CXIMPIdentityImp::NewLC( KMemberId1 ); // << miId

   780     // member info

   781     CPresentityGroupMemberInfoImp* memInfoImp =

   782         CPresentityGroupMemberInfoImp::NewLC( *miId, KMember1DisplayName ); // << memInfoImp

   783     evReqComplete->AppendParamL( memInfoImp );

   784     CleanupStack::Pop(); // memInfoImp owned by AppendParamL    // >> memInfoImp

   785     CleanupStack::PopAndDestroy( miId ); // copy was made   // >>> miId

   786 

   787     ctxObserver->ExpectL( evReqComplete );

   788     CleanupStack::Pop( evReqComplete ); // >> evReqComplete

   789 

   790     // do the call

   791     reqId = presGroups.AddPresentityGroupMemberL(

   792             *testGroupId, *member1, KMember1DisplayName );

   793 

   794     // Wait for events on the request

   795     wrapper->WaitRequestAndStackEvents( reqId );

   796     messenger->AssertAddPresentityGroupMemberCalled( ETrue );

   797 

   798  

   799     //add a member

   800 /*    MXIMPIdentity* testContactId = objFactory.NewIdentityLC();

   801     testContactId->SetIdentityL( _L("mukesh") );

   802     req = presGroups.AddPresentityGroupMemberL( *newGroupId,

   803                                                 *testContactId,

   804                                                 _L("h2") );

   805     // wait completion

   806     ctxObserver->WaitOpToCompleteL( req );

   807     

   808     

   809     CUserAfter::AfterL( 1000000 );*/

   810     

   811     

   812     //////////////////////////////////////////////////////////////////////////

   813     // ADD PRESENTITY GROUP MEMBER

   814     ////////////////////////////////////////////////////////////////////////// 

   815 

   816     // Setup event listener for RequestComplete

   817     ctxObserver->Reset();

   818     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); // << evReqComplete

   819 

   820     // group id

   821     CXIMPIdentityImp* grid2 = CXIMPIdentityImp::NewLC( testGroupId->Identity() );

   822     evReqComplete->AppendParamL( grid2 );

   823     CleanupStack::Pop(); // grid2

   824 

   825     // id for member info

   826     CXIMPIdentityImp* miId2 = CXIMPIdentityImp::NewLC( KMemberId2 );

   827     // member info

   828     CPresentityGroupMemberInfoImp* memInfoImp2 =

   829         CPresentityGroupMemberInfoImp::NewLC( *miId2, KMember2DisplayName );

   830     evReqComplete->AppendParamL( memInfoImp2 );

   831     CleanupStack::Pop(); // memInfoImp owned by AppendParamL

   832     CleanupStack::PopAndDestroy( miId2 ); // copy was made

   833 

   834     ctxObserver->ExpectL( evReqComplete );

   835     CleanupStack::Pop( evReqComplete );

   836     // reset the variable

   837     messenger->SetValueFor( EXIMPPlgTestAddPresentityGroupMemberCalled, 0 );

   838     // do the call

   839     reqId = presGroups.AddPresentityGroupMemberL(

   840             *testGroupId, *member2, KMember2DisplayName );

   841 

   842     // Wait for events on the request

   843     wrapper->WaitRequestAndStackEvents( reqId );

   844     messenger->AssertAddPresentityGroupMemberCalled( ETrue );

   845 

   846     

   847 /*    testContactId->SetIdentityL( _L("bb0") );

   848     req = presGroups.AddPresentityGroupMemberL( *newGroupId,

   849                                                 *testContactId,

   850                                                 _L("b1") );

   851     // wait completion

   852     ctxObserver->WaitOpToCompleteL( req );

   853     

   854 */    

   855     //////////////////////////////////////////////////////////////////////////

   856     // SUBSCRIBE PRESENTITY GROUP MEMBERS PRESENCE

   857     ////////////////////////////////////////////////////////////////////////// 

   858         

   859     // Setup status event listener for RequestComplete

   860     ctxObserver->Reset();

   861     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   862     ctxObserver->ExpectL( evReqComplete );

   863     CleanupStack::Pop( evReqComplete );

   864     SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );

   865 

   866     

   867     // Set filter for the group

   868     MPresenceInfoFilter* gpif = presFeat->PresenceObjectFactory().NewPresenceInfoFilterLC();

   869     gpif->AcceptPersonFilterL( NPresenceInfo::NFieldType::KStatusMessage  );

   870     gpif->AcceptPersonFilterL( NPresenceInfo::NFieldType::KAvatar );

   871 

   872     // register interest

   873     reqId = presWatch.SubscribePresentityGroupMembersPresenceL( *testGroupId, *gpif );

   874     

   875     CleanupStack::PopAndDestroy(); // >>> gpif

   876 

   877     // Wait for events on the request

   878     wrapper->WaitRequestAndStackEvents( reqId );

   879     wrapper->VerifyEventStackL( _L8("Subscribe presentity group members, complete with error: ") );

   880         

   881     // verify that UpdateInterest was called

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

   883 

   884      

   885 

   886 /*    CUserAfter::AfterL( 1000000 );

   887     MPresenceWatching& presWatch = presenceCtx->PresenceWatching();

   888     MPresenceInfoFilter* infoFilt = objFactory.NewPresenceInfoFilterLC();

   889     req = presWatch.SubscribePresentityGroupMembersPresenceL( *newGroupId, *infoFilt );

   890     // wait completion

   891     ctxObserver->WaitOpToCompleteL( req );

   892     

   893    // req = presWatch.SubscribePresentityPresenceL( *testContactId, *infoFilt );

   894     // wait completion

   895    // ctxObserver->WaitOpToCompleteL( req );

   896     //MXIMPClient* presClient1 = NULL;

   897    // MXIMPContext* presenceCtx1 = NULL;

   898     //CUSContextObserver* ctxObserver1  = NULL;

   899     

   900     /*TInt pushCount1 = DoSetupDefaultContext1LC( presClient1,

   901                                               presenceCtx1,

   902                                               ctxObserver1 );

   903     

   904     ctxObserver->WaitOpToCompleteL( req );*/

   905  //   CUserAfter::AfterL( 60000000 ); //60 seconds

   906     

   907     /*if ( !iWait.IsStarted() )

   908 			{    

   909 			iWait.Start();  // CSI: 10 # iWait is not an active object

   910 			}

   911      */

   912     //code is for login with diff id 

   913      //Initialize XIMP client

   914  /*  #if 0

   915     MXIMPClient* presClient1 = MXIMPClient::NewClientL();

   916     CleanupDeletePushL( presClient );

   917       

   918     //Create new sink to receive presence context events

   919     CUSContextObserver* eventObserver1 = CUSContextObserver::NewLC();

   920 

   921     //Create new presence context

   922     MXIMPContext* presecenCtx1 = presClient->NewPresenceContextLC();

   923     presecenCtx1->RegisterObserverL( *eventObserver1 );

   924 

   925     //Bind context to desired presence service

   926     TUid protocolUid = TUid::Uid( KProtocolUid );

   927 

   928 

   929     //Bind context to desired presence service

   930      req = presecenCtx1->BindToL( protocolUid,

   931                                                KServerAddress,

   932                                                KUserName2,

   933                                                KPassword2,

   934                                                KIAP );

   935  

   936     //Wait with CActiveSchedulerWait the binding to complete

   937     //If binding fails, it is handled with leave

   938     eventObserver1->WaitOpToCompleteL( req );

   939     MXIMPIdentity* newGroupId1 = objFactory.NewIdentityLC();//1

   940     newGroupId1->SetIdentityL( _L("bb0/jaya") );

   941 

   942      req = presGroups.CreatePresentityGroupL( *newGroupId1,_L("my_sweety") );

   943     // wait completion

   944     ctxObserver->WaitOpToCompleteL( req );

   945       

   946     CUserAfter::AfterL( 1000000 );

   947     presecenCtx1->UnbindL();

   948     eventObserver1->WaitOpToCompleteL( req );

   949     CleanupStack::PopAndDestroy( 4 ); //newGroupId1,presecenCtx1,eventObserver1,presClient1

   950     

   951     #endif*/

   952     //code is for login with diff id end

   953     

   954     //add this user to bb0's contact list.i should  recieve notification

   955     

   956     //   delete group friend which is created above statement 

   957     //req = presGroups.DeletePresentityGroupL( *newGroupId );

   958     // wait completion

   959    // ctxObserver->WaitOpToCompleteL( req );

   960  //   CUserAfter::AfterL( 60000000 );

   961     //Unbind the context and wait completion

   962   //  req = presenceCtx->UnbindL();

   963   //  ctxObserver->WaitOpToCompleteL( req );

   964 

   965     //Destroy the context (it is automaticly unbind)

   966  //   CleanupStack::PopAndDestroy( 3 ); //  infoFilt,testContactId,newGroupId

   967  //   CleanupStack::PopAndDestroy( pushCount );	

   968  

   969  

   970     //////////////////////////////////////////////////////////////////////////

   971     // SEND DATA FOR GROUP MEMBER -> HANDLE PRESENTITY PRESENCE

   972     ////////////////////////////////////////////////////////////////////////// 

   973 

   974      

   975      // create test message

   976     CPresenceInfoImp* presenceInfo = CPresenceInfoImp::NewLC(); // << presenceInfo

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

   978     CleanupStack::PopAndDestroy( presenceInfo );// >>> presenceInfo

   979     CleanupStack::PushL( packedInfo );  // << packedInfo

   980     

   981     CXIMPIdentityImp* changed = CXIMPIdentityImp::NewLC( ); // << changed

   982     changed->SetIdentityL( KMemberId1 );

   983     HBufC8* packedId = TXIMPObjectPacker< CXIMPIdentityImp >::PackL( *changed );

   984     CleanupStack::PopAndDestroy(); // >>> changed

   985     CleanupStack::PushL( packedId );// << packedId

   986     

   987     RPointerArray< HBufC8 > bufferArray;

   988     CleanupClosePushL( bufferArray );   // << bufferArray

   989     bufferArray.AppendL( packedId );

   990     bufferArray.AppendL( packedInfo );

   991     

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

   993     CleanupStack::PopAndDestroy( 2 ); // >>> packedId, packedInfo

   994     CleanupStack::PopAndDestroy(); // >>> bufferArray

   995     CleanupStack::PushL( packedBufferArray );   // << packedBufferArray

   996     

   997     // Send it to plugin 

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

   999                                                              *packedBufferArray );

  1000     CleanupStack::PopAndDestroy( packedBufferArray );   // >>> packedBufferArray

  1001     

  1002     CleanupStack::PushL( srvMsg );  // << srvMsg

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

  1004     CleanupStack::PopAndDestroy( srvMsg );  // >>> srvMsg

  1005     wrapper->FileTool().CleanAllL();

  1006 

  1007     // Wait for server to handle srvmsg.

  1008     User::After( 4 * 1000000 );       

  1009 

  1010     COMMONASSERT( messenger, EXIMPPlgTestHandlePresentityPresenceCalled, "HandlePresentityPresenceL was not called", ETrue, NULL );

  1011 

  1012     CleanupStack::PopAndDestroy( 3 ); // >>> testGroupId, member1, member2

  1013     CleanupStack::PopAndDestroy( ctxObserver ); // >>> ctxObserver

  1014     

  1015     UnbindL(); 

  1016 

  1017 }

  1018 // ===========================================================================

  1019 // SETUP HELPERS FOR THE LISTENER

  1020 // ===========================================================================

  1021 //

  1022 

  1023 // ---------------------------------------------------------------------------

  1024 // ---------------------------------------------------------------------------

  1025 // send a faked server-originated message with watcher info made

  1026 // from the given uri and displayname

  1027 //

  1028 void T_PresenceWatcherListManagement::SendSrvMsgL(

  1029         const TDesC& aUri, const TDesC& aDispName,

  1030         TInt aMsgType )

  1031     {

  1032     // we'll use hard-coded wrapper 0 instance for now.

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

  1034 

  1035     // create a grant req info contained within the server-originated

  1036     // faked message

  1037     RXIMPObjOwningPtrArray<CPresenceWatcherInfoImp> watcherList;

  1038     CleanupClosePushL( watcherList );

  1039 

  1040     CXIMPIdentityImp* watcherId = CXIMPIdentityImp::NewLC( aUri );

  1041     CPresenceWatcherInfoImp* watcherItem =

  1042                 CPresenceWatcherInfoImp::NewLC(

  1043                             (MPresenceWatcherInfo::TWatcherType)0,

  1044                             *watcherId,

  1045                             aDispName );

  1046     watcherList.AppendL( watcherItem );

  1047     CleanupStack::Pop( watcherItem );

  1048     CleanupStack::PopAndDestroy( watcherId );

  1049 

  1050     HBufC8* packedArray =

  1051         TXIMPObjectPacker<CPresenceWatcherInfoImp>::PackArrayL( watcherList );

  1052     CleanupStack::PushL( packedArray );

  1053 

  1054     // use filetool to send it for plugin.

  1055     CXIMPTestFileSrvMsg* srvMsg = CXIMPTestFileSrvMsg::NewL( aMsgType,

  1056             *packedArray );

  1057     CleanupStack::PushL( srvMsg );

  1058     wrapper->FileTool().CleanAllL();

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

  1060     CleanupStack::PopAndDestroy( 3 ); // srvMsg, packedArray, watcherList

  1061     }

  1062 

  1063 

  1064 // ---------------------------------------------------------------------------

  1065 // ---------------------------------------------------------------------------

  1066 // send a faked server-originated message with empty contents

  1067 //

  1068 void T_PresenceWatcherListManagement::SendSrvMsgL( TInt aMsgType )

  1069     {

  1070     // we'll use hard-coded wrapper 0 instance for now.

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

  1072 

  1073     // create a server-originated faked message with empty contents

  1074     RXIMPObjOwningPtrArray<CPresenceWatcherInfoImp> watcherList;

  1075 

  1076     HBufC8* packedArray = TXIMPObjectPacker<CPresenceWatcherInfoImp>::PackArrayL( watcherList );

  1077     CleanupStack::PushL( packedArray );

  1078 

  1079     // use filetool to send it for plugin.

  1080     CXIMPTestFileSrvMsg* srvMsg = CXIMPTestFileSrvMsg::NewL( aMsgType,

  1081             *packedArray );

  1082     CleanupStack::PushL( srvMsg );

  1083     wrapper->FileTool().CleanAllL();

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

  1085     CleanupStack::PopAndDestroy( 2 ); // srvMsg, packedArray

  1086     }

  1087 

  1088 // ---------------------------------------------------------------------------

  1089 // ---------------------------------------------------------------------------

  1090 // create a watcher list event with given arrays

  1091 //

  1092 CPresenceWatcherListEventImp* T_PresenceWatcherListManagement::CreateWatcherListEventLCX(

  1093         const TDesC& aUri,

  1094         const TDesC& aDispName,

  1095             MXIMPDataSubscriptionState::TSubscriptionState aSubscriptionState,

  1096             MXIMPDataSubscriptionState::TDataState aDataState,

  1097             TTestPWlOperation aOperation,

  1098             RPrWatLstInfoImpArray* aCurrentList)

  1099     {

  1100     // create the arrays

  1101 

  1102 

  1103     // new list

  1104     RPrWatLstInfoImpArray* newList = new ( ELeave ) RPrWatLstInfoImpArray;

  1105     CleanupDeletePushL( newList );

  1106 

  1107     // current list, created by caller

  1108     if(!aCurrentList) // if client didnt created the list

  1109         aCurrentList = new ( ELeave ) RPrWatLstInfoImpArray;

  1110     CleanupDeletePushL( aCurrentList );

  1111 

  1112     // disappeared list

  1113     RPrWatLstInfoImpArray* disappearedList = new ( ELeave ) RPrWatLstInfoImpArray;

  1114     CleanupDeletePushL( disappearedList );

  1115 

  1116     // create the watcher info

  1117     CPresenceWatcherInfoImp* watcherInfoForEvent1 = NULL; 

  1118             {

  1119             CXIMPIdentityImp* idForEvent = CXIMPIdentityImp::NewLC( aUri );

  1120             watcherInfoForEvent1 = CPresenceWatcherInfoImp::NewLC( (MPresenceWatcherInfo::TWatcherType)0, *idForEvent, aDispName );

  1121             CleanupStack::Pop( watcherInfoForEvent1 );        

  1122             CleanupStack::PopAndDestroy( idForEvent ); 

  1123             CleanupStack::PushL( watcherInfoForEvent1 );        

  1124             }

  1125     

  1126     CPresenceWatcherInfoImp* watcherInfoForEvent2 = 

  1127             TXIMPObjectCloner< CPresenceWatcherInfoImp >::CloneLC( *watcherInfoForEvent1 );

  1128     

  1129     TInt count(0);

  1130     TBool found(EFalse);

  1131     TInt i(0);

  1132     

  1133     // put the given watcher info into the specified array

  1134     switch ( aOperation )