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 

    25 #include <ximpbase.h>

    26 #include <ximpclient.h>

    27 #include <ximpcontext.h>

    28 #include <ximpcontextstateevent.h>

    29 #include <ximprequestcompleteevent.h>

    30 #include <ximpstatus.h>

    31 #include <presencefeatures.h>

    32 #include <presencewatching.h>

    33 #include <presencepublishing.h>

    34 #include <presentitypresenceevent.h>

    35 #include <ximpobjectfactory.h>

    36 

    37 #include <presentitygroups.h>

    38 #include <presentitygroupinfo.h>

    39 #include <presentitygrouplistevent.h>

    40 

    41 

    42 #include <presentitygroups.h>

    43 #include <presentitygroupmemberinfo.h>

    44 #include <presentitygroupcontentevent.h>

    45 

    46 #include <presenceauthorization.h>

    47 #include <presenceblocklistevent.h>

    48 #include <presenceblockinfo.h>

    49 

    50 #include "t_presenceall.h"

    51 #include "prfwteststatuseventlistener.h"

    52 #include "prfwtestmessaging.h"

    53 #include "prfwtestmessenger.h"

    54 #include "prfwtestcontextwrappermgr.h"

    55 #include "prfwtestcontextwrapper.h"

    56 

    57 #include "presenceinfoimp.h"

    58 #include "presenceinfofilterimp.h"

    59 #include "prfwtestpresencedatautils.h"

    60 #include "ximpidentityimp.h"

    61 #include "presentitygroupmemberinfoimp.h"

    62 #include "ximpobjecthelpers.h"

    63 #include "prfwtestfilesrvmsg.h"

    64 #include "prfwtestwaithelper.h"

    65 #include "prfwtestlistener.h"

    66 

    67 

    68 #include "presentitygroupcontenteventimp.h"

    69 #include "ximprequestcompleteeventimp.h"

    70 #include "presentitygroupinfoimp.h"

    71 #include "presentitygrouplisteventimp.h"

    72 #include "presentitygroupmemberinfoimp.h"

    73 #include "ximprequestcompleteeventimp.h"

    74 #include "ximprestrictedobjectcollection.h"

    75 #include "ximpobjectfactoryimp.h"

    76 

    77 #include "prfwtesteventfactory.h"

    78 

    79 #include "prfwtestpresencedatautils.h"

    80 

    81 #include "ximpobjecthelpers.h"

    82 #include "presentitygroupinfoimp.h"

    83 #include "presentitygrouplisteventimp.h"

    84 #include "presentitygroupcontenteventimp.h"

    85 

    86 #include "prfwtestfiletool.h"

    87 

    88 

    89 #include "prfwtestrobustnesstools.h"

    90 

    91 _LIT8( KPrefix1, "PreA_" );

    92 _LIT8( KPrefix2, "PreB_" );

    93 _LIT8( KPrefix3, "PreC_" );

    94 _LIT8( KPrefix4, "PreD_" );

    95 

    96 _LIT( KPrefix5, "PreXX_" );

    97 _LIT( KPrefix6, "PreYY_" );

    98 

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

   100 

   101 

   102 _LIT( KMemberId1, "tel:user1@foo.bar" );

   103 _LIT( KMemberDisplayName1,  "user1" );

   104 

   105 _LIT( KMemberId2, "tel:user2@foo.bar" );

   106 _LIT( KMemberDisplayName2,  "user2" );

   107 

   108 _LIT( KGroupId, "PrsDemoGrp" );

   109 _LIT( KGroupDisplayName,  "demo group" );

   110 

   111 

   112 

   113 // ============================ MEMBER FUNCTIONS ===============================

   114 

   115 // CONSTRUCTION

   116 T_PresenceAll* T_PresenceAll::NewL()

   117     {

   118     T_PresenceAll* self = new( ELeave ) T_PresenceAll;

   119     CleanupStack::PushL( self );

   120     self->ConstructL();

   121     CleanupStack::Pop( self );

   122 

   123     return self;

   124     }

   125 

   126 

   127 T_PresenceAll::~T_PresenceAll()

   128     {

   129     }

   130 

   131 

   132 void T_PresenceAll::ConstructL()

   133     {

   134     CEUnitTestSuiteClass::ConstructL();

   135     }

   136 

   137 

   138 T_PresenceAll::T_PresenceAll()

   139     {

   140     }

   141 

   142 

   143 

   144 // ===========================================================================

   145 // TEST CASE SETUP & TEARDOWN METHODS

   146 // ===========================================================================

   147 //

   148 

   149 void T_PresenceAll::Setup_L()

   150     {

   151     __UHEAP_MARK;

   152     PrfwTestRobustness::DoPreCleaning();

   153 

   154     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   155     iWrapperMgr->CreateWrapperL();

   156     }

   157 

   158 void T_PresenceAll::SetupMultiple_L()

   159     {

   160     PrfwTestRobustness::DoPreCleaning();

   161 

   162     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   163     iWrapperMgr->CreateWrapperL();

   164     iWrapperMgr->CreateWrapperL();

   165     iWrapperMgr->CreateWrapperL();

   166     }

   167 

   168 

   169 void T_PresenceAll::BindL()

   170     {

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

   172 

   173     wrapper0->BindL( 0 );

   174     }

   175 

   176 void T_PresenceAll::BindAllL()

   177     {

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

   179         {

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

   181         wrapper->BindL( 0 );

   182         }

   183     }

   184 

   185 

   186 void T_PresenceAll::Teardown()

   187     {

   188     delete iWrapperMgr;

   189     iWrapperMgr = NULL;

   190 

   191     REComSession::FinalClose();

   192 

   193     PrfwTestRobustness::DoPreCleaning();

   194     User::SetJustInTime( ETrue );

   195     __UHEAP_MARKEND;

   196     }

   197 

   198 void T_PresenceAll::UnbindL()

   199     {

   200     // Do unbind

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

   202     wrapper0->UnbindL();

   203     }

   204 

   205 void T_PresenceAll::UnbindAllL()

   206     {

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

   208         {

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

   210         wrapper->UnbindL();

   211         }

   212     }

   213 

   214 

   215 // ===========================================================================

   216 // TEST CASES for presentity presence subscription

   217 // ===========================================================================

   218 

   219 // Jani

   220 void T_PresenceAll::T_TMO_demo_Startup_L()

   221     {

   222     EUNIT_PRINT( _L("T_TMO_demo_Startup_L") );

   223 

   224     BindL();

   225 

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

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

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

   229 

   230     // Tell the protocol it should act normally

   231     messenger->SetNoError();

   232     

   233         

   234     // Get the interfaces

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

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

   237     MPresenceAuthorization& presAuth = presFeat->PresenceAuthorization();

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

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

   240     

   241     

   242     

   243     //////////////////////////////////////////////////////////////////////////

   244     // SUBSCRIBE OWN PRESENCE

   245     //////////////////////////////////////////////////////////////////////////

   246 

   247     // Create own presence info filter

   248     CPresenceInfoFilterImp* ownPif = CPresenceInfoFilterImp::NewLC(); // << ownPif

   249     ownPif->AcceptPersonFilterL( NPresenceInfo::NFieldType::KAcceptAll );

   250     //ownPif->AcceptPersonFilterL( NPresenceInfo::NFieldType::KStatusMessage );

   251     //ownPif->AcceptPersonFilterL( NPresenceInfo::NFieldType::KAvatar );

   252 

   253     // Setup status event listener for RequestComplete

   254     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   255 

   256     // subscribe own presence

   257     TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *ownPif );

   258     

   259     // Wait for events on the request

   260     wrapper->WaitRequestAndStackEvents( reqId );

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

   262 

   263     // verify that SubscribeOwnPresenceL was called

   264     COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", ETrue, NULL );

   265     

   266     //////////////////////////////////////////////////////////////////////////

   267     // SUBSCRIBE PRESENCE WATCHER LIST

   268     //////////////////////////////////////////////////////////////////////////

   269 

   270     // Setup status event listener for RequestComplete

   271     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   272 

   273     // subscribe

   274     reqId = presPub.SubscribePresenceWatcherListL();

   275     

   276     // Wait for events on the request

   277     wrapper->WaitRequestAndStackEvents( reqId );

   278     wrapper->VerifyEventStackL( _L8("Subscribing presence watcher list, complete with error: ") );

   279 

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

   281     

   282 

   283     //////////////////////////////////////////////////////////////////////////

   284     // SUBSCRIBE PRESENCE BLOCK LIST

   285     //////////////////////////////////////////////////////////////////////////

   286 

   287     // Setup status event listener for RequestComplete

   288     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   289 

   290     // subscribe

   291     reqId = presAuth.SubscribePresenceBlockListL();

   292     

   293     // Wait for events on the request

   294     wrapper->WaitRequestAndStackEvents( reqId );

   295     wrapper->VerifyEventStackL( _L8("Subscribing presence watcher list, complete with error: ") );

   296 

   297     // verify that SubscribeBlockListL was called

   298     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceBlockListCalled, "SubscribeBlockListL was not called", ETrue, NULL );

   299     

   300 

   301     

   302     //////////////////////////////////////////////////////////////////////////

   303     // SUBSCRIBE PRESENTITY GROUP LIST

   304     //////////////////////////////////////////////////////////////////////////

   305     

   306     // Setup status event listener for RequestComplete

   307     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   308 

   309     // subscribe

   310     reqId = presGroup.SubscribePresentityGroupListL();

   311     

   312     // Wait for events on the request

   313     wrapper->WaitRequestAndStackEvents( reqId );

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

   315     

   316     // verify that SubscribePresentityGroupListL was called

   317     messenger->AssertSubscribePresentityGroupListCalled( ETrue );

   318     

   319     

   320     //////////////////////////////////////////////////////////////////////////

   321     // EMPTY GROUP LIST EVENT

   322     /////////////////////////////////////////////////////////////////////////

   323     // According to design, this should not be called

   324     // because the group list is empty, this can be removed

   325     // Create help listener

   326 

   327 /*    CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

   328     CleanupStack::PushL( listener2 );    // << listener2    

   329     

   330     // Create faked server message about group list

   331     SendSrvMsgL( CXIMPTestFileSrvMsg::ETestSrvMsgPresentityGroupList );

   332 

   333     // expect empty MPresentityGroupList event.

   334     CPresentityGroupListEventImp* event = XIMPTestEventFactory::CreateGroupListEventLCX(

   335             KNullDesC, KNullDesC,

   336             XIMPTestEventFactory::ETestPGLEmpty,

   337             KNullDesC, KNullDesC,

   338             MXIMPDataSubscriptionState::ESubscriptionActive,

   339             MXIMPDataSubscriptionState::EDataAvailable

   340             );

   341 

   342     listener2->ExpectL( event );

   343     CleanupStack::Pop( event ); // 4 more items in cleanupstack

   344 

   345     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresentityGroupListL failed" );

   346     CleanupStack::PopAndDestroy( 4 ); // lists

   347     CleanupStack::PopAndDestroy( listener2 );   // >>> listener2

   348 

   349 */        

   350     //////////////////////////////////////////////////////////////////////////

   351     // CREATE PRESENTITY GROUP

   352     /////////////////////////////////////////////////////////////////////////

   353     

   354     // Setup status event listener for RequestComplete

   355     // This will also produce HandlePresentityGroupListEvent, since the

   356     // the group is subscribed

   357     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   358 

   359 

   360     MXIMPIdentity* groupId = context->ObjectFactory().NewIdentityLC();

   361     CleanupStack::Pop(); // groupId

   362     groupId->SetIdentityL( KGroupId );

   363     

   364     // subscribe

   365     reqId = presGroup.CreatePresentityGroupL( *groupId, KGroupDisplayName );

   366     

   367     // Wait for events on the request

   368     wrapper->WaitRequestAndStackEvents( reqId );

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

   370     

   371     // verify that SubscribePresentityGroupListL was called

   372     messenger->AssertCreatePresentityGroupCalled( ETrue );

   373 

   374     

   375   

   376     //////////////////////////////////////////////////////////////////////////

   377     // ADD PRESENTITY GROUP MEMBER

   378     ////////////////////////////////////////////////////////////////////////// 

   379     

   380     CXIMPTestListener* listener4 = CXIMPTestListener::NewL( context );

   381     CleanupStack::PushL( listener4 );    // << listener4

   382     

   383     MXIMPIdentity* member = context->ObjectFactory().NewIdentityLC(); // << member

   384     member->SetIdentityL( KMemberId1 );

   385 

   386 

   387     // request complete

   388     TXIMPRequestId reqIdDummy;

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

   390 

   391     // group id

   392     CXIMPIdentityImp* identity2 = CXIMPIdentityImp::NewLC( groupId->Identity() );

   393     evReqComplete->AppendParamL( identity2 );

   394     CleanupStack::Pop(identity2); // identity2

   395 

   396     // id for member info

   397     CXIMPIdentityImp* miId = CXIMPIdentityImp::NewLC( KMemberId1 );

   398     // member info

   399     CPresentityGroupMemberInfoImp* memInfoImp =

   400         CPresentityGroupMemberInfoImp::NewLC( *miId, KMemberDisplayName1 );

   401     evReqComplete->AppendParamL( memInfoImp );

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

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

   404 

   405     listener4->ExpectL( evReqComplete );

   406     CleanupStack::Pop( evReqComplete );

   407 

   408     // do the call

   409     reqId = presGroup.AddPresentityGroupMemberL(

   410             *groupId, *member, KMemberDisplayName1 );

   411 

   412     // and wait

   413     EUNIT_ASSERT_DESC( KErrNone == listener4->WaitAndAssertL(), "AddPresentityGroupMemberL (not subscribed) failed" );

   414 

   415     messenger->AssertAddPresentityGroupMemberCalled( ETrue );

   416     CleanupStack::PopAndDestroy(); // >>> member

   417     CleanupStack::PopAndDestroy( listener4 );// >>> listener4

   418 

   419 

   420     //////////////////////////////////////////////////////////////////////////

   421     // SUBSCRIBE PRESENTITY GROUP CONTENT

   422     //////////////////////////////////////////////////////////////////////////    

   423 

   424     // Setup status event listener for RequestComplete

   425     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   426     

   427     // subscribe group content

   428     MXIMPIdentity* identity = context->ObjectFactory().NewIdentityLC();

   429     identity->SetIdentityL( KGroupId ); // << identity

   430 

   431     reqId = presGroup.SubscribePresentityGroupContentL( *identity );

   432     

   433     // Wait for events on the request

   434     wrapper->WaitRequestAndStackEvents( reqId );

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

   436 

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

   438     

   439     //////////////////////////////////////////////////////////////////////////

   440     // SUBSCRIBE PRESENTITY GROUP MEMBERS PRESENCE

   441     ////////////////////////////////////////////////////////////////////////// 

   442         

   443     // Setup status event listener for RequestComplete

   444     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   445 

   446     // This is the group we are interested in

   447     MXIMPIdentity* group = context->ObjectFactory().NewIdentityLC();

   448     CleanupStack::Pop(); // group

   449     group->SetIdentityL( KGroupId );

   450     // Set filter for the group

   451     //CPresenceInfoFilterImp* gpif = CPresenceInfoFilterImp::NewLC();

   452     //gpif->AcceptPersonFilterL( NPresenceInfo::NFieldType::KStatusMessage  );

   453     //gpif->AcceptPersonFilterL( NPresenceInfo::NFieldType::KAvatar );

   454     

   455     

   456     

   457     CPresenceInfoFilterImp* gpif =

   458                 XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   459     

   460     CleanupStack::Pop(gpif); // gpif

   461 

   462     // register interest

   463     reqId = presWatch.SubscribePresentityGroupMembersPresenceL( *group, *gpif );

   464 

   465     // Wait for events on the request

   466     wrapper->WaitRequestAndStackEvents( reqId );

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

   468         

   469     // verify that UpdateInterest was called

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

   471 

   472     delete gpif;

   473 

   474     

   475     //////////////////////////////////////////////////////////////////////////

   476     // ADD PRESENTITY GROUP MEMBER, GROUP CONTENT SUBSCRIBED

   477     ////////////////////////////////////////////////////////////////////////// 

   478     

   479     // Setup status event listener for RequestComplete

   480     // This will also produce HandlePresentityGroupMemberAddedL, since the

   481     // the group is subscribed

   482     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   483     

   484     MXIMPIdentity* member2 = context->ObjectFactory().NewIdentityLC(); // << member2

   485     member2->SetIdentityL( KMemberId2 );

   486 

   487     // do the call

   488     reqId = presGroup.AddPresentityGroupMemberL(

   489             *groupId, *member2, KMemberDisplayName2 );

   490             

   491     // Wait for events on the request

   492     wrapper->WaitRequestAndStackEvents( reqId );

   493     wrapper->VerifyEventStackL( _L8("AddPresentityGroupMemberL (subscribed) failed, complete with error: ") );

   494 

   495 

   496     messenger->AssertAddPresentityGroupMemberCalled( ETrue );

   497     CleanupStack::PopAndDestroy(); // >>> member2

   498 

   499 

   500    

   501     //////////////////////////////////////////////////////////////////////////

   502     // GRANT PRESENTITY GROUP MEMBER

   503     //////////////////////////////////////////////////////////////////////////

   504 

   505     // This is the group we are interested in

   506     MXIMPIdentity* ggroup = context->ObjectFactory().NewIdentityLC();

   507     CleanupStack::Pop(); // ggroup

   508     ggroup->SetIdentityL( KGroupId );

   509     // Set filter for the group

   510     CPresenceInfoFilterImp* ggpif = CPresenceInfoFilterImp::NewLC();

   511     //ggpif->AcceptPersonFilterL( NPresenceInfo::NFieldType::KAcceptAll  );

   512     CleanupStack::Pop(); // ggpif

   513 

   514     // Setup status event listener for RequestComplete

   515     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   516 

   517     // grant for all

   518     reqId = presAuth.GrantPresenceForPresentityGroupMembersL( *ggroup, *ggpif );

   519 

   520     // Wait for events on the request

   521     wrapper->WaitRequestAndStackEvents( reqId );

   522     

   523     // verify that UpdateInterest was called

   524     COMMONASSERT( messenger, EXIMPPlgTestGrantPresenceForPresentityGroupMembersCalled, 

   525         "GrantPresenceForPresentityGroupMembersL was not called", ETrue, NULL );

   526         

   527     delete ggpif;    

   528 

   529 

   530     //////////////////////////////////////////////////////////////////////////

   531     // WITHDRAW PRESENTITY GROUP MEMBER

   532     //////////////////////////////////////////////////////////////////////////

   533 

   534 

   535     // Setup status event listener for RequestComplete

   536     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   537 

   538     // withdraw from all

   539     reqId = presAuth.WithdrawPresenceGrantFromPresentityGroupMembersL( *ggroup );

   540 

   541     // Wait for events on the request

   542     wrapper->WaitRequestAndStackEvents( reqId );

   543     // verify that UpdateInterest was called

   544     COMMONASSERT( messenger, EXIMPPlgTestGrantPresenceForPresentityGroupMembersCalled, 

   545         "GrantPresenceForPresentityGroupMembersL was not called", ETrue, NULL );

   546     

   547     delete ggroup;

   548             

   549 

   550     //////////////////////////////////////////////////////////////////////////

   551     // UNSUBSCRIBE PRESENTITY GROUP MEMBERS

   552     ////////////////////////////////////////////////////////////////////////// 

   553         

   554     // Setup status event listener for RequestComplete

   555     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   556 

   557     // unregister interest

   558     reqId = presWatch.UnsubscribePresentityGroupMembersPresenceL( *group );

   559 

   560     // Wait for events on the request

   561     wrapper->WaitRequestAndStackEvents( reqId );

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

   563         

   564     // verify that UpdateInterest was called

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

   566 

   567 

   568     

   569     //////////////////////////////////////////////////////////////////////////

   570     // UNSUBSCRIBE PRESENTITY GROUP CONTENT

   571     ////////////////////////////////////////////////////////////////////////// 

   572     

   573     // Setup status event listener for RequestComplete

   574     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   575     

   576     // unsubscribe

   577     reqId = presGroup.UnsubscribePresentityGroupContentL( *identity );

   578         

   579     // Wait for events on the request

   580     wrapper->WaitRequestAndStackEvents( reqId );

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

   582 

   583     // verify that UnsubscribePresentityGroupContentL was called

   584     messenger->AssertUnsubscribePresentityGroupContentCalled( ETrue );

   585     

   586     CleanupStack::PopAndDestroy(); // >>> identity

   587 

   588     //////////////////////////////////////////////////////////////////////////

   589     // UNSUBSCRIBE PRESENCE BLOCK LIST

   590     //////////////////////////////////////////////////////////////////////////

   591 

   592     // Setup status event listener for RequestComplete

   593     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   594 

   595     // subscribe

   596     reqId = presAuth.UnsubscribePresenceBlockListL();

   597     

   598     // Wait for events on the request

   599     wrapper->WaitRequestAndStackEvents( reqId );

   600     wrapper->VerifyEventStackL( _L8("Unsubscribing presence watcher list, complete with error: ") );

   601 

   602     // verify that SubscribeBlockListL was called

   603     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceBlockListCalled, "UnubscribeBlockListL was not called", ETrue, NULL );

   604     

   605     //////////////////////////////////////////////////////////////////////////

   606     // UNSUBSCRIBE PRESENTITY GROUP LIST

   607     //////////////////////////////////////////////////////////////////////////

   608     

   609     // Setup status event listener for RequestComplete

   610     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   611 

   612     // unsubscribe

   613     reqId = presGroup.UnsubscribePresentityGroupListL();

   614     

   615     // Wait for events on the request

   616     wrapper->WaitRequestAndStackEvents( reqId );

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

   618     

   619     // verify that SubscribePresentityGroupListL was called

   620     messenger->AssertUnsubscribePresentityGroupListCalled( ETrue );

   621    

   622 

   623     //////////////////////////////////////////////////////////////////////////

   624     // UNSUBSCRIBE PRESENCE WATCHER LIST

   625     //////////////////////////////////////////////////////////////////////////

   626 

   627     // Setup status event listener for RequestComplete

   628     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   629 

   630     // unsubscribe

   631     reqId = presPub.UnsubscribePresenceWatcherListL();

   632 

   633     // Wait for events on the request

   634     wrapper->WaitRequestAndStackEvents( reqId );

   635     wrapper->VerifyEventStackL( _L8("Unsubscribing presence watcher list, complete with error: ") );

   636 

   637     // verify that UnsubscribeWatcherListL was called

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

   639 

   640 

   641     ////////////////////////////////////////////////////////////////////////////

   642     // UNSUBSCRIBE OWN PRESENCE

   643     ////////////////////////////////////////////////////////////////////////////

   644     // Setup status event listener for RequestComplete

   645     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );    

   646     

   647     // unsubscribe own presence

   648     reqId = presPub.UnsubscribeOwnPresenceL();

   649     

   650     // Wait for events on the request

   651     wrapper->WaitRequestAndStackEvents( reqId );

   652     

   653     wrapper->VerifyEventStackL( _L8("Unsubscribing own presence, complete with error: ") );

   654         

   655     // verify that UnsubscribeOwnPresenceL was called

   656     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribeOwnPresenceCalled, "UnsubscribeOwnPresenceL was not called", ETrue, NULL );

   657 

   658     CleanupStack::PopAndDestroy( ownPif ); // >>> ownPif

   659     delete group;

   660     delete groupId;

   661    

   662 

   663     UnbindL();

   664     

   665     wrapper = NULL;

   666     context = NULL;

   667     messenger = NULL;

   668     

   669 

   670 

   671     }

   672 

   673 // Grant/Withdraw from group

   674 void T_PresenceAll::T_GrantWithdrawGroup_L()

   675     {

   676     EUNIT_PRINT( _L("T_GrantWithdrawGroup_L") );

   677 

   678     BindL();

   679 

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

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

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

   683 

   684     // Tell the protocol it should act normally

   685     messenger->SetNoError();

   686     

   687         

   688     // Get the interfaces

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

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

   691     MPresenceAuthorization& presAuth = presFeat->PresenceAuthorization();

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

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

   694     

   695     

   696     

   697     //////////////////////////////////////////////////////////////////////////

   698     // CREATE PRESENTITY GROUP

   699     /////////////////////////////////////////////////////////////////////////

   700     

   701     // Setup status event listener for RequestComplete

   702     // This will also produce HandlePresentityGroupListEvent, since the

   703     // the group is subscribed

   704     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   705 

   706 

   707     MXIMPIdentity* groupId = context->ObjectFactory().NewIdentityLC();

   708     CleanupStack::Pop(); // groupId

   709     groupId->SetIdentityL( KGroupId );

   710     

   711     // subscribe

   712     TXIMPRequestId reqId = presGroup.CreatePresentityGroupL( *groupId, KGroupDisplayName );

   713     

   714     // Wait for events on the request

   715     wrapper->WaitRequestAndStackEvents( reqId );

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

   717     

   718     // verify that SubscribePresentityGroupListL was called

   719     messenger->AssertCreatePresentityGroupCalled( ETrue );

   720 

   721     

   722   

   723     //////////////////////////////////////////////////////////////////////////

   724     // ADD PRESENTITY GROUP MEMBER

   725     ////////////////////////////////////////////////////////////////////////// 

   726     

   727     CXIMPTestListener* listener4 = CXIMPTestListener::NewL( context );

   728     CleanupStack::PushL( listener4 );    // << listener4

   729     

   730     MXIMPIdentity* member = context->ObjectFactory().NewIdentityLC(); // << member

   731     member->SetIdentityL( KMemberId1 );

   732 

   733 

   734     // request complete

   735     TXIMPRequestId reqIdDummy;

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

   737 

   738     // group id

   739     CXIMPIdentityImp* identity2 = CXIMPIdentityImp::NewLC( groupId->Identity() );

   740     evReqComplete->AppendParamL( identity2 );

   741     CleanupStack::Pop(); // identity2

   742 

   743     // id for member info

   744     CXIMPIdentityImp* miId = CXIMPIdentityImp::NewLC( KMemberId1 );

   745     // member info

   746     CPresentityGroupMemberInfoImp* memInfoImp =

   747         CPresentityGroupMemberInfoImp::NewLC( *miId, KMemberDisplayName1 );

   748     evReqComplete->AppendParamL( memInfoImp );

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

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

   751 

   752     listener4->ExpectL( evReqComplete );

   753     CleanupStack::Pop( evReqComplete );

   754 

   755     // do the call

   756     reqId = presGroup.AddPresentityGroupMemberL(

   757             *groupId, *member, KMemberDisplayName1 );

   758 

   759     // and wait

   760     EUNIT_ASSERT_DESC( KErrNone == listener4->WaitAndAssertL(), "AddPresentityGroupMemberL (not subscribed) failed" );

   761 

   762     messenger->AssertAddPresentityGroupMemberCalled( ETrue );

   763     CleanupStack::PopAndDestroy(); // >>> member

   764     CleanupStack::PopAndDestroy( listener4 );// >>> listener4

   765     

   766     delete groupId;

   767 

   768     //////////////////////////////////////////////////////////////////////////

   769     // ADD PRESENTITY GROUP MEMBER, GROUP CONTENT SUBSCRIBED

   770     ////////////////////////////////////////////////////////////////////////// 

   771     

   772     // Setup status event listener for RequestComplete

   773     // This will also produce HandlePresentityGroupMemberAddedL, since the

   774     // the group is subscribed

   775     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   776     

   777     MXIMPIdentity* member2 = context->ObjectFactory().NewIdentityLC(); // << member2

   778     member2->SetIdentityL( KMemberId2 );

   779 

   780     // do the call

   781     reqId = presGroup.AddPresentityGroupMemberL(

   782             *groupId, *member2, KMemberDisplayName2 );

   783             

   784     // Wait for events on the request

   785     wrapper->WaitRequestAndStackEvents( reqId );

   786     wrapper->VerifyEventStackL( _L8("AddPresentityGroupMemberL (subscribed) failed, complete with error: ") );

   787 

   788 

   789     messenger->AssertAddPresentityGroupMemberCalled( ETrue );

   790     CleanupStack::PopAndDestroy(); // >>> member2

   791 

   792 

   793    

   794     //////////////////////////////////////////////////////////////////////////

   795     // GRANT PRESENTITY GROUP MEMBER

   796     //////////////////////////////////////////////////////////////////////////

   797 

   798     // This is the group we are interested in

   799     MXIMPIdentity* ggroup = context->ObjectFactory().NewIdentityLC();

   800     CleanupStack::Pop(); // ggroup

   801     ggroup->SetIdentityL( KGroupId );

   802     // Set filter for the group

   803     CPresenceInfoFilterImp* ggpif = CPresenceInfoFilterImp::NewLC();

   804     ggpif->AcceptPersonFilterL( NPresenceInfo::NFieldType::KAcceptAll  );

   805     CleanupStack::Pop(); // ggpif

   806 

   807     // Setup status event listener for RequestComplete

   808     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   809 

   810     // grant for all

   811     reqId = presAuth.GrantPresenceForPresentityGroupMembersL( *ggroup, *ggpif );

   812 

   813     // Wait for events on the request

   814     wrapper->WaitRequestAndStackEvents( reqId );

   815     

   816     // verify that UpdateInterest was called

   817     COMMONASSERT( messenger, EXIMPPlgTestGrantPresenceForPresentityGroupMembersCalled, 

   818         "GrantPresenceForPresentityGroupMembersL was not called", ETrue, NULL );

   819     

   820     delete ggpif;

   821     

   822 

   823 

   824     //////////////////////////////////////////////////////////////////////////

   825     // WITHDRAW PRESENTITY GROUP MEMBER

   826     //////////////////////////////////////////////////////////////////////////

   827 

   828 

   829     // Setup status event listener for RequestComplete

   830     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   831 

   832     // withdraw from all

   833     reqId = presAuth.WithdrawPresenceGrantFromPresentityGroupMembersL( *ggroup );

   834 

   835     // Wait for events on the request

   836     wrapper->WaitRequestAndStackEvents( reqId );

   837     // verify that UpdateInterest was called

   838     COMMONASSERT( messenger, EXIMPPlgTestGrantPresenceForPresentityGroupMembersCalled, 

   839         "GrantPresenceForPresentityGroupMembersL was not called", ETrue, NULL );

   840     

   841     delete ggroup;        

   842 

   843     UnbindL();

   844     

   845     wrapper = NULL;

   846     context = NULL;

   847     messenger = NULL;

   848 

   849     }

   850 

   851 

   852 // ===========================================================================

   853 // SETUP HELPERS FOR THE LISTENER

   854 // ===========================================================================

   855 //

   856 void T_PresenceAll::SetupListenerReqCompleteL( CXIMPTestContextWrapper* aWrapper, TXIMPTestStatusEventTemplate aEventType )

   857     {

   858     RArray< TInt32 > array;

   859     CleanupClosePushL( array );

   860     array.Append( MXIMPContextStateEvent::KInterfaceId );

   861     array.Append( MPresentityPresenceEvent::KInterfaceId );

   862     aWrapper->SetupListenerReqCompleteL( aEventType, &array );

   863     CleanupStack::PopAndDestroy(); // array

   864     }

   865 

   866 void T_PresenceAll::SetupListenerReqCompleteAllowEventsL(  CXIMPTestContextWrapper* aWrapper, TXIMPTestStatusEventTemplate aEventType )

   867     {

   868     RArray< TInt32 > array;

   869     CleanupClosePushL( array );

   870     array.AppendL( MXIMPRequestCompleteEvent::KInterfaceId );

   871     array.AppendL( MXIMPContextStateEvent::KInterfaceId );

   872     array.AppendL( MPresentityPresenceEvent::KInterfaceId );

   873     aWrapper->SetupListenerReqCompleteL( aEventType, &array );

   874     CleanupStack::PopAndDestroy(); // array

   875     }

   876 

   877 void T_PresenceAll::SendSrvMsgL(

   878         const TDesC& aUri, const TDesC& aDispName,

   879         TInt aMsgType )

   880     {

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

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

   883 

   884     // create a group info contained within the server-originated

   885     // faked message

   886     CXIMPIdentityImp* groupId = CXIMPIdentityImp::NewLC( aUri );

   887     CPresentityGroupInfoImp* groupItem = CPresentityGroupInfoImp::NewLC( *groupId, aDispName );

   888     HBufC8* packet = NULL;

   889     if( aMsgType == CXIMPTestFileSrvMsg::ETestSrvMsgPresentityGroupDelete )

   890         {

   891         packet = TXIMPObjectPacker< CXIMPIdentityImp >::PackL( *groupId );        

   892         }

   893     else

   894         {

   895         packet = TXIMPObjectPacker< CPresentityGroupInfoImp >::PackL( *groupItem );        

   896         }

   897     CleanupStack::PushL( packet );

   898     

   899     // use filetool to send it for plugin.

   900     CXIMPTestFileSrvMsg* srvMsg = CXIMPTestFileSrvMsg::NewL( aMsgType, *packet );

   901     CleanupStack::PushL( srvMsg );

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

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

   904     CleanupStack::PopAndDestroy( 4, groupId ); // srvMsg, packet, groupItem, groupId

   905     }

   906 

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

   908 //

   909 void T_PresenceAll::SendSrvMsgL( TInt aMsgType )

   910     {

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

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

   913 

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

   915     RXIMPObjOwningPtrArray<CPresentityGroupInfoImp> groupList;

   916 

   917     HBufC8* packedArray = TXIMPObjectPacker<CPresentityGroupInfoImp>::PackArrayL( groupList );

   918     CleanupStack::PushL( packedArray );

   919 

   920     // use filetool to send it for plugin.

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

   922             *packedArray );

   923     CleanupStack::PushL( srvMsg );

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

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

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

   927     }

   928     

   929     

   930 void T_PresenceAll::T_BindUnbindL()

   931     {

   932     EUNIT_PRINT( _L("T_BindUnbindL") );

   933 

   934     BindL();

   935 

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

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

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

   939 

   940     // Tell the protocol it should act normally

   941     messenger->SetNoError();

   942     

   943         

   944     UnbindL();

   945     

   946     wrapper = NULL;

   947     context = NULL;

   948     messenger = NULL;

   949     }

   950 // ===========================================================================

   951 // TEST CASE TABLE

   952 // ===========================================================================

   953 //

   954 EUNIT_BEGIN_TEST_TABLE(

   955         T_PresenceAll,

   956         "XIMP presence all tests",

   957         "MODULE" )

   958         

   959 PRFW_DECORATED_TEST(

   960         "TMO_demo_Startup",

   961         "",

   962         "",

   963         "FUNCTIONALITY",

   964         Setup_L,

   965         T_TMO_demo_Startup_L,

   966         Teardown )

   967         

   968 PRFW_DECORATED_TEST(

   969         "BindUnbind",

   970         "",

   971         "",

   972         "FUNCTIONALITY",

   973         Setup_L,

   974         T_BindUnbindL,

   975         Teardown )

   976         

   977 PRFW_DECORATED_TEST(

   978         "GrantWithdrawGroup",

   979         "",

   980         "",

   981         "FUNCTIONALITY",

   982         Setup_L,

   983         T_GrantWithdrawGroup_L,

   984         Teardown )

   985 

   986 EUNIT_END_TEST_TABLE

   987 

   988 

   989 // ===========================================================================

   990 // TEST SUITE CONSTRUCTION

   991 // ===========================================================================

   992 //

   993 EXPORT_C MEUnitTest* CreateTestSuiteL()

   994     {

   995     return T_PresenceAll::NewL();

   996     }

   997 

   998 

   999 // end of file