1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 #include "eunittools.h"

    20 

    21 #include <eunitmacros.h>

    22 #include <ecom/ecom.h>

    23 #include <badesca.h>

    24 

    25 #include <ximpbase.h>

    26 #include <ximpclient.h>

    27 #include <ximpcontext.h>

    28 #include <ximpcontextstateevent.h>

    29 #include <ximprequestcompleteevent.h>

    30 #include <ximpstatus.h>

    31 #include <presencefeatures.h>

    32 #include <presencewatching.h>

    33 #include <presencepublishing.h>

    34 #include <presentitypresenceevent.h>

    35 #include <ximpobjectfactory.h>

    36 

    37 #include <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     if(*identity2 != *miId)

   399         {

   400         // nothing to do

   401         }         

   402     // member info

   403     CPresentityGroupMemberInfoImp* memInfoImp =

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

   405     evReqComplete->AppendParamL( memInfoImp );

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

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

   408 

   409     listener4->ExpectL( evReqComplete );

   410     CleanupStack::Pop( evReqComplete );

   411 

   412     // do the call

   413     reqId = presGroup.AddPresentityGroupMemberL(

   414             *groupId, *member, KMemberDisplayName1 );

   415 

   416     // and wait

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

   418 

   419     messenger->AssertAddPresentityGroupMemberCalled( ETrue );

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

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

   422 

   423 

   424     //////////////////////////////////////////////////////////////////////////

   425     // SUBSCRIBE PRESENTITY GROUP CONTENT

   426     //////////////////////////////////////////////////////////////////////////    

   427 

   428     // Setup status event listener for RequestComplete

   429     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   430     

   431     // subscribe group content

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

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

   434 

   435     reqId = presGroup.SubscribePresentityGroupContentL( *identity );

   436     

   437     // Wait for events on the request

   438     wrapper->WaitRequestAndStackEvents( reqId );

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

   440 

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

   442     

   443     //////////////////////////////////////////////////////////////////////////

   444     // SUBSCRIBE PRESENTITY GROUP MEMBERS PRESENCE

   445     ////////////////////////////////////////////////////////////////////////// 

   446         

   447     // Setup status event listener for RequestComplete

   448     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   449 

   450     // This is the group we are interested in

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

   452     CleanupStack::Pop(); // group

   453     group->SetIdentityL( KGroupId );

   454     // Set filter for the group

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

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

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

   458     

   459     

   460     

   461     CPresenceInfoFilterImp* gpif =

   462                 XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   463     

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

   465 

   466     // register interest

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

   468 

   469     // Wait for events on the request

   470     wrapper->WaitRequestAndStackEvents( reqId );

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

   472         

   473     // verify that UpdateInterest was called

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

   475 

   476     delete gpif;

   477 

   478     

   479     //////////////////////////////////////////////////////////////////////////

   480     // ADD PRESENTITY GROUP MEMBER, GROUP CONTENT SUBSCRIBED

   481     ////////////////////////////////////////////////////////////////////////// 

   482     

   483     // Setup status event listener for RequestComplete

   484     // This will also produce HandlePresentityGroupMemberAddedL, since the

   485     // the group is subscribed

   486     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   487     

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

   489     member2->SetIdentityL( KMemberId2 );

   490 

   491     // do the call

   492     reqId = presGroup.AddPresentityGroupMemberL(

   493             *groupId, *member2, KMemberDisplayName2 );

   494             

   495     // Wait for events on the request

   496     wrapper->WaitRequestAndStackEvents( reqId );

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

   498 

   499 

   500     messenger->AssertAddPresentityGroupMemberCalled( ETrue );

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

   502 

   503 

   504    

   505     //////////////////////////////////////////////////////////////////////////

   506     // GRANT PRESENTITY GROUP MEMBER

   507     //////////////////////////////////////////////////////////////////////////

   508 

   509     // This is the group we are interested in

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

   511     CleanupStack::Pop(); // ggroup

   512     ggroup->SetIdentityL( KGroupId );

   513     // Set filter for the group

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

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

   516     CleanupStack::Pop(); // ggpif

   517 

   518     // Setup status event listener for RequestComplete

   519     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   520 

   521     // grant for all

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

   523 

   524     // Wait for events on the request

   525     wrapper->WaitRequestAndStackEvents( reqId );

   526     

   527     // verify that UpdateInterest was called

   528     COMMONASSERT( messenger, EXIMPPlgTestGrantPresenceForPresentityGroupMembersCalled, 

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

   530         

   531     delete ggpif;    

   532 

   533 

   534     //////////////////////////////////////////////////////////////////////////

   535     // WITHDRAW PRESENTITY GROUP MEMBER

   536     //////////////////////////////////////////////////////////////////////////

   537 

   538 

   539     // Setup status event listener for RequestComplete

   540     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   541 

   542     // withdraw from all

   543     reqId = presAuth.WithdrawPresenceGrantFromPresentityGroupMembersL( *ggroup );

   544 

   545     // Wait for events on the request

   546     wrapper->WaitRequestAndStackEvents( reqId );

   547     // verify that UpdateInterest was called

   548     COMMONASSERT( messenger, EXIMPPlgTestGrantPresenceForPresentityGroupMembersCalled, 

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

   550     

   551     delete ggroup;

   552             

   553 

   554     //////////////////////////////////////////////////////////////////////////

   555     // UNSUBSCRIBE PRESENTITY GROUP MEMBERS

   556     ////////////////////////////////////////////////////////////////////////// 

   557         

   558     // Setup status event listener for RequestComplete

   559     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   560 

   561     // unregister interest

   562     reqId = presWatch.UnsubscribePresentityGroupMembersPresenceL( *group );

   563 

   564     // Wait for events on the request

   565     wrapper->WaitRequestAndStackEvents( reqId );

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

   567         

   568     // verify that UpdateInterest was called

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

   570 

   571 

   572     

   573     //////////////////////////////////////////////////////////////////////////

   574     // UNSUBSCRIBE PRESENTITY GROUP CONTENT

   575     ////////////////////////////////////////////////////////////////////////// 

   576     

   577     // Setup status event listener for RequestComplete

   578     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   579     

   580     // unsubscribe

   581     reqId = presGroup.UnsubscribePresentityGroupContentL( *identity );

   582         

   583     // Wait for events on the request

   584     wrapper->WaitRequestAndStackEvents( reqId );

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

   586 

   587     // verify that UnsubscribePresentityGroupContentL was called

   588     messenger->AssertUnsubscribePresentityGroupContentCalled( ETrue );

   589     

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

   591 

   592     //////////////////////////////////////////////////////////////////////////

   593     // UNSUBSCRIBE PRESENCE BLOCK LIST

   594     //////////////////////////////////////////////////////////////////////////

   595 

   596     // Setup status event listener for RequestComplete

   597     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   598 

   599     // subscribe

   600     reqId = presAuth.UnsubscribePresenceBlockListL();

   601     

   602     // Wait for events on the request

   603     wrapper->WaitRequestAndStackEvents( reqId );

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

   605 

   606     // verify that SubscribeBlockListL was called

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

   608     

   609     //////////////////////////////////////////////////////////////////////////

   610     // UNSUBSCRIBE PRESENTITY GROUP LIST

   611     //////////////////////////////////////////////////////////////////////////

   612     

   613     // Setup status event listener for RequestComplete

   614     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   615 

   616     // unsubscribe

   617     reqId = presGroup.UnsubscribePresentityGroupListL();

   618     

   619     // Wait for events on the request

   620     wrapper->WaitRequestAndStackEvents( reqId );

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

   622     

   623     // verify that SubscribePresentityGroupListL was called

   624     messenger->AssertUnsubscribePresentityGroupListCalled( ETrue );

   625    

   626 

   627     //////////////////////////////////////////////////////////////////////////

   628     // UNSUBSCRIBE PRESENCE WATCHER LIST

   629     //////////////////////////////////////////////////////////////////////////

   630 

   631     // Setup status event listener for RequestComplete

   632     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   633 

   634     // unsubscribe

   635     reqId = presPub.UnsubscribePresenceWatcherListL();

   636 

   637     // Wait for events on the request

   638     wrapper->WaitRequestAndStackEvents( reqId );

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

   640 

   641     // verify that UnsubscribeWatcherListL was called

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

   643 

   644 

   645     ////////////////////////////////////////////////////////////////////////////

   646     // UNSUBSCRIBE OWN PRESENCE

   647     ////////////////////////////////////////////////////////////////////////////

   648     // Setup status event listener for RequestComplete

   649     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );    

   650     

   651     // unsubscribe own presence

   652     reqId = presPub.UnsubscribeOwnPresenceL();

   653     

   654     // Wait for events on the request

   655     wrapper->WaitRequestAndStackEvents( reqId );

   656     

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

   658         

   659     // verify that UnsubscribeOwnPresenceL was called

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

   661 

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

   663     delete group;

   664     delete groupId;

   665    

   666 

   667     UnbindL();

   668     

   669     wrapper = NULL;

   670     context = NULL;

   671     messenger = NULL;

   672     

   673 

   674 

   675     }

   676 

   677 // Grant/Withdraw from group

   678 void T_PresenceAll::T_GrantWithdrawGroup_L()

   679     {

   680     EUNIT_PRINT( _L("T_GrantWithdrawGroup_L") );

   681 

   682     BindL();

   683 

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

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

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

   687 

   688     // Tell the protocol it should act normally

   689     messenger->SetNoError();

   690     

   691         

   692     // Get the interfaces

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

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

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

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

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

   698     

   699     

   700     

   701     //////////////////////////////////////////////////////////////////////////

   702     // CREATE PRESENTITY GROUP

   703     /////////////////////////////////////////////////////////////////////////

   704     

   705     // Setup status event listener for RequestComplete

   706     // This will also produce HandlePresentityGroupListEvent, since the

   707     // the group is subscribed

   708     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   709 

   710 

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

   712     CleanupStack::Pop(); // groupId

   713     groupId->SetIdentityL( KGroupId );

   714     

   715     // subscribe

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

   717     

   718     // Wait for events on the request

   719     wrapper->WaitRequestAndStackEvents( reqId );

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

   721     

   722     // verify that SubscribePresentityGroupListL was called

   723     messenger->AssertCreatePresentityGroupCalled( ETrue );

   724 

   725     

   726   

   727     //////////////////////////////////////////////////////////////////////////

   728     // ADD PRESENTITY GROUP MEMBER

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

   730     

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

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

   733     

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

   735     member->SetIdentityL( KMemberId1 );

   736 

   737 

   738     // request complete

   739     TXIMPRequestId reqIdDummy;

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

   741 

   742     // group id

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

   744     evReqComplete->AppendParamL( identity2 );

   745     CleanupStack::Pop(); // identity2

   746 

   747     // id for member info

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

   749     // member info

   750     CPresentityGroupMemberInfoImp* memInfoImp =

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

   752     evReqComplete->AppendParamL( memInfoImp );

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

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

   755 

   756     listener4->ExpectL( evReqComplete );

   757     CleanupStack::Pop( evReqComplete );

   758 

   759     // do the call

   760     reqId = presGroup.AddPresentityGroupMemberL(

   761             *groupId, *member, KMemberDisplayName1 );

   762 

   763     // and wait

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

   765 

   766     messenger->AssertAddPresentityGroupMemberCalled( ETrue );

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

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

   769     

   770     delete groupId;

   771 

   772     //////////////////////////////////////////////////////////////////////////

   773     // ADD PRESENTITY GROUP MEMBER, GROUP CONTENT SUBSCRIBED

   774     ////////////////////////////////////////////////////////////////////////// 

   775     

   776     // Setup status event listener for RequestComplete

   777     // This will also produce HandlePresentityGroupMemberAddedL, since the

   778     // the group is subscribed

   779     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   780     

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

   782     member2->SetIdentityL( KMemberId2 );

   783 

   784     // do the call

   785     reqId = presGroup.AddPresentityGroupMemberL(

   786             *groupId, *member2, KMemberDisplayName2 );

   787             

   788     // Wait for events on the request

   789     wrapper->WaitRequestAndStackEvents( reqId );

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

   791 

   792 

   793     messenger->AssertAddPresentityGroupMemberCalled( ETrue );

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

   795 

   796 

   797    

   798     //////////////////////////////////////////////////////////////////////////

   799     // GRANT PRESENTITY GROUP MEMBER

   800     //////////////////////////////////////////////////////////////////////////

   801 

   802     // This is the group we are interested in

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

   804     CleanupStack::Pop(); // ggroup

   805     ggroup->SetIdentityL( KGroupId );

   806     // Set filter for the group

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

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

   809     CleanupStack::Pop(); // ggpif

   810 

   811     // Setup status event listener for RequestComplete

   812     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   813 

   814     // grant for all

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

   816 

   817     // Wait for events on the request

   818     wrapper->WaitRequestAndStackEvents( reqId );

   819     

   820     // verify that UpdateInterest was called

   821     COMMONASSERT( messenger, EXIMPPlgTestGrantPresenceForPresentityGroupMembersCalled, 

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

   823     

   824     delete ggpif;

   825     

   826 

   827 

   828     //////////////////////////////////////////////////////////////////////////

   829     // WITHDRAW PRESENTITY GROUP MEMBER

   830     //////////////////////////////////////////////////////////////////////////

   831 

   832 

   833     // Setup status event listener for RequestComplete

   834     SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

   835 

   836     // withdraw from all

   837     reqId = presAuth.WithdrawPresenceGrantFromPresentityGroupMembersL( *ggroup );

   838 

   839     // Wait for events on the request

   840     wrapper->WaitRequestAndStackEvents( reqId );

   841     // verify that UpdateInterest was called

   842     COMMONASSERT( messenger, EXIMPPlgTestGrantPresenceForPresentityGroupMembersCalled, 

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

   844     

   845     delete ggroup;        

   846 

   847     UnbindL();

   848     

   849     wrapper = NULL;

   850     context = NULL;

   851     messenger = NULL;

   852 

   853     }

   854 

   855 

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

   857 // SETUP HELPERS FOR THE LISTENER

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

   859 //

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

   861     {

   862     RArray< TInt32 > array;

   863     CleanupClosePushL( array );

   864     array.Append( MXIMPContextStateEvent::KInterfaceId );

   865     array.Append( MPresentityPresenceEvent::KInterfaceId );

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

   867     CleanupStack::PopAndDestroy(); // array

   868     }

   869 

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

   871     {

   872     RArray< TInt32 > array;

   873     CleanupClosePushL( array );

   874     array.AppendL( MXIMPRequestCompleteEvent::KInterfaceId );

   875     array.AppendL( MXIMPContextStateEvent::KInterfaceId );

   876     array.AppendL( MPresentityPresenceEvent::KInterfaceId );

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

   878     CleanupStack::PopAndDestroy(); // array

   879     }

   880 

   881 void T_PresenceAll::SendSrvMsgL(

   882         const TDesC& aUri, const TDesC& aDispName,

   883         TInt aMsgType )

   884     {

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

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

   887 

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

   889     // faked message

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

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

   892     HBufC8* packet = NULL;

   893     if( aMsgType == CXIMPTestFileSrvMsg::ETestSrvMsgPresentityGroupDelete )

   894         {

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

   896         }

   897     else

   898         {

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

   900         }

   901     CleanupStack::PushL( packet );

   902     

   903     // use filetool to send it for plugin.

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

   905     CleanupStack::PushL( srvMsg );

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

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

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

   909     }

   910 

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

   912 //

   913 void T_PresenceAll::SendSrvMsgL( TInt aMsgType )

   914     {

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

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

   917 

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

   919     RXIMPObjOwningPtrArray<CPresentityGroupInfoImp> groupList;

   920 

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

   922     CleanupStack::PushL( packedArray );

   923 

   924     // use filetool to send it for plugin.

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

   926             *packedArray );

   927     CleanupStack::PushL( srvMsg );

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

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

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

   931     }

   932     

   933     

   934 void T_PresenceAll::T_BindUnbindL()

   935     {

   936     EUNIT_PRINT( _L("T_BindUnbindL") );

   937 

   938     BindL();

   939 

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

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

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

   943 

   944     // Tell the protocol it should act normally

   945     messenger->SetNoError();

   946     

   947         

   948     UnbindL();

   949     

   950     wrapper = NULL;

   951     context = NULL;

   952     messenger = NULL;

   953     }

   954 // ===========================================================================

   955 // TEST CASE TABLE

   956 // ===========================================================================

   957 //

   958 EUNIT_BEGIN_TEST_TABLE(

   959         T_PresenceAll,

   960         "XIMP presence all tests",

   961         "MODULE" )

   962         

   963 PRFW_DECORATED_TEST(

   964         "TMO_demo_Startup",

   965         "",

   966         "",

   967         "FUNCTIONALITY",

   968         Setup_L,

   969         T_TMO_demo_Startup_L,

   970         Teardown )

   971         

   972 PRFW_DECORATED_TEST(

   973         "BindUnbind",

   974         "",

   975         "",

   976         "FUNCTIONALITY",

   977         Setup_L,

   978         T_BindUnbindL,

   979         Teardown )

   980         

   981 PRFW_DECORATED_TEST(

   982         "GrantWithdrawGroup",

   983         "",

   984         "",

   985         "FUNCTIONALITY",

   986         Setup_L,

   987         T_GrantWithdrawGroup_L,

   988         Teardown )

   989 

   990 EUNIT_END_TEST_TABLE

   991 

   992 

   993 // ===========================================================================

   994 // TEST SUITE CONSTRUCTION

   995 // ===========================================================================

   996 //

   997 EXPORT_C MEUnitTest* CreateTestSuiteL()

   998     {

   999     return T_PresenceAll::NewL();

  1000     }

  1001 

  1002 

  1003 // end of file