diff -r 000000000000 -r e6b17d312c8b ximpfw/tsrc/src/t_presencepublishing/t_presencepublishing.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ximpfw/tsrc/src/t_presencepublishing/t_presencepublishing.cpp Thu Dec 17 08:54:49 2009 +0200 @@ -0,0 +1,1211 @@ +/* +* 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 +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 + + + + + +