/*
* 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 <ximpcontext.h>
#include <ximpcontextstateevent.h>
#include <ximpcontextstate.h>
#include <ximpobjectfactory.h>
#include <presencepublishing.h>
#include <presentitypresenceevent.h>
#include <presenceobjectfactory.h>
#include <presencefeatures.h>
#include <presenceinfofield.h>
#include <presenceinfofieldcollection.h>
#include <servicepresenceinfo.h>
#include <devicepresenceinfo.h>
#include <personpresenceinfo.h>
#include <presenceinfofieldvalueenum.h>
#include <presenceinfofieldvaluetext.h>
#include <presenceinfo.h>
#include "t_presencepublishing.h"
#include "prfwtestmessaging.h"
#include "prfwtestmessenger.h"
#include "prfwtestcontextwrappermgr.h"
#include "prfwtestcontextwrapper.h"
#include "prfwtestpresencedatautils.h"
#include "ximprequestcompleteeventimp.h"
#include "ximpcontextstateeventimp.h"
#include "ximpcontextstateimp.h"
#include "ximpstatusimp.h"
#include "ownpresenceeventimp.h"
// new test stuff
#include "prfwtestlistener.h"
#include "prfwtestfilesrvmsg.h"
#include "prfwtestfiletool.h"
#include "prfwtestrobustnesstools.h"
_LIT8( KPrefix1, "PreA_" );
_LIT8( KPrefix2, "PreB_" );
_LIT8( KPrefix3, "PreC_" );
_LIT8( KPrefix4, "PreD_" );
_LIT8( KServiceType, "test_service" );
_LIT( KStatusMsg, "This is my status." );
const TInt KTestAvailability = 1;
// ============================ MEMBER FUNCTIONS ===============================
// CONSTRUCTION
T_PresencePublishing* T_PresencePublishing::NewL()
{
T_PresencePublishing* self = new( ELeave ) T_PresencePublishing;
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
T_PresencePublishing::~T_PresencePublishing()
{
}
void T_PresencePublishing::ConstructL()
{
CEUnitTestSuiteClass::ConstructL();
}
T_PresencePublishing::T_PresencePublishing()
{
}
// ===========================================================================
// TEST CASE SETUP & TEARDOWN METHODS
// ===========================================================================
//
void T_PresencePublishing::Setup_L()
{
PrfwTestRobustness::DoPreCleaning();
iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();
iWrapperMgr->CreateWrapperL();
}
void T_PresencePublishing::SetupMultiple_L()
{
PrfwTestRobustness::DoPreCleaning();
iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();
iWrapperMgr->CreateWrapperL();
iWrapperMgr->CreateWrapperL();
iWrapperMgr->CreateWrapperL();
}
void T_PresencePublishing::BindL()
{
CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 );
wrapper0->BindL( 0 );
}
void T_PresencePublishing::Bind2L()
{
CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 );
wrapper0->BindWithSettingsL( 0 );
}
void T_PresencePublishing::BindAllL()
{
for( TInt a = 0; a < iWrapperMgr->WrapperCount(); ++a )
{
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );
wrapper->BindL( 0 );
}
}
void T_PresencePublishing::Teardown()
{
delete iWrapperMgr;
iWrapperMgr = NULL;
REComSession::FinalClose();
PrfwTestRobustness::DoPreCleaning();
}
void T_PresencePublishing::UnbindL()
{
// Do unbind
CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 );
wrapper0->UnbindL();
}
void T_PresencePublishing::UnbindAllL()
{
for( TInt a = 0; a < iWrapperMgr->WrapperCount(); ++a )
{
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );
wrapper->UnbindL();
}
}
// ===========================================================================
// TEST CASES for presence publish
// ===========================================================================
void T_PresencePublishing::T_Publish_Single_L()
{
EUNIT_PRINT( _L("Single Presence Publish test") );
BindL();
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
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();
// Generate a doc
CPresenceInfoImp* presInfo =
XIMPTestPresenceDataUtils::GenerateInfoLC( &KPrefix1 );
// Tell the protocol it should act normally
messenger->SetNoError();
// Publish the presence
TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *presInfo );
// Setup status event listener
CXIMPRequestCompleteEventImp* evReqComplete =
CXIMPRequestCompleteEventImp::NewLC( reqId );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Publishing presence failed" );
COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called", ETrue, NULL );
CleanupStack::PopAndDestroy( presInfo );
CleanupStack::PopAndDestroy( listener2 );
UnbindL();
}
void T_PresencePublishing::T_NetworkUnplugError_L()
{
EUNIT_PRINT( _L("Error from plug-in in publish own presence") );
// Creating the error which comes from KErrTimedOut and protocol sends Connection terminated.
// BIND AND SETUP
Bind2L();
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
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();
// PUBLISH OWN
//messenger->SetLeave( KErrAbort );
messenger->SetError(KErrTimedOut);
// publish own presence in here
MPresenceInfo* info = CreateInfoLC();
TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *info );
// Setup status event listener for RequestComplete
listener2->Reset();
// request complete with KErrAbort
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
evReqComplete->CompletionResultImp().SetResultCode( KErrTimedOut );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
CXIMPContextStateEventImp* evContextEvent = CXIMPContextStateEventImp::NewLC();
evContextEvent->ContextStateImp().SetStateValue( MXIMPContextState::EUnbinding);
listener2->ExpectL( evContextEvent );
CleanupStack::Pop( evContextEvent );
CXIMPContextStateEventImp* evContextEvent2 = CXIMPContextStateEventImp::NewLC();
evContextEvent2->ContextStateImp().SetStateValue( MXIMPContextState::EInactive);
listener2->ExpectL( evContextEvent2 );
CleanupStack::Pop( evContextEvent2 );
listener2->WaitAndAssertL();
// UNBIND
CleanupStack::PopAndDestroy(1);//info
CleanupStack::PopAndDestroy( listener2 );
messenger->SetError( KErrNone );
UnbindL();
}
void T_PresencePublishing::T_NetworkUnplugErrorMultiple_L()
{
EUNIT_PRINT( _L("Network disconnect from plug-in in publish own presence, multiple contexts") );
// Bind 2 contexts
BindAllL();
/*
* Make the 1st client publish someting and then the disconnect would happen
*/
CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 );
MXIMPContext* context0 = wrapper0->GetContext();
CXIMPTestMessenger* messenger0 = wrapper0->GetMessenger();
CXIMPTestListener* listener0 = CXIMPTestListener::NewL( context0);
CleanupStack::PushL( listener0);
MPresenceFeatures* presFeat0 = wrapper0->GetPresenceFeatures();
MPresencePublishing& presPub0 = presFeat0->PresencePublishing();
//messenger->SetLeave( KErrAbort );
messenger0->SetError(KErrTimedOut);
// publish own presence in here
MPresenceInfo* info = CreateInfoLC();
TXIMPRequestId reqId = presPub0.PublishOwnPresenceL( *info );
/* Setup status event listener for RequestComplete for client 1 */
listener0->Reset();
// request complete with KErrTimedOut
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
evReqComplete->CompletionResultImp().SetResultCode( KErrTimedOut );
listener0->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// Create the context state events for unbinding
CXIMPContextStateEventImp* evContextEvent = CXIMPContextStateEventImp::NewLC();
evContextEvent->ContextStateImp().SetStateValue( MXIMPContextState::EUnbinding);
listener0->ExpectL( evContextEvent );
CleanupStack::Pop( evContextEvent );
CXIMPContextStateEventImp* evContextEvent2 = CXIMPContextStateEventImp::NewLC();
evContextEvent2->ContextStateImp().SetStateValue( MXIMPContextState::EInactive);
listener0->ExpectL( evContextEvent2 );
CleanupStack::Pop( evContextEvent2 );
/*
* Create a request for client 2, this will not be processed by the protocol plug-in
*/
CXIMPTestContextWrapper* wrapper1 = iWrapperMgr->GetWrapperL( 1 );
MXIMPContext* context1 = wrapper1->GetContext();
MPresenceFeatures* presFeat1 = wrapper1->GetPresenceFeatures();
MPresencePublishing& presPub1 = presFeat1->PresencePublishing();
// Create the empty presence info filter
CPresenceInfoFilterImp* pif = CPresenceInfoFilterImp::NewLC();
TXIMPRequestId reqId1 = presPub1.SubscribeOwnPresenceL( *pif );
CleanupStack::PopAndDestroy(pif);
// Setup status event listener for RequestComplete
CXIMPTestListener* listener1 = CXIMPTestListener::NewL( context1);
CleanupStack::PushL( listener1);
listener1->Reset();
// normal request complete
CXIMPRequestCompleteEventImp* evReqComplete1 = CXIMPRequestCompleteEventImp::NewLC( reqId1 );
evReqComplete1->CompletionResultImp().SetResultCode( KErrTimedOut );
listener1->ExpectL( evReqComplete1 );
CleanupStack::Pop( evReqComplete1 );
// Create the context state events for unbinding
evContextEvent = CXIMPContextStateEventImp::NewLC();
evContextEvent->ContextStateImp().SetStateValue( MXIMPContextState::EUnbinding);
listener1->ExpectL( evContextEvent );
CleanupStack::Pop( evContextEvent );
evContextEvent2 = CXIMPContextStateEventImp::NewLC();
evContextEvent2->ContextStateImp().SetStateValue( MXIMPContextState::EInactive);
listener1->ExpectL( evContextEvent2 );
CleanupStack::Pop( evContextEvent2 );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listener0->WaitAndAssertL(), "Publish own presence failed in client 1");
EUNIT_ASSERT_DESC( KErrNone == listener1->WaitAndAssertL(), "SubscribeOwnPresence failed in client 2" );
CleanupStack::PopAndDestroy( listener1 );
CleanupStack::PopAndDestroy(1);//info
CleanupStack::PopAndDestroy( listener0 );
// Finish the test case
UnbindAllL();
}
void T_PresencePublishing::T_Publish_ErrFromPlg_Leave_L()
{
EUNIT_PRINT( _L("Single Presence Publish test") );
EUNIT_PRINT( _L("Plugin leaves from PublishOwnPresenceL") );
BindL();
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
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();
// Generate a doc
CPresenceInfoImp* presDoc =
XIMPTestPresenceDataUtils::GenerateInfoLC( &KPrefix1 );
// Setup status event listener
SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );
// Tell the test protocol to leave on next operation
messenger->SetLeave( KErrAbort );
// Publish the presence
TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *presDoc );
// Wait for events on the request
wrapper->WaitRequestAndStackEvents( reqId );
wrapper->VerifyEventStackL( _L8("Publishing single presence, leave with error: ") );
// Verify that plugin left and didn't go through the PublishOwnPresenceL.
COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called",
EFalse, "PublishPresenceL was called." );
// TODO wait and verify the events
EUNIT_FAIL_TEST( "Under construction." );
CleanupStack::PopAndDestroy( presDoc );
CleanupStack::PopAndDestroy( listener2 );
UnbindL();
}
void T_PresencePublishing::T_Publish_ErrFromPlg_CompleteWithError_L()
{
EUNIT_PRINT( _L("Single Presence Publish test") );
EUNIT_PRINT( _L("Plugin completes PublishOwnPresenceL with error") );
BindL();
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
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();
// Generate a doc
CPresenceInfoImp* presDoc =
XIMPTestPresenceDataUtils::GenerateInfoLC( &KPrefix1 );
// Setup status event listener:
//TODO Setup presence event listener
SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );
// Tell the test protocol to return with error on next operation
messenger->SetError( KErrAbort );
// Publish the presence
TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *presDoc );
// Wait for events on the request
wrapper->WaitRequestAndStackEvents( reqId );
wrapper->VerifyEventStackL( _L8("Publishing single presence, complete with error: ") );
// Verify that we did go through PublishOwnPresenceL.
COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called", ETrue, NULL );
// TODO wait and verify presence events
EUNIT_FAIL_TEST( "Under construction." );
CleanupStack::PopAndDestroy( presDoc );
CleanupStack::PopAndDestroy( listener2 );
UnbindL();
}
// ===========================================================================
// TEST CASES for presence interest registration
// ===========================================================================
// Single client, empty filter
void T_PresencePublishing::T_SubscribeOwnPresence_Single_Empty_L()
{
EUNIT_PRINT( _L("Single interest registration") );
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();
// Create the empty presence info filter
CPresenceInfoFilterImp* pif = CPresenceInfoFilterImp::NewLC();
// 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 own presence
TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "SubscribeOwnPresence failed" );
// verify that SubscribeOwnPresenceL was called
COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", ETrue, NULL );
// Setup status event listener for RequestComplete
listener2->Reset();
evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// unsubscribe own presence
reqId = presPub.UnsubscribeOwnPresenceL();
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "UnsubscribeOwnPresence failed" );
// verify that UnsubscribeOwnPresenceL was called
COMMONASSERT( messenger, EXIMPPlgTestUnsubscribeOwnPresenceCalled, "UnsubscribeOwnPresenceL was not called", ETrue, NULL );
CleanupStack::PopAndDestroy( pif );
CleanupStack::PopAndDestroy( listener2 );
UnbindL();
}
// Single client, empty filter
void T_PresencePublishing::T_SubscribeOwnPresence_Multiple_Empty_L()
{
EUNIT_PRINT( _L("Multiple client filter registration") );
BindAllL();
// Create the empty presence info filter
CPresenceInfoFilterImp* pif = CPresenceInfoFilterImp::NewLC();
TInt countOfWrappers = iWrapperMgr->WrapperCount();
CXIMPTestListener* listeners[ 50 ];
TXIMPRequestId reqIdDummy; // not checked
// Setup listeners
for( TInt a = 0; a < countOfWrappers; a++ )
{
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );
MXIMPContext* context = wrapper->GetContext();
listeners[ a ] = CXIMPTestListener::NewL( context );
CleanupStack::PushL( listeners[ a ] );
}
// SUBSCRIBE
for( TInt a = countOfWrappers - 1; a > 0 ; --a )
{
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );
MXIMPContext* context = wrapper->GetContext();
CXIMPTestMessenger* messenger = wrapper->GetMessenger();
// Tell the protocol it should act normally
messenger->SetNoError();
// Get the interfaces
MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
MPresencePublishing& presPub = presFeat->PresencePublishing();
// Setup status event listener for RequestComplete
listeners[ a ]->Reset();
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
listeners[ a ]->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
messenger->SetValueFor( EXIMPPlgTestSubscribeOwnPresenceCalled, 0 );
// subscribe own presence
TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listeners[ a ]->WaitAndAssertL(), "SubscribeOwnPresence failed" );
// verify that SubscribeOwnPresenceL was called
COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called",
( a > 1 ) ? ETrue : EFalse , "SubscribeOwnPresenceL was called." );
}
// REFRESH
for( TInt a = countOfWrappers - 1; a > 0 ; --a )
{
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );
MXIMPContext* context = wrapper->GetContext();
CXIMPTestMessenger* messenger = wrapper->GetMessenger();
// Tell the protocol it should act normally
messenger->SetNoError();
// Get the interfaces
MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
MPresencePublishing& presPub = presFeat->PresencePublishing();
// Setup status event listener for RequestComplete
listeners[ a ]->Reset();
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
listeners[ a ]->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
CXIMPDataSubscriptionStateImp* stateImp = CXIMPDataSubscriptionStateImp::NewLC();
stateImp->SetDataStateL( MXIMPDataSubscriptionState::EDataUnavailable );
stateImp->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive );
COwnPresenceEventImp* evOwnPresence = COwnPresenceEventImp::NewLC( stateImp );
CleanupStack::Pop( 2, stateImp );
CleanupStack::PushL( evOwnPresence );
listeners[ a ]->ExpectL( evOwnPresence );
CleanupStack::Pop( evOwnPresence );
// TODO check if this call is still needed
messenger->SetValueFor( EXIMPPlgTestSubscribeOwnPresenceCalled, 0 );
// subscribe own presence
TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listeners[ a ]->WaitAndAssertL(), "SubscribeOwnPresence failed" );
// verify that SubscribeOwnPresenceL was called
COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled,
"SubscribeOwnPresenceL was not called",
EFalse , "SubscribeOwnPresenceL was called." );
}
// UNSUBSCRIBE
for( TInt a = 0; a < countOfWrappers; ++a )
{
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );
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
listeners[ a ]->Reset();
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
listeners[ a ]->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// register interest
TXIMPRequestId reqId = presPub.UnsubscribeOwnPresenceL();
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listeners[ a ]->WaitAndAssertL(), "UnsubscribeOwnPresence failed" );
// verify that UpdateInterest was called
COMMONASSERT( messenger, EXIMPPlgTestUnsubscribeOwnPresenceCalled,
"UnsubscribeOwnPresenceL was not called",
( a < 2 ) ? EFalse : ETrue,
"UnsubscribeOwnPresenceL was called" );
}
// delete the listeners
CleanupStack::PopAndDestroy( countOfWrappers ); // the contents of listeners[]
CleanupStack::PopAndDestroy( pif );
UnbindAllL();
}
// Single client, filled filter
void T_PresencePublishing::T_SubscribeOwnPresence_Single_L()
{
EUNIT_PRINT( _L("Single interest registration") );
BindL();
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
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();
// Create the filled interest document
CPresenceInfoFilterImp* pif =
XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );
// Tell the protocol it should act normally
messenger->SetNoError();
// SUBSCRIBE
// subscribe own presence
TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif );
// Setup status event listener for RequestComplete
listener2->Reset();
SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "SubscribeOwnPresence failed" );
// verify that SubscribeOwnPresenceL was called
COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", ETrue, NULL );
// REFRESH
// subscribe own presence (refresh)
reqId = presPub.SubscribeOwnPresenceL( *pif );
// Setup status event listener for RequestComplete
SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );
messenger->SetValueFor( EXIMPPlgTestSubscribeOwnPresenceCalled, 0 );
listener2->Reset();
evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// also the event
CXIMPDataSubscriptionStateImp* stateImp = CXIMPDataSubscriptionStateImp::NewLC();
stateImp->SetDataStateL( MXIMPDataSubscriptionState::EDataUnavailable );
stateImp->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive );
COwnPresenceEventImp* event = COwnPresenceEventImp::NewLC( stateImp );
CleanupStack::Pop( 2, stateImp );
CleanupStack::PushL( event );
listener2->ExpectL( event );
CleanupStack::Pop( event );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Refreshing own presence subscription failed" );
// verify that SubscribeOwnPresenceL was called
COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", EFalse, "SubscribeOwnPresenceL was called" );
CleanupStack::PopAndDestroy( pif );
CleanupStack::PopAndDestroy( listener2 );
UnbindL();
}
void T_PresencePublishing::T_ErrFromPlg_LeaveOnSubscribeOwnPresence_L()
{
EUNIT_PRINT( _L("Error from plug-in in presentity presence subscribe") );
EUNIT_PRINT( _L("Plug-in leaves from SubscribePresence().") );
// BIND AND SETUP
BindL();
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
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();
// Create the filled interest document
CPresenceInfoFilterImp* pif =
XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );
// SUBSCRIBE
messenger->SetLeave( KErrAbort );
// subscribe own presence
TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif );
// Setup status event listener for RequestComplete
listener2->Reset();
// request complete with KErrAbort
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
evReqComplete->CompletionResultImp().SetResultCode( KErrAbort );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribing presentity presence, didn't complete with error" );
// verify that SubscribeOwnPresenceL was called
COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", EFalse, "SubscribeOwnPresenceL was called" );
// SUBSCRIBE
messenger->SetLeave( KErrNone );
// subscribe own presence
reqId = presPub.SubscribeOwnPresenceL( *pif );
// Setup status event listener for RequestComplete
listener2->Reset();
evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribing presentity presence failed" );
// verify that SubscribeOwnPresenceL was called
COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", ETrue, "SubscribeOwnPresenceL was called" );
// UNSUBSCRIBE
messenger->SetLeave( KErrAbort );
// register interest
reqId = presPub.UnsubscribeOwnPresenceL();
// Setup status event listener for RequestComplete
listener2->Reset();
evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
evReqComplete->CompletionResultImp().SetResultCode( KErrAbort );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribing presentity presence with error failed" );
// verify that UnsubscribeOwnPresenceL was called
COMMONASSERT( messenger, EXIMPPlgTestUnsubscribeOwnPresenceCalled, "UnsubscribeOwnPresenceL was not called", EFalse,
"UnsubscribeOwnPresenceL was called." );
// UNBIND
CleanupStack::PopAndDestroy( pif );
CleanupStack::PopAndDestroy( listener2 );
messenger->SetLeave( KErrNone );
UnbindL();
}
// ===========================================================================
// Single client, filled filter, publish.
// ===========================================================================
//
void T_PresencePublishing::T_SubscribeOwnPresence_Publish_Single_L()
{
EUNIT_PRINT( _L("Single interest registration with publish") );
/*
* TODO:
*
* case 1
*
* - subscribetä oma presence
* - luo filtteri
* - luo info
* - publishaa oma presence + info
* - tsekkaa että alakerta on saanut infon
* - subscribetä uudelleen (=refresh case)
* - tsekkaa että kaikki ok
*
* case 2
*
* - sama filtteri kuin edellä
* - feikkaa verkkoserveriltä tuleva viesti, jossa sama info kuin edellä
* - tsekkaa, että frameworkin läpi tuleva info sisältää vain ne kamat
* jotka on sallittu ja että muut on blokattu. ts. "test_service":n
* "availability" pitäisi tulla läpi. person-presenceen tungettu kama jää
* pois
*
*/
BindL();
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
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();
// Create the filter
MPresenceInfoFilter* pif = presFeat->PresenceObjectFactory().NewPresenceInfoFilterLC();
pif->AcceptServiceFilterL( KServiceType, NPresenceInfo::NFieldType::KAvailability ); // "test_service", "availability"
// note, the person info will be filtered out now since we don't accept it.
// Tell the protocol it should act normally
messenger->SetNoError();
// SUBSCRIBE
// subscribe own presence
TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif );
// Setup status event listener for RequestComplete
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "SubscribeOwnPresence failed" );
// verify that SubscribeOwnPresenceL was called
COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", ETrue, NULL );
// publish own presence in here
MPresenceInfo* info = CreateInfoLC();
reqId = presPub.PublishOwnPresenceL( *info );
// Setup status event listener
evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
CXIMPDataSubscriptionStateImp* stateImp = CXIMPDataSubscriptionStateImp::NewLC();
stateImp->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable );
stateImp->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive );
COwnPresenceEventImp* event = COwnPresenceEventImp::NewLC( stateImp );
CleanupStack::Pop( 2, stateImp );
CleanupStack::PushL( event );
listener2->ExpectL( event );
CleanupStack::Pop( event );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Publishing presence failed" );
COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called", ETrue, NULL );
// REFRESH
// subscribe own presence (refresh)
reqId = presPub.SubscribeOwnPresenceL( *pif );
// Setup status event listener for RequestComplete
messenger->SetValueFor( EXIMPPlgTestSubscribeOwnPresenceCalled, 0 );
evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// also the event
stateImp = CXIMPDataSubscriptionStateImp::NewLC();
stateImp->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable );
stateImp->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive );
event = COwnPresenceEventImp::NewLC( stateImp );
CleanupStack::Pop( 2, stateImp );
CleanupStack::PushL( event );
listener2->ExpectL( event );
CleanupStack::Pop( event );
// Wait for events on the request
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Refreshing own presence subscription failed" );
// verify that SubscribeOwnPresenceL was called
COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", EFalse, "SubscribeOwnPresenceL was called" );
CleanupStack::PopAndDestroy( 3, listener2 ); // info, pif, listener2
UnbindL();
}
// ===========================================================================
// SETUP HELPERS FOR THE LISTENER
// ===========================================================================
//
void T_PresencePublishing::SetupListenerReqCompleteL( CXIMPTestContextWrapper* aWrapper, TXIMPTestStatusEventTemplate aEventType )
{
RArray< TInt32 > array;
CleanupClosePushL( array );
array.Append( MXIMPContextStateEvent::KInterfaceId );
array.Append( MOwnPresenceEvent::KInterfaceId );
aWrapper->SetupListenerReqCompleteL( aEventType, &array );
CleanupStack::PopAndDestroy(); // array
}
void T_PresencePublishing::SetupListenerReqCompleteAllowEventsL( CXIMPTestContextWrapper* aWrapper, TXIMPTestStatusEventTemplate aEventType )
{
RArray< TInt32 > array;
CleanupClosePushL( array );
array.AppendL( MXIMPRequestCompleteEvent::KInterfaceId );
array.AppendL( MXIMPContextStateEvent::KInterfaceId );
array.AppendL( MOwnPresenceEvent::KInterfaceId );
aWrapper->SetupListenerReqCompleteL( aEventType, &array );
CleanupStack::PopAndDestroy(); // array
}
MPresenceInfo* T_PresencePublishing::CreateInfoLC()
{
// fill up the info structure with:
// service info imp:
// - info name: "test_service"
// - field name: availability
// - field value: enum type, value 1
// person info imp:
// - field name: "status-message"
// - field value: "This is my status message."
//
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
MXIMPContext* context = wrapper->GetContext();
// Get the interface
MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
MPresenceInfo* info = presFeat->PresenceObjectFactory().NewPresenceInfoLC();
// fill service info
MServicePresenceInfo* srvInfo = presFeat->PresenceObjectFactory().NewServicePresenceInfoLC();
srvInfo->SetServiceTypeL( KServiceType ); // test
MPresenceInfoField* infoField = presFeat->PresenceObjectFactory().NewInfoFieldLC();
MPresenceInfoFieldValueEnum* enumField = presFeat->PresenceObjectFactory().NewEnumInfoFieldLC();
enumField->SetValueL( KTestAvailability ); // 1
infoField->SetFieldTypeL( NPresenceInfo::NFieldType::KAvailability ); // "availability"
infoField->SetFieldValue( enumField );
CleanupStack::Pop(); // enumField
srvInfo->Fields().AddOrReplaceFieldL( infoField );
CleanupStack::Pop(); // infoField
info->AddServicePresenceL( srvInfo );
CleanupStack::Pop(); // srvInfo
// fill person info
MPersonPresenceInfo* persInfo = presFeat->PresenceObjectFactory().NewPersonPresenceInfoLC();
MPresenceInfoField* infoField2 = presFeat->PresenceObjectFactory().NewInfoFieldLC();
MPresenceInfoFieldValueText* textField = presFeat->PresenceObjectFactory().NewTextInfoFieldLC();
textField->SetTextValueL( KStatusMsg );
infoField2->SetFieldTypeL( NPresenceInfo::NFieldType::KStatusMessage );
infoField2->SetFieldValue( textField );
CleanupStack::Pop(); // textField
persInfo->Fields().AddOrReplaceFieldL( infoField2 );
CleanupStack::Pop(); // infoField2
info->SetPersonPresenceL( persInfo );
CleanupStack::Pop(); // persInfo
// that's it
return info;
}
// ===========================================================================
// TEST CASE TABLE
// ===========================================================================
//
EUNIT_BEGIN_TEST_TABLE(
T_PresencePublishing,
"XIMP presence management tests",
"MODULE" )
PRFW_DECORATED_TEST(
"Publish single presence",
"",
"",
"FUNCTIONALITY",
Setup_L,
T_Publish_Single_L,
Teardown )
/*
PRFW_NOT_DECORATED_TEST(
"Publish, error leave",
"",
"",
"ERRORHANDLING",
Setup_Bind_L,
T_Publish_ErrFromPlg_Leave_L,
Teardown_Unbind )
PRFW_NOT_DECORATED_TEST(
"Publish, error complete",
"",
"",
"ERRORHANDLING",
Setup_Bind_L,
T_Publish_ErrFromPlg_CompleteWithError_L,
Teardown_Unbind )
*/
PRFW_DECORATED_TEST(
"Empty own presence subscribtion",
"",
"",
"FUNCTIONALITY",
Setup_L,
T_SubscribeOwnPresence_Single_Empty_L,
Teardown )
PRFW_DECORATED_TEST(
"Empty own presence subscribtion for multiple clients",
"",
"",
"FUNCTIONALITY",
SetupMultiple_L,
T_SubscribeOwnPresence_Multiple_Empty_L,
Teardown )
PRFW_DECORATED_TEST(
"Single own presence subscribtion",
"",
"",
"FUNCTIONALITY",
Setup_L,
T_SubscribeOwnPresence_Single_L,
Teardown )
PRFW_DECORATED_TEST(
"Single own presence subscribtion with publish",
"",
"",
"FUNCTIONALITY",
Setup_L,
T_SubscribeOwnPresence_Publish_Single_L,
Teardown )
PRFW_DECORATED_TEST(
"Error - Fail subscription",
"",
"",
"FUNCTIONALITY",
Setup_L,
T_ErrFromPlg_LeaveOnSubscribeOwnPresence_L,
Teardown )
PRFW_DECORATED_TEST(
"Error - Network UnplugError",
"",
"",
"FUNCTIONALITY",
Setup_L,
T_NetworkUnplugError_L,
Teardown )
/*
PRFW_DECORATED_TEST(
"Error - Network UnplugError",
"",
"",
"FUNCTIONALITY",
SetupMultiple_L,
T_NetworkUnplugErrorMultiple_L,
Teardown )
*/
EUNIT_END_TEST_TABLE
// ===========================================================================
// TEST SUITE CONSTRUCTION
// ===========================================================================
//
EXPORT_C MEUnitTest* CreateTestSuiteL()
{
return T_PresencePublishing::NewL();
}
// end of file