|
1 /* |
|
2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: XIMP Framework Test Code |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include "eunittools.h" |
|
20 |
|
21 #include <eunitmacros.h> |
|
22 #include <ecom/ecom.h> |
|
23 #include <badesca.h> |
|
24 |
|
25 #include <ximpbase.h> |
|
26 #include <ximpclient.h> |
|
27 #include <ximpcontext.h> |
|
28 #include <ximpcontextstateevent.h> |
|
29 #include <ximpcontextstate.h> |
|
30 #include <ximpobjectfactory.h> |
|
31 #include <presencepublishing.h> |
|
32 #include <presentitypresenceevent.h> |
|
33 #include <presenceobjectfactory.h> |
|
34 #include <presencefeatures.h> |
|
35 #include <presenceinfofield.h> |
|
36 #include <presenceinfofieldcollection.h> |
|
37 #include <servicepresenceinfo.h> |
|
38 #include <devicepresenceinfo.h> |
|
39 #include <personpresenceinfo.h> |
|
40 #include <presenceinfofieldvalueenum.h> |
|
41 #include <presenceinfofieldvaluetext.h> |
|
42 #include <presenceinfo.h> |
|
43 |
|
44 #include "t_presencepublishing.h" |
|
45 |
|
46 #include "prfwtestmessaging.h" |
|
47 #include "prfwtestmessenger.h" |
|
48 #include "prfwtestcontextwrappermgr.h" |
|
49 #include "prfwtestcontextwrapper.h" |
|
50 |
|
51 #include "prfwtestpresencedatautils.h" |
|
52 |
|
53 #include "ximprequestcompleteeventimp.h" |
|
54 #include "ximpcontextstateeventimp.h" |
|
55 #include "ximpcontextstateimp.h" |
|
56 #include "ximpstatusimp.h" |
|
57 #include "ownpresenceeventimp.h" |
|
58 |
|
59 // new test stuff |
|
60 #include "prfwtestlistener.h" |
|
61 #include "prfwtestfilesrvmsg.h" |
|
62 #include "prfwtestfiletool.h" |
|
63 |
|
64 |
|
65 #include "prfwtestrobustnesstools.h" |
|
66 |
|
67 _LIT8( KPrefix1, "PreA_" ); |
|
68 _LIT8( KPrefix2, "PreB_" ); |
|
69 _LIT8( KPrefix3, "PreC_" ); |
|
70 _LIT8( KPrefix4, "PreD_" ); |
|
71 |
|
72 _LIT8( KServiceType, "test_service" ); |
|
73 _LIT( KStatusMsg, "This is my status." ); |
|
74 |
|
75 const TInt KTestAvailability = 1; |
|
76 |
|
77 // ============================ MEMBER FUNCTIONS =============================== |
|
78 |
|
79 // CONSTRUCTION |
|
80 T_PresencePublishing* T_PresencePublishing::NewL() |
|
81 { |
|
82 T_PresencePublishing* self = new( ELeave ) T_PresencePublishing; |
|
83 CleanupStack::PushL( self ); |
|
84 self->ConstructL(); |
|
85 CleanupStack::Pop( self ); |
|
86 |
|
87 return self; |
|
88 } |
|
89 |
|
90 |
|
91 T_PresencePublishing::~T_PresencePublishing() |
|
92 { |
|
93 } |
|
94 |
|
95 |
|
96 void T_PresencePublishing::ConstructL() |
|
97 { |
|
98 CEUnitTestSuiteClass::ConstructL(); |
|
99 } |
|
100 |
|
101 |
|
102 T_PresencePublishing::T_PresencePublishing() |
|
103 { |
|
104 } |
|
105 |
|
106 |
|
107 |
|
108 // =========================================================================== |
|
109 // TEST CASE SETUP & TEARDOWN METHODS |
|
110 // =========================================================================== |
|
111 // |
|
112 |
|
113 void T_PresencePublishing::Setup_L() |
|
114 { |
|
115 PrfwTestRobustness::DoPreCleaning(); |
|
116 |
|
117 iWrapperMgr = CXIMPTestContextWrapperMgr::NewL(); |
|
118 iWrapperMgr->CreateWrapperL(); |
|
119 } |
|
120 |
|
121 void T_PresencePublishing::SetupMultiple_L() |
|
122 { |
|
123 PrfwTestRobustness::DoPreCleaning(); |
|
124 |
|
125 iWrapperMgr = CXIMPTestContextWrapperMgr::NewL(); |
|
126 iWrapperMgr->CreateWrapperL(); |
|
127 iWrapperMgr->CreateWrapperL(); |
|
128 iWrapperMgr->CreateWrapperL(); |
|
129 } |
|
130 |
|
131 |
|
132 void T_PresencePublishing::BindL() |
|
133 { |
|
134 CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 ); |
|
135 |
|
136 wrapper0->BindL( 0 ); |
|
137 } |
|
138 |
|
139 void T_PresencePublishing::Bind2L() |
|
140 { |
|
141 CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 ); |
|
142 wrapper0->BindWithSettingsL( 0 ); |
|
143 } |
|
144 |
|
145 void T_PresencePublishing::BindAllL() |
|
146 { |
|
147 for( TInt a = 0; a < iWrapperMgr->WrapperCount(); ++a ) |
|
148 { |
|
149 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a ); |
|
150 wrapper->BindL( 0 ); |
|
151 } |
|
152 } |
|
153 |
|
154 |
|
155 void T_PresencePublishing::Teardown() |
|
156 { |
|
157 delete iWrapperMgr; |
|
158 iWrapperMgr = NULL; |
|
159 |
|
160 REComSession::FinalClose(); |
|
161 |
|
162 PrfwTestRobustness::DoPreCleaning(); |
|
163 } |
|
164 |
|
165 void T_PresencePublishing::UnbindL() |
|
166 { |
|
167 // Do unbind |
|
168 CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 ); |
|
169 wrapper0->UnbindL(); |
|
170 } |
|
171 |
|
172 void T_PresencePublishing::UnbindAllL() |
|
173 { |
|
174 for( TInt a = 0; a < iWrapperMgr->WrapperCount(); ++a ) |
|
175 { |
|
176 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a ); |
|
177 wrapper->UnbindL(); |
|
178 } |
|
179 } |
|
180 |
|
181 |
|
182 // =========================================================================== |
|
183 // TEST CASES for presence publish |
|
184 // =========================================================================== |
|
185 void T_PresencePublishing::T_Publish_Single_L() |
|
186 { |
|
187 EUNIT_PRINT( _L("Single Presence Publish test") ); |
|
188 |
|
189 BindL(); |
|
190 |
|
191 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 ); |
|
192 MXIMPContext* context = wrapper->GetContext(); |
|
193 CXIMPTestMessenger* messenger = wrapper->GetMessenger(); |
|
194 |
|
195 CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context ); |
|
196 CleanupStack::PushL( listener2 ); |
|
197 |
|
198 // Get the interfaces |
|
199 MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures(); |
|
200 MPresencePublishing& presPub = presFeat->PresencePublishing(); |
|
201 |
|
202 // Generate a doc |
|
203 CPresenceInfoImp* presInfo = |
|
204 XIMPTestPresenceDataUtils::GenerateInfoLC( &KPrefix1 ); |
|
205 |
|
206 // Tell the protocol it should act normally |
|
207 messenger->SetNoError(); |
|
208 |
|
209 // Publish the presence |
|
210 TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *presInfo ); |
|
211 |
|
212 // Setup status event listener |
|
213 CXIMPRequestCompleteEventImp* evReqComplete = |
|
214 CXIMPRequestCompleteEventImp::NewLC( reqId ); |
|
215 listener2->ExpectL( evReqComplete ); |
|
216 CleanupStack::Pop( evReqComplete ); |
|
217 |
|
218 // Wait for events on the request |
|
219 EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Publishing presence failed" ); |
|
220 |
|
221 |
|
222 COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called", ETrue, NULL ); |
|
223 |
|
224 CleanupStack::PopAndDestroy( presInfo ); |
|
225 CleanupStack::PopAndDestroy( listener2 ); |
|
226 UnbindL(); |
|
227 } |
|
228 |
|
229 void T_PresencePublishing::T_NetworkUnplugError_L() |
|
230 { |
|
231 EUNIT_PRINT( _L("Error from plug-in in publish own presence") ); |
|
232 |
|
233 // Creating the error which comes from KErrTimedOut and protocol sends Connection terminated. |
|
234 |
|
235 // BIND AND SETUP |
|
236 |
|
237 Bind2L(); |
|
238 |
|
239 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 ); |
|
240 MXIMPContext* context = wrapper->GetContext(); |
|
241 CXIMPTestMessenger* messenger = wrapper->GetMessenger(); |
|
242 |
|
243 |
|
244 CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context ); |
|
245 CleanupStack::PushL( listener2 ); |
|
246 |
|
247 // Get the interfaces |
|
248 MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures(); |
|
249 MPresencePublishing& presPub = presFeat->PresencePublishing(); |
|
250 |
|
251 |
|
252 // PUBLISH OWN |
|
253 |
|
254 //messenger->SetLeave( KErrAbort ); |
|
255 messenger->SetError(KErrTimedOut); |
|
256 |
|
257 // publish own presence in here |
|
258 MPresenceInfo* info = CreateInfoLC(); |
|
259 |
|
260 TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *info ); |
|
261 |
|
262 |
|
263 // Setup status event listener for RequestComplete |
|
264 listener2->Reset(); |
|
265 // request complete with KErrAbort |
|
266 CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); |
|
267 evReqComplete->CompletionResultImp().SetResultCode( KErrTimedOut ); |
|
268 listener2->ExpectL( evReqComplete ); |
|
269 CleanupStack::Pop( evReqComplete ); |
|
270 |
|
271 CXIMPContextStateEventImp* evContextEvent = CXIMPContextStateEventImp::NewLC(); |
|
272 evContextEvent->ContextStateImp().SetStateValue( MXIMPContextState::EUnbinding); |
|
273 listener2->ExpectL( evContextEvent ); |
|
274 CleanupStack::Pop( evContextEvent ); |
|
275 |
|
276 CXIMPContextStateEventImp* evContextEvent2 = CXIMPContextStateEventImp::NewLC(); |
|
277 evContextEvent2->ContextStateImp().SetStateValue( MXIMPContextState::EInactive); |
|
278 listener2->ExpectL( evContextEvent2 ); |
|
279 CleanupStack::Pop( evContextEvent2 ); |
|
280 |
|
281 listener2->WaitAndAssertL(); |
|
282 |
|
283 // UNBIND |
|
284 |
|
285 CleanupStack::PopAndDestroy(1);//info |
|
286 CleanupStack::PopAndDestroy( listener2 ); |
|
287 |
|
288 messenger->SetError( KErrNone ); |
|
289 |
|
290 UnbindL(); |
|
291 } |
|
292 |
|
293 |
|
294 void T_PresencePublishing::T_NetworkUnplugErrorMultiple_L() |
|
295 { |
|
296 EUNIT_PRINT( _L("Network disconnect from plug-in in publish own presence, multiple contexts") ); |
|
297 |
|
298 // Bind 2 contexts |
|
299 BindAllL(); |
|
300 |
|
301 /* |
|
302 * Make the 1st client publish someting and then the disconnect would happen |
|
303 */ |
|
304 CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 ); |
|
305 MXIMPContext* context0 = wrapper0->GetContext(); |
|
306 CXIMPTestMessenger* messenger0 = wrapper0->GetMessenger(); |
|
307 |
|
308 |
|
309 CXIMPTestListener* listener0 = CXIMPTestListener::NewL( context0); |
|
310 CleanupStack::PushL( listener0); |
|
311 |
|
312 MPresenceFeatures* presFeat0 = wrapper0->GetPresenceFeatures(); |
|
313 MPresencePublishing& presPub0 = presFeat0->PresencePublishing(); |
|
314 |
|
315 //messenger->SetLeave( KErrAbort ); |
|
316 messenger0->SetError(KErrTimedOut); |
|
317 |
|
318 |
|
319 // publish own presence in here |
|
320 MPresenceInfo* info = CreateInfoLC(); |
|
321 TXIMPRequestId reqId = presPub0.PublishOwnPresenceL( *info ); |
|
322 |
|
323 /* Setup status event listener for RequestComplete for client 1 */ |
|
324 listener0->Reset(); |
|
325 // request complete with KErrTimedOut |
|
326 CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); |
|
327 evReqComplete->CompletionResultImp().SetResultCode( KErrTimedOut ); |
|
328 listener0->ExpectL( evReqComplete ); |
|
329 CleanupStack::Pop( evReqComplete ); |
|
330 |
|
331 // Create the context state events for unbinding |
|
332 CXIMPContextStateEventImp* evContextEvent = CXIMPContextStateEventImp::NewLC(); |
|
333 evContextEvent->ContextStateImp().SetStateValue( MXIMPContextState::EUnbinding); |
|
334 listener0->ExpectL( evContextEvent ); |
|
335 CleanupStack::Pop( evContextEvent ); |
|
336 |
|
337 CXIMPContextStateEventImp* evContextEvent2 = CXIMPContextStateEventImp::NewLC(); |
|
338 evContextEvent2->ContextStateImp().SetStateValue( MXIMPContextState::EInactive); |
|
339 listener0->ExpectL( evContextEvent2 ); |
|
340 CleanupStack::Pop( evContextEvent2 ); |
|
341 |
|
342 |
|
343 |
|
344 /* |
|
345 * Create a request for client 2, this will not be processed by the protocol plug-in |
|
346 */ |
|
347 CXIMPTestContextWrapper* wrapper1 = iWrapperMgr->GetWrapperL( 1 ); |
|
348 MXIMPContext* context1 = wrapper1->GetContext(); |
|
349 |
|
350 MPresenceFeatures* presFeat1 = wrapper1->GetPresenceFeatures(); |
|
351 MPresencePublishing& presPub1 = presFeat1->PresencePublishing(); |
|
352 |
|
353 |
|
354 // Create the empty presence info filter |
|
355 CPresenceInfoFilterImp* pif = CPresenceInfoFilterImp::NewLC(); |
|
356 TXIMPRequestId reqId1 = presPub1.SubscribeOwnPresenceL( *pif ); |
|
357 CleanupStack::PopAndDestroy(pif); |
|
358 |
|
359 // Setup status event listener for RequestComplete |
|
360 CXIMPTestListener* listener1 = CXIMPTestListener::NewL( context1); |
|
361 CleanupStack::PushL( listener1); |
|
362 listener1->Reset(); |
|
363 // normal request complete |
|
364 CXIMPRequestCompleteEventImp* evReqComplete1 = CXIMPRequestCompleteEventImp::NewLC( reqId1 ); |
|
365 evReqComplete1->CompletionResultImp().SetResultCode( KErrTimedOut ); |
|
366 listener1->ExpectL( evReqComplete1 ); |
|
367 CleanupStack::Pop( evReqComplete1 ); |
|
368 |
|
369 // Create the context state events for unbinding |
|
370 evContextEvent = CXIMPContextStateEventImp::NewLC(); |
|
371 evContextEvent->ContextStateImp().SetStateValue( MXIMPContextState::EUnbinding); |
|
372 listener1->ExpectL( evContextEvent ); |
|
373 CleanupStack::Pop( evContextEvent ); |
|
374 |
|
375 evContextEvent2 = CXIMPContextStateEventImp::NewLC(); |
|
376 evContextEvent2->ContextStateImp().SetStateValue( MXIMPContextState::EInactive); |
|
377 listener1->ExpectL( evContextEvent2 ); |
|
378 CleanupStack::Pop( evContextEvent2 ); |
|
379 |
|
380 |
|
381 // Wait for events on the request |
|
382 |
|
383 EUNIT_ASSERT_DESC( KErrNone == listener0->WaitAndAssertL(), "Publish own presence failed in client 1"); |
|
384 |
|
385 EUNIT_ASSERT_DESC( KErrNone == listener1->WaitAndAssertL(), "SubscribeOwnPresence failed in client 2" ); |
|
386 |
|
387 CleanupStack::PopAndDestroy( listener1 ); |
|
388 CleanupStack::PopAndDestroy(1);//info |
|
389 CleanupStack::PopAndDestroy( listener0 ); |
|
390 |
|
391 // Finish the test case |
|
392 UnbindAllL(); |
|
393 } |
|
394 |
|
395 void T_PresencePublishing::T_Publish_ErrFromPlg_Leave_L() |
|
396 { |
|
397 EUNIT_PRINT( _L("Single Presence Publish test") ); |
|
398 EUNIT_PRINT( _L("Plugin leaves from PublishOwnPresenceL") ); |
|
399 |
|
400 BindL(); |
|
401 |
|
402 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 ); |
|
403 MXIMPContext* context = wrapper->GetContext(); |
|
404 CXIMPTestMessenger* messenger = wrapper->GetMessenger(); |
|
405 |
|
406 CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context ); |
|
407 CleanupStack::PushL( listener2 ); |
|
408 |
|
409 // Get the interfaces |
|
410 MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures(); |
|
411 MPresencePublishing& presPub = presFeat->PresencePublishing(); |
|
412 |
|
413 // Generate a doc |
|
414 CPresenceInfoImp* presDoc = |
|
415 XIMPTestPresenceDataUtils::GenerateInfoLC( &KPrefix1 ); |
|
416 |
|
417 // Setup status event listener |
|
418 SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk ); |
|
419 |
|
420 // Tell the test protocol to leave on next operation |
|
421 messenger->SetLeave( KErrAbort ); |
|
422 |
|
423 // Publish the presence |
|
424 TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *presDoc ); |
|
425 // Wait for events on the request |
|
426 wrapper->WaitRequestAndStackEvents( reqId ); |
|
427 wrapper->VerifyEventStackL( _L8("Publishing single presence, leave with error: ") ); |
|
428 |
|
429 // Verify that plugin left and didn't go through the PublishOwnPresenceL. |
|
430 COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called", |
|
431 EFalse, "PublishPresenceL was called." ); |
|
432 |
|
433 |
|
434 // TODO wait and verify the events |
|
435 EUNIT_FAIL_TEST( "Under construction." ); |
|
436 |
|
437 CleanupStack::PopAndDestroy( presDoc ); |
|
438 CleanupStack::PopAndDestroy( listener2 ); |
|
439 UnbindL(); |
|
440 } |
|
441 |
|
442 void T_PresencePublishing::T_Publish_ErrFromPlg_CompleteWithError_L() |
|
443 { |
|
444 EUNIT_PRINT( _L("Single Presence Publish test") ); |
|
445 EUNIT_PRINT( _L("Plugin completes PublishOwnPresenceL with error") ); |
|
446 |
|
447 BindL(); |
|
448 |
|
449 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 ); |
|
450 MXIMPContext* context = wrapper->GetContext(); |
|
451 CXIMPTestMessenger* messenger = wrapper->GetMessenger(); |
|
452 |
|
453 CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context ); |
|
454 CleanupStack::PushL( listener2 ); |
|
455 |
|
456 // Get the interfaces |
|
457 MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures(); |
|
458 MPresencePublishing& presPub = presFeat->PresencePublishing(); |
|
459 |
|
460 // Generate a doc |
|
461 CPresenceInfoImp* presDoc = |
|
462 XIMPTestPresenceDataUtils::GenerateInfoLC( &KPrefix1 ); |
|
463 |
|
464 // Setup status event listener: |
|
465 //TODO Setup presence event listener |
|
466 SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk ); |
|
467 |
|
468 // Tell the test protocol to return with error on next operation |
|
469 messenger->SetError( KErrAbort ); |
|
470 |
|
471 // Publish the presence |
|
472 TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *presDoc ); |
|
473 // Wait for events on the request |
|
474 wrapper->WaitRequestAndStackEvents( reqId ); |
|
475 wrapper->VerifyEventStackL( _L8("Publishing single presence, complete with error: ") ); |
|
476 |
|
477 // Verify that we did go through PublishOwnPresenceL. |
|
478 COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called", ETrue, NULL ); |
|
479 |
|
480 // TODO wait and verify presence events |
|
481 EUNIT_FAIL_TEST( "Under construction." ); |
|
482 |
|
483 CleanupStack::PopAndDestroy( presDoc ); |
|
484 CleanupStack::PopAndDestroy( listener2 ); |
|
485 |
|
486 UnbindL(); |
|
487 } |
|
488 |
|
489 |
|
490 // =========================================================================== |
|
491 // TEST CASES for presence interest registration |
|
492 // =========================================================================== |
|
493 |
|
494 // Single client, empty filter |
|
495 void T_PresencePublishing::T_SubscribeOwnPresence_Single_Empty_L() |
|
496 { |
|
497 EUNIT_PRINT( _L("Single interest registration") ); |
|
498 |
|
499 BindL(); |
|
500 |
|
501 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 ); |
|
502 MXIMPContext* context = wrapper->GetContext(); |
|
503 CXIMPTestMessenger* messenger = wrapper->GetMessenger(); |
|
504 |
|
505 |
|
506 CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context ); |
|
507 CleanupStack::PushL( listener2 ); |
|
508 |
|
509 // Tell the protocol it should act normally |
|
510 messenger->SetNoError(); |
|
511 |
|
512 // Get the interfaces |
|
513 MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures(); |
|
514 MPresencePublishing& presPub = presFeat->PresencePublishing(); |
|
515 |
|
516 // Create the empty presence info filter |
|
517 CPresenceInfoFilterImp* pif = CPresenceInfoFilterImp::NewLC(); |
|
518 |
|
519 // Setup status event listener for RequestComplete |
|
520 listener2->Reset(); |
|
521 // normal request complete |
|
522 TXIMPRequestId reqIdDummy; // not checked |
|
523 CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy ); |
|
524 listener2->ExpectL( evReqComplete ); |
|
525 CleanupStack::Pop( evReqComplete ); |
|
526 |
|
527 // subscribe own presence |
|
528 TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif ); |
|
529 |
|
530 // Wait for events on the request |
|
531 EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "SubscribeOwnPresence failed" ); |
|
532 |
|
533 // verify that SubscribeOwnPresenceL was called |
|
534 COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", ETrue, NULL ); |
|
535 |
|
536 // Setup status event listener for RequestComplete |
|
537 listener2->Reset(); |
|
538 evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy ); |
|
539 listener2->ExpectL( evReqComplete ); |
|
540 CleanupStack::Pop( evReqComplete ); |
|
541 |
|
542 // unsubscribe own presence |
|
543 reqId = presPub.UnsubscribeOwnPresenceL(); |
|
544 |
|
545 // Wait for events on the request |
|
546 EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "UnsubscribeOwnPresence failed" ); |
|
547 |
|
548 // verify that UnsubscribeOwnPresenceL was called |
|
549 COMMONASSERT( messenger, EXIMPPlgTestUnsubscribeOwnPresenceCalled, "UnsubscribeOwnPresenceL was not called", ETrue, NULL ); |
|
550 |
|
551 CleanupStack::PopAndDestroy( pif ); |
|
552 CleanupStack::PopAndDestroy( listener2 ); |
|
553 UnbindL(); |
|
554 } |
|
555 |
|
556 // Single client, empty filter |
|
557 void T_PresencePublishing::T_SubscribeOwnPresence_Multiple_Empty_L() |
|
558 { |
|
559 EUNIT_PRINT( _L("Multiple client filter registration") ); |
|
560 |
|
561 BindAllL(); |
|
562 |
|
563 // Create the empty presence info filter |
|
564 CPresenceInfoFilterImp* pif = CPresenceInfoFilterImp::NewLC(); |
|
565 |
|
566 TInt countOfWrappers = iWrapperMgr->WrapperCount(); |
|
567 |
|
568 CXIMPTestListener* listeners[ 50 ]; |
|
569 TXIMPRequestId reqIdDummy; // not checked |
|
570 |
|
571 |
|
572 |
|
573 // Setup listeners |
|
574 for( TInt a = 0; a < countOfWrappers; a++ ) |
|
575 { |
|
576 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a ); |
|
577 MXIMPContext* context = wrapper->GetContext(); |
|
578 listeners[ a ] = CXIMPTestListener::NewL( context ); |
|
579 CleanupStack::PushL( listeners[ a ] ); |
|
580 } |
|
581 |
|
582 |
|
583 // SUBSCRIBE |
|
584 for( TInt a = countOfWrappers - 1; a > 0 ; --a ) |
|
585 { |
|
586 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a ); |
|
587 MXIMPContext* context = wrapper->GetContext(); |
|
588 CXIMPTestMessenger* messenger = wrapper->GetMessenger(); |
|
589 |
|
590 // Tell the protocol it should act normally |
|
591 messenger->SetNoError(); |
|
592 |
|
593 // Get the interfaces |
|
594 MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures(); |
|
595 MPresencePublishing& presPub = presFeat->PresencePublishing(); |
|
596 |
|
597 // Setup status event listener for RequestComplete |
|
598 listeners[ a ]->Reset(); |
|
599 CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy ); |
|
600 listeners[ a ]->ExpectL( evReqComplete ); |
|
601 CleanupStack::Pop( evReqComplete ); |
|
602 |
|
603 messenger->SetValueFor( EXIMPPlgTestSubscribeOwnPresenceCalled, 0 ); |
|
604 // subscribe own presence |
|
605 TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif ); |
|
606 |
|
607 // Wait for events on the request |
|
608 EUNIT_ASSERT_DESC( KErrNone == listeners[ a ]->WaitAndAssertL(), "SubscribeOwnPresence failed" ); |
|
609 |
|
610 // verify that SubscribeOwnPresenceL was called |
|
611 COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", |
|
612 ( a > 1 ) ? ETrue : EFalse , "SubscribeOwnPresenceL was called." ); |
|
613 } |
|
614 |
|
615 // REFRESH |
|
616 |
|
617 for( TInt a = countOfWrappers - 1; a > 0 ; --a ) |
|
618 { |
|
619 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a ); |
|
620 MXIMPContext* context = wrapper->GetContext(); |
|
621 CXIMPTestMessenger* messenger = wrapper->GetMessenger(); |
|
622 |
|
623 // Tell the protocol it should act normally |
|
624 messenger->SetNoError(); |
|
625 |
|
626 // Get the interfaces |
|
627 MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures(); |
|
628 MPresencePublishing& presPub = presFeat->PresencePublishing(); |
|
629 |
|
630 // Setup status event listener for RequestComplete |
|
631 listeners[ a ]->Reset(); |
|
632 CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy ); |
|
633 listeners[ a ]->ExpectL( evReqComplete ); |
|
634 CleanupStack::Pop( evReqComplete ); |
|
635 |
|
636 CXIMPDataSubscriptionStateImp* stateImp = CXIMPDataSubscriptionStateImp::NewLC(); |
|
637 stateImp->SetDataStateL( MXIMPDataSubscriptionState::EDataUnavailable ); |
|
638 stateImp->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive ); |
|
639 COwnPresenceEventImp* evOwnPresence = COwnPresenceEventImp::NewLC( stateImp ); |
|
640 CleanupStack::Pop( 2, stateImp ); |
|
641 CleanupStack::PushL( evOwnPresence ); |
|
642 listeners[ a ]->ExpectL( evOwnPresence ); |
|
643 CleanupStack::Pop( evOwnPresence ); |
|
644 |
|
645 // TODO check if this call is still needed |
|
646 messenger->SetValueFor( EXIMPPlgTestSubscribeOwnPresenceCalled, 0 ); |
|
647 |
|
648 // subscribe own presence |
|
649 TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif ); |
|
650 |
|
651 // Wait for events on the request |
|
652 EUNIT_ASSERT_DESC( KErrNone == listeners[ a ]->WaitAndAssertL(), "SubscribeOwnPresence failed" ); |
|
653 |
|
654 // verify that SubscribeOwnPresenceL was called |
|
655 COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, |
|
656 "SubscribeOwnPresenceL was not called", |
|
657 EFalse , "SubscribeOwnPresenceL was called." ); |
|
658 } |
|
659 |
|
660 |
|
661 // UNSUBSCRIBE |
|
662 |
|
663 for( TInt a = 0; a < countOfWrappers; ++a ) |
|
664 { |
|
665 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a ); |
|
666 MXIMPContext* context = wrapper->GetContext(); |
|
667 CXIMPTestMessenger* messenger = wrapper->GetMessenger(); |
|
668 |
|
669 // Get the interfaces |
|
670 MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures(); |
|
671 MPresencePublishing& presPub = presFeat->PresencePublishing(); |
|
672 |
|
673 // Setup status event listener for RequestComplete |
|
674 listeners[ a ]->Reset(); |
|
675 CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy ); |
|
676 listeners[ a ]->ExpectL( evReqComplete ); |
|
677 CleanupStack::Pop( evReqComplete ); |
|
678 |
|
679 |
|
680 // register interest |
|
681 TXIMPRequestId reqId = presPub.UnsubscribeOwnPresenceL(); |
|
682 |
|
683 // Wait for events on the request |
|
684 EUNIT_ASSERT_DESC( KErrNone == listeners[ a ]->WaitAndAssertL(), "UnsubscribeOwnPresence failed" ); |
|
685 |
|
686 |
|
687 // verify that UpdateInterest was called |
|
688 COMMONASSERT( messenger, EXIMPPlgTestUnsubscribeOwnPresenceCalled, |
|
689 "UnsubscribeOwnPresenceL was not called", |
|
690 ( a < 2 ) ? EFalse : ETrue, |
|
691 "UnsubscribeOwnPresenceL was called" ); |
|
692 } |
|
693 |
|
694 |
|
695 // delete the listeners |
|
696 CleanupStack::PopAndDestroy( countOfWrappers ); // the contents of listeners[] |
|
697 |
|
698 CleanupStack::PopAndDestroy( pif ); |
|
699 |
|
700 UnbindAllL(); |
|
701 } |
|
702 |
|
703 |
|
704 // Single client, filled filter |
|
705 void T_PresencePublishing::T_SubscribeOwnPresence_Single_L() |
|
706 { |
|
707 EUNIT_PRINT( _L("Single interest registration") ); |
|
708 |
|
709 BindL(); |
|
710 |
|
711 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 ); |
|
712 MXIMPContext* context = wrapper->GetContext(); |
|
713 CXIMPTestMessenger* messenger = wrapper->GetMessenger(); |
|
714 |
|
715 CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context ); |
|
716 CleanupStack::PushL( listener2 ); |
|
717 |
|
718 // Get the interfaces |
|
719 MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures(); |
|
720 MPresencePublishing& presPub = presFeat->PresencePublishing(); |
|
721 |
|
722 // Create the filled interest document |
|
723 CPresenceInfoFilterImp* pif = |
|
724 XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 ); |
|
725 |
|
726 // Tell the protocol it should act normally |
|
727 messenger->SetNoError(); |
|
728 |
|
729 |
|
730 // SUBSCRIBE |
|
731 |
|
732 // subscribe own presence |
|
733 TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif ); |
|
734 |
|
735 // Setup status event listener for RequestComplete |
|
736 listener2->Reset(); |
|
737 SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk ); |
|
738 CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); |
|
739 listener2->ExpectL( evReqComplete ); |
|
740 CleanupStack::Pop( evReqComplete ); |
|
741 |
|
742 // Wait for events on the request |
|
743 EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "SubscribeOwnPresence failed" ); |
|
744 |
|
745 // verify that SubscribeOwnPresenceL was called |
|
746 COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", ETrue, NULL ); |
|
747 |
|
748 // REFRESH |
|
749 |
|
750 // subscribe own presence (refresh) |
|
751 reqId = presPub.SubscribeOwnPresenceL( *pif ); |
|
752 |
|
753 // Setup status event listener for RequestComplete |
|
754 SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk ); |
|
755 messenger->SetValueFor( EXIMPPlgTestSubscribeOwnPresenceCalled, 0 ); |
|
756 listener2->Reset(); |
|
757 evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); |
|
758 listener2->ExpectL( evReqComplete ); |
|
759 CleanupStack::Pop( evReqComplete ); |
|
760 // also the event |
|
761 |
|
762 CXIMPDataSubscriptionStateImp* stateImp = CXIMPDataSubscriptionStateImp::NewLC(); |
|
763 stateImp->SetDataStateL( MXIMPDataSubscriptionState::EDataUnavailable ); |
|
764 stateImp->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive ); |
|
765 COwnPresenceEventImp* event = COwnPresenceEventImp::NewLC( stateImp ); |
|
766 CleanupStack::Pop( 2, stateImp ); |
|
767 CleanupStack::PushL( event ); |
|
768 listener2->ExpectL( event ); |
|
769 CleanupStack::Pop( event ); |
|
770 |
|
771 // Wait for events on the request |
|
772 EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Refreshing own presence subscription failed" ); |
|
773 |
|
774 // verify that SubscribeOwnPresenceL was called |
|
775 COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", EFalse, "SubscribeOwnPresenceL was called" ); |
|
776 |
|
777 CleanupStack::PopAndDestroy( pif ); |
|
778 CleanupStack::PopAndDestroy( listener2 ); |
|
779 UnbindL(); |
|
780 } |
|
781 |
|
782 void T_PresencePublishing::T_ErrFromPlg_LeaveOnSubscribeOwnPresence_L() |
|
783 { |
|
784 EUNIT_PRINT( _L("Error from plug-in in presentity presence subscribe") ); |
|
785 EUNIT_PRINT( _L("Plug-in leaves from SubscribePresence().") ); |
|
786 |
|
787 // BIND AND SETUP |
|
788 |
|
789 BindL(); |
|
790 |
|
791 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 ); |
|
792 MXIMPContext* context = wrapper->GetContext(); |
|
793 CXIMPTestMessenger* messenger = wrapper->GetMessenger(); |
|
794 |
|
795 |
|
796 CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context ); |
|
797 CleanupStack::PushL( listener2 ); |
|
798 |
|
799 // Get the interfaces |
|
800 MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures(); |
|
801 MPresencePublishing& presPub = presFeat->PresencePublishing(); |
|
802 |
|
803 // Create the filled interest document |
|
804 CPresenceInfoFilterImp* pif = |
|
805 XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 ); |
|
806 |
|
807 // SUBSCRIBE |
|
808 |
|
809 messenger->SetLeave( KErrAbort ); |
|
810 |
|
811 // subscribe own presence |
|
812 TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif ); |
|
813 |
|
814 // Setup status event listener for RequestComplete |
|
815 listener2->Reset(); |
|
816 // request complete with KErrAbort |
|
817 CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); |
|
818 evReqComplete->CompletionResultImp().SetResultCode( KErrAbort ); |
|
819 listener2->ExpectL( evReqComplete ); |
|
820 CleanupStack::Pop( evReqComplete ); |
|
821 |
|
822 // Wait for events on the request |
|
823 EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribing presentity presence, didn't complete with error" ); |
|
824 |
|
825 // verify that SubscribeOwnPresenceL was called |
|
826 COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", EFalse, "SubscribeOwnPresenceL was called" ); |
|
827 |
|
828 |
|
829 // SUBSCRIBE |
|
830 |
|
831 messenger->SetLeave( KErrNone ); |
|
832 |
|
833 // subscribe own presence |
|
834 reqId = presPub.SubscribeOwnPresenceL( *pif ); |
|
835 |
|
836 // Setup status event listener for RequestComplete |
|
837 listener2->Reset(); |
|
838 evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); |
|
839 listener2->ExpectL( evReqComplete ); |
|
840 CleanupStack::Pop( evReqComplete ); |
|
841 |
|
842 // Wait for events on the request |
|
843 EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribing presentity presence failed" ); |
|
844 |
|
845 // verify that SubscribeOwnPresenceL was called |
|
846 COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", ETrue, "SubscribeOwnPresenceL was called" ); |
|
847 |
|
848 |
|
849 // UNSUBSCRIBE |
|
850 |
|
851 messenger->SetLeave( KErrAbort ); |
|
852 |
|
853 // register interest |
|
854 reqId = presPub.UnsubscribeOwnPresenceL(); |
|
855 |
|
856 // Setup status event listener for RequestComplete |
|
857 listener2->Reset(); |
|
858 evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); |
|
859 evReqComplete->CompletionResultImp().SetResultCode( KErrAbort ); |
|
860 listener2->ExpectL( evReqComplete ); |
|
861 CleanupStack::Pop( evReqComplete ); |
|
862 |
|
863 // Wait for events on the request |
|
864 EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribing presentity presence with error failed" ); |
|
865 |
|
866 // verify that UnsubscribeOwnPresenceL was called |
|
867 COMMONASSERT( messenger, EXIMPPlgTestUnsubscribeOwnPresenceCalled, "UnsubscribeOwnPresenceL was not called", EFalse, |
|
868 "UnsubscribeOwnPresenceL was called." ); |
|
869 |
|
870 // UNBIND |
|
871 |
|
872 CleanupStack::PopAndDestroy( pif ); |
|
873 CleanupStack::PopAndDestroy( listener2 ); |
|
874 |
|
875 messenger->SetLeave( KErrNone ); |
|
876 |
|
877 UnbindL(); |
|
878 } |
|
879 |
|
880 // =========================================================================== |
|
881 // Single client, filled filter, publish. |
|
882 // =========================================================================== |
|
883 // |
|
884 |
|
885 void T_PresencePublishing::T_SubscribeOwnPresence_Publish_Single_L() |
|
886 { |
|
887 EUNIT_PRINT( _L("Single interest registration with publish") ); |
|
888 |
|
889 /* |
|
890 * TODO: |
|
891 * |
|
892 * case 1 |
|
893 * |
|
894 * - subscribetä oma presence |
|
895 * - luo filtteri |
|
896 * - luo info |
|
897 * - publishaa oma presence + info |
|
898 * - tsekkaa että alakerta on saanut infon |
|
899 * - subscribetä uudelleen (=refresh case) |
|
900 * - tsekkaa että kaikki ok |
|
901 * |
|
902 * case 2 |
|
903 * |
|
904 * - sama filtteri kuin edellä |
|
905 * - feikkaa verkkoserveriltä tuleva viesti, jossa sama info kuin edellä |
|
906 * - tsekkaa, että frameworkin läpi tuleva info sisältää vain ne kamat |
|
907 * jotka on sallittu ja että muut on blokattu. ts. "test_service":n |
|
908 * "availability" pitäisi tulla läpi. person-presenceen tungettu kama jää |
|
909 * pois |
|
910 * |
|
911 */ |
|
912 |
|
913 BindL(); |
|
914 |
|
915 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 ); |
|
916 MXIMPContext* context = wrapper->GetContext(); |
|
917 CXIMPTestMessenger* messenger = wrapper->GetMessenger(); |
|
918 |
|
919 CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context ); |
|
920 CleanupStack::PushL( listener2 ); |
|
921 |
|
922 // Get the interfaces |
|
923 MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures(); |
|
924 MPresencePublishing& presPub = presFeat->PresencePublishing(); |
|
925 |
|
926 // Create the filter |
|
927 MPresenceInfoFilter* pif = presFeat->PresenceObjectFactory().NewPresenceInfoFilterLC(); |
|
928 pif->AcceptServiceFilterL( KServiceType, NPresenceInfo::NFieldType::KAvailability ); // "test_service", "availability" |
|
929 // note, the person info will be filtered out now since we don't accept it. |
|
930 |
|
931 // Tell the protocol it should act normally |
|
932 messenger->SetNoError(); |
|
933 |
|
934 // SUBSCRIBE |
|
935 |
|
936 // subscribe own presence |
|
937 TXIMPRequestId reqId = presPub.SubscribeOwnPresenceL( *pif ); |
|
938 |
|
939 // Setup status event listener for RequestComplete |
|
940 CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); |
|
941 listener2->ExpectL( evReqComplete ); |
|
942 CleanupStack::Pop( evReqComplete ); |
|
943 |
|
944 // Wait for events on the request |
|
945 EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "SubscribeOwnPresence failed" ); |
|
946 |
|
947 // verify that SubscribeOwnPresenceL was called |
|
948 COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", ETrue, NULL ); |
|
949 |
|
950 // publish own presence in here |
|
951 MPresenceInfo* info = CreateInfoLC(); |
|
952 |
|
953 reqId = presPub.PublishOwnPresenceL( *info ); |
|
954 |
|
955 // Setup status event listener |
|
956 evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); |
|
957 listener2->ExpectL( evReqComplete ); |
|
958 CleanupStack::Pop( evReqComplete ); |
|
959 |
|
960 CXIMPDataSubscriptionStateImp* stateImp = CXIMPDataSubscriptionStateImp::NewLC(); |
|
961 stateImp->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable ); |
|
962 stateImp->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive ); |
|
963 COwnPresenceEventImp* event = COwnPresenceEventImp::NewLC( stateImp ); |
|
964 CleanupStack::Pop( 2, stateImp ); |
|
965 CleanupStack::PushL( event ); |
|
966 listener2->ExpectL( event ); |
|
967 CleanupStack::Pop( event ); |
|
968 |
|
969 // Wait for events on the request |
|
970 EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Publishing presence failed" ); |
|
971 COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called", ETrue, NULL ); |
|
972 |
|
973 // REFRESH |
|
974 |
|
975 // subscribe own presence (refresh) |
|
976 reqId = presPub.SubscribeOwnPresenceL( *pif ); |
|
977 |
|
978 // Setup status event listener for RequestComplete |
|
979 messenger->SetValueFor( EXIMPPlgTestSubscribeOwnPresenceCalled, 0 ); |
|
980 evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqId ); |
|
981 listener2->ExpectL( evReqComplete ); |
|
982 CleanupStack::Pop( evReqComplete ); |
|
983 // also the event |
|
984 |
|
985 stateImp = CXIMPDataSubscriptionStateImp::NewLC(); |
|
986 stateImp->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable ); |
|
987 stateImp->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive ); |
|
988 event = COwnPresenceEventImp::NewLC( stateImp ); |
|
989 CleanupStack::Pop( 2, stateImp ); |
|
990 CleanupStack::PushL( event ); |
|
991 listener2->ExpectL( event ); |
|
992 CleanupStack::Pop( event ); |
|
993 |
|
994 // Wait for events on the request |
|
995 EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Refreshing own presence subscription failed" ); |
|
996 |
|
997 // verify that SubscribeOwnPresenceL was called |
|
998 COMMONASSERT( messenger, EXIMPPlgTestSubscribeOwnPresenceCalled, "SubscribeOwnPresenceL was not called", EFalse, "SubscribeOwnPresenceL was called" ); |
|
999 |
|
1000 CleanupStack::PopAndDestroy( 3, listener2 ); // info, pif, listener2 |
|
1001 UnbindL(); |
|
1002 } |
|
1003 |
|
1004 |
|
1005 // =========================================================================== |
|
1006 // SETUP HELPERS FOR THE LISTENER |
|
1007 // =========================================================================== |
|
1008 // |
|
1009 void T_PresencePublishing::SetupListenerReqCompleteL( CXIMPTestContextWrapper* aWrapper, TXIMPTestStatusEventTemplate aEventType ) |
|
1010 { |
|
1011 RArray< TInt32 > array; |
|
1012 CleanupClosePushL( array ); |
|
1013 array.Append( MXIMPContextStateEvent::KInterfaceId ); |
|
1014 array.Append( MOwnPresenceEvent::KInterfaceId ); |
|
1015 aWrapper->SetupListenerReqCompleteL( aEventType, &array ); |
|
1016 CleanupStack::PopAndDestroy(); // array |
|
1017 } |
|
1018 |
|
1019 void T_PresencePublishing::SetupListenerReqCompleteAllowEventsL( CXIMPTestContextWrapper* aWrapper, TXIMPTestStatusEventTemplate aEventType ) |
|
1020 { |
|
1021 RArray< TInt32 > array; |
|
1022 CleanupClosePushL( array ); |
|
1023 array.AppendL( MXIMPRequestCompleteEvent::KInterfaceId ); |
|
1024 array.AppendL( MXIMPContextStateEvent::KInterfaceId ); |
|
1025 array.AppendL( MOwnPresenceEvent::KInterfaceId ); |
|
1026 aWrapper->SetupListenerReqCompleteL( aEventType, &array ); |
|
1027 CleanupStack::PopAndDestroy(); // array |
|
1028 } |
|
1029 |
|
1030 MPresenceInfo* T_PresencePublishing::CreateInfoLC() |
|
1031 { |
|
1032 // fill up the info structure with: |
|
1033 // service info imp: |
|
1034 // - info name: "test_service" |
|
1035 // - field name: availability |
|
1036 // - field value: enum type, value 1 |
|
1037 // person info imp: |
|
1038 // - field name: "status-message" |
|
1039 // - field value: "This is my status message." |
|
1040 // |
|
1041 CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 ); |
|
1042 MXIMPContext* context = wrapper->GetContext(); |
|
1043 |
|
1044 // Get the interface |
|
1045 MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures(); |
|
1046 MPresenceInfo* info = presFeat->PresenceObjectFactory().NewPresenceInfoLC(); |
|
1047 |
|
1048 // fill service info |
|
1049 MServicePresenceInfo* srvInfo = presFeat->PresenceObjectFactory().NewServicePresenceInfoLC(); |
|
1050 srvInfo->SetServiceTypeL( KServiceType ); // test |
|
1051 |
|
1052 MPresenceInfoField* infoField = presFeat->PresenceObjectFactory().NewInfoFieldLC(); |
|
1053 |
|
1054 MPresenceInfoFieldValueEnum* enumField = presFeat->PresenceObjectFactory().NewEnumInfoFieldLC(); |
|
1055 enumField->SetValueL( KTestAvailability ); // 1 |
|
1056 infoField->SetFieldTypeL( NPresenceInfo::NFieldType::KAvailability ); // "availability" |
|
1057 infoField->SetFieldValue( enumField ); |
|
1058 CleanupStack::Pop(); // enumField |
|
1059 |
|
1060 srvInfo->Fields().AddOrReplaceFieldL( infoField ); |
|
1061 CleanupStack::Pop(); // infoField |
|
1062 |
|
1063 info->AddServicePresenceL( srvInfo ); |
|
1064 CleanupStack::Pop(); // srvInfo |
|
1065 |
|
1066 // fill person info |
|
1067 MPersonPresenceInfo* persInfo = presFeat->PresenceObjectFactory().NewPersonPresenceInfoLC(); |
|
1068 MPresenceInfoField* infoField2 = presFeat->PresenceObjectFactory().NewInfoFieldLC(); |
|
1069 |
|
1070 MPresenceInfoFieldValueText* textField = presFeat->PresenceObjectFactory().NewTextInfoFieldLC(); |
|
1071 textField->SetTextValueL( KStatusMsg ); |
|
1072 |
|
1073 infoField2->SetFieldTypeL( NPresenceInfo::NFieldType::KStatusMessage ); |
|
1074 infoField2->SetFieldValue( textField ); |
|
1075 CleanupStack::Pop(); // textField |
|
1076 |
|
1077 persInfo->Fields().AddOrReplaceFieldL( infoField2 ); |
|
1078 CleanupStack::Pop(); // infoField2 |
|
1079 |
|
1080 info->SetPersonPresenceL( persInfo ); |
|
1081 CleanupStack::Pop(); // persInfo |
|
1082 // that's it |
|
1083 |
|
1084 return info; |
|
1085 } |
|
1086 |
|
1087 // =========================================================================== |
|
1088 // TEST CASE TABLE |
|
1089 // =========================================================================== |
|
1090 // |
|
1091 EUNIT_BEGIN_TEST_TABLE( |
|
1092 T_PresencePublishing, |
|
1093 "XIMP presence management tests", |
|
1094 "MODULE" ) |
|
1095 |
|
1096 |
|
1097 PRFW_DECORATED_TEST( |
|
1098 "Publish single presence", |
|
1099 "", |
|
1100 "", |
|
1101 "FUNCTIONALITY", |
|
1102 Setup_L, |
|
1103 T_Publish_Single_L, |
|
1104 Teardown ) |
|
1105 |
|
1106 /* |
|
1107 PRFW_NOT_DECORATED_TEST( |
|
1108 "Publish, error leave", |
|
1109 "", |
|
1110 "", |
|
1111 "ERRORHANDLING", |
|
1112 Setup_Bind_L, |
|
1113 T_Publish_ErrFromPlg_Leave_L, |
|
1114 Teardown_Unbind ) |
|
1115 |
|
1116 PRFW_NOT_DECORATED_TEST( |
|
1117 "Publish, error complete", |
|
1118 "", |
|
1119 "", |
|
1120 "ERRORHANDLING", |
|
1121 Setup_Bind_L, |
|
1122 T_Publish_ErrFromPlg_CompleteWithError_L, |
|
1123 Teardown_Unbind ) |
|
1124 */ |
|
1125 |
|
1126 PRFW_DECORATED_TEST( |
|
1127 "Empty own presence subscribtion", |
|
1128 "", |
|
1129 "", |
|
1130 "FUNCTIONALITY", |
|
1131 Setup_L, |
|
1132 T_SubscribeOwnPresence_Single_Empty_L, |
|
1133 Teardown ) |
|
1134 |
|
1135 PRFW_DECORATED_TEST( |
|
1136 "Empty own presence subscribtion for multiple clients", |
|
1137 "", |
|
1138 "", |
|
1139 "FUNCTIONALITY", |
|
1140 SetupMultiple_L, |
|
1141 T_SubscribeOwnPresence_Multiple_Empty_L, |
|
1142 Teardown ) |
|
1143 |
|
1144 |
|
1145 PRFW_DECORATED_TEST( |
|
1146 "Single own presence subscribtion", |
|
1147 "", |
|
1148 "", |
|
1149 "FUNCTIONALITY", |
|
1150 Setup_L, |
|
1151 T_SubscribeOwnPresence_Single_L, |
|
1152 Teardown ) |
|
1153 |
|
1154 PRFW_DECORATED_TEST( |
|
1155 "Single own presence subscribtion with publish", |
|
1156 "", |
|
1157 "", |
|
1158 "FUNCTIONALITY", |
|
1159 Setup_L, |
|
1160 T_SubscribeOwnPresence_Publish_Single_L, |
|
1161 Teardown ) |
|
1162 |
|
1163 PRFW_DECORATED_TEST( |
|
1164 "Error - Fail subscription", |
|
1165 "", |
|
1166 "", |
|
1167 "FUNCTIONALITY", |
|
1168 Setup_L, |
|
1169 T_ErrFromPlg_LeaveOnSubscribeOwnPresence_L, |
|
1170 Teardown ) |
|
1171 |
|
1172 PRFW_DECORATED_TEST( |
|
1173 "Error - Network UnplugError", |
|
1174 "", |
|
1175 "", |
|
1176 "FUNCTIONALITY", |
|
1177 Setup_L, |
|
1178 T_NetworkUnplugError_L, |
|
1179 Teardown ) |
|
1180 |
|
1181 /* |
|
1182 PRFW_DECORATED_TEST( |
|
1183 "Error - Network UnplugError", |
|
1184 "", |
|
1185 "", |
|
1186 "FUNCTIONALITY", |
|
1187 SetupMultiple_L, |
|
1188 T_NetworkUnplugErrorMultiple_L, |
|
1189 Teardown ) |
|
1190 */ |
|
1191 |
|
1192 EUNIT_END_TEST_TABLE |
|
1193 |
|
1194 |
|
1195 // =========================================================================== |
|
1196 // TEST SUITE CONSTRUCTION |
|
1197 // =========================================================================== |
|
1198 // |
|
1199 EXPORT_C MEUnitTest* CreateTestSuiteL() |
|
1200 { |
|
1201 return T_PresencePublishing::NewL(); |
|
1202 } |
|
1203 |
|
1204 |
|
1205 // end of file |
|
1206 |
|
1207 |
|
1208 |
|
1209 |
|
1210 |
|
1211 |