1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: XIMP Framework Test Code 

    15 *

    16 */

    17 

    18 

    19 #include "eunittools.h"

    20 

    21 #include <eunitmacros.h>

    22 #include <ecom/ecom.h>

    23 #include <badesca.h>

    24 #include <e32std.h>

    25 

    26 #include <ximpclient.h>

    27 #include <ximpcontext.h>

    28 #include <ximpobjectfactory.h>

    29 #include <ximpcontextstateevent.h>

    30 #include <ximprequestcompleteevent.h>

    31 #include <ximpstatus.h>

    32 #include <presencefeatures.h>

    33 #include <presentitygroups.h>

    34 #include <presentitygroupmemberinfo.h>

    35 #include <presentitygroupcontentevent.h>

    36 

    37 

    38 #include "ximpeventcodec.h"

    39 

    40 #include "t_presencegroupmembermngt.h"

    41 #include "prfwteststatuseventlistener.h"

    42 #include "prfwtestmessaging.h"

    43 #include "prfwtestmessenger.h"

    44 #include "prfwtestlistener.h"

    45 #include "prfwtestcontextwrappermgr.h"

    46 #include "prfwtestcontextwrapper.h"

    47 #include "ximpcontextstateeventimp.h"

    48 #include "ximpcontextstateevent.h"

    49 

    50 #include "presenceinfoimp.h"

    51 #include "presenceinfofilterimp.h"

    52 #include "prfwtestpresencedatautils.h"

    53 #include "ximpidentityimp.h"

    54 #include "presentitygroupcontenteventimp.h"

    55 #include "ximprequestcompleteeventimp.h"

    56 #include "presentitygroupinfoimp.h"

    57 #include "presentitygrouplisteventimp.h"

    58 #include "presentitygroupmemberinfoimp.h"

    59 #include "ximprequestcompleteeventimp.h"

    60 #include "ximprestrictedobjectcollection.h"

    61 #include "ximpobjectfactoryimp.h"

    62 

    63 #include "prfwtestrobustnesstools.h"

    64 #include "ximpobjecthelpers.h"

    65 #include "prfwtestfilesrvmsg.h"

    66 #include "prfwtestfiletool.h"

    67 #include "prfwtestwaithelper.h"

    68 #include "prfwtesteventfactory.h"

    69 

    70 

    71 _LIT( KGroupId,   "wv:group/member@imps.com" );

    72 _LIT( KGroupId2,  "wv:group2/chutney@naan.com" );

    73 _LIT( KGroupDisplayName, "Salamapartio Z" );

    74 

    75 _LIT( KMemberId, "wv:member@imps.com" );

    76 _LIT( KMemberDisplayName,  "Stroustrup" );

    77 _LIT( KMemberDisplayName2, "Bjarne" );

    78 

    79 // ============================ MEMBER FUNCTIONS ===============================

    80 

    81 // CONSTRUCTION

    82 T_PresenceGroupMemberManagement* T_PresenceGroupMemberManagement::NewL()

    83     {

    84     T_PresenceGroupMemberManagement* self = new( ELeave ) T_PresenceGroupMemberManagement;

    85     CleanupStack::PushL( self );

    86     self->ConstructL();

    87     CleanupStack::Pop( self );

    88 

    89     return self;

    90     }

    91 

    92 T_PresenceGroupMemberManagement::~T_PresenceGroupMemberManagement()

    93     {

    94     delete iLastEvent;

    95 

    96     if ( iASWait && iASWait->IsStarted() )

    97         {

    98         iASWait->AsyncStop();

    99         }

   100     delete iASWait;

   101 

   102     delete iListener2;

   103 

   104     delete iCurrentGrId;

   105     }

   106 

   107 void T_PresenceGroupMemberManagement::ConstructL()

   108     {

   109     CEUnitTestSuiteClass::ConstructL();

   110     iASWait = new ( ELeave ) CActiveSchedulerWait();

   111     }

   112 

   113 

   114 T_PresenceGroupMemberManagement::T_PresenceGroupMemberManagement()

   115     {

   116     }

   117 

   118 // ===========================================================================

   119 // TEST CASE SETUP & TEARDOWN METHODS

   120 // ===========================================================================

   121 //

   122 

   123 void T_PresenceGroupMemberManagement::Setup_L()

   124     {

   125     PrfwTestRobustness::DoPreCleaning();

   126 

   127     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   128     iWrapperMgr->CreateWrapperL();

   129 

   130     // must reset these to EFalse

   131     iSkipSubscribe = EFalse;

   132     iSkipUnsubscribe = EFalse;

   133     }

   134 

   135 void T_PresenceGroupMemberManagement::SetupMultiple_L()

   136     {

   137     PrfwTestRobustness::DoPreCleaning();

   138 

   139     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   140     iWrapperMgr->CreateWrapperL();

   141     iWrapperMgr->CreateWrapperL();

   142     iWrapperMgr->CreateWrapperL();

   143 

   144     // must reset these to EFalse

   145     iSkipSubscribe = EFalse;

   146     iSkipUnsubscribe = EFalse;

   147     }

   148 

   149 // bind helper

   150 void T_PresenceGroupMemberManagement::BindAllL()

   151     {

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

   153         {

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

   155         wrapper->BindL( 0 );

   156         }

   157     }

   158 

   159 // unbind helper

   160 void T_PresenceGroupMemberManagement::UnbindAllL()

   161     {

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

   163         {

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

   165         wrapper->UnbindL();

   166         }

   167     }

   168 

   169 void T_PresenceGroupMemberManagement::TeardownTestSupport()

   170     {

   171     // anything NOT initialized by test case Setup method,

   172     // but initialized in the test case itself, goes here

   173     delete iCurrentGrId;

   174     iCurrentGrId = NULL;

   175 

   176     delete iListener2;

   177     iListener2 = NULL;

   178 

   179     delete iLastEvent;

   180     iLastEvent = NULL;

   181     }

   182 

   183 void T_PresenceGroupMemberManagement::Teardown()

   184     {

   185     TeardownTestSupport();

   186     // just in case to avoid memleaks. should not have anything to

   187     // delete anyway

   188 

   189     delete iWrapperMgr;

   190     iWrapperMgr = NULL;

   191 

   192     REComSession::FinalClose();

   193 

   194     // must reset these to EFalse

   195     iSkipSubscribe = EFalse;

   196     iSkipUnsubscribe = EFalse;

   197 

   198     // it's best to nuke the servers during exit too.

   199     PrfwTestRobustness::DoPreCleaning();

   200     }

   201 

   202 // ===========================================================================

   203 // TEST CASES for presentity presence subscription

   204 // ===========================================================================

   205 

   206 // General test case for single member

   207 void T_PresenceGroupMemberManagement::T_GenericSubAndUnsubL(

   208         TXIMPCallBack& aCbFuncL )

   209     {

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

   211     wrapper->BindL( 0 );

   212 

   213     // ------------------------------------------------------

   214     // some startup stuff

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

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

   217 

   218     // Get the interfaces

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

   220     MPresentityGroups& presGroup = presFeat->PresentityGroups();

   221 

   222     iListener2 = CXIMPTestListener::NewL( context );

   223     // ------------------------------------------------------

   224 

   225     // Tell the protocol it should act normally

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

   227 

   228     iCurrentGrId = context->ObjectFactory().NewIdentityLC();

   229     CleanupStack::Pop(); // iCurrentGrId

   230     iCurrentGrId->SetIdentityL( KGroupId );

   231 

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

   233     // create presentity group

   234     //

   235     // expect events:

   236     // - request complete.

   237     // NOTE: no presentitygrouplistevent as we've not subscribed the group lists

   238 

   239     // normal request complete

   240     TXIMPRequestId reqIdDummy;  // not checked

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

   242 

   243     // identity + displayname

   244     CPresentityGroupInfoImp* infoImp = CPresentityGroupInfoImp::NewLC( *iCurrentGrId, KGroupDisplayName );

   245     evReqComplete->AppendParamL( infoImp );

   246     CleanupStack::Pop( infoImp );

   247 

   248     iListener2->ExpectL( evReqComplete );

   249     CleanupStack::Pop( evReqComplete );

   250 

   251     TXIMPRequestId reqId = presGroup.CreatePresentityGroupL( *iCurrentGrId, KGroupDisplayName );

   252 

   253     // and wait

   254     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "CreatePresentityGroupL failed" );

   255     messenger->AssertCreatePresentityGroupCalled( ETrue );

   256 

   257     if ( ! iSkipSubscribe )

   258         {

   259         // ------------------------------------------------------

   260         // subscribe presentity group CONTENT

   261         //

   262         // expect events:

   263         // - request complete

   264         evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   265         iListener2->ExpectL( evReqComplete );

   266         CleanupStack::Pop( evReqComplete );

   267 

   268         // do the call

   269         reqId = presGroup.SubscribePresentityGroupContentL( *iCurrentGrId );

   270 

   271         // and wait

   272         EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "SubscribePresentityGroupContentL failed" );

   273 

   274         // verify that subscribe was called

   275         messenger->AssertSubscribePresentityGroupContentCalled( ETrue );

   276         }

   277 

   278     // ------------------------------------------------------

   279     // do the actual test. this is a function pointer because the

   280     // "red tape" of each test is similar (create group, subscribe content, do

   281     // actual test, unsubscribe content, delete group) - this is the variable

   282     // part, the "do actual test".

   283     (this->*aCbFuncL)();

   284 

   285     if ( ! iSkipUnsubscribe )

   286         {

   287         // ------------------------------------------------------

   288         // unsubscribe presentity group content

   289         //

   290         // expect events:

   291         // - request complete

   292         // - presentity group content event

   293 

   294         evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   295         iListener2->ExpectL( evReqComplete );

   296         CleanupStack::Pop( evReqComplete );

   297 

   298         CPresentityGroupContentEventImp* groupCntEvent =

   299             XIMPTestEventFactory::CreateGroupContentEventLCX(

   300                     KGroupId,

   301                     KNullDesC,

   302                     KNullDesC,

   303                     XIMPTestEventFactory::ETestPGLCntRemoved,

   304                     KNullDesC,

   305                     KNullDesC,

   306                     MXIMPDataSubscriptionState::ESubscriptionInactive,

   307                     MXIMPDataSubscriptionState::EDataUnavailable

   308                     );

   309 

   310         iListener2->ExpectL( groupCntEvent );

   311         CleanupStack::Pop( groupCntEvent ); // 5 more items in cleanupstack

   312 

   313         // do the call

   314         reqId = presGroup.UnsubscribePresentityGroupContentL( *iCurrentGrId );

   315 

   316         // and wait

   317         EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "UnsubscribePresentityGroupContentL failed" );

   318         CleanupStack::PopAndDestroy( 5 ); // lists

   319 

   320         // verify that unsubscribe was called

   321         messenger->AssertUnsubscribePresentityGroupContentCalled( ETrue );

   322         }

   323 

   324     // ------------------------------------------------------

   325     // delete presentity group

   326     //

   327     // expect events:

   328     // - request complete

   329     // NO presentity group content event as we've just unsubscribed it.

   330 

   331     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   332     iListener2->ExpectL( evReqComplete );

   333     CleanupStack::Pop( evReqComplete );

   334 

   335     // do the call

   336     reqId = presGroup.DeletePresentityGroupL( *iCurrentGrId );

   337 

   338     // and wait

   339     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "DeletePresentityGroupL failed" );

   340 

   341     // ------------------------------------------------------

   342 

   343     // make sure the new listener is not listening for events!

   344     iListener2->SetEventSourceL( NULL );

   345 

   346     wrapper->UnbindL();

   347 

   348     TeardownTestSupport();

   349     }

   350 

   351 // ===========================================================================

   352 // Variant methods, this is where the actual testing happens.

   353 // Called by the generic subscribe and unsubscribe -method

   354 // ===========================================================================

   355 

   356 // ------------------------------------------------------

   357 // empty test variant method

   358 // test only the creation, subscribe and unsubcscribe

   359 // ------------------------------------------------------

   360 //

   361 void T_PresenceGroupMemberManagement::T_EmptyFunc()

   362     {

   363     // nothing

   364     }

   365 

   366 // ------------------------------------------------------

   367 // test adding members

   368 // ------------------------------------------------------

   369 //

   370 void T_PresenceGroupMemberManagement::T_TestAddMembersL()

   371     {

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

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

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

   375 

   376     // Get the interfaces

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

   378     MPresentityGroups& presGroup = presFeat->PresentityGroups();

   379 

   380     // Tell the protocol it should act normally

   381     messenger->SetNoError();

   382 

   383     // ------------------------------------------------------

   384     // add presentity group member

   385     //

   386     // expect events:

   387     // - request complete,

   388     // - presentitygroupcontentevent

   389 

   390     MXIMPIdentity* member = context->ObjectFactory().NewIdentityLC();

   391     member->SetIdentityL( KMemberId );

   392 

   393     // normal request complete

   394     TXIMPRequestId reqIdDummy;  // not checked

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

   396 

   397     // group id

   398     CXIMPIdentityImp* identity = CXIMPIdentityImp::NewLC( iCurrentGrId->Identity() );

   399     evReqComplete->AppendParamL( identity );

   400     CleanupStack::Pop(); // identity

   401 

   402     // id for member info

   403     CXIMPIdentityImp* miId = CXIMPIdentityImp::NewLC( KMemberId );

   404     // member info

   405     CPresentityGroupMemberInfoImp* memInfoImp =

   406         CPresentityGroupMemberInfoImp::NewLC( *miId, KMemberDisplayName );

   407     evReqComplete->AppendParamL( memInfoImp );

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

   409     CleanupStack::PopAndDestroy( miId ); // copy was made

   410 

   411     iListener2->ExpectL( evReqComplete );

   412     CleanupStack::Pop( evReqComplete );

   413 

   414     // group content event

   415     CPresentityGroupContentEventImp* groupCntEvent =

   416         XIMPTestEventFactory::CreateGroupContentEventLCX(

   417                 iCurrentGrId->Identity(),

   418                 KMemberId,

   419                 KMemberDisplayName,

   420                 XIMPTestEventFactory::ETestPGLCntAdded,

   421                 KMemberId,

   422                 KMemberDisplayName,

   423                 MXIMPDataSubscriptionState::ESubscriptionActive,

   424                 MXIMPDataSubscriptionState::EDataAvailable

   425                 );

   426 

   427     iListener2->ExpectL( groupCntEvent );

   428     CleanupStack::Pop( groupCntEvent ); // 5 more items in cleanupstack

   429 

   430     // do the call

   431     TXIMPRequestId reqId = presGroup.AddPresentityGroupMemberL(

   432             *iCurrentGrId, *member, KMemberDisplayName );

   433 

   434     // and wait

   435     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "AddPresentityGroupMemberL failed" );

   436     CleanupStack::PopAndDestroy( 5 ); // lists from groupCntEvent

   437 

   438     messenger->AssertAddPresentityGroupMemberCalled( ETrue );

   439 

   440     // ------------------------------------------------------

   441     CleanupStack::PopAndDestroy(); // member

   442     }

   443 

   444 // ------------------------------------------------------

   445 // test adding members when not subscribed

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

   447 //

   448 void T_PresenceGroupMemberManagement::T_TestAddMembers_NonSub_L()

   449     {

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

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

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

   453 

   454     // Get the interfaces

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

   456     MPresentityGroups& presGroup = presFeat->PresentityGroups();

   457 

   458     // Tell the protocol it should act normally

   459     messenger->SetNoError();

   460 

   461     // ------------------------------------------------------

   462     // add presentity group member

   463     //

   464     // expect events:

   465     // - request complete,

   466 

   467     MXIMPIdentity* member = context->ObjectFactory().NewIdentityLC();

   468     member->SetIdentityL( KMemberId );

   469 

   470     // normal request complete

   471     TXIMPRequestId reqIdDummy;  // not checked

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

   473 

   474     // group id

   475     CXIMPIdentityImp* identity = CXIMPIdentityImp::NewLC( iCurrentGrId->Identity() );

   476     evReqComplete->AppendParamL( identity );

   477     CleanupStack::Pop(); // identity

   478 

   479     // id for member info

   480     CXIMPIdentityImp* miId = CXIMPIdentityImp::NewLC( KMemberId );

   481     // member info

   482     CPresentityGroupMemberInfoImp* memInfoImp =

   483         CPresentityGroupMemberInfoImp::NewLC( *miId, KMemberDisplayName );

   484     evReqComplete->AppendParamL( memInfoImp );

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

   486     CleanupStack::PopAndDestroy( miId ); // copy was made

   487 

   488     iListener2->ExpectL( evReqComplete );

   489     CleanupStack::Pop( evReqComplete );

   490 

   491     // do the call

   492     TXIMPRequestId reqId = presGroup.AddPresentityGroupMemberL(

   493             *iCurrentGrId, *member, KMemberDisplayName );

   494 

   495     // and wait

   496     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "AddPresentityGroupMemberL failed" );

   497 

   498     messenger->AssertAddPresentityGroupMemberCalled( ETrue );

   499 

   500     // ------------------------------------------------------

   501     CleanupStack::PopAndDestroy(); // member

   502     }

   503 

   504 // ------------------------------------------------------

   505 // test removing members

   506 // ------------------------------------------------------

   507 //

   508 void T_PresenceGroupMemberManagement::T_TestRemoveMembersL()

   509     {

   510     // add a member

   511     T_TestAddMembersL();

   512 

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

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

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

   516 

   517     // Get the interfaces

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

   519     MPresentityGroups& presGroup = presFeat->PresentityGroups();

   520 

   521     // Tell the protocol it should act normally

   522     messenger->SetNoError();

   523 

   524     // ------------------------------------------------------

   525     // remove presentity group member

   526     //

   527     // expect events:

   528     // - request complete,

   529     // - presentitygroupcontentevent

   530 

   531     MXIMPIdentity* member = context->ObjectFactory().NewIdentityLC();

   532     member->SetIdentityL( KMemberId );

   533 

   534     // normal request complete

   535     TXIMPRequestId reqIdDummy;  // not checked

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

   537     iListener2->ExpectL( evReqComplete );

   538     CleanupStack::Pop( evReqComplete );

   539 

   540     // group content event

   541     CPresentityGroupContentEventImp* groupCntEvent =

   542         XIMPTestEventFactory::CreateGroupContentEventLCX(

   543                 iCurrentGrId->Identity(),

   544                 KMemberId,

   545                 KNullDesC,

   546                 XIMPTestEventFactory::ETestPGLCntRemoved,

   547                 KNullDesC,

   548                 KNullDesC,

   549                 MXIMPDataSubscriptionState::ESubscriptionActive,

   550                 MXIMPDataSubscriptionState::EDataAvailable

   551                 );

   552 

   553     iListener2->ExpectL( groupCntEvent );

   554     CleanupStack::Pop( groupCntEvent ); // 5 more items in cleanupstack

   555 

   556     // do the call

   557     TXIMPRequestId reqId = presGroup.RemovePresentityGroupMemberL(

   558             *iCurrentGrId, *member );

   559 

   560     // and wait

   561     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "RemovePresentityGroupMemberL failed" );

   562     CleanupStack::PopAndDestroy( 5 ); // lists from groupCntEvent

   563 

   564     messenger->AssertRemovePresentityGroupMemberCalled( ETrue );

   565 

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

   567     CleanupStack::PopAndDestroy(); //member

   568     }

   569 

   570 // ------------------------------------------------------

   571 // test removing members when non-subscribed

   572 // ------------------------------------------------------

   573 //

   574 void T_PresenceGroupMemberManagement::T_TestRemoveMembers_NonSub_L()

   575     {

   576     // add a member

   577     T_TestAddMembers_NonSub_L();

   578 

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

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

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

   582 

   583     // Get the interfaces

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

   585     MPresentityGroups& presGroup = presFeat->PresentityGroups();

   586 

   587     // Tell the protocol it should act normally

   588     messenger->SetNoError();

   589 

   590     // ------------------------------------------------------

   591     // remove presentity group member

   592     //

   593     // expect events:

   594     // - request complete,

   595     // - presentitygroupcontentevent

   596 

   597     MXIMPIdentity* member = context->ObjectFactory().NewIdentityLC();

   598     member->SetIdentityL( KMemberId );

   599 

   600     // normal request complete

   601     TXIMPRequestId reqIdDummy;  // not checked

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

   603     iListener2->ExpectL( evReqComplete );

   604     CleanupStack::Pop( evReqComplete );

   605 

   606     // do the call

   607     TXIMPRequestId reqId = presGroup.RemovePresentityGroupMemberL(

   608             *iCurrentGrId, *member );

   609 

   610     // and wait

   611     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "RemovePresentityGroupMemberL failed" );

   612 

   613     messenger->AssertRemovePresentityGroupMemberCalled( ETrue );

   614 

   615     // ------------------------------------------------------

   616     CleanupStack::PopAndDestroy(); //member

   617     }

   618 

   619 // test removing nonexisting members

   620 void T_PresenceGroupMemberManagement::T_TestRemoveMembers_NonExisting_L()

   621     {

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

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

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

   625 

   626     // Get the interfaces

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

   628     MPresentityGroups& presGroup = presFeat->PresentityGroups();

   629 

   630     // Tell the protocol it should act normally

   631     messenger->SetNoError();

   632 

   633     // ------------------------------------------------------

   634     // remove presentity group member

   635     //

   636     // expect events:

   637     // - request complete,

   638 

   639     MXIMPIdentity* member = context->ObjectFactory().NewIdentityLC();

   640     member->SetIdentityL( KMemberId );

   641 

   642     // normal request complete

   643     TXIMPRequestId reqIdDummy;  // not checked

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

   645     iListener2->ExpectL( evReqComplete );

   646     CleanupStack::Pop( evReqComplete );

   647 

   648     // do the call

   649     TXIMPRequestId reqId = presGroup.RemovePresentityGroupMemberL(

   650             *iCurrentGrId, *member );

   651 

   652     // and wait

   653     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "RemovePresentityGroupMemberL failed" );

   654 

   655     messenger->AssertRemovePresentityGroupMemberCalled( ETrue );

   656 

   657     // ------------------------------------------------------

   658     CleanupStack::PopAndDestroy(); //member

   659     }

   660 

   661 // ------------------------------------------------------

   662 // test updating members

   663 // ------------------------------------------------------

   664 //

   665 void T_PresenceGroupMemberManagement::T_TestUpdateMembers_L()

   666     {

   667     // add a member

   668     T_TestAddMembersL();

   669 

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

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

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

   673 

   674     // Get the interfaces

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

   676     MPresentityGroups& presGroup = presFeat->PresentityGroups();

   677 

   678     // Tell the protocol it should act normally

   679     messenger->SetNoError();

   680 

   681     // ------------------------------------------------------

   682     // update presentity group member

   683     //

   684     // expect events:

   685     // - request complete,

   686     // - presentitygroupcontentevent

   687 

   688     MXIMPIdentity* member = context->ObjectFactory().NewIdentityLC();

   689     member->SetIdentityL( KMemberId );

   690 

   691     // group content request complete

   692     TXIMPRequestId reqIdDummy;  // not checked

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

   694     CXIMPIdentityImp* identity = CXIMPIdentityImp::NewLC( iCurrentGrId->Identity() );

   695     evReqComplete->AppendParamL( identity );

   696     CleanupStack::Pop( identity );

   697 

   698     CPresentityGroupMemberInfoImp* mbrInfo = CPresentityGroupMemberInfoImp::NewLC( *member, KMemberDisplayName2 );

   699     evReqComplete->AppendParamL( mbrInfo );

   700     CleanupStack::Pop( mbrInfo );

   701 

   702     iListener2->ExpectL( evReqComplete );

   703     CleanupStack::Pop( evReqComplete );

   704 

   705     // group content event

   706     CPresentityGroupContentEventImp* groupCntEvent =

   707         XIMPTestEventFactory::CreateGroupContentEventLCX(

   708                 iCurrentGrId->Identity(),

   709                 KMemberId,

   710                 KMemberDisplayName2,

   711                 XIMPTestEventFactory::ETestPGLCntUpdated,

   712                 KMemberId,

   713                 KMemberDisplayName2,

   714                 MXIMPDataSubscriptionState::ESubscriptionActive,

   715                 MXIMPDataSubscriptionState::EDataAvailable

   716                 );

   717 

   718     iListener2->ExpectL( groupCntEvent );

   719     CleanupStack::Pop( groupCntEvent ); // 5 more items in cleanupstack

   720 

   721     // do the call

   722     TXIMPRequestId reqId = presGroup.UpdatePresentityGroupMemberDisplayNameL(

   723             *iCurrentGrId, *member, KMemberDisplayName2 );

   724 

   725     // and wait

   726     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "UpdatePresentityGroupMemberDisplayNameL failed" );

   727     CleanupStack::PopAndDestroy( 5 ); // lists from groupCntEvent

   728 

   729     messenger->AssertUpdatePresentityGroupMemberDisplayNameCalled( ETrue );

   730 

   731     // ------------------------------------------------------

   732     CleanupStack::PopAndDestroy();

   733     }

   734 

   735 // ------------------------------------------------------

   736 // test updating members (nonsubscribed)

   737 // ------------------------------------------------------

   738 //

   739 void T_PresenceGroupMemberManagement::T_TestUpdateMembers_NonSub_L()

   740     {

   741     // add a member

   742     T_TestAddMembers_NonSub_L();

   743 

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

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

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

   747 

   748     // Get the interfaces

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

   750     MPresentityGroups& presGroup = presFeat->PresentityGroups();

   751 

   752     // Tell the protocol it should act normally

   753     messenger->SetNoError();

   754 

   755     // ------------------------------------------------------

   756     // update presentity group member

   757     //

   758     // expect events:

   759     // - request complete,

   760 

   761     MXIMPIdentity* member = context->ObjectFactory().NewIdentityLC();

   762     member->SetIdentityL( KMemberId );

   763 

   764     // group content request complete

   765     TXIMPRequestId reqIdDummy;  // not checked

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

   767     CXIMPIdentityImp* identity = CXIMPIdentityImp::NewLC( iCurrentGrId->Identity() );

   768     evReqComplete->AppendParamL( identity );

   769     CleanupStack::Pop( identity );

   770 

   771     CPresentityGroupMemberInfoImp* mbrInfo = CPresentityGroupMemberInfoImp::NewLC( *member, KMemberDisplayName2 );

   772     evReqComplete->AppendParamL( mbrInfo );

   773     CleanupStack::Pop( mbrInfo );

   774 

   775     iListener2->ExpectL( evReqComplete );

   776     CleanupStack::Pop( evReqComplete );

   777 

   778     // do the call

   779     TXIMPRequestId reqId = presGroup.UpdatePresentityGroupMemberDisplayNameL(

   780             *iCurrentGrId, *member, KMemberDisplayName2 );

   781 

   782     // and wait

   783     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "UpdatePresentityGroupMemberDisplayNameL failed" );

   784 

   785     messenger->AssertUpdatePresentityGroupMemberDisplayNameCalled( ETrue );

   786 

   787     // ------------------------------------------------------

   788     CleanupStack::PopAndDestroy();

   789     }

   790 

   791 // ------------------------------------------------------

   792 // test updating members with non-existing id

   793 // ------------------------------------------------------

   794 //

   795 void T_PresenceGroupMemberManagement::T_TestUpdateMembers_NonExisting_L()

   796     {

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

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

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

   800 

   801     // Get the interfaces

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

   803     MPresentityGroups& presGroup = presFeat->PresentityGroups();

   804     

   805     // Tell the protocol it should act normally

   806     messenger->SetNoError();

   807 

   808     // ------------------------------------------------------

   809     // update presentity group member

   810     //

   811     // expect events:

   812     // - request complete,

   813 

   814     MXIMPIdentity* member = context->ObjectFactory().NewIdentityLC();

   815     member->SetIdentityL( KMemberId );

   816 

   817     // group content request complete

   818     TXIMPRequestId reqIdDummy;  // not checked

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

   820     CXIMPIdentityImp* identity = CXIMPIdentityImp::NewLC( iCurrentGrId->Identity() );

   821     evReqComplete->AppendParamL( identity );

   822     CleanupStack::Pop( identity );

   823 

   824     CPresentityGroupMemberInfoImp* mbrInfo = CPresentityGroupMemberInfoImp::NewLC( *member, KMemberDisplayName2 );

   825     evReqComplete->AppendParamL( mbrInfo );

   826     CleanupStack::Pop( mbrInfo );

   827 

   828     iListener2->ExpectL( evReqComplete );

   829     CleanupStack::Pop( evReqComplete );

   830 

   831     // do the call

   832     TXIMPRequestId reqId = presGroup.UpdatePresentityGroupMemberDisplayNameL(

   833             *iCurrentGrId, *member, KMemberDisplayName2 );

   834 

   835     // and wait

   836     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "UpdatePresentityGroupMemberDisplayNameL failed" );

   837 

   838     messenger->AssertUpdatePresentityGroupMemberDisplayNameCalled( ETrue );

   839 

   840     // ------------------------------------------------------

   841     CleanupStack::PopAndDestroy();

   842     }

   843 

   844 // ===========================================================================

   845 // Test case methods

   846 // ===========================================================================

   847 

   848 // Subscribe and unsubscribe test

   849 void T_PresenceGroupMemberManagement::T_SubUnsubGroupContent_Single_L()

   850     {

   851     EUNIT_PRINT( _L("Single presentity group content sub and unsub") );

   852 

   853     TXIMPCallBack callback = &T_PresenceGroupMemberManagement::T_EmptyFunc;

   854     T_GenericSubAndUnsubL( callback );

   855     }

   856 

   857 // subscribe and unsubscribe, altered id

   858 void T_PresenceGroupMemberManagement::T_SubUnsubGroupContent_Altered_Single_L()

   859     {

   860     EUNIT_PRINT( _L("Single presentity group content sub and unsub with altered id") );

   861 

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

   863     wrapper->BindL( 0 );

   864 

   865     // ------------------------------------------------------

   866     // some startup stuff

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

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

   869 

   870     // Get the interfaces

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

   872     MPresentityGroups& presGroup = presFeat->PresentityGroups();

   873 

   874     iListener2 = CXIMPTestListener::NewL( context );

   875     // ------------------------------------------------------

   876 

   877     // Tell the protocol it should act normally

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

   879 

   880     iCurrentGrId = context->ObjectFactory().NewIdentityLC();

   881     CleanupStack::Pop(); // iCurrentGrId

   882     iCurrentGrId->SetIdentityL( KGroupId );

   883 

   884     // ------------------------------------------------------

   885     // create presentity group

   886     //

   887     // expect events:

   888     // - request complete.

   889     // NOTE: no presentitygrouplistevent as we've not subscribed the group lists

   890 

   891     // normal request complete

   892     TXIMPRequestId reqIdDummy;  // not checked

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

   894 

   895     // identity + displayname

   896     CPresentityGroupInfoImp* infoImp = CPresentityGroupInfoImp::NewLC( *iCurrentGrId, KGroupDisplayName );

   897     evReqComplete->AppendParamL( infoImp );

   898     CleanupStack::Pop( infoImp );

   899 

   900     iListener2->ExpectL( evReqComplete );

   901     CleanupStack::Pop( evReqComplete );

   902 

   903     TXIMPRequestId reqId = presGroup.CreatePresentityGroupL( *iCurrentGrId, KGroupDisplayName );

   904 

   905     // and wait

   906     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "CreatePresentityGroupL failed" );

   907     messenger->AssertCreatePresentityGroupCalled( ETrue );

   908 

   909     // ------------------------------------------------------

   910     // subscribe presentity group CONTENT

   911     //

   912     // expect events:

   913     // - request complete

   914     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   915     iListener2->ExpectL( evReqComplete );

   916     CleanupStack::Pop( evReqComplete );

   917 

   918     // tell the test protocol to send back an altered id

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

   920     identityParam->SetIdentityL( KGroupId2 );

   921 

   922     CXIMPIdentityImp* identityParamImp =

   923              ( CXIMPIdentityImp* ) identityParam->GetInterface(

   924                                         CXIMPIdentityImp::KClassId,

   925                                         MXIMPBase::EPanicIfUnknown );

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

   927     CleanupStack::PopAndDestroy(); // identityParam

   928     CleanupStack::PushL( packedId );

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

   930                                                              *packedId );

   931     CleanupStack::PopAndDestroy( packedId );

   932     CleanupStack::PushL( srvMsg );

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

   934     CleanupStack::PopAndDestroy( srvMsg );

   935 

   936     // Wait for server to handle srvmsg.

   937     User::After( 2 );

   938     // now the adaptation should know how to answer

   939 

   940     // do the call

   941     reqId = presGroup.SubscribePresentityGroupContentL( *iCurrentGrId );

   942 

   943     // and wait

   944     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "SubscribePresentityGroupContentL failed" );

   945 

   946     // verify that subscribe was called

   947     messenger->AssertSubscribePresentityGroupContentCalled( ETrue );

   948 

   949     // ------------------------------------------------------

   950 

   951     // make sure the new listener is not listening for events!

   952     iListener2->SetEventSourceL( NULL );

   953 

   954     wrapper->UnbindL();

   955 

   956     TeardownTestSupport();

   957     }

   958 

   959 // subscribe and unsubscribe, altered id is the same

   960 void T_PresenceGroupMemberManagement::T_SubUnsubGroupContent_AlteredSame_Single_L()

   961     {

   962     EUNIT_PRINT( _L("Single presentity group content sub and unsub with altered but same id") );

   963 

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

   965     wrapper->BindL( 0 );

   966 

   967     // ------------------------------------------------------

   968     // some startup stuff

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

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

   971 

   972     // Get the interfaces

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

   974     MPresentityGroups& presGroup = presFeat->PresentityGroups();

   975 

   976     iListener2 = CXIMPTestListener::NewL( context );

   977     // ------------------------------------------------------

   978 

   979     // Tell the protocol it should act normally

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

   981 

   982     iCurrentGrId = context->ObjectFactory().NewIdentityLC();

   983     CleanupStack::Pop(); // iCurrentGrId

   984     iCurrentGrId->SetIdentityL( KGroupId );

   985 

   986     // ------------------------------------------------------

   987     // create presentity group

   988     //

   989     // expect events:

   990     // - request complete.

   991     // NOTE: no presentitygrouplistevent as we've not subscribed the group lists

   992 

   993     // normal request complete

   994     TXIMPRequestId reqIdDummy;  // not checked

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

   996 

   997     // identity + displayname

   998     CPresentityGroupInfoImp* infoImp = CPresentityGroupInfoImp::NewLC( *iCurrentGrId, KGroupDisplayName );

   999     evReqComplete->AppendParamL( infoImp );

  1000     CleanupStack::Pop( infoImp );

  1001 

  1002     iListener2->ExpectL( evReqComplete );

  1003     CleanupStack::Pop( evReqComplete );

  1004 

  1005     TXIMPRequestId reqId = presGroup.CreatePresentityGroupL( *iCurrentGrId, KGroupDisplayName );

  1006 

  1007     // and wait

  1008     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "CreatePresentityGroupL failed" );

  1009     messenger->AssertCreatePresentityGroupCalled( ETrue );

  1010 

  1011     // ------------------------------------------------------

  1012     // subscribe presentity group CONTENT

  1013     //

  1014     // expect events:

  1015     // - request complete

  1016     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

  1017     iListener2->ExpectL( evReqComplete );

  1018     CleanupStack::Pop( evReqComplete );

  1019 

  1020     // tell the test protocol to send back an altered id

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

  1022     identityParam->SetIdentityL( KGroupId );

  1023 

  1024     CXIMPIdentityImp* identityParamImp =

  1025              ( CXIMPIdentityImp* ) identityParam->GetInterface(

  1026                                         CXIMPIdentityImp::KClassId,

  1027                                         MXIMPBase::EPanicIfUnknown );

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

  1029     CleanupStack::PopAndDestroy(); // identityParam

  1030     CleanupStack::PushL( packedId );

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

  1032                                                              *packedId );

  1033     CleanupStack::PopAndDestroy( packedId );

  1034     CleanupStack::PushL( srvMsg );

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

  1036     CleanupStack::PopAndDestroy( srvMsg );

  1037 

  1038     // Wait for server to handle srvmsg.

  1039     User::After( 2 );

  1040     // now the adaptation should know how to answer

  1041 

  1042     // do the call

  1043     reqId = presGroup.SubscribePresentityGroupContentL( *iCurrentGrId );

  1044 

  1045     // and wait

  1046     EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "SubscribePresentityGroupContentL failed" );

  1047 

  1048     // verify that subscribe was called

  1049     messenger->AssertSubscribePresentityGroupContentCalled( ETrue );

  1050 

  1051     // ------------------------------------------------------

  1052 

  1053     // make sure the new listener is not listening for events!

  1054     iListener2->SetEventSourceL( NULL );

  1055 

  1056     wrapper->UnbindL();

  1057 

  1058     TeardownTestSupport();

  1059     }

  1060 

  1061 

  1062 // Add members

  1063 void T_PresenceGroupMemberManagement::T_AddGroupMembers_Single_L()

  1064     {

  1065     EUNIT_PRINT( _L("Single add members to group") );

  1066 

  1067     TXIMPCallBack callback = &T_PresenceGroupMemberManagement::T_TestAddMembersL;

  1068     T_GenericSubAndUnsubL( callback );

  1069     }

  1070 

  1071 // Remove members

  1072 void T_PresenceGroupMemberManagement::T_RemoveGroupMembers_Single_L()

  1073     {

  1074     EUNIT_PRINT( _L("Single remove member of group") );

  1075 

  1076     TXIMPCallBack callback = &T_PresenceGroupMemberManagement::T_TestRemoveMembersL;

  1077     T_GenericSubAndUnsubL( callback );

  1078     }

  1079 

  1080 // Update members

  1081 void T_PresenceGroupMemberManagement::T_UpdateGroupMembers_Single_L()

  1082     {

  1083     EUNIT_PRINT( _L("Single update member of group") );

  1084 

  1085     TXIMPCallBack callback = &T_PresenceGroupMemberManagement::T_TestUpdateMembers_L;

  1086     T_GenericSubAndUnsubL( callback );

  1087     }

  1088 

  1089 // Update members without subscription

  1090 void T_PresenceGroupMemberManagement::T_UpdateGroupMembers_NonSub_Single_L()

  1091     {

  1092     EUNIT_PRINT( _L("Single update member of group, unsubscribed") );

  1093 

  1094     TXIMPCallBack callback = &T_PresenceGroupMemberManagement::T_TestUpdateMembers_NonSub_L;

  1095     iSkipSubscribe = ETrue;

  1096     iSkipUnsubscribe = ETrue;

  1097     T_GenericSubAndUnsubL( callback );

  1098     }

  1099 

  1100 // Update members with non-existing member

  1101 void T_PresenceGroupMemberManagement::T_UpdateGroupMembers_NonExist_Single_L()

  1102     {

  1103     EUNIT_PRINT( _L("Single update nonexisting member of group") );

  1104 

  1105     TXIMPCallBack callback = &T_PresenceGroupMemberManagement::T_TestUpdateMembers_NonExisting_L;

  1106     T_GenericSubAndUnsubL( callback );

  1107     }

  1108 

  1109 // Remove members without subscription

  1110 void T_PresenceGroupMemberManagement::T_RemoveGroupMembers_NonSub_Single_L()

  1111     {

  1112     EUNIT_PRINT( _L("Single remove member of group, unsubscribed") );

  1113 

  1114     TXIMPCallBack callback = &T_PresenceGroupMemberManagement::T_TestRemoveMembers_NonSub_L;

  1115     iSkipSubscribe = ETrue;

  1116     iSkipUnsubscribe = ETrue;

  1117     T_GenericSubAndUnsubL( callback );

  1118     }

  1119 

  1120 // Remove members with non-existing member

  1121 void T_PresenceGroupMemberManagement::T_RemoveGroupMembers_NonExist_Single_L()

  1122     {

  1123     EUNIT_PRINT( _L("Single remove nonexisting member of group") );

  1124 

  1125     TXIMPCallBack callback = &T_PresenceGroupMemberManagement::T_TestRemoveMembers_NonExisting_L;

  1126     T_GenericSubAndUnsubL( callback );

  1127     }

  1128 

  1129 // ------------------------------------------------------

  1130 // expire non-subscribed data

  1131 // ------------------------------------------------------

  1132 //

  1133 void T_PresenceGroupMemberManagement::T_ExpireNonSubscribedData_L()

  1134     {