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

    30 #include <ximpobjectfactory.h>

    31 #include <presencepublishing.h>

    32 #include <presentitypresenceevent.h>

    33 #include <presenceobjectfactory.h>

    34 #include <presencefeatures.h>

    35 #include <presenceinfofield.h>

    36 #include <presenceinfofieldcollection.h>

    37 #include <servicepresenceinfo.h>

    38 #include <devicepresenceinfo.h>

    39 #include <personpresenceinfo.h>

    40 #include <presenceinfofieldvalueenum.h>

    41 #include <presenceinfofieldvaluetext.h>

    42 #include <presenceinfo.h>

    43 

    44 #include "t_presencepublishing.h"

    45 

    46 #include "prfwtestmessaging.h"

    47 #include "prfwtestmessenger.h"

    48 #include "prfwtestcontextwrappermgr.h"

    49 #include "prfwtestcontextwrapper.h"

    50 

    51 #include "prfwtestpresencedatautils.h"

    52 

    53 #include "ximprequestcompleteeventimp.h"

    54 #include "ximpcontextstateeventimp.h"

    55 #include "ximpcontextstateimp.h"

    56 #include "ximpstatusimp.h"

    57 #include "ownpresenceeventimp.h"

    58 

    59 // new test stuff

    60 #include "prfwtestlistener.h"

    61 #include "prfwtestfilesrvmsg.h"

    62 #include "prfwtestfiletool.h"

    63 

    64 

    65 #include "prfwtestrobustnesstools.h"

    66 

    67 _LIT8( KPrefix1, "PreA_" );

    68 _LIT8( KPrefix2, "PreB_" );

    69 _LIT8( KPrefix3, "PreC_" );

    70 _LIT8( KPrefix4, "PreD_" );

    71 

    72 _LIT8( KServiceType, "test_service" );

    73 _LIT(  KStatusMsg, "This is my status." );

    74 

    75 const TInt KTestAvailability = 1;

    76 

    77 // ============================ MEMBER FUNCTIONS ===============================

    78 

    79 // CONSTRUCTION

    80 T_PresencePublishing* T_PresencePublishing::NewL()

    81     {

    82     T_PresencePublishing* self = new( ELeave ) T_PresencePublishing;

    83     CleanupStack::PushL( self );

    84     self->ConstructL();

    85     CleanupStack::Pop( self );

    86 

    87     return self;

    88     }

    89 

    90 

    91 T_PresencePublishing::~T_PresencePublishing()

    92     {

    93     }

    94 

    95 

    96 void T_PresencePublishing::ConstructL()

    97     {

    98     CEUnitTestSuiteClass::ConstructL();

    99     }

   100 

   101 

   102 T_PresencePublishing::T_PresencePublishing()

   103     {

   104     }

   105 

   106 

   107 

   108 // ===========================================================================

   109 // TEST CASE SETUP & TEARDOWN METHODS

   110 // ===========================================================================

   111 //

   112 

   113 void T_PresencePublishing::Setup_L()

   114     {

   115     PrfwTestRobustness::DoPreCleaning();

   116   

   117     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   118     iWrapperMgr->CreateWrapperL();

   119     }

   120 

   121 void T_PresencePublishing::SetupMultiple_L()

   122     {

   123     PrfwTestRobustness::DoPreCleaning();

   124 

   125     iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

   126     iWrapperMgr->CreateWrapperL();

   127     iWrapperMgr->CreateWrapperL();

   128     iWrapperMgr->CreateWrapperL();

   129     }

   130 

   131 

   132 void T_PresencePublishing::BindL()

   133     {

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

   135 

   136     wrapper0->BindL( 0 );

   137     }

   138 

   139 void T_PresencePublishing::Bind2L()

   140     {

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

   142     wrapper0->BindWithSettingsL( 0 );

   143     }

   144     

   145 void T_PresencePublishing::BindAllL()

   146     {

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

   148         {

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

   150         wrapper->BindL( 0 );

   151         }

   152     }

   153 

   154 

   155 void T_PresencePublishing::Teardown()

   156     {

   157     delete iWrapperMgr;

   158     iWrapperMgr = NULL;

   159 

   160     REComSession::FinalClose();

   161 

   162     PrfwTestRobustness::DoPreCleaning();

   163     }

   164 

   165 void T_PresencePublishing::UnbindL()

   166     {

   167     // Do unbind

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

   169     wrapper0->UnbindL();

   170     }

   171 

   172 void T_PresencePublishing::UnbindAllL()

   173     {

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

   175         {

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

   177         wrapper->UnbindL();

   178         }

   179     }

   180 

   181 

   182 // ===========================================================================

   183 // TEST CASES for presence publish

   184 // ===========================================================================

   185 void T_PresencePublishing::T_Publish_Single_L()

   186     {

   187     EUNIT_PRINT( _L("Single Presence Publish test") );

   188 

   189     BindL();

   190 

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

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

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

   194 

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

   196     CleanupStack::PushL( listener2 );

   197 

   198     // Get the interfaces

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

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

   201 

   202     // Generate a doc

   203     CPresenceInfoImp* presInfo =

   204             XIMPTestPresenceDataUtils::GenerateInfoLC( &KPrefix1 );

   205 

   206     // Tell the protocol it should act normally

   207     messenger->SetNoError();

   208 

   209     // Publish the presence

   210     TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *presInfo );

   211 

   212     // Setup status event listener

   213     CXIMPRequestCompleteEventImp* evReqComplete =

   214                             CXIMPRequestCompleteEventImp::NewLC( reqId );

   215     listener2->ExpectL( evReqComplete );

   216     CleanupStack::Pop( evReqComplete );

   217 

   218     // Wait for events on the request

   219     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Publishing presence failed" );

   220     

   221 

   222     COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called", ETrue, NULL );

   223 

   224     CleanupStack::PopAndDestroy( presInfo );

   225     CleanupStack::PopAndDestroy( listener2 );

   226     UnbindL();

   227     }

   228 

   229 void T_PresencePublishing::T_NetworkUnplugError_L()

   230 	{

   231     EUNIT_PRINT( _L("Error from plug-in in publish own presence") );

   232     

   233     // Creating the error which comes from KErrTimedOut and protocol sends Connection terminated.

   234 

   235 // BIND AND SETUP

   236 

   237     Bind2L();

   238 

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

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

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

   242 

   243 

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

   245     CleanupStack::PushL( listener2 );

   246 

   247     // Get the interfaces

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

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

   250 

   251 

   252 // PUBLISH OWN

   253 

   254     //messenger->SetLeave( KErrAbort );

   255 	messenger->SetError(KErrTimedOut);

   256 	

   257     // publish own presence in here

   258     MPresenceInfo* info = CreateInfoLC();

   259 

   260     TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *info );

   261     

   262    

   263     // Setup status event listener for RequestComplete

   264     listener2->Reset();

   265     // request complete with KErrAbort

   266     CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   267     evReqComplete->CompletionResultImp().SetResultCode( KErrTimedOut );

   268     listener2->ExpectL( evReqComplete );

   269     CleanupStack::Pop( evReqComplete );

   270     

   271     CXIMPContextStateEventImp* evContextEvent = CXIMPContextStateEventImp::NewLC();

   272     evContextEvent->ContextStateImp().SetStateValue( MXIMPContextState::EUnbinding);

   273     listener2->ExpectL( evContextEvent );

   274     CleanupStack::Pop( evContextEvent );

   275     

   276     CXIMPContextStateEventImp* evContextEvent2 = CXIMPContextStateEventImp::NewLC();

   277     evContextEvent2->ContextStateImp().SetStateValue( MXIMPContextState::EInactive);

   278     listener2->ExpectL( evContextEvent2 );

   279     CleanupStack::Pop( evContextEvent2 );

   280     

   281     listener2->WaitAndAssertL();

   282 

   283 // UNBIND

   284 

   285     CleanupStack::PopAndDestroy(1);//info

   286     CleanupStack::PopAndDestroy( listener2 );

   287 

   288     messenger->SetError( KErrNone );

   289 

   290     UnbindL();

   291 	}    

   292 

   293 

   294 void T_PresencePublishing::T_NetworkUnplugErrorMultiple_L()

   295 	{

   296     EUNIT_PRINT( _L("Network disconnect from plug-in in publish own presence, multiple contexts") );

   297 

   298 	// Bind 2 contexts

   299 	BindAllL();

   300 

   301 	/* 

   302 	 * Make the 1st client publish someting and then the disconnect would happen 

   303 	 */

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

   305     MXIMPContext* context0 = wrapper0->GetContext();

   306     CXIMPTestMessenger* messenger0 = wrapper0->GetMessenger();

   307 

   308 

   309     CXIMPTestListener* listener0 = CXIMPTestListener::NewL( context0);

   310     CleanupStack::PushL( listener0);

   311 

   312     MPresenceFeatures* presFeat0 = wrapper0->GetPresenceFeatures();

   313     MPresencePublishing& presPub0 = presFeat0->PresencePublishing();

   314 

   315     //messenger->SetLeave( KErrAbort );

   316 	messenger0->SetError(KErrTimedOut);

   317 	

   318 

   319     // publish own presence in here

   320     MPresenceInfo* info = CreateInfoLC();

   321     TXIMPRequestId reqId = presPub0.PublishOwnPresenceL( *info );

   322 

   323     /* Setup status event listener for RequestComplete for client 1 */

   324     listener0->Reset();

   325     // request complete with KErrTimedOut

   326     CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   327     evReqComplete->CompletionResultImp().SetResultCode( KErrTimedOut );

   328     listener0->ExpectL( evReqComplete );

   329     CleanupStack::Pop( evReqComplete );

   330     

   331     // Create the context state events for unbinding

   332     CXIMPContextStateEventImp* evContextEvent = CXIMPContextStateEventImp::NewLC();

   333     evContextEvent->ContextStateImp().SetStateValue( MXIMPContextState::EUnbinding);

   334     listener0->ExpectL( evContextEvent );

   335     CleanupStack::Pop( evContextEvent );

   336     

   337     CXIMPContextStateEventImp* evContextEvent2 = CXIMPContextStateEventImp::NewLC();

   338     evContextEvent2->ContextStateImp().SetStateValue( MXIMPContextState::EInactive);

   339     listener0->ExpectL( evContextEvent2 );

   340     CleanupStack::Pop( evContextEvent2 );

   341 

   342   

   343    

   344    	/* 

   345    	 * Create a request for client 2, this will not be processed by the protocol plug-in 

   346    	 */

   347 	CXIMPTestContextWrapper* wrapper1 = iWrapperMgr->GetWrapperL( 1 );

   348     MXIMPContext* context1 = wrapper1->GetContext();

   349 

   350     MPresenceFeatures* presFeat1 = wrapper1->GetPresenceFeatures();

   351     MPresencePublishing& presPub1 = presFeat1->PresencePublishing();

   352 

   353 

   354     // Create the empty presence info filter

   355     CPresenceInfoFilterImp* pif = CPresenceInfoFilterImp::NewLC();

   356     TXIMPRequestId reqId1 = presPub1.SubscribeOwnPresenceL( *pif );

   357 	CleanupStack::PopAndDestroy(pif);

   358 

   359     // Setup status event listener for RequestComplete

   360     CXIMPTestListener* listener1 = CXIMPTestListener::NewL( context1);

   361     CleanupStack::PushL( listener1);

   362     listener1->Reset();

   363     // normal request complete

   364     CXIMPRequestCompleteEventImp* evReqComplete1 = CXIMPRequestCompleteEventImp::NewLC( reqId1 );

   365     evReqComplete1->CompletionResultImp().SetResultCode( KErrTimedOut );

   366     listener1->ExpectL( evReqComplete1 );

   367     CleanupStack::Pop( evReqComplete1 );

   368 

   369     // Create the context state events for unbinding

   370     evContextEvent = CXIMPContextStateEventImp::NewLC();

   371     evContextEvent->ContextStateImp().SetStateValue( MXIMPContextState::EUnbinding);

   372     listener1->ExpectL( evContextEvent );

   373     CleanupStack::Pop( evContextEvent );

   374     

   375     evContextEvent2 = CXIMPContextStateEventImp::NewLC();

   376     evContextEvent2->ContextStateImp().SetStateValue( MXIMPContextState::EInactive);

   377     listener1->ExpectL( evContextEvent2 );

   378     CleanupStack::Pop( evContextEvent2 );

   379 

   380 

   381     // Wait for events on the request

   382     

   383     EUNIT_ASSERT_DESC( KErrNone == listener0->WaitAndAssertL(), "Publish own presence failed in client 1");

   384 

   385     EUNIT_ASSERT_DESC( KErrNone == listener1->WaitAndAssertL(), "SubscribeOwnPresence failed in client 2" );

   386 

   387     CleanupStack::PopAndDestroy( listener1 );

   388     CleanupStack::PopAndDestroy(1);//info

   389     CleanupStack::PopAndDestroy( listener0 );

   390 		

   391 	// Finish the test case	

   392 	UnbindAllL();	

   393 	}

   394 

   395 void T_PresencePublishing::T_Publish_ErrFromPlg_Leave_L()

   396     {

   397     EUNIT_PRINT( _L("Single Presence Publish test") );

   398     EUNIT_PRINT( _L("Plugin leaves from PublishOwnPresenceL") );

   399 

   400     BindL();

   401 

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

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

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

   405 

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

   407     CleanupStack::PushL( listener2 );

   408 

   409     // Get the interfaces

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

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

   412 

   413     // Generate a doc

   414     CPresenceInfoImp* presDoc =

   415                 XIMPTestPresenceDataUtils::GenerateInfoLC( &KPrefix1 );

   416 

   417     // Setup status event listener

   418     SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );

   419 

   420     // Tell the test protocol to leave on next operation

   421     messenger->SetLeave( KErrAbort );

   422 

   423     // Publish the presence

   424     TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *presDoc );

   425     // Wait for events on the request

   426     wrapper->WaitRequestAndStackEvents( reqId );

   427     wrapper->VerifyEventStackL( _L8("Publishing single presence, leave with error: ") );

   428 

   429     // Verify that plugin left and didn't go through the PublishOwnPresenceL.

   430     COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called",

   431                                                 EFalse, "PublishPresenceL was called." );

   432 

   433 

   434     // TODO wait and verify the events

   435     EUNIT_FAIL_TEST( "Under construction." );

   436 

   437     CleanupStack::PopAndDestroy( presDoc );

   438     CleanupStack::PopAndDestroy( listener2 );

   439     UnbindL();

   440     }

   441 

   442 void T_PresencePublishing::T_Publish_ErrFromPlg_CompleteWithError_L()

   443     {

   444     EUNIT_PRINT( _L("Single Presence Publish test") );

   445     EUNIT_PRINT( _L("Plugin completes PublishOwnPresenceL with error") );

   446 

   447     BindL();

   448 

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

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

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

   452 

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

   454     CleanupStack::PushL( listener2 );

   455 

   456     // Get the interfaces

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

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

   459 

   460     // Generate a doc

   461     CPresenceInfoImp* presDoc =

   462                 XIMPTestPresenceDataUtils::GenerateInfoLC( &KPrefix1 );

   463 

   464     // Setup status event listener:

   465     //TODO  Setup presence event listener

   466     SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );

   467 

   468     // Tell the test protocol to return with error on next operation

   469     messenger->SetError( KErrAbort );

   470 

   471     // Publish the presence

   472     TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *presDoc );

   473     // Wait for events on the request

   474     wrapper->WaitRequestAndStackEvents( reqId );

   475     wrapper->VerifyEventStackL( _L8("Publishing single presence, complete with error: ") );

   476 

   477     // Verify that we did go through PublishOwnPresenceL.

   478     COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called", ETrue, NULL );

   479 

   480     // TODO wait and verify presence events

   481     EUNIT_FAIL_TEST( "Under construction." );

   482 

   483     CleanupStack::PopAndDestroy( presDoc );

   484     CleanupStack::PopAndDestroy( listener2 );

   485 

   486     UnbindL();

   487     }

   488 

   489 

   490 // ===========================================================================

   491 // TEST CASES for presence interest registration

   492 // ===========================================================================

   493 

   494 // Single client, empty filter

   495 void T_PresencePublishing::T_SubscribeOwnPresence_Single_Empty_L()

   496     {

   497     EUNIT_PRINT( _L("Single interest registration") );

   498 

   499     BindL();

   500 

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

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

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

   504 

   505 

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

   507     CleanupStack::PushL( listener2 );

   508 

   509     // Tell the protocol it should act normally

   510     messenger->SetNoError();

   511 

   512     // Get the interfaces

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

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

   515 

   516     // Create the empty presence info filter

   517     CPresenceInfoFilterImp* pif = CPresenceInfoFilterImp::NewLC();

   518 

   519     // Setup status event listener for RequestComplete

   520     listener2->Reset();

   521     // normal request complete

   522     TXIMPRequestId reqIdDummy;  // not checked

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

   524     listener2->ExpectL( evReqComplete );

   525     CleanupStack::Pop( evReqComplete );

   526 

   527     // subscribe own presence

   528     TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif );

   529 

   530     // Wait for events on the request

   531     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "SubscribeOwnPresence failed" );

   532 

   533     // verify that SubscribeOwnPresenceL was called

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

   535 

   536     // Setup status event listener for RequestComplete

   537     listener2->Reset();

   538     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

   539     listener2->ExpectL( evReqComplete );

   540     CleanupStack::Pop( evReqComplete );

   541   

   542     // unsubscribe own presence

   543     reqId = presPub.UnsubscribeOwnPresenceL();

   544 

   545     // Wait for events on the request

   546     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "UnsubscribeOwnPresence failed" );

   547     

   548     // verify that UnsubscribeOwnPresenceL was called

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

   550 

   551     CleanupStack::PopAndDestroy( pif );

   552     CleanupStack::PopAndDestroy( listener2 );

   553     UnbindL();

   554     }

   555 

   556 // Single client, empty filter

   557 void T_PresencePublishing::T_SubscribeOwnPresence_Multiple_Empty_L()

   558     {

   559     EUNIT_PRINT( _L("Multiple client filter registration") );

   560 

   561     BindAllL();

   562 

   563     // Create the empty presence info filter

   564     CPresenceInfoFilterImp* pif = CPresenceInfoFilterImp::NewLC();

   565 

   566     TInt countOfWrappers = iWrapperMgr->WrapperCount();

   567 

   568     CXIMPTestListener* listeners[ 50 ];

   569     TXIMPRequestId reqIdDummy;  // not checked

   570 

   571 

   572 

   573 // Setup listeners

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

   575         {

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

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

   578         listeners[ a ] = CXIMPTestListener::NewL( context );

   579         CleanupStack::PushL( listeners[ a ] );

   580         }

   581 

   582 

   583 // SUBSCRIBE

   584     for( TInt a = countOfWrappers - 1; a > 0 ; --a )

   585         {

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

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

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

   589 

   590         // Tell the protocol it should act normally

   591         messenger->SetNoError();

   592 

   593         // Get the interfaces

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

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

   596 

   597         // Setup status event listener for RequestComplete

   598         listeners[ a ]->Reset();

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

   600         listeners[ a ]->ExpectL( evReqComplete );

   601         CleanupStack::Pop( evReqComplete );

   602 

   603         messenger->SetValueFor( EXIMPPlgTestSubscribeOwnPresenceCalled, 0 );

   604         // subscribe own presence

   605         TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif );

   606 

   607         // Wait for events on the request

   608         EUNIT_ASSERT_DESC( KErrNone == listeners[ a ]->WaitAndAssertL(), "SubscribeOwnPresence failed" );

   609 

   610         // verify that SubscribeOwnPresenceL was called

   611         COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", 

   612         ( a > 1 ) ? ETrue : EFalse , "SubscribeOwnPresenceL was called." );

   613         }

   614         

   615 // REFRESH

   616 

   617     for( TInt a = countOfWrappers - 1; a > 0 ; --a )

   618         {

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

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

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

   622 

   623         // Tell the protocol it should act normally

   624         messenger->SetNoError();

   625 

   626         // Get the interfaces

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

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

   629 

   630         // Setup status event listener for RequestComplete

   631         listeners[ a ]->Reset();

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

   633         listeners[ a ]->ExpectL( evReqComplete );

   634         CleanupStack::Pop( evReqComplete );

   635         

   636         CXIMPDataSubscriptionStateImp* stateImp = CXIMPDataSubscriptionStateImp::NewLC();

   637         stateImp->SetDataStateL( MXIMPDataSubscriptionState::EDataUnavailable );

   638         stateImp->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive );

   639         COwnPresenceEventImp* evOwnPresence = COwnPresenceEventImp::NewLC( stateImp );

   640         CleanupStack::Pop( 2, stateImp );

   641         CleanupStack::PushL( evOwnPresence );

   642         listeners[ a ]->ExpectL( evOwnPresence );

   643         CleanupStack::Pop( evOwnPresence );

   644         

   645         // TODO check if this call is still needed

   646         messenger->SetValueFor( EXIMPPlgTestSubscribeOwnPresenceCalled, 0 );

   647 

   648         // subscribe own presence

   649         TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif );

   650 

   651         // Wait for events on the request

   652         EUNIT_ASSERT_DESC( KErrNone == listeners[ a ]->WaitAndAssertL(), "SubscribeOwnPresence failed" );

   653         

   654         // verify that SubscribeOwnPresenceL was called

   655         COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled,

   656                         "SubscribeOwnPresenceL was not called", 

   657                         EFalse , "SubscribeOwnPresenceL was called." );

   658         }

   659 

   660         

   661 // UNSUBSCRIBE

   662         

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

   664         {

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

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

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

   668 

   669         // Get the interfaces

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

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

   672 

   673         // Setup status event listener for RequestComplete

   674         listeners[ a ]->Reset();

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

   676         listeners[ a ]->ExpectL( evReqComplete );

   677         CleanupStack::Pop( evReqComplete );

   678         

   679 

   680         // register interest

   681         TXIMPRequestId reqId = presPub.UnsubscribeOwnPresenceL();

   682 

   683         // Wait for events on the request

   684         EUNIT_ASSERT_DESC( KErrNone == listeners[ a ]->WaitAndAssertL(), "UnsubscribeOwnPresence failed" );

   685 

   686  

   687         // verify that UpdateInterest was called

   688         COMMONASSERT( messenger, EXIMPPlgTestUnsubscribeOwnPresenceCalled, 

   689             "UnsubscribeOwnPresenceL was not called",

   690             ( a < 2 ) ? EFalse : ETrue,

   691             "UnsubscribeOwnPresenceL was called" );

   692         }

   693 

   694 

   695     // delete the listeners

   696     CleanupStack::PopAndDestroy( countOfWrappers ); // the contents of listeners[]

   697 

   698     CleanupStack::PopAndDestroy( pif );

   699     

   700     UnbindAllL();

   701     }

   702 

   703 

   704 // Single client, filled filter

   705 void T_PresencePublishing::T_SubscribeOwnPresence_Single_L()

   706     {

   707     EUNIT_PRINT( _L("Single interest registration") );

   708 

   709     BindL();

   710 

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

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

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

   714 

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

   716     CleanupStack::PushL( listener2 );

   717 

   718     // Get the interfaces

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

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

   721 

   722     // Create the filled interest document

   723     CPresenceInfoFilterImp* pif =

   724                 XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   725 

   726     // Tell the protocol it should act normally

   727     messenger->SetNoError();

   728 

   729 

   730 // SUBSCRIBE

   731 

   732     // subscribe own presence

   733     TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif );

   734 

   735     // Setup status event listener for RequestComplete

   736     listener2->Reset();

   737     SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );

   738     CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   739     listener2->ExpectL( evReqComplete );

   740     CleanupStack::Pop( evReqComplete );

   741 

   742     // Wait for events on the request

   743     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "SubscribeOwnPresence failed" );

   744 

   745     // verify that SubscribeOwnPresenceL was called

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

   747 

   748 // REFRESH

   749 

   750     // subscribe own presence (refresh)

   751     reqId = presPub.SubscribeOwnPresenceL( *pif );

   752 

   753     // Setup status event listener for RequestComplete

   754     SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );

   755     messenger->SetValueFor( EXIMPPlgTestSubscribeOwnPresenceCalled, 0 );

   756     listener2->Reset();

   757     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   758     listener2->ExpectL( evReqComplete );

   759     CleanupStack::Pop( evReqComplete );

   760     // also the event

   761     

   762     CXIMPDataSubscriptionStateImp* stateImp = CXIMPDataSubscriptionStateImp::NewLC();

   763     stateImp->SetDataStateL( MXIMPDataSubscriptionState::EDataUnavailable );

   764     stateImp->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive );    

   765     COwnPresenceEventImp* event = COwnPresenceEventImp::NewLC( stateImp );

   766     CleanupStack::Pop( 2, stateImp );

   767     CleanupStack::PushL( event );    

   768     listener2->ExpectL( event );

   769     CleanupStack::Pop( event );

   770 

   771     // Wait for events on the request

   772     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Refreshing own presence subscription failed" );

   773 

   774     // verify that SubscribeOwnPresenceL was called

   775     COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", EFalse, "SubscribeOwnPresenceL was called" );

   776 

   777     CleanupStack::PopAndDestroy( pif );

   778     CleanupStack::PopAndDestroy( listener2 );

   779     UnbindL();

   780     }

   781 

   782 void T_PresencePublishing::T_ErrFromPlg_LeaveOnSubscribeOwnPresence_L()

   783     {

   784     EUNIT_PRINT( _L("Error from plug-in in presentity presence subscribe") );

   785     EUNIT_PRINT( _L("Plug-in leaves from SubscribePresence().") );

   786 

   787 // BIND AND SETUP

   788 

   789     BindL();

   790 

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

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

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

   794 

   795 

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

   797     CleanupStack::PushL( listener2 );

   798 

   799     // Get the interfaces

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

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

   802 

   803     // Create the filled interest document

   804     CPresenceInfoFilterImp* pif =

   805                 XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

   806 

   807 // SUBSCRIBE

   808 

   809     messenger->SetLeave( KErrAbort );

   810 

   811     // subscribe own presence

   812     TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif );

   813 

   814     // Setup status event listener for RequestComplete

   815     listener2->Reset();

   816     // request complete with KErrAbort

   817     CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   818     evReqComplete->CompletionResultImp().SetResultCode( KErrAbort );

   819     listener2->ExpectL( evReqComplete );

   820     CleanupStack::Pop( evReqComplete );

   821 

   822     // Wait for events on the request

   823     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribing presentity presence, didn't complete with error" );

   824     

   825     // verify that SubscribeOwnPresenceL was called

   826     COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", EFalse, "SubscribeOwnPresenceL was called" );

   827     

   828         

   829 // SUBSCRIBE

   830 

   831     messenger->SetLeave( KErrNone );

   832 

   833     // subscribe own presence

   834     reqId = presPub.SubscribeOwnPresenceL( *pif );

   835 

   836     // Setup status event listener for RequestComplete

   837     listener2->Reset();

   838     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   839     listener2->ExpectL( evReqComplete );

   840     CleanupStack::Pop( evReqComplete );

   841 

   842     // Wait for events on the request

   843     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribing presentity presence failed" );

   844 

   845     // verify that SubscribeOwnPresenceL was called

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

   847     

   848 

   849 // UNSUBSCRIBE

   850 

   851     messenger->SetLeave( KErrAbort );

   852 

   853     // register interest

   854     reqId = presPub.UnsubscribeOwnPresenceL();

   855 

   856     // Setup status event listener for RequestComplete

   857     listener2->Reset();

   858     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   859     evReqComplete->CompletionResultImp().SetResultCode( KErrAbort );

   860     listener2->ExpectL( evReqComplete );

   861     CleanupStack::Pop( evReqComplete );

   862 

   863     // Wait for events on the request

   864     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribing presentity presence with error failed" );

   865 

   866     // verify that UnsubscribeOwnPresenceL was called

   867     COMMONASSERT( messenger, EXIMPPlgTestUnsubscribeOwnPresenceCalled, "UnsubscribeOwnPresenceL was not called", EFalse, 

   868                                                                        "UnsubscribeOwnPresenceL was called." );

   869     

   870 // UNBIND

   871 

   872     CleanupStack::PopAndDestroy( pif );

   873     CleanupStack::PopAndDestroy( listener2 );

   874 

   875     messenger->SetLeave( KErrNone );

   876 

   877     UnbindL();

   878     }

   879 

   880 // ===========================================================================

   881 // Single client, filled filter, publish.

   882 // ===========================================================================

   883 //

   884 

   885 void T_PresencePublishing::T_SubscribeOwnPresence_Publish_Single_L()

   886     {

   887     EUNIT_PRINT( _L("Single interest registration with publish") );

   888 

   889     /*

   890      * TODO: 

   891      *

   892      * case 1

   893      *

   894      * - subscribetä oma presence

   895      * - luo filtteri

   896      * - luo info

   897      * - publishaa oma presence + info

   898      * - tsekkaa että alakerta on saanut infon

   899      * - subscribetä uudelleen (=refresh case)

   900      * - tsekkaa että kaikki ok

   901      *

   902      * case 2

   903      *

   904      * - sama filtteri kuin edellä

   905      * - feikkaa verkkoserveriltä tuleva viesti, jossa sama info kuin edellä

   906      * - tsekkaa, että frameworkin läpi tuleva info sisältää vain ne kamat

   907      *   jotka on sallittu ja että muut on blokattu. ts. "test_service":n

   908      *   "availability" pitäisi tulla läpi. person-presenceen tungettu kama jää

   909      *   pois

   910      *

   911      */

   912 

   913     BindL();

   914 

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

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

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

   918 

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

   920     CleanupStack::PushL( listener2 );

   921 

   922     // Get the interfaces

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

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

   925 

   926     // Create the filter 

   927     MPresenceInfoFilter* pif = presFeat->PresenceObjectFactory().NewPresenceInfoFilterLC();

   928     pif->AcceptServiceFilterL( KServiceType, NPresenceInfo::NFieldType::KAvailability ); // "test_service", "availability"

   929     // note, the person info will be filtered out now since we don't accept it.

   930 

   931     // Tell the protocol it should act normally

   932     messenger->SetNoError();

   933 

   934     // SUBSCRIBE

   935 

   936     // subscribe own presence

   937     TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif );

   938 

   939     // Setup status event listener for RequestComplete

   940     CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   941     listener2->ExpectL( evReqComplete );

   942     CleanupStack::Pop( evReqComplete );

   943 

   944     // Wait for events on the request

   945     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "SubscribeOwnPresence failed" );

   946 

   947     // verify that SubscribeOwnPresenceL was called

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

   949     

   950     // publish own presence in here

   951     MPresenceInfo* info = CreateInfoLC();

   952 

   953     reqId = presPub.PublishOwnPresenceL( *info );

   954 

   955     // Setup status event listener

   956     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   957     listener2->ExpectL( evReqComplete );

   958     CleanupStack::Pop( evReqComplete );

   959     

   960     CXIMPDataSubscriptionStateImp* stateImp = CXIMPDataSubscriptionStateImp::NewLC();

   961     stateImp->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable );

   962     stateImp->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive );    

   963     COwnPresenceEventImp* event = COwnPresenceEventImp::NewLC( stateImp );

   964     CleanupStack::Pop( 2, stateImp );

   965     CleanupStack::PushL( event );    

   966     listener2->ExpectL( event );

   967     CleanupStack::Pop( event );

   968 

   969     // Wait for events on the request

   970     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Publishing presence failed" );

   971     COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called", ETrue, NULL );

   972 

   973     // REFRESH

   974 

   975     // subscribe own presence (refresh)

   976     reqId = presPub.SubscribeOwnPresenceL( *pif );

   977 

   978     // Setup status event listener for RequestComplete

   979     messenger->SetValueFor( EXIMPPlgTestSubscribeOwnPresenceCalled, 0 );

   980     evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );

   981     listener2->ExpectL( evReqComplete );

   982     CleanupStack::Pop( evReqComplete );

   983     // also the event

   984     

   985     stateImp = CXIMPDataSubscriptionStateImp::NewLC();

   986     stateImp->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable );

   987     stateImp->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive );    

   988     event = COwnPresenceEventImp::NewLC( stateImp );

   989     CleanupStack::Pop( 2, stateImp );

   990     CleanupStack::PushL( event );    

   991     listener2->ExpectL( event );

   992     CleanupStack::Pop( event );

   993 

   994     // Wait for events on the request

   995     EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Refreshing own presence subscription failed" );

   996 

   997     // verify that SubscribeOwnPresenceL was called

   998     COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", EFalse, "SubscribeOwnPresenceL was called" );

   999 

  1000     CleanupStack::PopAndDestroy( 3, listener2 ); // info, pif, listener2

  1001     UnbindL();

  1002     }

  1003 

  1004 

  1005 // ===========================================================================

  1006 // SETUP HELPERS FOR THE LISTENER

  1007 // ===========================================================================

  1008 //

  1009 void T_PresencePublishing::SetupListenerReqCompleteL( CXIMPTestContextWrapper* aWrapper, TXIMPTestStatusEventTemplate aEventType )

  1010     {

  1011     RArray< TInt32 > array;

  1012     CleanupClosePushL( array );

  1013     array.Append( MXIMPContextStateEvent::KInterfaceId );

  1014     array.Append( MOwnPresenceEvent::KInterfaceId );

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

  1016     CleanupStack::PopAndDestroy(); // array

  1017     }

  1018 

  1019 void T_PresencePublishing::SetupListenerReqCompleteAllowEventsL(  CXIMPTestContextWrapper* aWrapper, TXIMPTestStatusEventTemplate aEventType )

  1020     {

  1021     RArray< TInt32 > array;

  1022     CleanupClosePushL( array );

  1023     array.AppendL( MXIMPRequestCompleteEvent::KInterfaceId );

  1024     array.AppendL( MXIMPContextStateEvent::KInterfaceId );

  1025     array.AppendL( MOwnPresenceEvent::KInterfaceId );

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

  1027     CleanupStack::PopAndDestroy(); // array

  1028     }

  1029 

  1030 MPresenceInfo* T_PresencePublishing::CreateInfoLC()

  1031     {

  1032     // fill up the info structure with:

  1033     // service info imp: 

  1034     //   - info name:    "test_service"

  1035     //   - field name:   availability

  1036     //   - field value:  enum type, value 1

  1037     // person info imp:

  1038     //   - field name:   "status-message"

  1039     //   - field value:  "This is my status message."

  1040     //

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

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

  1043 

  1044     // Get the interface

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

  1046     MPresenceInfo* info = presFeat->PresenceObjectFactory().NewPresenceInfoLC();

  1047 

  1048     // fill service info

  1049     MServicePresenceInfo* srvInfo = presFeat->PresenceObjectFactory().NewServicePresenceInfoLC();

  1050     srvInfo->SetServiceTypeL( KServiceType );  // test

  1051 

  1052     MPresenceInfoField* infoField = presFeat->PresenceObjectFactory().NewInfoFieldLC();

  1053     

  1054     MPresenceInfoFieldValueEnum* enumField = presFeat->PresenceObjectFactory().NewEnumInfoFieldLC();

  1055     enumField->SetValueL( KTestAvailability ); // 1

  1056     infoField->SetFieldTypeL( NPresenceInfo::NFieldType::KAvailability ); // "availability"

  1057     infoField->SetFieldValue( enumField );

  1058     CleanupStack::Pop(); // enumField

  1059 

  1060     srvInfo->Fields().AddOrReplaceFieldL( infoField );

  1061     CleanupStack::Pop(); // infoField 

  1062 

  1063     info->AddServicePresenceL( srvInfo );

  1064     CleanupStack::Pop(); // srvInfo 

  1065 

  1066     // fill person info

  1067     MPersonPresenceInfo* persInfo = presFeat->PresenceObjectFactory().NewPersonPresenceInfoLC();

  1068     MPresenceInfoField* infoField2 = presFeat->PresenceObjectFactory().NewInfoFieldLC();

  1069     

  1070     MPresenceInfoFieldValueText* textField = presFeat->PresenceObjectFactory().NewTextInfoFieldLC();

  1071     textField->SetTextValueL( KStatusMsg );

  1072 

  1073     infoField2->SetFieldTypeL( NPresenceInfo::NFieldType::KStatusMessage );

  1074     infoField2->SetFieldValue( textField );

  1075     CleanupStack::Pop(); // textField

  1076 

  1077     persInfo->Fields().AddOrReplaceFieldL( infoField2 );

  1078     CleanupStack::Pop(); // infoField2

  1079 

  1080     info->SetPersonPresenceL( persInfo );

  1081     CleanupStack::Pop(); // persInfo

  1082     // that's it

  1083 

  1084     return info;

  1085     }

  1086 

  1087 // ===========================================================================

  1088 // TEST CASE TABLE

  1089 // ===========================================================================

  1090 //

  1091 EUNIT_BEGIN_TEST_TABLE(

  1092         T_PresencePublishing,

  1093         "XIMP presence management tests",

  1094         "MODULE" )

  1095 

  1096 

  1097 PRFW_DECORATED_TEST(

  1098         "Publish single presence",

  1099         "",

  1100         "",

  1101         "FUNCTIONALITY",

  1102         Setup_L,

  1103         T_Publish_Single_L,

  1104         Teardown )

  1105 

  1106 /*

  1107 PRFW_NOT_DECORATED_TEST(

  1108         "Publish, error leave",

  1109         "",

  1110         "",

  1111         "ERRORHANDLING",

  1112         Setup_Bind_L,

  1113         T_Publish_ErrFromPlg_Leave_L,

  1114         Teardown_Unbind )

  1115 

  1116 PRFW_NOT_DECORATED_TEST(

  1117         "Publish, error complete",

  1118         "",

  1119         "",

  1120         "ERRORHANDLING",

  1121         Setup_Bind_L,

  1122         T_Publish_ErrFromPlg_CompleteWithError_L,

  1123         Teardown_Unbind )

  1124 */

  1125 

  1126 PRFW_DECORATED_TEST(

  1127         "Empty own presence subscribtion",

  1128         "",

  1129         "",

  1130         "FUNCTIONALITY",

  1131         Setup_L,

  1132         T_SubscribeOwnPresence_Single_Empty_L,

  1133         Teardown )

  1134