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

    29 #include <presenceauthorization.h>

    30 

    31 #include "t_presencegrantrequestmngt.h"

    32 

    33 #include "ximprequestcompleteeventimp.h"

    34 

    35 //#include "prfwtestpresencedatautils.h"

    36 

    37 // grant req includes

    38 #include "presencegrantrequestinfoimp.h"

    39 #include "presencegrantrequestlisteventimp.h"

    40 

    41 

    42 // other data model includes

    43 #include "ximpidentityimp.h"

    44 

    45 // utils includes

    46 #include "ximpobjecthelpers.h"

    47 

    48 // testing tool includes

    49 #include "prfwtestmessaging.h"

    50 #include "prfwtestmessenger.h"

    51 #include "prfwtestcontextwrappermgr.h"

    52 #include "prfwtestcontextwrapper.h"

    53 

    54 #include "prfwtestfilesrvmsg.h"

    55 #include "prfwtestfiletool.h"

    56 #include "prfwtestlistener.h"

    57 

    58 #include "prfwtestrobustnesstools.h"

    59 

    60 _LIT8( KPrefix1, "PreA_" );

    61 _LIT8( KPrefix2, "PreB_" );

    62 _LIT8( KPrefix3, "PreC_" );

    63 _LIT8( KPrefix4, "PreD_" );

    64 

    65 // ============================ MEMBER FUNCTIONS ===============================

    66 

    67 // CONSTRUCTION

    68 T_PresenceGrantRequestManagement* T_PresenceGrantRequestManagement::NewL()

    69     {

    70     T_PresenceGrantRequestManagement* self = new( ELeave ) T_PresenceGrantRequestManagement;

    71     CleanupStack::PushL( self );

    72     self->ConstructL();

    73     CleanupStack::Pop( self );

    74 

    75     return self;

    76     }

    77 

    78 

    79 T_PresenceGrantRequestManagement::~T_PresenceGrantRequestManagement()

    80     {

    81     PrfwTestRobustness::DoPreCleaning();

    82     }

    83 

    84 

    85 void T_PresenceGrantRequestManagement::ConstructL()

    86     {

    87     CEUnitTestSuiteClass::ConstructL();

    88     }

    89 

    90 

    91 T_PresenceGrantRequestManagement::T_PresenceGrantRequestManagement()

    92     {

    93     }

    94 

    95 

    96 

    97 // ===========================================================================

    98 // TEST CASE SETUP & TEARDOWN METHODS

    99 // ===========================================================================

   100 //

   101 

   102 void T_PresenceGrantRequestManagement::Setup_L()

   103     {

   104     PrfwTestRobustness::DoPreCleaning();

   105 

   106     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   107     iWrapperMgr->CreateWrapperL();

   108     }

   109 

   110 void T_PresenceGrantRequestManagement::SetupMultiple_L()

   111     {

   112     PrfwTestRobustness::DoPreCleaning();

   113 

   114     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   115     iWrapperMgr->CreateWrapperL();

   116     iWrapperMgr->CreateWrapperL();

   117     iWrapperMgr->CreateWrapperL();

   118     }

   119 

   120 

   121 void T_PresenceGrantRequestManagement::BindL()

   122     {

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

   124 

   125     wrapper0->BindL( 0 );

   126     }

   127 

   128 void T_PresenceGrantRequestManagement::BindAllL()

   129     {

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

   131         {

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

   133         wrapper->BindL( 0 );

   134         }

   135     }

   136 

   137 

   138 void T_PresenceGrantRequestManagement::Teardown()

   139     {

   140     delete iWrapperMgr;

   141     iWrapperMgr = NULL;

   142 

   143     REComSession::FinalClose();

   144 

   145     PrfwTestRobustness::DoPreCleaning();

   146     }

   147 

   148 void T_PresenceGrantRequestManagement::UnbindL()

   149     {

   150     // Do unbind

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

   152     wrapper0->UnbindL();

   153     }

   154 

   155 void T_PresenceGrantRequestManagement::UnbindAllL()

   156     {

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

   158         {

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

   160         wrapper->UnbindL();

   161         }

   162     }

   163 

   164 

   165 // ===========================================================================

   166 // TEST CASES for presentity presence subscription

   167 // ===========================================================================

   168 

   169 

   170 // ---------------------------------------------------------------------------

   171 // ---------------------------------------------------------------------------

   172 void T_PresenceGrantRequestManagement::T_SubscribeGrantRequestList_Single_L()

   173     {

   174     EUNIT_PRINT( _L("Single presence grant request list subscription") );

   175 

   176     BindL();

   177 

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

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

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

   181 

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

   183     CleanupStack::PushL( listener2 );

   184 

   185     // Tell the protocol it should act normally

   186     messenger->SetNoError();

   187 

   188     // Get the interfaces

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

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

   191 

   192     // ---------------------------------------------

   193     // 1. Subscribe grant request list

   194 

   195     // Setup status event listener for RequestComplete

   196     listener2->Reset();

   197 

   198     // normal request complete

   199     TXIMPRequestId reqIdDummy;  // not checked

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

   201     listener2->ExpectL( evReqComplete );

   202     CleanupStack::Pop( evReqComplete );

   203     // ---------------------------------------------

   204 

   205     // subscribe

   206     // ---------------------------------------------

   207     TXIMPRequestId reqId = presAuth.SubscribePresenceGrantRequestListL();

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

   209     // ---------------------------------------------

   210 

   211     // verify that SubscribeGrantListL was called

   212     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceGrantRequestListCalled, "SubscribeGrantListL was not called", ETrue, NULL );

   213 

   214 

   215     // ---------------------------------------------

   216     // 2. refresh subscription

   217     

   218     // Setup status event listener for RequestComplete

   219     listener2->Reset();

   220 

   221     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   222     listener2->ExpectL( evReqComplete );

   223     CleanupStack::Pop( evReqComplete );

   224 

   225     RPrGrntReqInfoImpArray* pendingList(NULL);

   226     CPresenceGrantRequestListEventImp* event = CreateGrantRequestListEventLCX(

   227         KNullDesC, KNullDesC,

   228         MXIMPDataSubscriptionState::ESubscriptionActive,

   229         MXIMPDataSubscriptionState::EDataUnavailable,

   230         ETestPGRPending, pendingList );

   231     listener2->ExpectL( event );

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

   233 

   234     // refresh subscription

   235     // ---------------------------------------------

   236     reqId = presAuth.SubscribePresenceGrantRequestListL();

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

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

   239 

   240 

   241     // ---------------------------------------------

   242     // 3. Unsubscribe grant request list

   243 

   244     // Setup status event listener for RequestComplete

   245     listener2->Reset();

   246 

   247     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   248     listener2->ExpectL( evReqComplete );

   249     CleanupStack::Pop( evReqComplete );

   250 

   251     // unsubscribe

   252     // ---------------------------------------------

   253     reqId = presAuth.UnsubscribePresenceGrantRequestListL();

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

   255 

   256 

   257     // verify that UnsubscribeGrantListL was called

   258     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceGrantRequestListCalled, "UnsubscribeGrantListL was not called", ETrue, NULL );

   259     

   260 

   261     // ---------------------------------------------

   262     // 4. Unsubscribe grant request list (non-subscribed)

   263 

   264     // Setup status event listener for RequestComplete

   265     listener2->Reset();

   266 

   267     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   268     listener2->ExpectL( evReqComplete );

   269     CleanupStack::Pop( evReqComplete );

   270 

   271     // unsubscribe

   272     // ---------------------------------------------

   273     reqId = presAuth.UnsubscribePresenceGrantRequestListL();

   274 

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

   276 

   277     // verify that UnsubscribeGrantListL was called

   278     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceGrantRequestListCalled, "UnsubscribeGrantListL was not called", ETrue, NULL );

   279 

   280     // Deinitiliaze event source from listener.

   281     listener2->SetEventSourceL( NULL );

   282 

   283     UnbindL();

   284 

   285     CleanupStack::PopAndDestroy( listener2 );

   286     }

   287 

   288 // ---------------------------------------------------------------------------

   289 // ---------------------------------------------------------------------------

   290 void T_PresenceGrantRequestManagement::T_SubscribeGrantRequestList_Multiple_L()

   291     {

   292     EUNIT_PRINT( _L("Multiple presence grant request list subscription") );

   293 

   294     BindAllL();

   295 

   296     TInt countOfWrappers = iWrapperMgr->WrapperCount();

   297     TInt a(0);

   298     for( a = 0; a < countOfWrappers; ++a )

   299         {

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

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

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

   303 

   304         // Get the interfaces

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

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

   307 

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

   309         CleanupStack::PushL( listener2 );

   310 

   311         // Tell the protocol it should act normally

   312         messenger->SetNoError();

   313 

   314         // expect normal request complete

   315         TXIMPRequestId reqIdDummy;  // not checked

   316         CXIMPRequestCompleteEventImp* evReqComplete =

   317                                 CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   318         listener2->ExpectL( evReqComplete );

   319         CleanupStack::Pop( evReqComplete );

   320 

   321         // subscribe

   322         TXIMPRequestId reqId = presAuth.SubscribePresenceGrantRequestListL();

   323 

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

   325 

   326         // verify that SubscribePresenceGrantRequestListL was called

   327         COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceGrantRequestListCalled, "SubscribePresenceGrantRequestListL was not called", ETrue, NULL );

   328 

   329         CleanupStack::PopAndDestroy( listener2 );

   330         }

   331 

   332     for( a = 0; a < countOfWrappers; ++a )

   333         {

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

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

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

   337         

   338         // Get the interfaces

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

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

   341 

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

   343         CleanupStack::PushL( listener2 );

   344 

   345         // Tell the protocol it should act normally

   346         messenger->SetNoError();

   347 

   348         // expect normal request complete

   349         TXIMPRequestId reqIdDummy;  // not checked

   350         CXIMPRequestCompleteEventImp* evReqComplete =

   351                             CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   352         listener2->ExpectL( evReqComplete );

   353         CleanupStack::Pop( evReqComplete );

   354 

   355         // unsubscribe

   356         TXIMPRequestId reqId = presAuth.UnsubscribePresenceGrantRequestListL();

   357 

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

   359 

   360         // verify that EXIMPPlgTestUnsubscribeGroupListCalled was called

   361         COMMONASSERT( messenger, EXIMPPlgTestUnsubscribeGroupListCalled,

   362                 "UnsubscribePresenceGrantRequestListL was not called",

   363                 EFalse,

   364                 "UnsubscribePresenceGrantRequestListL was called" );

   365 

   366         CleanupStack::PopAndDestroy( listener2 );

   367         }

   368 

   369     UnbindAllL();

   370     }

   371 

   372 // ---------------------------------------------------------------------------

   373 // ---------------------------------------------------------------------------

   374 void T_PresenceGrantRequestManagement::SubscribeL()

   375     {

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

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

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

   379 

   380     // Get the interfaces

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

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

   383 

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

   385     CleanupStack::PushL( listener2 );

   386 

   387     // ------------------------------------------------------

   388     // expect normal request complete

   389     TXIMPRequestId reqIdDummy;  // not checked

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

   391     listener2->ExpectL( evReqComplete );

   392     CleanupStack::Pop( evReqComplete );

   393     // ------------------------------------------------------

   394 

   395     // subscribe

   396     TXIMPRequestId reqId = presAuth.SubscribePresenceGrantRequestListL();

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

   398 

   399     COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceGrantRequestListCalled, "SubscribeGrantRequestListL was not called", ETrue, NULL );

   400 

   401     CleanupStack::PopAndDestroy( listener2 );

   402     }

   403 

   404 // ---------------------------------------------------------------------------

   405 // ---------------------------------------------------------------------------

   406 void T_PresenceGrantRequestManagement::UnsubscribeL()

   407     {

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

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

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

   411 

   412     // Get the interfaces

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

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

   415 

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

   417     CleanupStack::PushL( listener2 );

   418 

   419     // ------------------------------------------------------

   420     // expect normal request complete

   421     TXIMPRequestId reqIdDummy;  // not checked

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

   423     listener2->ExpectL( evReqComplete );

   424     CleanupStack::Pop( evReqComplete );

   425     // ------------------------------------------------------

   426 

   427     // unsubscribe

   428     TXIMPRequestId reqId = presAuth.UnsubscribePresenceGrantRequestListL();

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

   430 

   431     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceGrantRequestListCalled, "UnsubscribeGrantRequestListL was not called", ETrue, NULL );

   432 

   433     CleanupStack::PopAndDestroy( listener2 );

   434     }

   435 

   436 

   437 // ---------------------------------------------------------------------------

   438 // ---------------------------------------------------------------------------

   439 void T_PresenceGrantRequestManagement::T_HandlePresenceGrantRequestList_L()

   440     {

   441     EUNIT_PRINT( _L("Handle presence grant request list.") );

   442 

   443     // log in and subscribe a group list

   444     BindL();

   445     SubscribeL();

   446 

   447     // ------------------------------------------------------

   448     // some startup stuff

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

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

   451 

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

   453     CleanupStack::PushL( listener2 );

   454     // ------------------------------------------------------

   455 

   456     // Tell the protocol it should act normally

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

   458 

   459     // ------------------------------------------------------

   460     // 1. Create faked server message about grant req list (empty)

   461     SendSrvMsgL( CXIMPTestFileSrvMsg::ETestSrvMsgPresenceGrantRequestList );

   462 

   463     // ------------------------------------------------------

   464     // expect empty MPresentityGroupList event.

   465 

   466     RPrGrntReqInfoImpArray* pendingList(NULL);

   467     CPresenceGrantRequestListEventImp* event = CreateGrantRequestListEventLCX(

   468             KNullDesC, KNullDesC,

   469             MXIMPDataSubscriptionState::ESubscriptionActive,

   470             MXIMPDataSubscriptionState::EDataAvailable,

   471             ETestPGRPending, pendingList );

   472 

   473     listener2->ExpectL( event );

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

   475 

   476     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceGrantRequestListL failed" );

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

   478     // ------------------------------------------------------

   479 

   480 

   481     _LIT16( KGrantReqUri,      "http://carpe.diem.com" );

   482     _LIT16( KGrantReqDispName, "DispnameA, LoremI" );

   483 

   484     // ------------------------------------------------------

   485     // 2. Create faked server message about grant req list (new)

   486     listener2->Reset();

   487 

   488     pendingList = NULL; // previous one was destroyed

   489     event = CreateGrantRequestListEventLCX( KGrantReqUri,

   490                                             KGrantReqDispName,

   491                                             MXIMPDataSubscriptionState::ESubscriptionActive,

   492                                             MXIMPDataSubscriptionState::EDataAvailable,

   493                                             ETestPGRNewReq, pendingList  );

   494 

   495     SendSrvMsgL( KGrantReqUri,

   496                      KGrantReqDispName,

   497                      CXIMPTestFileSrvMsg::ETestSrvMsgPresenceGrantRequestList );

   498 

   499     listener2->ExpectL( event );

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

   501 

   502     // Waqas: Fixed Ticket #18

   503     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceGrantRequestListL failed" );

   504     

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

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

   507 

   508 

   509     CleanupStack::PopAndDestroy( listener2 );

   510 

   511     // clean it up

   512     UnsubscribeL();

   513     UnbindL();

   514     }

   515 

   516 

   517 // ---------------------------------------------------------------------------

   518 // ---------------------------------------------------------------------------

   519 _LIT16(  KPresentUri1,      "http://lorem.ipsum.com" );

   520 _LIT16(  KPresentUri2,      "http://carpe.diem.com" );

   521 _LIT16( KPresentDispName1, "DispnameA, LoremI" );

   522 _LIT16( KPresentDispName2, "DispnameB, CarpeD" );

   523 _LIT16( KPresentProtAddr1, "ABC" );

   524 _LIT16( KPresentProtAddr2, "HIJ" );

   525 

   526 void T_PresenceGrantRequestManagement::T_HandlePresenceGrantRequestReceivedObsoleted_L()

   527     {

   528     EUNIT_PRINT( _L("Handle presence grant request received") );

   529 

   530     BindL();

   531     SubscribeL();

   532 

   533     // ------------------------------------------------------

   534     // some startup stuff

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

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

   537 

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

   539     CleanupStack::PushL( listener2 );

   540     // ------------------------------------------------------

   541 

   542     // Tell the protocol it should act normally

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

   544 

   545     // ------------------------------------------------------

   546     // 1. Create faked server message about grant req received

   547     SendSrvMsgInfoL( KPresentUri1,

   548                      KPresentDispName1,

   549                      CXIMPTestFileSrvMsg::ETestSrvMsgPresenceGrantRequestReceived );

   550 

   551     // ------------------------------------------------------

   552     // expect MPresenceGrantRequestList event.

   553 

   554     CPresenceGrantRequestListEventImp* event = CreateGrantRequestListEventLCX(

   555             KPresentUri1, KPresentDispName1,

   556             MXIMPDataSubscriptionState::ESubscriptionActive,

   557             MXIMPDataSubscriptionState::EDataAvailable,

   558             ETestPGRNewReq, NULL );

   559 

   560     listener2->ExpectL( event );

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

   562 

   563     // Waqas: Fixed Ticket #18

   564     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceGrantRequesReceivedL failed" );

   565 

   566 

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

   568     // ------------------------------------------------------

   569 

   570 

   571     // ------------------------------------------------------

   572     // 2. Create faked server message about grant req obsoleted

   573     listener2->Reset();

   574 

   575     SendSrvMsgInfoL( KPresentUri1,

   576                      KPresentDispName1,

   577                      CXIMPTestFileSrvMsg::ETestSrvMsgPresenceGrantRequestObsoleted );

   578 

   579                      

   580     // we need to create pending list to give to the event

   581     RPrGrntReqInfoImpArray* pendingList = new ( ELeave ) RPrGrntReqInfoImpArray;

   582     CleanupDeletePushL( pendingList );

   583             // create the group info

   584     CXIMPIdentityImp* idForEvent = CXIMPIdentityImp::NewLC( KPresentUri1 );

   585     CPresenceGrantRequestInfoImp* grantInfoForEvent = 

   586                             CPresenceGrantRequestInfoImp::NewLC( *idForEvent, KPresentDispName1 );

   587     pendingList->AppendL( grantInfoForEvent );

   588     CleanupStack::Pop( grantInfoForEvent );

   589     CleanupStack::PopAndDestroy( idForEvent );

   590     CleanupStack::Pop( pendingList );

   591     

   592     //Now create the event

   593     event = CreateGrantRequestListEventLCX(

   594             KPresentUri1, KPresentDispName1,

   595             MXIMPDataSubscriptionState::ESubscriptionActive,

   596             MXIMPDataSubscriptionState::EDataAvailable,

   597             ETestPGRObsoleted, pendingList );

   598 

   599     listener2->ExpectL( event );

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

   601 

   602     // Waqas: Fixed Ticket #18

   603     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceGrantRequesObsoletedL failed" );

   604 

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

   606     // ------------------------------------------------------

   607 

   608     CleanupStack::PopAndDestroy( listener2 );

   609 

   610     // clean it up

   611     UnsubscribeL();

   612     UnbindL();

   613     }

   614 

   615 

   616 // ---------------------------------------------------------------------------

   617 // ---------------------------------------------------------------------------

   618 // send a faked server-originated message with grant request list made

   619 // from the given uri and displayname

   620 //

   621 void T_PresenceGrantRequestManagement::SendSrvMsgL(

   622         const TDesC& aUri, const TDesC& aDispName,

   623         TInt aMsgType )

   624     {

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

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

   627 

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

   629     // faked message

   630     RXIMPObjOwningPtrArray<CPresenceGrantRequestInfoImp> grantList;

   631     CleanupClosePushL( grantList );

   632 

   633     CXIMPIdentityImp* grantId = CXIMPIdentityImp::NewLC( aUri );

   634     CPresenceGrantRequestInfoImp* grantItem =

   635                 CPresenceGrantRequestInfoImp::NewLC( *grantId, aDispName );

   636     grantList.AppendL( grantItem );

   637     CleanupStack::Pop( grantItem );

   638     CleanupStack::PopAndDestroy( grantId );

   639 

   640     HBufC8* packedArray =

   641         TXIMPObjectPacker<CPresenceGrantRequestInfoImp>::PackArrayL( grantList );

   642     CleanupStack::PushL( packedArray );

   643 

   644     // use filetool to send it for plugin.

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

   646             *packedArray );

   647     CleanupStack::PushL( srvMsg );

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

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

   650     CleanupStack::PopAndDestroy( 3 ); // srvMsg, packedArray, grantList

   651     }

   652 

   653 // ---------------------------------------------------------------------------

   654 // ---------------------------------------------------------------------------

   655 // send a faked server-originated message with grant request info made

   656 // from the given uri and displayname

   657 //

   658 void T_PresenceGrantRequestManagement::SendSrvMsgInfoL(

   659         const TDesC& aUri, const TDesC& aDispName,

   660         TInt aMsgType )

   661     {

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

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

   664 

   665     CXIMPIdentityImp* grantId = CXIMPIdentityImp::NewLC( aUri );

   666     CPresenceGrantRequestInfoImp* grantItem =

   667                 CPresenceGrantRequestInfoImp::NewLC( *grantId, aDispName );

   668 

   669     HBufC8* packedInfo =

   670         TXIMPObjectPacker<CPresenceGrantRequestInfoImp>::PackL( *grantItem );

   671     CleanupStack::PushL( packedInfo );

   672 

   673     // use filetool to send it for plugin.

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

   675             *packedInfo );

   676     CleanupStack::PushL( srvMsg );

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

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

   679     CleanupStack::PopAndDestroy( 4 ); // srvMsg, packedItem, grantItem, grantId

   680     }

   681 

   682 

   683 // ---------------------------------------------------------------------------

   684 // ---------------------------------------------------------------------------

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

   686 //

   687 void T_PresenceGrantRequestManagement::SendSrvMsgL( TInt aMsgType )

   688     {

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

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

   691 

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

   693     RXIMPObjOwningPtrArray<CPresenceGrantRequestInfoImp> grantList;

   694 

   695     HBufC8* packedArray = TXIMPObjectPacker<CPresenceGrantRequestInfoImp>::PackArrayL( grantList );

   696     CleanupStack::PushL( packedArray );

   697 

   698     // use filetool to send it for plugin.

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

   700             *packedArray );

   701     CleanupStack::PushL( srvMsg );

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

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

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

   705     }

   706 

   707 // ---------------------------------------------------------------------------

   708 // ---------------------------------------------------------------------------

   709 // create a grant request list event with given arrays

   710 //

   711 CPresenceGrantRequestListEventImp*

   712     T_PresenceGrantRequestManagement::CreateGrantRequestListEventLCX(

   713         const TDesC& aUri,

   714         const TDesC& aDispName,

   715         MXIMPDataSubscriptionState::TSubscriptionState aSubscriptionState,

   716         MXIMPDataSubscriptionState::TDataState aDataState,

   717         TTestPGROperation aOperation,

   718         RPrGrntReqInfoImpArray* aPendingList

   719         )

   720     {

   721     // create the arrays

   722 

   723 

   724     // new list

   725     RPrGrntReqInfoImpArray* newList = new ( ELeave ) RPrGrntReqInfoImpArray;

   726     CleanupDeletePushL( newList );

   727 

   728     // pending list

   729     if(!aPendingList) // if client didnt created the list

   730         aPendingList = new ( ELeave ) RPrGrntReqInfoImpArray;

   731     CleanupDeletePushL( aPendingList );

   732 

   733     // obsoleted list

   734     RPrGrntReqInfoImpArray* obsoletedList = new ( ELeave ) RPrGrntReqInfoImpArray;

   735     CleanupDeletePushL( obsoletedList );

   736 

   737 	// create subscription state

   738 	CXIMPDataSubscriptionStateImp* subsState = CXIMPDataSubscriptionStateImp::NewLC();

   739 

   740     // create the group info

   741     CPresenceGrantRequestInfoImp* grantInfoForEvent1 = NULL;

   742             {

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

   744             grantInfoForEvent1 = CPresenceGrantRequestInfoImp::NewLC( *idForEvent, aDispName );

   745             CleanupStack::Pop( grantInfoForEvent1 );        

   746             CleanupStack::PopAndDestroy( idForEvent ); 

   747             CleanupStack::PushL( grantInfoForEvent1 );        

   748             }

   749     

   750     CPresenceGrantRequestInfoImp* grantInfoForEvent2 = 

   751             TXIMPObjectCloner< CPresenceGrantRequestInfoImp >::CloneLC( *grantInfoForEvent1 );

   752     

   753     TInt count(0);

   754     TBool found(EFalse);

   755     TInt i(0);

   756    

   757 

   758     // put the given grant info into the specified array

   759     switch ( aOperation )

   760         {

   761         case ETestPGRNewReq:

   762             {

   763             newList->AppendL( grantInfoForEvent2 );

   764             CleanupStack::Pop( grantInfoForEvent2 );

   765             

   766             aPendingList->AppendL( grantInfoForEvent1 );

   767             CleanupStack::Pop( grantInfoForEvent1 );

   768             

   769             break;

   770             }

   771         case ETestPGRPending:

   772             {

   773             // don't add, thus return what user has given

   774             CleanupStack::PopAndDestroy( grantInfoForEvent2 ); // grantInfoForEvent2

   775             CleanupStack::PopAndDestroy( grantInfoForEvent1 ); // grantInfoForEvent1

   776             break;

   777             }

   778 

   779         case ETestPGRObsoleted:

   780             {

   781             // search the given id in pending list

   782             count = aPendingList->Count();

   783             for(i=0;i<count;i++)

   784                 {

   785                 // if dispname and id are same

   786                 if (( ((((*aPendingList)[i])->RequestorId()).Identity()) == aUri )

   787                     && ( (((*aPendingList)[i])->RequestorDisplayName()) == aDispName ))

   788                     {

   789                     found = ETrue;

   790             break;

   791             }

   792                 }

   793             if(found) // do we need to leave if error? Waqas

   794             {

   795                 delete (*aPendingList)[i];

   796                 aPendingList->Remove(i);

   797                 obsoletedList->AppendL( grantInfoForEvent2 );

   798                 CleanupStack::Pop( grantInfoForEvent2 );

   799                 }

   800             else

   801                 CleanupStack::PopAndDestroy( grantInfoForEvent2 );

   802             

   803             CleanupStack::PopAndDestroy( grantInfoForEvent1 );

   804             break;

   805             }

   806 

   807         default:

   808             {

   809             User::Leave( KErrArgument );

   810             break;

   811             }

   812         };

   813 

   814 	subsState->SetSubscriptionStateL(aSubscriptionState);

   815     subsState->SetDataStateL(aDataState);

   816 

   817     // create the actual event

   818     CPresenceGrantRequestListEventImp* tmp =

   819         CPresenceGrantRequestListEventImp::NewLC(

   820                 newList,

   821                 aPendingList,

   822                 obsoletedList,

   823                 subsState );

   824 

   825     // subState is owned by the event, we need to pop it out from the stack

   826     CleanupStack::Pop( tmp );        

   827     CleanupStack::Pop( subsState ); 

   828     CleanupStack::PushL( tmp );        

   829 

   830     /*

   831      * In cleanupstack there are 4 items, FIFO:

   832      *   - new list

   833      *   - pending list

   834      *   - obsoleted list

   835      *   - event imp

   836      */

   837 

   838     return tmp;

   839     }

   840 

   841 // ===========================================================================

   842 // TEST CASE TABLE

   843 // ===========================================================================

   844 //

   845 EUNIT_BEGIN_TEST_TABLE(

   846         T_PresenceGrantRequestManagement,

   847         "XIMP presence grant request management tests",

   848         "MODULE" )

   849 

   850 PRFW_DECORATED_TEST(

   851         "Grant request list subscription, single client",

   852         "",

   853         "",

   854         "FUNCTIONALITY",

   855         Setup_L,

   856         T_SubscribeGrantRequestList_Single_L,

   857         Teardown )

   858 

   859 PRFW_DECORATED_TEST(

   860         "Grant request list subscription, multiple clients",

   861         "",

   862         "",

   863         "FUNCTIONALITY",

   864         SetupMultiple_L,

   865         T_SubscribeGrantRequestList_Multiple_L,

   866         Teardown )

   867 

   868 PRFW_DECORATED_TEST(

   869         "Handle presence grant request List",

   870         "",

   871         "",

   872         "FUNCTIONALITY",

   873         Setup_L,

   874         T_HandlePresenceGrantRequestList_L,

   875         Teardown )

   876 

   877 PRFW_DECORATED_TEST(

   878         "Handle presence grant request received and obsoleted",

   879         "",

   880         "",

   881         "FUNCTIONALITY",

   882         Setup_L,

   883         T_HandlePresenceGrantRequestReceivedObsoleted_L,

   884         Teardown )

   885 

   886 

   887 /*

   888 PRFW_DECORATED_TEST(

   889         "New and obsolete request.",

   890         "",

   891         "",

   892         "FUNCTIONALITY",

   893         Setup_L,

   894         T_HandlePresentityGroupCreateAndDelete_L,

   895         Teardown )

   896 */

   897 

   898 EUNIT_END_TEST_TABLE

   899 

   900 

   901 // ===========================================================================

   902 // TEST SUITE CONSTRUCTION

   903 // ===========================================================================

   904 //

   905 EXPORT_C MEUnitTest* CreateTestSuiteL()

   906     {

   907     return T_PresenceGrantRequestManagement::NewL();

   908     }

   909 

   910 

   911 // end of file