--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ximpfw/tsrc/src/t_presencewatcherlistmngt/t_presencewatcherlistmngt.cpp Thu Dec 17 08:54:49 2009 +0200
@@ -0,0 +1,1353 @@
+/*
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: XIMP Framework Test Code
+*
+*/
+
+
+#include "eunittools.h"
+
+#include <eunitmacros.h>
+#include <ecom/ecom.h>
+#include <badesca.h>
+
+#include <ximpbase.h>
+#include <ximpclient.h>
+#include <presencefeatures.h>
+#include <presencepublishing.h>
+#include <ximpdatasubscriptionstate.h>
+#include <presentitygroups.h>
+#include <ximpobjectfactory.h>
+#include <presencewatching.h>
+#include <presenceobjectfactory.h>
+#include <ximpcontext.h>
+#include <ximpcontextstateevent.h>
+#include <ximprequestcompleteevent.h>
+#include <ximpstatus.h>
+#include <presentitypresenceevent.h>
+#include "prfwtestpresencedatautils.h"
+
+
+
+#include "t_presencewatcherlistmngt.h"
+
+// watcher list related includes
+#include "presencewatcherinfoimp.h"
+#include "presencewatcherlisteventimp.h"
+
+// other data model includes
+#include "ximpidentityimp.h"
+#include "ximpdatasubscriptionstateimp.h"
+#include "presentitygroupmemberinfoimp.h"
+#include "presenceinfofilterimp.h"
+
+// utils includes
+#include "ximpobjecthelpers.h"
+
+#include "ximprequestcompleteeventimp.h"
+
+// testing tool includes
+#include "prfwtestmessaging.h"
+#include "prfwtestmessenger.h"
+#include "prfwtestcontextwrappermgr.h"
+#include "prfwtestcontextwrapper.h"
+#include "prfwtestwaithelper.h"
+
+#include "prfwtestfilesrvmsg.h"
+#include "prfwtestfiletool.h"
+#include "prfwtestlistener.h"
+
+#include "prfwtestrobustnesstools.h"
+
+
+
+
+
+/*#include "presenceinfoimp.h"
+#include "presenceinfofilterimp.h"
+#include "prfwtestpresencedatautils.h"
+#include "ximpidentityimp.h"
+#include "presentitygroupmemberinfoimp.h"
+#include "ximpobjecthelpers.h"
+#include "prfwtestfilesrvmsg.h"
+#include "prfwtestwaithelper.h"*/
+
+_LIT8( KPrefix1, "PreA_" );
+_LIT8( KPrefix2, "PreB_" );
+_LIT8( KPrefix3, "PreC_" );
+_LIT8( KPrefix4, "PreD_" );
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// CONSTRUCTION
+T_PresenceWatcherListManagement* T_PresenceWatcherListManagement::NewL()
+ {
+ T_PresenceWatcherListManagement* self = new( ELeave ) T_PresenceWatcherListManagement;
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+
+T_PresenceWatcherListManagement::~T_PresenceWatcherListManagement()
+ {
+ }
+
+
+void T_PresenceWatcherListManagement::ConstructL()
+ {
+ CEUnitTestSuiteClass::ConstructL();
+ }
+
+
+T_PresenceWatcherListManagement::T_PresenceWatcherListManagement()
+ {
+ }
+
+
+
+// ===========================================================================
+// TEST CASE SETUP & TEARDOWN METHODS
+// ===========================================================================
+//
+
+void T_PresenceWatcherListManagement::Setup_L()
+ {
+
+ __UHEAP_MARK;
+ PrfwTestRobustness::DoPreCleaning();
+
+ iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();
+ iWrapperMgr->CreateWrapperL();
+ }
+
+void T_PresenceWatcherListManagement::SetupMultiple_L()
+ {
+ __UHEAP_MARK;
+ PrfwTestRobustness::DoPreCleaning();
+
+ iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();
+ iWrapperMgr->CreateWrapperL();
+ iWrapperMgr->CreateWrapperL();
+ iWrapperMgr->CreateWrapperL();
+ }
+
+
+void T_PresenceWatcherListManagement::BindL()
+ {
+ CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 );
+
+ wrapper0->BindL( 0 );
+ }
+
+void T_PresenceWatcherListManagement::BindAllL()
+ {
+ for( TInt a = 0; a < iWrapperMgr->WrapperCount(); ++a )
+ {
+ CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );
+ wrapper->BindL( 0 );
+ }
+ }
+
+
+void T_PresenceWatcherListManagement::Teardown()
+ {
+ delete iWrapperMgr;
+ iWrapperMgr = NULL;
+
+ REComSession::FinalClose();
+
+ PrfwTestRobustness::DoPreCleaning();
+
+ __UHEAP_MARKEND;
+ }
+
+void T_PresenceWatcherListManagement::UnbindL()
+ {
+ // Do unbind
+ CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 );
+ wrapper0->UnbindL();
+ }
+
+void T_PresenceWatcherListManagement::UnbindAllL()
+ {
+ for( TInt a = 0; a < iWrapperMgr->WrapperCount(); ++a )
+ {
+ CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );
+ wrapper->UnbindL();
+ }
+ }
+
+
+// ===========================================================================
+// TEST CASES for presentity presence subscription
+// ===========================================================================
+// Check that this don't leak memory
+void T_PresenceWatcherListManagement::T_BindUnbind_L()
+ {
+ BindL();
+ UnbindL();
+ }
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Subscribe, unsubscribe - Single client
+void T_PresenceWatcherListManagement::T_SubscribePresenceWatcherList_Single_L()
+ {
+
+ EUNIT_PRINT( _L("Single client presence watcher list subscription") );
+
+ BindL();
+
+ CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
+ MXIMPContext* context = wrapper->GetContext();
+ CXIMPTestMessenger* messenger = wrapper->GetMessenger();
+
+ CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
+ CleanupStack::PushL( listener2 );
+
+ // Tell the protocol it should act normally
+ messenger->SetNoError();
+
+ // Get the interfaces
+ MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
+ MPresencePublishing& presPub = presFeat->PresencePublishing();
+
+ //-------------------------------------------------
+ // subscribe
+
+ // Setup status event listener for RequestComplete
+ // ---------------------------------------------
+ listener2->Reset();
+
+ // normal request complete
+ TXIMPRequestId reqIdDummy; // not checked
+ CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
+ listener2->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete );
+
+
+ // Subscribe
+ TXIMPRequestId reqId = presPub.SubscribePresenceWatcherListL();
+
+ EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribe failed" );
+
+ // verify that SubscribePresenceWatcherListL was called
+ COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceWatcherListCalled, "SubscribePresenceWatcherListL was not called", ETrue, NULL );
+
+ //-------------------------------------------------
+ // refresh subscribe
+
+ // Setup status event listener for RequestComplete
+ listener2->Reset();
+
+ evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
+ listener2->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete );
+
+ RPrWatLstInfoImpArray* currentList(NULL);
+ CPresenceWatcherListEventImp* event = CreateWatcherListEventLCX(
+ KNullDesC, KNullDesC,
+ MXIMPDataSubscriptionState::ESubscriptionActive,
+ MXIMPDataSubscriptionState::EDataUnavailable,
+ ETestPWlCurrent, currentList);
+ listener2->ExpectL( event );
+ CleanupStack::Pop(); //event 3 to go.
+ // ---------------------------------------------
+
+ // Subscribe second time
+ reqId = presPub.SubscribePresenceWatcherListL();
+
+ EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Refresh failed" );
+ CleanupStack::PopAndDestroy( 3 ); // rest of the items.
+
+ // verify that SubscribePresenceWatcherListL was called
+ COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceWatcherListCalled, "SubscribePresenceWatcherListL was not called", ETrue, NULL );
+
+
+ //-------------------------------------------------
+ // unsubscribe
+
+ // Setup status event listener for RequestComplete
+ listener2->Reset();
+
+ evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
+ listener2->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete );
+
+ // register interest
+ reqId = presPub.UnsubscribePresenceWatcherListL();
+
+ EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe failed" );
+
+ // verify that UnsubscribePresenceWatcherListL was called
+ COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled, "UnsubscribePresenceWatcherListL was not called", ETrue, NULL );
+
+ //-------------------------------------------------
+ // unsubscribe nonsubscribed
+
+ // Setup status event listener for RequestComplete
+ listener2->Reset();
+
+ evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
+ listener2->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete );
+
+ // register interest
+ reqId = presPub.UnsubscribePresenceWatcherListL();
+
+ // Wait for events on the request
+ EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe failed" );
+
+ // verify that UpdateInterest was called
+ COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled, "UnsubscribePresenceWatcherListL was not called", ETrue, NULL );
+
+
+
+ listener2->SetEventSourceL( NULL );
+
+ UnbindL();
+
+ CleanupStack::PopAndDestroy( listener2 );
+ }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Subscribe, Unsubscribe - Multiple clients
+void T_PresenceWatcherListManagement::T_SubscribePresenceWatcherList_Multiple_L()
+ {
+ EUNIT_PRINT( _L("Multiple client presence watcher list subscription") );
+
+ BindAllL();
+
+ TInt countOfWrappers = iWrapperMgr->WrapperCount();
+ for( TInt a = 0; a < countOfWrappers; ++a )
+ {
+ CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );
+ MXIMPContext* context = wrapper->GetContext();
+ CXIMPTestMessenger* messenger = wrapper->GetMessenger();
+
+ // Tell the protocol it should act normally
+ messenger->SetNoError();
+
+ CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
+ CleanupStack::PushL( listener2 );
+
+ // Get the interfaces
+ MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
+ MPresencePublishing& presPub = presFeat->PresencePublishing();
+
+ // Setup status event listener for RequestComplete
+ listener2->Reset();
+
+ TXIMPRequestId reqIdDummy; // not checked
+ CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
+ listener2->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete );
+
+ // Subscribe
+ TXIMPRequestId reqId = presPub.SubscribePresenceWatcherListL();
+
+ // Wait for events on the request
+ EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribe failed" );
+
+ // verify that SubscribePresenceWatcherListL was called
+ COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceWatcherListCalled, "SubscribePresenceWatcherListL was not called", ETrue, NULL );
+
+ CleanupStack::PopAndDestroy( listener2 );
+ }
+ for( TInt a = 0; a < countOfWrappers; ++a )
+ {
+ CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );
+ MXIMPContext* context = wrapper->GetContext();
+ CXIMPTestMessenger* messenger = wrapper->GetMessenger();
+
+ CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
+ CleanupStack::PushL( listener2 );
+
+ // Get the interfaces
+ MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
+ MPresencePublishing& presPub = presFeat->PresencePublishing();
+
+ // Setup status event listener for RequestComplete
+ listener2->Reset();
+
+ TXIMPRequestId reqIdDummy; // not checked
+ CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
+ listener2->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete );
+
+ // Unsubscribe
+ TXIMPRequestId reqId = presPub.UnsubscribePresenceWatcherListL();
+
+ // Wait for events on the request
+ EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe failed" );
+
+ // verify that unsubscribe was called
+ COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled,
+ "UnsubscribePresenceWatcherListL was not called",
+ ( a < 2 ) ? EFalse : ETrue,
+ "UnsubscribePresenceWatcherListL was called" );
+
+ CleanupStack::PopAndDestroy( listener2 );
+ }
+
+ UnbindAllL();
+ }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+void T_PresenceWatcherListManagement::SubscribeL()
+ {
+ CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
+ MXIMPContext* context = wrapper->GetContext();
+ CXIMPTestMessenger* messenger = wrapper->GetMessenger();
+
+ // Get the interfaces
+ MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
+ MPresencePublishing& presPub = presFeat->PresencePublishing();
+
+ CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
+ CleanupStack::PushL( listener2 );
+
+ // Setup status event listener for RequestComplete
+ listener2->Reset();
+
+ TXIMPRequestId reqIdDummy; // not checked
+ CXIMPRequestCompleteEventImp* evReqComplete =
+ CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
+ listener2->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete );
+
+ // subscribe
+ TXIMPRequestId reqId = presPub.SubscribePresenceWatcherListL();
+
+ // Wait for events on the request
+ EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribe failed" );
+
+ COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceWatcherListCalled, "SubscribeWatcherListL was not called", ETrue, NULL );
+
+ CleanupStack::PopAndDestroy( listener2 );
+ }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+void T_PresenceWatcherListManagement::UnsubscribeL()
+ {
+ CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
+ MXIMPContext* context = wrapper->GetContext();
+ CXIMPTestMessenger* messenger = wrapper->GetMessenger();
+
+ // Get the interfaces
+ MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
+ MPresencePublishing& presPub = presFeat->PresencePublishing();
+
+ // Setup status event listener for RequestComplete
+ CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
+ CleanupStack::PushL( listener2 );
+
+ // Setup status event listener for RequestComplete
+ listener2->Reset();
+
+ TXIMPRequestId reqIdDummy; // not checked
+ CXIMPRequestCompleteEventImp* evReqComplete =
+ CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
+ listener2->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete );
+
+ // unsubscribe
+ TXIMPRequestId reqId = presPub.UnsubscribePresenceWatcherListL();
+
+ EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsbscribe failed" );
+
+ // verify that UnsubscribeWatcherListL was called
+ COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled, "UnsubscribeWatcherListL was not called", ETrue, NULL );
+
+ CleanupStack::PopAndDestroy( listener2 );
+
+ }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+void T_PresenceWatcherListManagement::T_HandlePresenceWatcherList_L()
+ {
+ EUNIT_PRINT( _L("Handle presence watcher list.") );
+
+ BindL();
+ SubscribeL();
+
+ // ------------------------------------------------------
+ // some startup stuff
+ CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
+ MXIMPContext* context = wrapper->GetContext();
+
+ CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
+ CleanupStack::PushL( listener2 );
+ // ------------------------------------------------------
+
+ // Tell the protocol it should act normally
+ wrapper->GetMessenger()->SetNoError();
+
+ // ------------------------------------------------------
+ // 1. Create faked server message about watcher list (empty)
+ SendSrvMsgL( CXIMPTestFileSrvMsg::ETestSrvMsgPresenceWatcherList );
+
+ // ------------------------------------------------------
+ // expect empty MPresencewatcherList event.
+
+ RPrWatLstInfoImpArray* currentList(NULL);
+ CPresenceWatcherListEventImp* event = CreateWatcherListEventLCX(
+ KNullDesC, KNullDesC,
+ MXIMPDataSubscriptionState::ESubscriptionActive,
+ MXIMPDataSubscriptionState::EDataAvailable,
+ ETestPWlCurrent, currentList);
+
+ listener2->ExpectL( event );
+ CleanupStack::Pop( event ); // 3 more items in cleanupstack
+
+ //Waqas: Fixed task Ticket#22
+ EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceWatcherListL failed" );
+ CleanupStack::PopAndDestroy( 3 ); // lists
+ // ------------------------------------------------------
+
+
+ // ------------------------------------------------------
+ // 2. Create faked server message about watcher list (new)
+ listener2->Reset();
+
+ _LIT16( KWatcherUri1, "http://carpe.diem.com" );
+ _LIT16( KWatcherDispName1, "DispnameA, LoremI" );
+
+ SendSrvMsgL( KWatcherUri1,
+ KWatcherDispName1,
+ CXIMPTestFileSrvMsg::ETestSrvMsgPresenceWatcherList );
+
+ // ------------------------------------------------------
+ // MPresencewatcherList event.
+
+ currentList = NULL; // previous one was destroyed
+ //Now create the actual event
+ event = CreateWatcherListEventLCX( // previous event was destroyed
+ KWatcherUri1, KWatcherDispName1,
+ MXIMPDataSubscriptionState::ESubscriptionActive,
+ MXIMPDataSubscriptionState::EDataAvailable,
+ ETestPWlNew, currentList);
+
+
+ listener2->ExpectL( event );
+ CleanupStack::Pop( event ); // 3 more items in cleanupstack
+
+ EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceWatcherListL failed" );
+ CleanupStack::PopAndDestroy( 3 ); // lists
+
+
+ // ------------------------------------------------------
+ // 3. Create faked server message about watcher list (disappeared)
+ listener2->Reset();
+
+ SendSrvMsgL( CXIMPTestFileSrvMsg::ETestSrvMsgPresenceWatcherList );
+ // ------------------------------------------------------
+ // MPresencewatcherList event.
+
+ CXIMPIdentityImp* idForEvent = CXIMPIdentityImp::NewLC( KWatcherUri1 );
+ // we need to create current list to give to the event
+ currentList = new ( ELeave ) RPrWatLstInfoImpArray; // previous is destroyed
+ CleanupDeletePushL( currentList );
+ // create the group info
+ CPresenceWatcherInfoImp* watcherInfoForEvent =
+ CPresenceWatcherInfoImp::NewLC( (MPresenceWatcherInfo::TWatcherType)0, *idForEvent, KWatcherDispName1);
+ currentList->AppendL( watcherInfoForEvent );
+ CleanupStack::Pop( watcherInfoForEvent );
+ CleanupStack::Pop( currentList );
+ CleanupStack::PopAndDestroy( idForEvent );
+
+
+ //Now create the actual event
+ event = CreateWatcherListEventLCX(
+ KWatcherUri1, KWatcherDispName1,
+ MXIMPDataSubscriptionState::ESubscriptionActive,
+ MXIMPDataSubscriptionState::EDataAvailable,
+ ETestPWlDisappeared, currentList);
+
+ listener2->ExpectL( event );
+ CleanupStack::Pop( event ); // 3 more items in cleanupstack
+
+ //Waqas: Fixed task Ticket#22
+ EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceWatcherListL failed" );
+
+ CleanupStack::PopAndDestroy( 3 ); // lists
+
+
+ // clean it up
+ UnsubscribeL();
+
+ /* TODO later on better time.
+ // ------------------------------------------------------
+ // 4. Create faked server message about watcher list (no subscribers to list)
+ // Make sure no event is
+ listener2->Reset();
+
+ event = CreateWatcherListEventLCX(
+ KNullDesC, KNullDesC,
+ ETestPWlEmpty );
+
+ //EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceWatcherListL failed" );
+
+ */
+ CleanupStack::PopAndDestroy( listener2 );
+
+ UnbindL();
+ }
+
+////////////////////////////////////////////////////
+//// INTIA CASE
+////////////////////////////////////////////////////
+void T_PresenceWatcherListManagement::T_IndiaCase_L()
+ {
+
+ EUNIT_PRINT( _L("Presence notification subscribed list, Intia") );
+
+
+ BindL();
+
+ CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
+ MXIMPContext* presenceCtx = wrapper->GetContext();
+ CXIMPTestMessenger* messenger = wrapper->GetMessenger();
+
+ CXIMPTestListener* ctxObserver = CXIMPTestListener::NewL( presenceCtx );
+ CleanupStack::PushL( ctxObserver ); // << ctxObserver
+
+
+ // Tell the protocol it should act normally
+ messenger->SetNoError();
+
+ // Get the interfaces
+ MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
+ MPresencePublishing& presPub = presFeat->PresencePublishing();
+ MPresentityGroups& presGroups = presFeat->PresentityGroups();
+ MPresenceWatching& presWatch = presFeat->PresenceWatching();
+
+ MXIMPObjectFactory& objFactory = presenceCtx->ObjectFactory();
+
+ _LIT( KGroupId, "rakesh.harsh/Friends" );
+ _LIT( KGroupDisplayName, "my_friend" );
+ _LIT( KMemberId1, "user1" );
+ _LIT( KMember1DisplayName, "user1DisplayName" );
+ _LIT( KMemberId2, "user2" );
+ _LIT( KMember2DisplayName, "user2DisplayName" );
+
+
+ // Create test variables
+ MXIMPIdentity* testGroupId = objFactory.NewIdentityLC(); // << testGroupId
+ testGroupId->SetIdentityL( KGroupId );
+
+ MXIMPIdentity* member1 = objFactory.NewIdentityLC(); // << member1
+ member1->SetIdentityL( KMemberId1 );
+
+ MXIMPIdentity* member2 = objFactory.NewIdentityLC(); // << member2
+ member2->SetIdentityL( KMemberId2 );
+
+ //////////////////////////////////////////////////////////////////////////
+ // SUBSCRIBE PRESENTITY GROUP LIST
+ //////////////////////////////////////////////////////////////////////////
+
+ // Setup status event listener for RequestComplete
+ TXIMPRequestId reqId;
+ ctxObserver->Reset();
+ CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );// << evReqComplete
+ ctxObserver->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete ); // >> evReqComplete
+
+ SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );
+
+ // subscribe PresentityGroupList
+ reqId = presGroups.SubscribePresentityGroupListL();
+
+ // Wait for events on the request
+ wrapper->WaitRequestAndStackEvents( reqId );
+ wrapper->VerifyEventStackL( _L8("Subscribing presentity group list, complete with error: ") );
+
+ // verify that SubscribePresentityGroupListL was called
+ messenger->AssertSubscribePresentityGroupListCalled( ETrue );
+
+
+ // get list request
+/* TXIMPRequestId req = presGroups.SubscribePresentityGroupListL();
+ ctxObserver->WaitOpToCompleteL( req );
+
+ CUserAfter::AfterL( 1000000 );
+*/
+
+ //////////////////////////////////////////////////////////////////////////
+ // SUBSCRIBE PRESENTITY GROUP CONTENT
+ //////////////////////////////////////////////////////////////////////////
+
+ // Setup status event listener for RequestComplete
+ ctxObserver->Reset();
+ evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
+ ctxObserver->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete );
+ SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );
+
+ // subscribe group content
+ reqId = presGroups.SubscribePresentityGroupContentL( *testGroupId );
+
+ // Wait for events on the request
+ wrapper->WaitRequestAndStackEvents( reqId );
+ wrapper->VerifyEventStackL( _L8("Subscribe presentity group content, complete with error: ") );
+
+ COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityGroupContentCalled, "SubscribeGroupContentL was not called", ETrue, NULL );
+
+/* TInt count = ctxObserver->gidcount;
+ // List manage request
+ for(TInt i = 0; i<count;i++)
+ {
+ //get the content of the lists
+ MXIMPIdentity* tgid = objFactory.NewIdentityLC();
+ tgid->SetIdentityL( ctxObserver->gid[i] );
+ // tgid->SetIdentityL( _L("rakesh.harsh/basu2@nokia.com") );
+
+ TXIMPRequestId req = presGroups.SubscribePresentityGroupContentL( *tgid );
+
+ ctxObserver->WaitOpToCompleteL( req );
+
+ CleanupStack::PopAndDestroy( 1 ); // tgid
+ } */
+
+ //////////////////////////////////////////////////////////////////////////
+ // CREATE PRESENTITY GROUP
+ /////////////////////////////////////////////////////////////////////////
+
+ // Setup status event listener for RequestComplete
+ // This will also produce HandlePresentityGroupListEvent, since the
+ // the group is subscribed
+ ctxObserver->Reset();
+ evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
+ ctxObserver->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete );//TODO???
+
+ SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );
+
+ // Create group
+ reqId = presGroups.CreatePresentityGroupL( *testGroupId, KGroupDisplayName );
+
+ // Wait for events on the request
+ wrapper->WaitRequestAndStackEvents( reqId );
+ wrapper->VerifyEventStackL( _L8("CreatePresentityGroupL failed, complete with error: ") );
+
+ // verify that SubscribePresentityGroupListL was called
+ messenger->AssertCreatePresentityGroupCalled( ETrue );
+
+
+
+ // first make a test group in our roster
+ /* MXIMPIdentity* newGroupId = objFactory.NewIdentityLC();//1
+ newGroupId->SetIdentityL( _L("rakesh.harsh/Friends") );
+
+ req = presGroups.CreatePresentityGroupL( *newGroupId,_L("my_friend") );
+ // wait completion
+ ctxObserver->WaitOpToCompleteL( req );
+
+ CUserAfter::AfterL( 1000000 );*/
+
+ //////////////////////////////////////////////////////////////////////////
+ // ADD PRESENTITY GROUP MEMBER
+ //////////////////////////////////////////////////////////////////////////
+
+ // Setup event listener for RequestComplete
+ ctxObserver->Reset();
+ evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); // << evReqComplete
+
+ // group id
+ CXIMPIdentityImp* grid = CXIMPIdentityImp::NewLC( testGroupId->Identity() ); // << grid
+ evReqComplete->AppendParamL( grid );
+ CleanupStack::Pop(); // >> grid
+
+ // id for member info
+ CXIMPIdentityImp* miId = CXIMPIdentityImp::NewLC( KMemberId1 ); // << miId
+ // member info
+ CPresentityGroupMemberInfoImp* memInfoImp =
+ CPresentityGroupMemberInfoImp::NewLC( *miId, KMember1DisplayName ); // << memInfoImp
+ evReqComplete->AppendParamL( memInfoImp );
+ CleanupStack::Pop(); // memInfoImp owned by AppendParamL // >> memInfoImp
+ CleanupStack::PopAndDestroy( miId ); // copy was made // >>> miId
+
+ ctxObserver->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete ); // >> evReqComplete
+
+ // do the call
+ reqId = presGroups.AddPresentityGroupMemberL(
+ *testGroupId, *member1, KMember1DisplayName );
+
+ // Wait for events on the request
+ wrapper->WaitRequestAndStackEvents( reqId );
+ messenger->AssertAddPresentityGroupMemberCalled( ETrue );
+
+
+ //add a member
+/* MXIMPIdentity* testContactId = objFactory.NewIdentityLC();
+ testContactId->SetIdentityL( _L("mukesh") );
+ req = presGroups.AddPresentityGroupMemberL( *newGroupId,
+ *testContactId,
+ _L("h2") );
+ // wait completion
+ ctxObserver->WaitOpToCompleteL( req );
+
+
+ CUserAfter::AfterL( 1000000 );*/
+
+
+ //////////////////////////////////////////////////////////////////////////
+ // ADD PRESENTITY GROUP MEMBER
+ //////////////////////////////////////////////////////////////////////////
+
+ // Setup event listener for RequestComplete
+ ctxObserver->Reset();
+ evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); // << evReqComplete
+
+ // group id
+ CXIMPIdentityImp* grid2 = CXIMPIdentityImp::NewLC( testGroupId->Identity() );
+ evReqComplete->AppendParamL( grid2 );
+ CleanupStack::Pop(); // grid2
+
+ // id for member info
+ CXIMPIdentityImp* miId2 = CXIMPIdentityImp::NewLC( KMemberId2 );
+ // member info
+ CPresentityGroupMemberInfoImp* memInfoImp2 =
+ CPresentityGroupMemberInfoImp::NewLC( *miId2, KMember2DisplayName );
+ evReqComplete->AppendParamL( memInfoImp2 );
+ CleanupStack::Pop(); // memInfoImp owned by AppendParamL
+ CleanupStack::PopAndDestroy( miId2 ); // copy was made
+
+ ctxObserver->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete );
+ // reset the variable
+ messenger->SetValueFor( EXIMPPlgTestAddPresentityGroupMemberCalled, 0 );
+ // do the call
+ reqId = presGroups.AddPresentityGroupMemberL(
+ *testGroupId, *member2, KMember2DisplayName );
+
+ // Wait for events on the request
+ wrapper->WaitRequestAndStackEvents( reqId );
+ messenger->AssertAddPresentityGroupMemberCalled( ETrue );
+
+
+/* testContactId->SetIdentityL( _L("bb0") );
+ req = presGroups.AddPresentityGroupMemberL( *newGroupId,
+ *testContactId,
+ _L("b1") );
+ // wait completion
+ ctxObserver->WaitOpToCompleteL( req );
+
+*/
+ //////////////////////////////////////////////////////////////////////////
+ // SUBSCRIBE PRESENTITY GROUP MEMBERS PRESENCE
+ //////////////////////////////////////////////////////////////////////////
+
+ // Setup status event listener for RequestComplete
+ ctxObserver->Reset();
+ evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
+ ctxObserver->ExpectL( evReqComplete );
+ CleanupStack::Pop( evReqComplete );
+ SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );
+
+
+ // Set filter for the group
+ MPresenceInfoFilter* gpif = presFeat->PresenceObjectFactory().NewPresenceInfoFilterLC();
+ gpif->AcceptPersonFilterL( NPresenceInfo::NFieldType::KStatusMessage );
+ gpif->AcceptPersonFilterL( NPresenceInfo::NFieldType::KAvatar );
+
+ // register interest
+ reqId = presWatch.SubscribePresentityGroupMembersPresenceL( *testGroupId, *gpif );
+
+ CleanupStack::PopAndDestroy(); // >>> gpif
+
+ // Wait for events on the request
+ wrapper->WaitRequestAndStackEvents( reqId );
+ wrapper->VerifyEventStackL( _L8("Subscribe presentity group members, complete with error: ") );
+
+ // verify that UpdateInterest was called
+ COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityGroupMembersPresesenceCalled, "SubscribePresentityGroupMembersPresenceL was not called", ETrue, NULL );
+
+
+
+/* CUserAfter::AfterL( 1000000 );
+ MPresenceWatching& presWatch = presenceCtx->PresenceWatching();
+ MPresenceInfoFilter* infoFilt = objFactory.NewPresenceInfoFilterLC();
+ req = presWatch.SubscribePresentityGroupMembersPresenceL( *newGroupId, *infoFilt );
+ // wait completion
+ ctxObserver->WaitOpToCompleteL( req );
+
+ // req = presWatch.SubscribePresentityPresenceL( *testContactId, *infoFilt );
+ // wait completion
+ // ctxObserver->WaitOpToCompleteL( req );
+ //MXIMPClient* presClient1 = NULL;
+ // MXIMPContext* presenceCtx1 = NULL;
+ //CUSContextObserver* ctxObserver1 = NULL;
+
+ /*TInt pushCount1 = DoSetupDefaultContext1LC( presClient1,
+ presenceCtx1,
+ ctxObserver1 );
+
+ ctxObserver->WaitOpToCompleteL( req );*/
+ // CUserAfter::AfterL( 60000000 ); //60 seconds
+
+ /*if ( !iWait.IsStarted() )
+ {
+ iWait.Start(); // CSI: 10 # iWait is not an active object
+ }
+ */
+ //code is for login with diff id
+ //Initialize XIMP client
+ /* #if 0
+ MXIMPClient* presClient1 = MXIMPClient::NewClientL();
+ CleanupDeletePushL( presClient );
+
+ //Create new sink to receive presence context events
+ CUSContextObserver* eventObserver1 = CUSContextObserver::NewLC();
+
+ //Create new presence context
+ MXIMPContext* presecenCtx1 = presClient->NewPresenceContextLC();
+ presecenCtx1->RegisterObserverL( *eventObserver1 );
+
+ //Bind context to desired presence service
+ TUid protocolUid = TUid::Uid( KProtocolUid );
+
+
+ //Bind context to desired presence service
+ req = presecenCtx1->BindToL( protocolUid,
+ KServerAddress,
+ KUserName2,
+ KPassword2,
+ KIAP );
+
+ //Wait with CActiveSchedulerWait the binding to complete
+ //If binding fails, it is handled with leave
+ eventObserver1->WaitOpToCompleteL( req );
+ MXIMPIdentity* newGroupId1 = objFactory.NewIdentityLC();//1
+ newGroupId1->SetIdentityL( _L("bb0/jaya") );
+
+ req = presGroups.CreatePresentityGroupL( *newGroupId1,_L("my_sweety") );
+ // wait completion
+ ctxObserver->WaitOpToCompleteL( req );
+
+ CUserAfter::AfterL( 1000000 );
+ presecenCtx1->UnbindL();
+ eventObserver1->WaitOpToCompleteL( req );
+ CleanupStack::PopAndDestroy( 4 ); //newGroupId1,presecenCtx1,eventObserver1,presClient1
+
+ #endif*/
+ //code is for login with diff id end
+
+ //add this user to bb0's contact list.i should recieve notification
+
+ // delete group friend which is created above statement
+ //req = presGroups.DeletePresentityGroupL( *newGroupId );
+ // wait completion
+ // ctxObserver->WaitOpToCompleteL( req );
+ // CUserAfter::AfterL( 60000000 );
+ //Unbind the context and wait completion
+ // req = presenceCtx->UnbindL();
+ // ctxObserver->WaitOpToCompleteL( req );
+
+ //Destroy the context (it is automaticly unbind)
+ // CleanupStack::PopAndDestroy( 3 ); // infoFilt,testContactId,newGroupId
+ // CleanupStack::PopAndDestroy( pushCount );
+
+
+ //////////////////////////////////////////////////////////////////////////
+ // SEND DATA FOR GROUP MEMBER -> HANDLE PRESENTITY PRESENCE
+ //////////////////////////////////////////////////////////////////////////
+
+
+ // create test message
+ CPresenceInfoImp* presenceInfo = CPresenceInfoImp::NewLC(); // << presenceInfo
+ HBufC8* packedInfo = TXIMPObjectPacker< CPresenceInfoImp >::PackL( *presenceInfo );
+ CleanupStack::PopAndDestroy( presenceInfo );// >>> presenceInfo
+ CleanupStack::PushL( packedInfo ); // << packedInfo
+
+ CXIMPIdentityImp* changed = CXIMPIdentityImp::NewLC( ); // << changed
+ changed->SetIdentityL( KMemberId1 );
+ HBufC8* packedId = TXIMPObjectPacker< CXIMPIdentityImp >::PackL( *changed );
+ CleanupStack::PopAndDestroy(); // >>> changed
+ CleanupStack::PushL( packedId );// << packedId
+
+ RPointerArray< HBufC8 > bufferArray;
+ CleanupClosePushL( bufferArray ); // << bufferArray
+ bufferArray.AppendL( packedId );
+ bufferArray.AppendL( packedInfo );
+
+ HBufC8* packedBufferArray = TXIMPHBuf8Packer::PackArrayL( bufferArray );
+ CleanupStack::PopAndDestroy( 2 ); // >>> packedId, packedInfo
+ CleanupStack::PopAndDestroy(); // >>> bufferArray
+ CleanupStack::PushL( packedBufferArray ); // << packedBufferArray
+
+ // Send it to plugin
+ CXIMPTestFileSrvMsg* srvMsg = CXIMPTestFileSrvMsg::NewL( CXIMPTestFileSrvMsg::ETestSrvMsgPresentityPresence,
+ *packedBufferArray );
+ CleanupStack::PopAndDestroy( packedBufferArray ); // >>> packedBufferArray
+
+ CleanupStack::PushL( srvMsg ); // << srvMsg
+ wrapper->FileTool().SrvMsgStoreL( srvMsg );
+ CleanupStack::PopAndDestroy( srvMsg ); // >>> srvMsg
+ wrapper->FileTool().CleanAllL();
+
+ // Wait for server to handle srvmsg.
+ User::After( 4 * 1000000 );
+
+ COMMONASSERT( messenger, EXIMPPlgTestHandlePresentityPresenceCalled, "HandlePresentityPresenceL was not called", ETrue, NULL );
+
+ CleanupStack::PopAndDestroy( 3 ); // >>> testGroupId, member1, member2
+ CleanupStack::PopAndDestroy( ctxObserver ); // >>> ctxObserver
+
+ UnbindL();
+
+}
+// ===========================================================================
+// SETUP HELPERS FOR THE LISTENER
+// ===========================================================================
+//
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// send a faked server-originated message with watcher info made
+// from the given uri and displayname
+//
+void T_PresenceWatcherListManagement::SendSrvMsgL(
+ const TDesC& aUri, const TDesC& aDispName,
+ TInt aMsgType )
+ {
+ // we'll use hard-coded wrapper 0 instance for now.
+ CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
+
+ // create a grant req info contained within the server-originated
+ // faked message
+ RXIMPObjOwningPtrArray<CPresenceWatcherInfoImp> watcherList;
+ CleanupClosePushL( watcherList );
+
+ CXIMPIdentityImp* watcherId = CXIMPIdentityImp::NewLC( aUri );
+ CPresenceWatcherInfoImp* watcherItem =
+ CPresenceWatcherInfoImp::NewLC(
+ (MPresenceWatcherInfo::TWatcherType)0,
+ *watcherId,
+ aDispName );
+ watcherList.AppendL( watcherItem );
+ CleanupStack::Pop( watcherItem );
+ CleanupStack::PopAndDestroy( watcherId );
+
+ HBufC8* packedArray =
+ TXIMPObjectPacker<CPresenceWatcherInfoImp>::PackArrayL( watcherList );
+ CleanupStack::PushL( packedArray );
+
+ // use filetool to send it for plugin.
+ CXIMPTestFileSrvMsg* srvMsg = CXIMPTestFileSrvMsg::NewL( aMsgType,
+ *packedArray );
+ CleanupStack::PushL( srvMsg );
+ wrapper->FileTool().CleanAllL();
+ wrapper->FileTool().SrvMsgStoreL( srvMsg );
+ CleanupStack::PopAndDestroy( 3 ); // srvMsg, packedArray, watcherList
+ }
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// send a faked server-originated message with empty contents
+//
+void T_PresenceWatcherListManagement::SendSrvMsgL( TInt aMsgType )
+ {
+ // we'll use hard-coded wrapper 0 instance for now.
+ CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
+
+ // create a server-originated faked message with empty contents
+ RXIMPObjOwningPtrArray<CPresenceWatcherInfoImp> watcherList;
+
+ HBufC8* packedArray = TXIMPObjectPacker<CPresenceWatcherInfoImp>::PackArrayL( watcherList );
+ CleanupStack::PushL( packedArray );
+
+ // use filetool to send it for plugin.
+ CXIMPTestFileSrvMsg* srvMsg = CXIMPTestFileSrvMsg::NewL( aMsgType,
+ *packedArray );
+ CleanupStack::PushL( srvMsg );
+ wrapper->FileTool().CleanAllL();
+ wrapper->FileTool().SrvMsgStoreL( srvMsg );
+ CleanupStack::PopAndDestroy( 2 ); // srvMsg, packedArray
+ }
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// create a watcher list event with given arrays
+//
+CPresenceWatcherListEventImp* T_PresenceWatcherListManagement::CreateWatcherListEventLCX(
+ const TDesC& aUri,
+ const TDesC& aDispName,
+ MXIMPDataSubscriptionState::TSubscriptionState aSubscriptionState,
+ MXIMPDataSubscriptionState::TDataState aDataState,
+ TTestPWlOperation aOperation,
+ RPrWatLstInfoImpArray* aCurrentList)
+ {
+ // create the arrays
+
+
+ // new list
+ RPrWatLstInfoImpArray* newList = new ( ELeave ) RPrWatLstInfoImpArray;
+ CleanupDeletePushL( newList );
+
+ // current list, created by caller
+ if(!aCurrentList) // if client didnt created the list
+ aCurrentList = new ( ELeave ) RPrWatLstInfoImpArray;
+ CleanupDeletePushL( aCurrentList );
+
+ // disappeared list
+ RPrWatLstInfoImpArray* disappearedList = new ( ELeave ) RPrWatLstInfoImpArray;
+ CleanupDeletePushL( disappearedList );
+
+ // create the watcher info
+ CPresenceWatcherInfoImp* watcherInfoForEvent1 = NULL;
+ {
+ CXIMPIdentityImp* idForEvent = CXIMPIdentityImp::NewLC( aUri );
+ watcherInfoForEvent1 = CPresenceWatcherInfoImp::NewLC( (MPresenceWatcherInfo::TWatcherType)0, *idForEvent, aDispName );
+ CleanupStack::Pop( watcherInfoForEvent1 );
+ CleanupStack::PopAndDestroy( idForEvent );
+ CleanupStack::PushL( watcherInfoForEvent1 );
+ }
+
+ CPresenceWatcherInfoImp* watcherInfoForEvent2 =
+ TXIMPObjectCloner< CPresenceWatcherInfoImp >::CloneLC( *watcherInfoForEvent1 );
+
+ TInt count(0);
+ TBool found(EFalse);
+ TInt i(0);
+
+ // put the given watcher info into the specified array
+ switch ( aOperation )
+ {
+ case ETestPWlNew:
+ {
+ newList->AppendL( watcherInfoForEvent2 );
+ CleanupStack::Pop( watcherInfoForEvent2 );
+
+ aCurrentList->AppendL( watcherInfoForEvent1 );
+ CleanupStack::Pop( watcherInfoForEvent1 );
+ }
+ break;
+ case ETestPWlCurrent:
+ {
+ // don't add, thus return what user has given
+ CleanupStack::PopAndDestroy( watcherInfoForEvent2 ); // watcherInfoForEvent2
+ CleanupStack::PopAndDestroy( watcherInfoForEvent1 ); // watcherInfoForEvent1
+ }
+ break;
+ case ETestPWlDisappeared:
+ {
+ // search the given id in current list
+ count = aCurrentList->Count();
+ for(i=0;i<count;i++)
+ {
+ // if dispname and id are same
+ if (( ((((*aCurrentList)[i])->WatcherId()).Identity()) == aUri )
+ && ( (((*aCurrentList)[i])->WatcherDisplayName()) == aDispName ))
+ {
+ found = ETrue;
+ break;
+ }
+ }
+ if(found) // do we need to leave if error? Waqas
+ {
+ delete (*aCurrentList)[i];
+ aCurrentList->Remove(i);
+ disappearedList->AppendL( watcherInfoForEvent2 );
+ CleanupStack::Pop( watcherInfoForEvent2 );
+ }
+ else
+ CleanupStack::PopAndDestroy( watcherInfoForEvent2 );
+
+ CleanupStack::PopAndDestroy( watcherInfoForEvent1 );
+ }
+ break;
+ default:
+ {
+ User::Leave( KErrArgument );
+ }
+ break;
+ };
+
+ CXIMPDataSubscriptionStateImp* stateImp = CXIMPDataSubscriptionStateImp::NewLC();
+ stateImp->SetDataStateL( aDataState );
+ stateImp->SetSubscriptionStateL( aSubscriptionState );
+ CleanupStack::Pop( stateImp );
+
+ // create the actual event
+ CPresenceWatcherListEventImp* tmp =
+ CPresenceWatcherListEventImp::NewLC(
+ newList,
+ aCurrentList,
+ disappearedList,
+ stateImp );
+
+
+ /*
+ * In cleanupstack there are 4 items, FIFO
+ * - new list
+ * - current list
+ * - disappeared list
+ * - event imp
+ */
+
+ return tmp;
+ }
+
+void T_PresenceWatcherListManagement::SetupListenerReqCompleteL( CXIMPTestContextWrapper* aWrapper, TXIMPTestStatusEventTemplate aEventType )
+ {
+ RArray< TInt32 > array;
+ CleanupClosePushL( array );
+ array.AppendL( MXIMPRequestCompleteEvent::KInterfaceId );
+ array.Append( MXIMPContextStateEvent::KInterfaceId );
+ array.Append( MPresentityPresenceEvent::KInterfaceId );
+ aWrapper->SetupListenerReqCompleteL( aEventType, &array );
+ CleanupStack::PopAndDestroy(); // array
+ }
+
+void T_PresenceWatcherListManagement::SetupListenerReqCompleteAllowEventsL( CXIMPTestContextWrapper* aWrapper, TXIMPTestStatusEventTemplate aEventType )
+ {
+ RArray< TInt32 > array;
+ CleanupClosePushL( array );
+ array.AppendL( MXIMPRequestCompleteEvent::KInterfaceId );
+ array.AppendL( MXIMPContextStateEvent::KInterfaceId );
+ array.AppendL( MPresentityPresenceEvent::KInterfaceId );
+ aWrapper->SetupListenerReqCompleteL( aEventType, &array );
+ CleanupStack::PopAndDestroy(); // array
+ }
+
+// ===========================================================================
+// EVENT OBSERVER METHODS
+// ===========================================================================
+//
+void T_PresenceWatcherListManagement::HandlePresenceContextEvent(
+ const MXIMPContext& aContext,
+ const MXIMPBase& aEvent )
+ {
+ iLastError = KErrNone;
+ TInt ifId = aEvent.GetInterfaceId();
+ TInt gg = MPresentityPresenceEvent::KInterfaceId;
+ if( ifId == MPresenceWatcherListEvent::KInterfaceId )
+ {
+ const MPresenceWatcherListEvent* watcherListEvent =
+ TXIMPGetInterface< const MPresenceWatcherListEvent >::From( aEvent, MXIMPBase::EPanicIfUnknown );
+
+ if( watcherListEvent->NewWatchersCount() )
+ {
+ iLastEvent = EWatcherList;
+ TInt count = watcherListEvent->NewWatchersCount();
+ for( TInt a = 0; a < count; ++a )
+ {
+ TRAPD( error,
+ CPresenceWatcherInfoImp* watcherInfo = CPresenceWatcherInfoImp::NewLC(
+ watcherListEvent->NewWatcher( a ).WatcherType(),
+ watcherListEvent->NewWatcher( a ).WatcherId(),
+ watcherListEvent->NewWatcher( a ).WatcherDisplayName() );
+ iValidateArray.AppendL( watcherInfo );
+ CleanupStack::Pop( watcherInfo );
+ );
+ if( error != KErrNone )
+ {
+ iLastError = error;
+ return;
+ }
+ }
+ }
+ }
+ else if( ifId == MPresentityPresenceEvent::KInterfaceId )
+ {
+ const MPresentityPresenceEvent* presentityPresenceEvent =
+ TXIMPGetInterface< const MPresentityPresenceEvent >::From( aEvent, MXIMPBase::EPanicIfUnknown );
+ const MXIMPIdentity& prId = presentityPresenceEvent->PresentityId();
+ const MPresenceInfo& prPif = presentityPresenceEvent->SubscribedPresence();
+ const MXIMPDataSubscriptionState& prDataStae = presentityPresenceEvent->DataSubscriptionState();
+ }
+ else
+ {
+ iLastEvent = EInvalid;
+ }
+ }
+
+// ===========================================================================
+// TEST CASE TABLE
+// ===========================================================================
+//
+EUNIT_BEGIN_TEST_TABLE(
+ T_PresenceWatcherListManagement,
+ "XIMP presence watching tests",
+ "MODULE" )
+
+PRFW_DECORATED_TEST(
+ "Bind Unbind",
+ "",
+ "",
+ "FUNCTIONALITY",
+ Setup_L,
+ T_BindUnbind_L,
+ Teardown )
+
+PRFW_DECORATED_TEST(
+ "Single client watcher list subscription",
+ "",
+ "",
+ "FUNCTIONALITY",
+ Setup_L,
+ T_SubscribePresenceWatcherList_Single_L,
+ Teardown )
+
+PRFW_DECORATED_TEST(
+ "Multiple client watcher list subscription",
+ "",
+ "",
+ "FUNCTIONALITY",
+ SetupMultiple_L,
+ T_SubscribePresenceWatcherList_Multiple_L,
+ Teardown )
+
+PRFW_DECORATED_TEST(
+ "Handle Presence Watcher List",
+ "",
+ "",
+ "FUNCTIONALITY",
+ Setup_L,
+ T_HandlePresenceWatcherList_L,
+ Teardown )
+
+ PRFW_DECORATED_TEST(
+ "Test India Case",
+ "",
+ "",
+ "FUNCTIONALITY",
+ Setup_L,
+ T_IndiaCase_L,
+ Teardown )
+
+
+EUNIT_END_TEST_TABLE
+
+
+// ===========================================================================
+// TEST SUITE CONSTRUCTION
+// ===========================================================================
+//
+EXPORT_C MEUnitTest* CreateTestSuiteL()
+ {
+ return T_PresenceWatcherListManagement::NewL();
+ }
+
+
+// end of file