--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/imsrv_plat/ximp_core_feature_plugin_api/tsrc/tsrcutils/testcaseutils/prfwteststatuseventlistener.cpp Thu Dec 17 08:54:49 2009 +0200
@@ -0,0 +1,1049 @@
+/*
+* 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:
+*
+*/
+
+#include "prfwteststatuseventlistener.h"
+#include "prfwtestcaseutilspanics.h"
+#include <eunitmacros.h>
+
+#include <ximpcontext.h>
+#include <ximpcontextstateevent.h>
+#include <ximprequestcompleteevent.h>
+#include <ximpstatus.h>
+#include <ownpresenceevent.h>
+#include <presentitypresenceevent.h>
+#include <presentitygrouplistevent.h>
+#include <presentitygroupcontentevent.h>
+#include <presencewatcherlistevent.h>
+#include <presencewatcherinfo.h>
+#include <ximpdatasubscriptionstate.h>
+
+
+using namespace NXIMPTestCaseUtilsPanic;
+EUNIT_DECLARE_PRINTABLE_AS_TINT( MXIMPContextState::TState )
+
+
+ // ============================ MEMBER FUNCTIONS ===============================
+EXPORT_C TXIMPTestStatusEventSnapshot::TXIMPTestStatusEventSnapshot()
+ {
+ iEventType = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ iReqId = TXIMPRequestId();
+ iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ }
+
+
+EXPORT_C TXIMPTestStatusEventSnapshot::TXIMPTestStatusEventSnapshot(
+ TInt aEventType,
+ TInt aCtxState,
+ TInt aResultCode )
+ {
+ iEventType = aEventType;
+ iCtxState = (MXIMPContextState::TState) aCtxState;
+ iResultCode = aResultCode;
+ }
+
+EXPORT_C TBool TXIMPTestStatusEventSnapshot::Equals(
+ const TXIMPTestStatusEventSnapshot& aOther ) const
+ {
+ TBool equals = ETrue;
+
+ if( iEventType != aOther.iEventType )
+ {
+ equals = EFalse;
+ }
+
+ if( iCtxState != aOther.iCtxState )
+ {
+ equals = EFalse;
+ }
+
+ if( iResultCode != aOther.iResultCode )
+ {
+ equals = EFalse;
+ }
+
+ return equals;
+ }
+
+
+
+
+
+// ============================ MEMBER FUNCTIONS ===============================
+EXPORT_C CXIMPTestStatusEventListener* CXIMPTestStatusEventListener::NewL(
+ TInt aStackSize,
+ MXIMPContext* aEventSource )
+ {
+ CXIMPTestStatusEventListener* self =
+ new (ELeave) CXIMPTestStatusEventListener( aStackSize, aEventSource );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+
+CXIMPTestStatusEventListener::~CXIMPTestStatusEventListener()
+ {
+ User::Free( iSnapshots );
+ if( iEventSource )
+ {
+ iEventSource->UnregisterObserver( *this );
+ }
+
+ iAcceptedEventTypes.Reset();
+ iDescription.Close();
+ }
+
+
+CXIMPTestStatusEventListener::CXIMPTestStatusEventListener(
+ TInt aStackSize,
+ MXIMPContext* aEventSource )
+: iSnapshotMaxCount( aStackSize ),
+ iEventSource( aEventSource )
+ {
+ }
+
+
+void CXIMPTestStatusEventListener::ConstructL()
+ {
+ __ASSERT_ALWAYS( iSnapshotMaxCount > 0,
+ Panic( EStatusEventListenerBadMaxCount ) );
+
+ TInt allocSize = iSnapshotMaxCount * sizeof( TXIMPTestStatusEventSnapshot );
+ iSnapshots = (TXIMPTestStatusEventSnapshot*) User::AllocL( allocSize );
+ ResetEventStack();
+ ResetEventTypeStack();
+
+ if( iEventSource )
+ {
+ TArray< TInt32 > eventFilterArray = iAcceptedEventTypes.Array();
+ iEventSource->RegisterObserverL( *this, &eventFilterArray );
+ }
+
+ iDescription.CreateL( 512 );
+ }
+
+
+
+
+// ===========================================================================
+// PUBLIC FUNCTIONS
+// ===========================================================================
+//
+EXPORT_C void CXIMPTestStatusEventListener::SetEventSourceL(
+ MXIMPContext* aEventSource )
+ {
+ if( iEventSource )
+ {
+ iEventSource->UnregisterObserver( *this );
+ }
+
+ if( aEventSource )
+ {
+ TArray< TInt32 > eventFilterArray = iAcceptedEventTypes.Array();
+ aEventSource->RegisterObserverL( *this, &eventFilterArray );
+ }
+
+ iEventSource = aEventSource;
+ }
+
+
+
+EXPORT_C void CXIMPTestStatusEventListener::ReRegisterEventFilterL()
+ {
+ if( iEventSource )
+ {
+ TArray< TInt32 > eventFilterArray = iAcceptedEventTypes.Array();
+ iEventSource->RegisterObserverL( *this, &eventFilterArray );
+ }
+ }
+
+
+
+EXPORT_C RArray< TInt32 >& CXIMPTestStatusEventListener::AcceptedEventTypes()
+ {
+ return iAcceptedEventTypes;
+ }
+
+
+
+EXPORT_C void CXIMPTestStatusEventListener::GetEventTemplateL(
+ RArray< TXIMPTestStatusEventSnapshot >& aArray,
+ TXIMPTestStatusEventTemplate aTemplate )
+ {
+ switch( aTemplate )
+ {
+ // session handling
+ case EXIMPTestStatusEvents_BindingOk:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MXIMPContextStateEvent::KInterfaceId;
+ event.iCtxState = MXIMPContextState::EBinding;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStatusObjNotPresent;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPContextStateEvent::KInterfaceId;
+ event.iCtxState = MXIMPContextState::EActive;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStatusObjNotPresent;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNone;
+ aArray.AppendL( event );
+
+ break;
+ }
+
+ case EXIMPTestStatusEvents_BindingFailKErrAbort:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MXIMPContextStateEvent::KInterfaceId;
+ event.iCtxState = MXIMPContextState::EBinding;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStatusObjNotPresent;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPContextStateEvent::KInterfaceId;
+ event.iCtxState = MXIMPContextState::EInactive;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStatusObjNotPresent;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrAbort;
+ aArray.AppendL( event );
+ break;
+ }
+
+ case EXIMPTestStatusEvents_BindingFailInvalidReqId:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MXIMPContextStateEvent::KInterfaceId;
+ event.iCtxState = MXIMPContextState::EBinding;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStatusObjNotPresent;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent,
+ event.iResultCode = KErrServerTerminated;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPContextStateEvent::KInterfaceId;
+ event.iCtxState = MXIMPContextState::EInactive;
+ event.iResultCode = KErrServerTerminated;
+
+ aArray.AppendL( event );
+ break;
+ }
+
+
+ case EXIMPTestStatusEvents_BindingFailServerTermination:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MXIMPContextStateEvent::KInterfaceId;
+ event.iCtxState = MXIMPContextState::EUnbinding;
+ event.iResultCode = KErrServerTerminated;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPContextStateEvent::KInterfaceId;
+ event.iCtxState = MXIMPContextState::EInactive;
+ event.iResultCode = KErrServerTerminated;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrServerTerminated;
+ aArray.AppendL( event );
+
+ break;
+ }
+
+ case EXIMPTestStatusEvents_UnbindingOk:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MXIMPContextStateEvent::KInterfaceId;
+ event.iCtxState = MXIMPContextState::EUnbinding;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStatusObjNotPresent;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPContextStateEvent::KInterfaceId;
+ event.iCtxState = MXIMPContextState::EInactive;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStatusObjNotPresent;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNone;
+ aArray.AppendL( event );
+ break;
+ }
+
+
+ case EXIMPTestStatusEvents_RequestOk:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNone;
+ aArray.AppendL( event );
+ break;
+ }
+
+
+ case EXIMPTestStatusEvents_RequestOOM:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNoMemory;
+ aArray.AppendL( event );
+ break;
+ }
+
+
+
+ // own presence
+ case EXIMPTestStatusEvents_SubscribeOwnPresenceSingleCtx:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MOwnPresenceEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) ( MXIMPDataSubscriptionState::EDataUnavailable + MXIMPDataSubscriptionState::ESubscriptionActive );
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ aArray.AppendL( event );
+ break;
+ }
+
+ case EXIMPTestStatusEvents_UnsubscribeOwnPresenceSingleCtx:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MOwnPresenceEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) ( MXIMPDataSubscriptionState::EDataUnavailable + MXIMPDataSubscriptionState::ESubscriptionInactive );
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ aArray.AppendL( event );
+ break;
+ }
+
+ // presentity presence
+ case EXIMPTestStatusEvents_SubscribePresentityPresenceSingleCtx:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresentityPresenceEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) ( MXIMPDataSubscriptionState::EDataUnavailable + MXIMPDataSubscriptionState::ESubscriptionActive );
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ aArray.AppendL( event );
+ break;
+ }
+
+ case EXIMPTestStatusEvents_UnsubscribePresentityPresenceSingleCtx:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresentityPresenceEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) ( MXIMPDataSubscriptionState::EDataUnavailable + MXIMPDataSubscriptionState::ESubscriptionInactive );
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ aArray.AppendL( event );
+ break;
+ }
+
+ // group lists
+ case EXIMPTestStatusEvents_SubscribePresentityGroupListCtx:
+ {
+ // TODO check this
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresentityGroupListEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNone;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNone;
+ aArray.AppendL( event );
+ break;
+ }
+
+ case EXIMPTestStatusEvents_UnsubscribePresentityGroupListCtx:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresentityGroupListEvent::KInterfaceId;
+ // TODO check this
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ aArray.AppendL( event );
+ break;
+ }
+
+ case EXIMPTestStatusEvents_CreatePresentityGroup:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresentityGroupListEvent::KInterfaceId;
+ // TODO check this
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNone;
+ aArray.AppendL( event );
+
+ break;
+ }
+
+ case EXIMPTestStatusEvents_HandlePresentityGroupList:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresentityGroupListEvent::KInterfaceId;
+ // TODO check this
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ aArray.AppendL( event );
+ break;
+ }
+
+ // group content
+ case EXIMPTestStatusEvents_SubscribePresentityGroupContentSingleCtx:
+ {
+ // TODO check this
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresentityGroupContentEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNone;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNone;
+ aArray.AppendL( event );
+ break;
+ }
+
+ case EXIMPTestStatusEvents_UnsubscribePresentityGroupContentSingleCtx:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresentityGroupContentEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNone;
+ aArray.AppendL( event );
+ break;
+ }
+
+ // watcher list
+ case EXIMPTestStatusEvents_SubscribePresenceWatcherListCtx:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresenceWatcherListEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNone;
+ aArray.AppendL( event );
+
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNone;
+ aArray.AppendL( event );
+ break;
+ }
+
+ case EXIMPTestStatusEvents_UnsubscribePresenceWatcherListCtx:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresenceWatcherListEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ aArray.AppendL( event );
+ break;
+ }
+
+ case EXIMPTestStatusEvents_HandlePresenceWatcherList:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresenceWatcherListEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ aArray.AppendL( event );
+ break;
+ }
+
+ case EXIMPTestStatusEvents_HandlePresentityPresence:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresentityPresenceEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) ( MXIMPDataSubscriptionState::EDataAvailable + MXIMPDataSubscriptionState::ESubscriptionActive );
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ aArray.AppendL( event );
+ break;
+ }
+
+
+ case EXIMPTestStatusEvents_HandlePresentityPresencePending:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MPresentityPresenceEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) ( MXIMPDataSubscriptionState::EDataUnavailable + MXIMPDataSubscriptionState::ESubscriptionActive );
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ aArray.AppendL( event );
+ break;
+ }
+
+ case EXIMPTestStatusEvents_PresentitySubscribeFailKErrAbort:
+ {
+ TXIMPTestStatusEventSnapshot event;
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrAbort;
+ aArray.AppendL( event );
+ break;
+ }
+
+ // misc
+ case EXIMPTestStatusEvents_PublishOk:
+ {
+ TXIMPTestStatusEventSnapshot event;
+
+ // request complete with KErrNone
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrNone;
+ aArray.AppendL( event );
+
+ // OwnPresenceEvent
+ event.iEventType = MOwnPresenceEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = TXIMPTestStatusEventSnapshot::EStatusObjNotPresent;
+ aArray.AppendL( event );
+
+ break;
+ }
+
+ case EXIMPTestStatusEvents_PublishFailKErrAbort:
+ {
+ TXIMPTestStatusEventSnapshot event;
+
+ // Request completed with KErrAbort
+ event.iEventType = MXIMPRequestCompleteEvent::KInterfaceId;
+ event.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ event.iResultCode = KErrAbort;
+ aArray.AppendL( event );
+
+ break;
+ }
+
+ default:
+ {
+ Panic( EStatusEventListenerUnknownEventTemplate );
+ }
+ }
+ }
+
+
+
+EXPORT_C void CXIMPTestStatusEventListener::WaitRequestAndStackEvents(
+ const TXIMPRequestId& aReqToWait, TBool aAnyReq /* = EFalse */ )
+ {
+ __ASSERT_ALWAYS( !iWait.IsStarted(),
+ Panic( EStatusEventListenerAlreadyWaiting ) );
+
+ iWaitForAnyReq = aAnyReq;
+ iReqToWait = aReqToWait;
+ iWaitForAnyEvent = EFalse;
+
+ iWait.Start();
+ }
+
+EXPORT_C void CXIMPTestStatusEventListener::WaitAnyEvent()
+ {
+ iWaitForAnyEvent = ETrue;
+ iWait.Start();
+ }
+
+
+EXPORT_C void CXIMPTestStatusEventListener::VerifyEventStackL(
+ const TArray< TXIMPTestStatusEventSnapshot >& aEventTraits,
+ const TDesC8& aErrorTitle ) const
+ {
+ iDescription.Zero();
+ TInt ix = 0;
+
+ //Dumb event lists if there is some mismatches
+ if( !HasSameEvents( aEventTraits ) )
+ {
+ iDescription = aErrorTitle;
+ iDescription += _L8("Mismatches in event stack");
+ EUNIT_PRINT( iDescription );
+
+ iDescription = _L8("Received: ");
+ for( ix = 0; ix < iSnapshotCount; ix++ )
+ {
+ GetNameForEvent( iDescription, SnapshotFromStack( ix ).iEventType );
+ }
+ EUNIT_PRINT( iDescription );
+
+
+ iDescription = _L8("Expected: ");
+ const TInt traitCount = aEventTraits.Count();
+ for( ix = 0; ix < traitCount; ix++ )
+ {
+ GetNameForEvent( iDescription, aEventTraits[ ix ].iEventType );
+ }
+ EUNIT_PRINT( iDescription );
+ }
+
+
+ //Now do the actual verification
+ iDescription = aErrorTitle;
+ iDescription += _L8("Event count mismatch");
+ EUNIT_ASSERT_EQUALS_DESC( iSnapshotCount, aEventTraits.Count(), iDescription.PtrZ() );
+
+
+ for( TInt ix = 0; ix < iSnapshotCount; ix++ )
+ {
+ const TXIMPTestStatusEventSnapshot& expected = aEventTraits[ ix ];
+ const TXIMPTestStatusEventSnapshot& received = SnapshotFromStack( ix );
+
+ {
+ iDescription = aErrorTitle;
+ iDescription.AppendFormat( _L8("Event type mismatch on event [%d]"), ix );
+ EUNIT_ASSERT_EQUALS_DESC( expected.iEventType, expected.iEventType, iDescription.PtrZ() );
+ }
+
+ {
+ const TInt type = received.iEventType;
+
+ iDescription = aErrorTitle;
+ iDescription += _L8("Content mismatch on ");
+ GetNameForEvent( iDescription, type );
+ iDescription.AppendFormat( _L8("event on position [%d]"), ix );
+ switch( type )
+ {
+ case MXIMPRequestCompleteEvent::KInterfaceId:
+ {
+ EUNIT_ASSERT_EQUALS_DESC( expected.iResultCode, received.iResultCode, iDescription.PtrZ() );
+ break;
+ }
+
+
+ case MXIMPContextStateEvent::KInterfaceId:
+ {
+ EUNIT_ASSERT_EQUALS_DESC( expected.iCtxState, received.iCtxState, iDescription.PtrZ() );
+ EUNIT_ASSERT_EQUALS_DESC( expected.iResultCode, received.iResultCode, iDescription.PtrZ() );
+ break;
+ }
+
+ case MOwnPresenceEvent::KInterfaceId:
+ case MPresentityPresenceEvent::KInterfaceId:
+ {
+ EUNIT_ASSERT_EQUALS_DESC( expected.iCtxState, received.iCtxState, iDescription.PtrZ() );
+ break;
+ }
+
+ case MPresentityGroupListEvent::KInterfaceId:
+ {
+ EUNIT_ASSERT_EQUALS_DESC( expected.iCtxState, received.iCtxState, iDescription.PtrZ() );
+ EUNIT_ASSERT_EQUALS_DESC( expected.iResultCode, received.iResultCode, iDescription.PtrZ() );
+ break;
+ }
+
+ case MPresentityGroupContentEvent::KInterfaceId:
+ {
+ EUNIT_ASSERT_EQUALS_DESC( expected.iCtxState, received.iCtxState, iDescription.PtrZ() );
+ EUNIT_ASSERT_EQUALS_DESC( expected.iResultCode, received.iResultCode, iDescription.PtrZ() );
+ break;
+ }
+
+ case MPresenceWatcherListEvent::KInterfaceId:
+ {
+ EUNIT_ASSERT_EQUALS_DESC( expected.iCtxState, received.iCtxState, iDescription.PtrZ() );
+ EUNIT_ASSERT_EQUALS_DESC( expected.iResultCode, received.iResultCode, iDescription.PtrZ() );
+ break;
+ }
+
+
+ default:
+ {
+ Panic( EUnsupportedEventTypeInVerification );
+ break;
+ }
+ }
+ }
+ }
+ }
+
+
+
+
+EXPORT_C TInt CXIMPTestStatusEventListener::GetReqCompletionErrL(
+ const TXIMPRequestId& aReqId ) const
+ {
+ for( TInt ix = 0; ix < iSnapshotCount; ix++ )
+ {
+ const TXIMPTestStatusEventSnapshot& received = SnapshotFromStack( ix );
+ const TInt type = received.iEventType;
+
+ if( type == MXIMPRequestCompleteEvent::KInterfaceId )
+ {
+ if( received.iReqId == aReqId )
+ {
+ return received.iResultCode;
+ }
+ }
+ }
+
+ User::Leave( KErrNotFound );
+ return KErrNotFound;
+ }
+
+
+EXPORT_C void CXIMPTestStatusEventListener::ResetEventStack()
+ {
+ for( TInt ix = 0; ix < iSnapshotMaxCount; ix++ )
+ {
+ new( &iSnapshots[ ix ] ) TXIMPTestStatusEventSnapshot();
+ }
+
+ iSnapshotCount = 0;
+ }
+
+EXPORT_C void CXIMPTestStatusEventListener::ResetEventTypeStack()
+ {
+ iAcceptedEventTypes.Reset();
+ iAcceptedEventTypes.AppendL( MXIMPRequestCompleteEvent::KInterfaceId );
+ iAcceptedEventTypes.AppendL( MXIMPContextStateEvent::KInterfaceId );
+ iAcceptedEventTypes.AppendL( MOwnPresenceEvent::KInterfaceId );
+ iAcceptedEventTypes.AppendL( MPresentityPresenceEvent::KInterfaceId );
+ }
+
+EXPORT_C void CXIMPTestStatusEventListener::SetEventObserver( MXIMPContextObserver* aObserver )
+ {
+ iObserver = aObserver;
+ }
+
+
+
+
+
+
+
+
+// ===========================================================================
+// FROM MPRFWPRESENCECONTEXTOBSERVER
+// ===========================================================================
+//
+void CXIMPTestStatusEventListener::HandlePresenceContextEvent(
+ const MXIMPContext& aContext,
+ const MXIMPBase& aEvent )
+ {
+ const TInt32 eventType = aEvent.GetInterfaceId();
+
+ __ASSERT_ALWAYS( iEventSource == &aContext,
+ Panic( EReceivingEventFromWrongContext ) );
+
+ __ASSERT_ALWAYS( IsAcceptedEventType( eventType ),
+ Panic( EReceivedNotAcceptedEventType ) );
+
+ TXIMPTestStatusEventSnapshot snapShot;
+ switch( eventType )
+ {
+ case MXIMPRequestCompleteEvent::KInterfaceId:
+ {
+ const MXIMPRequestCompleteEvent* event =
+ TXIMPGetInterface< const MXIMPRequestCompleteEvent >::From( aEvent, MXIMPBase::EPanicIfUnknown );
+ {
+ snapShot.iEventType = event->GetInterfaceId();
+ snapShot.iCtxState = (MXIMPContextState::TState) TXIMPTestStatusEventSnapshot::EStateValueNotPresent;
+ snapShot.iReqId = event->RequestId();
+ snapShot.iResultCode = event->CompletionResult().ResultCode();
+
+ AddSnapshotToStack( snapShot );
+ }
+
+ if( iWaitForAnyReq || event->RequestId() == iReqToWait )
+ {
+ HandleRequestCompleteReceived();
+ }
+
+ break;
+ }
+
+ case MXIMPContextStateEvent::KInterfaceId:
+ {
+ const MXIMPContextStateEvent& event =
+ *TXIMPGetInterface< const MXIMPContextStateEvent >::From( aEvent,
+ MXIMPBase::EPanicIfUnknown );
+ {
+ TXIMPTestStatusEventSnapshot snapShot;
+ snapShot.iEventType = event.GetInterfaceId();
+ snapShot.iCtxState = event.ContextState().ContextState();
+ if( event.StateChangeReason() )
+ {
+ snapShot.iResultCode = event.StateChangeReason()->ResultCode();
+ }
+ else
+ {
+ snapShot.iResultCode = TXIMPTestStatusEventSnapshot::EStatusObjNotPresent;
+ }
+
+ AddSnapshotToStack( snapShot );
+ }
+ break;
+ }
+
+ case MOwnPresenceEvent::KInterfaceId:
+ {
+ const MOwnPresenceEvent& event =
+ *TXIMPGetInterface< const MOwnPresenceEvent >::From( aEvent,
+ MXIMPBase::EPanicIfUnknown );
+ {
+ TXIMPTestStatusEventSnapshot snapShot;
+ snapShot.iEventType = event.GetInterfaceId();
+ snapShot.iCtxState = ( MXIMPContextState::TState ) ( event.DataSubscriptionState().DataState() + event.DataSubscriptionState().SubscriptionState() );
+ AddSnapshotToStack( snapShot );
+ }
+ break;
+ }
+
+ case MPresentityPresenceEvent::KInterfaceId:
+ {
+ const MPresentityPresenceEvent& event =
+ *TXIMPGetInterface< const MPresentityPresenceEvent >::From( aEvent,
+ MXIMPBase::EPanicIfUnknown );
+ {
+ TXIMPTestStatusEventSnapshot snapShot;
+ snapShot.iEventType = event.GetInterfaceId();
+ snapShot.iCtxState = ( MXIMPContextState::TState ) ( event.DataSubscriptionState().DataState() + event.DataSubscriptionState().SubscriptionState() );
+ AddSnapshotToStack( snapShot );
+ }
+ break;
+ }
+
+ case MPresentityGroupListEvent::KInterfaceId:
+ {
+ const MPresentityGroupListEvent& event =
+ *TXIMPGetInterface< const MPresentityGroupListEvent >::From( aEvent,
+ MXIMPBase::EPanicIfUnknown );
+ {
+ TXIMPTestStatusEventSnapshot snapShot;
+ snapShot.iEventType = event.GetInterfaceId();
+ AddSnapshotToStack( snapShot );
+ }
+ break;
+ }
+
+ case MPresentityGroupContentEvent::KInterfaceId:
+ {
+ const MPresentityGroupContentEvent& event =
+ *TXIMPGetInterface< const MPresentityGroupContentEvent >::From( aEvent,
+ MXIMPBase::EPanicIfUnknown );
+ {
+ TXIMPTestStatusEventSnapshot snapShot;
+ snapShot.iEventType = event.GetInterfaceId();
+ AddSnapshotToStack( snapShot );
+ }
+ break;
+ }
+
+
+ case MPresenceWatcherListEvent::KInterfaceId:
+ {
+ const MPresenceWatcherListEvent& event =
+ *TXIMPGetInterface< const MPresenceWatcherListEvent >::From( aEvent,
+ MXIMPBase::EPanicIfUnknown );
+ {
+ TXIMPTestStatusEventSnapshot snapShot;
+ snapShot.iEventType = event.GetInterfaceId();
+ AddSnapshotToStack( snapShot );
+ }
+ break;
+ }
+
+
+ default:
+ {
+ break;
+ }
+ }
+
+ if( iObserver )
+ {
+ iObserver->HandlePresenceContextEvent( aContext, aEvent );
+ }
+
+ if( iWaitForAnyEvent )
+ {
+ HandleRequestCompleteReceived();
+ }
+ }
+
+
+
+// ===========================================================================
+// HELPERS
+// ===========================================================================
+//
+void CXIMPTestStatusEventListener::HandleRequestCompleteReceived()
+ {
+ if( iWait.IsStarted() )
+ {
+ iWait.AsyncStop();
+ }
+ }
+
+
+
+TBool CXIMPTestStatusEventListener::IsAcceptedEventType( TInt32 aEventType ) const
+ {
+ TInt index = iAcceptedEventTypes.Find( aEventType );
+ if( index == KErrNotFound )
+ {
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+
+
+void CXIMPTestStatusEventListener::AddSnapshotToStack(
+ TXIMPTestStatusEventSnapshot aSnapshot )
+ {
+ __ASSERT_ALWAYS( iSnapshotCount < iSnapshotMaxCount,
+ Panic( EAddSnapshotOverflow ) );
+
+ iSnapshots[ iSnapshotCount ] = aSnapshot;
+ iSnapshotCount++;
+ }
+
+
+
+const TXIMPTestStatusEventSnapshot& CXIMPTestStatusEventListener::SnapshotFromStack( TInt aIndex ) const
+ {
+ __ASSERT_ALWAYS( aIndex < iSnapshotCount,
+ Panic( ESnapshotIndexOutOfBounds ) );
+
+ return iSnapshots[ aIndex ];
+ }
+
+
+
+TBool CXIMPTestStatusEventListener::HasSameEvents(
+ const TArray< TXIMPTestStatusEventSnapshot >& aEventTraits ) const
+ {
+ TBool hasSameEvents = ETrue;
+
+ if( iSnapshotCount != aEventTraits.Count() )
+ {
+ hasSameEvents = EFalse;
+ }
+ else
+ {
+ for( TInt ix = 0; ix < iSnapshotCount; ix++ )
+ {
+ const TXIMPTestStatusEventSnapshot& eventTrait = aEventTraits[ ix ];
+ const TXIMPTestStatusEventSnapshot& receivedEvent = SnapshotFromStack( ix );
+
+ if( !receivedEvent.Equals( eventTrait ) )
+ {
+ hasSameEvents = EFalse;
+ }
+ }
+ }
+
+ return hasSameEvents;
+ }
+
+
+
+void CXIMPTestStatusEventListener::GetNameForEvent(
+ TDes8& aTarget,
+ TInt aEventType ) const
+ {
+ switch( aEventType )
+ {
+ case MXIMPRequestCompleteEvent::KInterfaceId:
+ {
+ SafeAppendEventName( aTarget, _L8("[ReqComplete] ") );
+ break;
+ }
+
+ case MXIMPContextStateEvent::KInterfaceId:
+ {
+ SafeAppendEventName( aTarget, _L8("[PresCtx] ") );
+ break;
+ }
+
+ case MOwnPresenceEvent::KInterfaceId:
+ {
+ SafeAppendEventName( aTarget, _L8("[OwnPres] ") );
+ break;
+ }
+
+ case MPresentityGroupListEvent::KInterfaceId:
+ {
+ SafeAppendEventName( aTarget, _L8("[GroupList] ") );
+ break;
+ }
+
+ case MPresentityGroupContentEvent::KInterfaceId:
+ {
+ SafeAppendEventName( aTarget, _L8("[GroupContent] ") );
+ break;
+ }
+
+ case MPresentityPresenceEvent::KInterfaceId:
+ {
+ SafeAppendEventName( aTarget, _L8("[Presentity] ") );
+ break;
+ }
+
+ default:
+ {
+ SafeAppendEventName( aTarget, _L8("[Unknown] ") );
+ break;
+ }
+ }
+ }
+
+
+
+void CXIMPTestStatusEventListener::SafeAppendEventName(
+ TDes8& aTarget,
+ const TDesC8& aName ) const
+ {
+ const TInt sizeAvailable = aTarget.MaxLength() - aTarget.Length();
+
+ if( sizeAvailable > aName.Size() )
+ {
+ aTarget += aName;
+ }
+ else
+ {
+ _LIT8( KEllipsis, "..." );
+ if( sizeAvailable > KEllipsis().Size() )
+ {
+ aTarget += KEllipsis;
+ }
+ }
+ }
+
+
+
+
+// end of file
+