void T_CGlxCache::T_CGlxCache_Delete_SubTest5L( )
{
// Create helper class
T_CacheTestHelpers cacheTestHelper(iCGlxCache);
// Create media user class
CGlxMediaUserTest* mediaUser = CGlxMediaUserTest::NewL();
CleanupStack::PushL(mediaUser);
cacheTestHelper.ItemPool()[1]->ReserveUsersL(1);
cacheTestHelper.ItemPool()[1]->AddUser(*mediaUser, KErrNotFound);
// Delete item where user has reference to media
EUNIT_PRINT(_L("Delete item where user has reference to media"));
iCGlxCache->Delete(1);
EUNIT_PRINT(_L("Check item deleted"));
EUNIT_ASSERT_DESC(cacheTestHelper.ItemPool().Count() == 1, "Cache doesn't contain one item");
TInt media1Index = cacheTestHelper.ItemPool().FindInOrder(TGlxMediaId(KMediaId1), T_CacheTestHelpers::MediaItemOrderByKey);
EUNIT_ASSERT_DESC(media1Index != KErrNotFound, "Incorrect item deleted from cache");
EUNIT_PRINT(_L("Check user called to remove reference"));
EUNIT_ASSERT_DESC(mediaUser->RemoveReferenceCalled(), "User not called to remove reference");
CleanupStack::PopAndDestroy(mediaUser);
}
void T_CGlxCache::T_CGlxCache_Delete_SubTest3L( )
{
// Create helper class
T_CacheTestHelpers cacheTestHelper(iCGlxCache);
// Create item without users
CGlxMedia* media3 = new (ELeave) CGlxMedia(TGlxMediaId(KMediaId3));
CleanupStack::PushL(media3);
media3->SetTObjectValueL<TBool>(KGlxMediaGeneralSystemItem, EFalse);
cacheTestHelper.ItemPool().AppendL(media3);
CleanupStack::Pop(media3);
// Delete item without users
EUNIT_PRINT(_L("Delete item without users"));
iCGlxCache->Delete(2);
EUNIT_PRINT(_L("Check item deleted"));
EUNIT_ASSERT_DESC(cacheTestHelper.ItemPool().Count() == 2, "Cache doesn't contain two items");
TInt media1Index = cacheTestHelper.ItemPool().FindInOrder(TGlxMediaId(KMediaId1), T_CacheTestHelpers::MediaItemOrderByKey);
TInt media2Index = cacheTestHelper.ItemPool().FindInOrder(TGlxMediaId(KMediaId2), T_CacheTestHelpers::MediaItemOrderByKey);
EUNIT_ASSERT_DESC((media1Index != KErrNotFound) && (media2Index != KErrNotFound), "Incorrect item deleted from cache");
}
// 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();
}
// from MCFContextSource
void UT_CCFContextManager::NoSubscribers( const TDesC& aContextSource,
const TDesC& aContextType )
{
iNoSubscribersCalled = ETrue;
EUNIT_ASSERT_DESC( iExpectedSubscribersSource.Compare( aContextSource ) == 0,
"No expected source");
EUNIT_ASSERT_DESC( iExpectedSubscribersType.Compare( aContextType ) == 0,
"No expected type");
}
void UT_CCFEngine::UT_RemoveSubscriptionDuringIdicationL()
{
RThread thread;
CleanupClosePushL(thread);
CCFContextSubscription* subscription1 = CCFContextSubscription::NewLC();
subscription1->SetContextSourceL(_L("testsource"));
subscription1->SetContextTypeL(_L("listenedtype"));
CleanupStack::Pop( subscription1 );
// make the dummy subscription
TInt error = iCFContextInterface->SubscribeContext(subscription1,
this, thread);
EUNIT_ASSERT_DESC ( error == KErrNone, "Subscription did not succeeded!");
CCFContextSubscription* subscription2 = CCFContextSubscription::NewLC();
subscription2->SetContextSourceL(_L("testsource"));
subscription2->SetContextTypeL(_L("listenedtype"));
CleanupStack::Pop( subscription2 );
// make subscription
error = iCFContextInterface->SubscribeContext(subscription2, this, thread);
EUNIT_ASSERT_DESC ( error == KErrNone, "Subscription did not succeeded!");
// define context
static _LIT_SECURITY_POLICY_PASS( alwaysPass );
error = iCFContextInterface->DefineContext( _L("testsource"),
_L("listenedtype"), alwaysPass );
EUNIT_ASSERT_DESC ( error == KErrNone, "DefineContext did not succeeded!");
// Set remove susbcription that will be removed during next context
// indication
iRemoveSubscription = subscription1;
iIndication = EFalse;
CCFContextObject* co = CCFContextObject::NewLC();
co->SetSourceL(_L("testsource"));
co->SetTypeL(_L("listenedtype"));
co->SetValueL(_L("testvalue"));
error = iCFContextInterface->PublishContext( *co, thread );
iTestDelay->Start( KSecond / 2 );
// check that we get the published context
EUNIT_ASSERT_DESC ( iIndication, "Context indication shoud have arrived");
iIndication = EFalse;
CleanupStack::PopAndDestroy( co );
CleanupStack::PopAndDestroy( &thread );
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
void T_PresenceWatcherListManagement::UnsubscribeL()
{
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
MXIMPContext* context = wrapper->GetContext();
CXIMPTestMessenger* messenger = wrapper->GetMessenger();
// Get the interfaces
MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
MPresencePublishing& presPub = presFeat->PresencePublishing();
// Setup status event listener for RequestComplete
CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
CleanupStack::PushL( listener2 );
// Setup status event listener for RequestComplete
listener2->Reset();
TXIMPRequestId reqIdDummy; // not checked
CXIMPRequestCompleteEventImp* evReqComplete =
CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// unsubscribe
TXIMPRequestId reqId = presPub.UnsubscribePresenceWatcherListL();
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsbscribe failed" );
// verify that UnsubscribeWatcherListL was called
COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled, "UnsubscribeWatcherListL was not called", ETrue, NULL );
CleanupStack::PopAndDestroy( listener2 );
}
// ===========================================================================
// USAGE SCENARIO:
//
// ===========================================================================
//
void T_RootServices::Test_ListProtocolsAndTheirCapabilities_L()
{
//Initialize XIMP client
MXIMPClient* presClient = MXIMPClient::NewClientL();
CleanupDeletePushL( presClient );
RXIMPObjOwningPtrArray< MXIMPProtocolInfo > protocolList;
CleanupClosePushL( protocolList );
//List & dump all available protocols
presClient->GetProtocolsL( protocolList );
__DumpProtocolListL( protocolList );
//Verify that atleast main test protocol exist in list
//And for it is reported corect properties
TBool mainTestProtocolFound( EFalse );
for ( TInt index( 0 ); index < protocolList.Count(); index++ )
{
MXIMPProtocolInfo& protocol = *protocolList[ index ];
if (protocol.DisplayName() == K_PRFW_TST_PROTOCOL_1_DISPLAY_NAME )
{
if ( protocol.ImplementationUid() == TUid::Uid( K_PRFW_TST_PROTOCOL_1_IMPLEMENTATION_UID ) )
{
mainTestProtocolFound = ETrue;
break;
}
}
}
EUNIT_ASSERT_DESC( mainTestProtocolFound, "Primary test protocol not found." );
CleanupStack::PopAndDestroy(); //protocolList
CleanupStack::PopAndDestroy(); //presClient
}
///NEW BIND
EXPORT_C void CXIMPTestContextWrapper::BindWithSettingsL( TInt aId )
{
SetupListenerL( EXIMPTestStatusEvents_BindingOk );
iMessenger->SetNoError();
iMessenger->SetPluginIndex( 0/*aId*/ );
// create fake info
TInt extraLength = 8; // bad style... but length is enough
HBufC* fakeSrv = HBufC::NewLC( KTestFakeServer().Length() + extraLength );
fakeSrv->Des().AppendFormat( KTestFakeServer, aId );
HBufC* fakeUser = HBufC::NewLC( KTestFakeUser().Length() + extraLength );
fakeUser->Des().AppendFormat( KTestFakeUser, aId );
HBufC* fakePass = HBufC::NewLC( KTestFakePassword().Length() + extraLength );
fakePass->Des().AppendFormat( KTestFakePassword, aId );
delete iFileTool;
iFileTool = NULL;
iFileTool = CXIMPTestFileTool::NewL( KTestProtocolUid.iUid, iIndex );
TXIMPRequestId reqId = iContext->BindToL(
KTestProtocolUid, aId );
CleanupStack::PopAndDestroy( 3, fakeSrv );
WaitRequestAndStackEvents( reqId );
VerifyEventStackL( _L8("Binding (wrapper BindWithSettingsL): ") );
EUNIT_ASSERT_DESC( iMessenger->GetBoolean( EXIMPPlgTestOpenSessionCalled ) ||
iMessenger->GetBoolean( EXIMPPlgTestShareSessionCalled ), "OpenSessionL was not called" );
}
void T_PresenceGroupListManagement::SubscribeL()
{
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
MXIMPContext* context = wrapper->GetContext();
CXIMPTestMessenger* messenger = wrapper->GetMessenger();
// Get the interfaces
MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
MPresentityGroups& presGroup = presFeat->PresentityGroups();
CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
CleanupStack::PushL( listener2 );
// ------------------------------------------------------
// expect normal request complete
TXIMPRequestId reqIdDummy; // not checked
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// ------------------------------------------------------
// subscribe
TXIMPRequestId reqId = presGroup.SubscribePresentityGroupListL();
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribe failed" );
messenger->AssertSubscribePresentityGroupListCalled( ETrue );
CleanupStack::PopAndDestroy( listener2 );
}
// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
EXPORT_C void CXIMPTestContextWrapper::BindL(
TUid aUid,
const TDesC& aServer,
const TDesC& aUser,
const TDesC& aPassword )
{
SetupListenerL( EXIMPTestStatusEvents_BindingOk );
iMessenger->SetNoError();
iMessenger->SetPluginIndex( iIndex );
delete iFileTool;
iFileTool = NULL;
iFileTool = CXIMPTestFileTool::NewL( aUid.iUid, iIndex );
TXIMPRequestId reqId = iContext->BindToL(
aUid,
aServer,
aUser,
aPassword,
*iInstance,
iIndex );
WaitRequestAndStackEvents( reqId );
VerifyEventStackL( _L8("Binding (wrapper BindL): ") );
EUNIT_ASSERT_DESC( iMessenger->GetBoolean( EXIMPPlgTestOpenSessionCalled ) ||
iMessenger->GetBoolean( EXIMPPlgTestShareSessionCalled ), "OpenSessionL was not called" );
}
void T_PresenceGroupListManagement::SubscribeGroupL( const TDesC& aGroupId )
{
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
MXIMPContext* context = wrapper->GetContext();
CXIMPTestMessenger* messenger = wrapper->GetMessenger();
// Get the interfaces
MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
MPresentityGroups& presGroup = presFeat->PresentityGroups();
CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
CleanupStack::PushL( listener2 );
// ------------------------------------------------------
// expect normal request complete
TXIMPRequestId reqIdDummy; // not checked
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// ------------------------------------------------------
// subscribe group content
MXIMPIdentity* identity = context->ObjectFactory().NewIdentityLC();
identity->SetIdentityL( aGroupId );
TXIMPRequestId reqId = presGroup.SubscribePresentityGroupContentL( *identity );
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribe content failed" );
COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityGroupContentCalled, "SubscribeGroupContentL was not called", ETrue, NULL );
CleanupStack::PopAndDestroy(); // identity
CleanupStack::PopAndDestroy( listener2 );
}
void UT_CCFContextManager::UT_CCFContextManager_NewLL( )
{
CCFContextManager* instance = CCFContextManager::NewL( *this );
CleanupStack::PushL ( instance );
EUNIT_ASSERT_DESC ( instance, "CCFContextManager not created!" );
CleanupStack::PopAndDestroy( instance );
}
// Single client, empty filter, error in unsubscribe
void T_PresenceGroupListManagement::T_UnsubscribePresentityGroup_Error_Single_L()
{
EUNIT_PRINT( _L("Single presentity group list unsubscribe with error") );
BindL();
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
MXIMPContext* context = wrapper->GetContext();
CXIMPTestMessenger* messenger = wrapper->GetMessenger();
// Get the interfaces
MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
MPresentityGroups& presGroup = presFeat->PresentityGroups();
CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
CleanupStack::PushL( listener2 );
// Tell the protocol it should act normally
messenger->SetNoError();
// ---------------------------------------------
// subscribe
TXIMPRequestId reqIdDummy; // not checked
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
TXIMPRequestId reqId = presGroup.SubscribePresentityGroupListL();
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribe failed" );
messenger->AssertSubscribePresentityGroupListCalled( ETrue );
// ---------------------------------------------
// unsubscribe
messenger->SetError( KErrArgument );
evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
evReqComplete->CompletionResultImp().SetResultCode( KErrArgument );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
reqId = presGroup.UnsubscribePresentityGroupListL();
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe failed" );
messenger->AssertUnsubscribePresentityGroupListCalled( ETrue );
CleanupStack::PopAndDestroy( listener2 );
UnbindL();
}
void T_CGlxCache::T_CGlxCache_MediaL( )
{
// Create helper class
T_CacheTestHelpers cacheTestHelper(iCGlxCache);
EUNIT_PRINT(_L("Obtain non-existing media by id"));
CGlxMedia* media = iCGlxCache->Media(TGlxMediaId(KMediaId3));
EUNIT_PRINT(_L("Check returned media"));
EUNIT_ASSERT_DESC(media == NULL, "Media returned");
EUNIT_PRINT(_L("Obtain media by id"));
media = iCGlxCache->Media(TGlxMediaId(KMediaId1));
EUNIT_PRINT(_L("Check returned media"));
EUNIT_ASSERT_DESC(media == cacheTestHelper.ItemPool()[0], "Incorrect media returned");
}
void T_CGlxCache::T_CGlxCache_CountL( )
{
EUNIT_PRINT(_L("Obtain media count"));
TInt count = iCGlxCache->Count();
EUNIT_PRINT(_L("Check media count"));
EUNIT_ASSERT_DESC(count == 2, "Incorrect media count");
}
void T_CGlxCache::T_CGlxCache_Media2L( )
{
EUNIT_PRINT(_L("Obtain media by index"));
CGlxMedia& media = iCGlxCache->Media(1);
EUNIT_PRINT(_L("Check returned media"));
EUNIT_ASSERT_DESC(media.Id().Value() == KMediaId2, "Incorrect media returned");
}
//-----------------------------------------------------------------------------
// MT_CFOperationPluginManager::T_CCFOperationPluginManager_NewLL
//-----------------------------------------------------------------------------
//
void MT_CFOperationPluginManager::T_CCFOperationPluginManager_NewLCL( )
{
CCFOperationPluginManager* instance =
CCFOperationPluginManager::NewLC( *this );
EUNIT_ASSERT_DESC( instance, "CCFOperationPluginManager instance not created!" );
CleanupStack::PopAndDestroy( instance );
}
void T_CGlxCache::T_CGlxCache_FindItemForceCreateLL( )
{
// Create helper class
T_CacheTestHelpers cacheTestHelper(iCGlxCache);
// Find existing instance
EUNIT_PRINT(_L("Find existing media"));
CGlxMedia* media = iCGlxCache->FindItemForceCreateL(TGlxMediaId(KMediaId1));
EUNIT_PRINT(_L("Check returned media"));
EUNIT_ASSERT_DESC(media == cacheTestHelper.ItemPool()[0], "Incorrect media returned");
// Find non-existing media
EUNIT_PRINT(_L("Find non-existing media"));
media = iCGlxCache->FindItemForceCreateL(TGlxMediaId(KMediaId3));
EUNIT_PRINT(_L("Check returned media"));
EUNIT_ASSERT_DESC(media == cacheTestHelper.ItemPool()[2], "Incorrect media returned");
}
void UT_CCFEngine::UT_CCFEngine_NewLCL( )
{
CCFEngine* engine = CCFEngine::NewLC( *this );
EUNIT_ASSERT_DESC( engine, "CFEngine not created!" );
iTestDelay->Start( KSecond * 2 );
CleanupStack::PopAndDestroy(engine);
}
void UT_CCFEngine::UT_RemoveContextSubscriptionL()
{
RThread thread;
CleanupClosePushL(thread);
CCFContextSubscription* subscription = CCFContextSubscription::NewLC();
subscription->SetContextSourceL(_L("testsource"));
subscription->SetContextTypeL(_L("listenedtype"));
CleanupStack::Pop( subscription );
// make subscription
TInt error = iCFContextInterface->SubscribeContext(subscription,
this, thread);
EUNIT_ASSERT_DESC ( !error, "Subscription did not succeeded!");
// define context
static _LIT_SECURITY_POLICY_PASS( alwaysPass );
error = iCFContextInterface->DefineContext( _L("testsource"),
_L("listenedtype"), alwaysPass );
EUNIT_ASSERT_DESC ( !error, "Could not define context!" );
iCFContextInterface->UnsubscribeContext(*subscription,
*this);
EUNIT_ASSERT_DESC ( !error, "Could not remove context subscription!" );
iTestDelay->Start( KSecond / 2 );
CCFContextObject* co = CCFContextObject::NewLC();
co->SetSourceL(_L("testsource"));
co->SetTypeL(_L("listenedtype"));
co->SetValueL(_L("testvalue"));
error = iCFContextInterface->PublishContext( *co, thread );
EUNIT_ASSERT_DESC ( !error, "Context publish returned an error!" );
iTestDelay->Start( KSecond / 2 );
// check that we get the published context
EUNIT_ASSERT_DESC ( !iIndication, "Context indication did arrive");
iIndication = EFalse;
CleanupStack::PopAndDestroy( co );
CleanupStack::PopAndDestroy( &thread );
}
void T_PresenceGroupListManagement::UnsubscribeGroupL( const TDesC& aGroupId )
{
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
MXIMPContext* context = wrapper->GetContext();
CXIMPTestMessenger* messenger = wrapper->GetMessenger();
// Get the interfaces
MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
MPresentityGroups& presGroup = presFeat->PresentityGroups();
CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
CleanupStack::PushL( listener2 );
// ------------------------------------------------------
// expect normal request complete
TXIMPRequestId reqIdDummy; // not checked
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// and a group content event, IF we have subscribed the group beforehand
// i.e. SubscribeGroupL has been called before this
MXIMPIdentity* identity = context->ObjectFactory().NewIdentityLC();
identity->SetIdentityL( aGroupId );
CPresentityGroupContentEventImp* groupCntEvent =
XIMPTestEventFactory::CreateGroupContentEventLCX(
aGroupId,
KNullDesC,
KNullDesC,
XIMPTestEventFactory::ETestPGLCntRemoved,
KNullDesC,
KNullDesC,
MXIMPDataSubscriptionState::ESubscriptionInactive,
MXIMPDataSubscriptionState::EDataUnavailable
);
listener2->ExpectL( groupCntEvent );
CleanupStack::Pop( groupCntEvent );
// ------------------------------------------------------
// unsubscribe
TXIMPRequestId reqId = presGroup.UnsubscribePresentityGroupContentL( *identity );
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe group content failed" );
messenger->AssertUnsubscribePresentityGroupContentCalled( ETrue );
CleanupStack::PopAndDestroy( 5 ); // rest of the group content event
CleanupStack::PopAndDestroy(); // identity
CleanupStack::PopAndDestroy( listener2 );
}
void UT_CCFEngine::UT_DefineContextL()
{
RThread thread;
CleanupClosePushL( thread );
static _LIT_SECURITY_POLICY_PASS( alwaysPass );
// x. Define test context
//--------------------------------------------------------------------------
TInt err = iCFContextInterface->DefineContext(
_L("testsource"), _L("testtype"), alwaysPass );
EUNIT_ASSERT_DESC ( err == KErrNone, "Define context failed" );
// x. Re-define test context
//--------------------------------------------------------------------------
err = iCFContextInterface->DefineContext(
_L("testsource"), _L("testtype"), alwaysPass );
EUNIT_ASSERT_DESC ( err == KErrNone, "Define context failed" );
CleanupStack::PopAndDestroy( &thread );
}
void UT_CCFContextManager::UT_CCFContextManager_RequestContextL_3L( )
{
RThread thread;
CleanupClosePushL(thread);
SetupContextCacheL();
CCFContextObject* co;
EUNIT_ASSERT_NO_LEAVE(
co = iCFContextManagerInterface->RequestContextL(
_L("TypeA"),
_L("SourceA"),
thread )
);
EUNIT_ASSERT_DESC( co->Source() == _L("SourceA"), "Source doesn't match!");
EUNIT_ASSERT_DESC( co->Type() == _L("TypeA"), "Type doesn't match!");
EUNIT_ASSERT_DESC( co->Value() == _L("ValueBA"), "Value doesn't match!");
CleanupStack::PopAndDestroy( &thread );
}
// Single client, subscribed to the group, then subscribe list
void T_PresenceGroupListManagement::T_HandlePresentityGroupList_Subscribed_L()
{
EUNIT_PRINT( _L("Handle presentity group list, subscribed to the group.") );
// log in
BindL();
SubscribeGroupL( KPresentUri1 );
SubscribeL();
// ------------------------------------------------------
// some startup stuff
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
MXIMPContext* context = wrapper->GetContext();
CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
CleanupStack::PushL( listener2 );
// ------------------------------------------------------
// Tell the protocol it should act normally
wrapper->GetMessenger()->SetNoError();
// ------------------------------------------------------
// 1. Create faked server message about group list
SendSrvMsgL( KPresentUri1,
KPresentDispName1,
CXIMPTestFileSrvMsg::ETestSrvMsgPresentityGroupCreate );
// ------------------------------------------------------
// expect empty MPresentityGroupList event.
CPresentityGroupListEventImp* event = XIMPTestEventFactory::CreateGroupListEventLCX(
KPresentUri1, KPresentDispName1,
XIMPTestEventFactory::ETestPGLCreated,
KPresentUri1, KPresentDispName1,
MXIMPDataSubscriptionState::ESubscriptionActive,
MXIMPDataSubscriptionState::EDataAvailable
);
listener2->ExpectL( event );
CleanupStack::Pop( event ); // 4 more items in cleanupstack
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresentityGroupListL failed" );
CleanupStack::PopAndDestroy( 4 ); // lists
// ------------------------------------------------------
CleanupStack::PopAndDestroy( listener2 );
// clean it up
UnsubscribeL();
UnsubscribeGroupL( KPresentUri1 );
UnbindL();
}
void T_CGlxCache::T_CGlxCache_HandleItemModifiedL( )
{
// Create helper class
T_CacheTestHelpers cacheTestHelper(iCGlxCache);
RArray<TMPXAttribute> attributes;
CleanupClosePushL(attributes);
attributes.AppendL(KMPXMediaDrmProtected);
EUNIT_PRINT(_L("Modify item attributes"));
iCGlxCache->HandleItemModified(TGlxMediaId(KMediaId1), attributes);
CleanupStack::PopAndDestroy(&attributes);
EUNIT_PRINT(_L("Check attribute deleted as result of item modification"));
TInt Media1AttributeCount = cacheTestHelper.ItemPool()[0]->Count();
TInt Media2AttributeCount = cacheTestHelper.ItemPool()[1]->Count();
EUNIT_ASSERT_DESC(Media1AttributeCount == 0, "Attribute not deleted for item modified");
EUNIT_ASSERT_DESC(Media2AttributeCount == 1, "Attribute deleted for item not modified");
}
// Single client, unsubscribe nonsubscribed
void T_PresenceGroupListManagement::T_UnsubNonsubscribed_Single_L()
{
EUNIT_PRINT( _L("Single unsubscribe nonsubscribed") );
BindL();
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
MXIMPContext* context = wrapper->GetContext();
CXIMPTestMessenger* messenger = wrapper->GetMessenger();
// Get the interfaces
MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
MPresentityGroups& presGroup = presFeat->PresentityGroups();
CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
CleanupStack::PushL( listener2 );
// Tell the protocol it should act normally
messenger->SetNoError();
// ---------------------------------------------
// unsubscribe
TXIMPRequestId reqIdDummy; // not checked
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// group list event with Unsubscribed
CPresentityGroupListEventImp* event = XIMPTestEventFactory::CreateGroupListEventLCX(
KNullDesC, KNullDesC,
XIMPTestEventFactory::ETestPGLEmpty,
KNullDesC, KNullDesC,
MXIMPDataSubscriptionState::ESubscriptionInactive,
MXIMPDataSubscriptionState::EDataUnavailable
);
listener2->ExpectL( event );
CleanupStack::Pop( event ); // 4 more items in cleanupstack
TXIMPRequestId reqId = presGroup.UnsubscribePresentityGroupListL();
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe failed" );
CleanupStack::PopAndDestroy( 4 ); // rest of the group list event
messenger->AssertUnsubscribePresentityGroupListCalled( EFalse ); // should not be called, no subscriptions
CleanupStack::PopAndDestroy( listener2 );
UnbindL();
}
void UT_CCFContextManager::UT_CCFContextManager_RemoveSubscription2L()
{
RThread thread;
CleanupClosePushL(thread);
CCFContextSubscription* dummySubscription = CCFContextSubscription::NewLC();
dummySubscription->SetContextSourceL(_L("testsource"));
dummySubscription->SetContextTypeL(_L("listenedtype"));
CleanupStack::Pop( dummySubscription );
// make the dummy subscription
EUNIT_ASSERT_NO_LEAVE (
iCFContextManagerInterface->SubscribeContextL(dummySubscription,
this, thread) );
CCFContextSubscription* subscription = CCFContextSubscription::NewLC();
subscription->SetContextSourceL(_L("testsource"));
subscription->SetContextTypeL(_L("listenedtype"));
CleanupStack::Pop( subscription );
// make subscription
EUNIT_ASSERT_NO_LEAVE (
iCFContextManagerInterface->SubscribeContextL(subscription,
this, thread) );
// define context
static _LIT_SECURITY_POLICY_PASS( alwaysPass );
EUNIT_ASSERT_NO_LEAVE (
iCFContextManagerInterface->DefineContextL( _L("testsource"),
_L("listenedtype"), alwaysPass, alwaysPass ) );
EUNIT_ASSERT_NO_LEAVE (
iCFContextManagerInterface->RemoveSubscription(*subscription,
*this) );
CCFContextObject* co = CCFContextObject::NewLC();
co->SetSourceL(_L("testsource"));
co->SetTypeL(_L("listenedtype"));
co->SetValueL(_L("testvalue"));
EUNIT_ASSERT_NO_LEAVE (
iCFContextManagerInterface->PublishContextL( *co, thread ) );
// check that we get the published context
EUNIT_ASSERT_DESC ( !iIndication, "Context indication shoud not have arrived");
iIndication = EFalse;
CleanupStack::PopAndDestroy( co );
CleanupStack::PopAndDestroy( &thread );
}
void UT_CCFEngine::UT_PublishContextL( )
{
RThread thread;
CleanupClosePushL(thread);
CCFContextObject* co = CCFContextObject::NewLC();
co->SetSourceL(_L("testsource"));
co->SetTypeL(_L("testtype"));
co->SetValueL(_L("testvalue"));
TInt error = iCFContextInterface->PublishContext( *co, thread );
EUNIT_ASSERT_DESC ( error, "Context published succeed without defining!" );
static _LIT_SECURITY_POLICY_PASS( alwaysPass );
error = iCFContextInterface->DefineContext( _L("testsource"),
_L("testtype"), alwaysPass );
EUNIT_ASSERT_DESC ( !error, "Could not define context!" );
error = iCFContextInterface->PublishContext( *co, thread );
EUNIT_ASSERT_DESC ( !error, "Context published returned an error!" );
CleanupStack::PopAndDestroy( co );
CleanupStack::PopAndDestroy( &thread );
}
// update display name of group without having subscribed to it
void T_PresenceGroupListManagement::T_UpdateDisplayNameL(
const TDesC& aGroupId,
const TDesC& aDispName )
{
CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );
MXIMPContext* context = wrapper->GetContext();
CXIMPTestMessenger* messenger = wrapper->GetMessenger();
// Get the interfaces
MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();
MPresentityGroups& presGroup = presFeat->PresentityGroups();
wrapper->GetMessenger()->SetNoError();
CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );
CleanupStack::PushL( listener2 );
MXIMPIdentity* groupId = context->ObjectFactory().NewIdentityLC();
groupId->SetIdentityL( aGroupId );
// ------------------------------------------------------
// expect request complete with a group info imp inside
TXIMPRequestId reqIdDummy; // not checked
CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );
CPresentityGroupInfoImp* grpInfo = CPresentityGroupInfoImp::NewLC(
*groupId,
aDispName );
evReqComplete->AppendParamL( grpInfo );
CleanupStack::Pop(); // grpInfo
listener2->ExpectL( evReqComplete );
CleanupStack::Pop( evReqComplete );
// ------------------------------------------------------
// update
TXIMPRequestId reqId = presGroup.UpdatePresentityGroupDisplayNameL(
*groupId,
aDispName );
EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe group content failed" );
messenger->AssertUpdatePresentityGroupDisplayNameCalled( ETrue );
CleanupStack::PopAndDestroy(); // groupId
CleanupStack::PopAndDestroy( listener2 );
}
// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
EXPORT_C void CXIMPTestContextWrapper::UnbindL()
{
SetupListenerL( EXIMPTestStatusEvents_UnbindingOk );
iMessenger->SetNoError();
TXIMPRequestId reqId = iContext->UnbindL();
WaitRequestAndStackEvents( reqId );
VerifyEventStackL( _L8("Unbinding (wrapper UnbindL): ") );
EUNIT_ASSERT_DESC( iMessenger->GetBoolean( EXIMPPlgTestCloseSessionCalled ) ||
iMessenger->GetBoolean( EXIMPPlgTestUnshareSessionCalled ) , "CloseSession was not called" );
if( iMessenger->GetBoolean( EXIMPPlgTestCloseSessionCalled ) )
{
DeletePresenceContext();
//EUNIT_ASSERT_DESC( iMessenger->GetBoolean( EXIMPPlgTestDeath ), "Plugin did not die, destructor not called.");
}
}
