|
1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 /** |
|
17 @file The TEFUnit integration test suite for MBMS Context support in the Common TSY. |
|
18 */ |
|
19 |
|
20 #include "cctsyucasembms008.h" |
|
21 #include "cctsyactiveretriever.h" |
|
22 #include <etel.h> |
|
23 #include <etelmm.h> |
|
24 #include <et_clsvr.h> |
|
25 #include <ctsy/mmtsy_names.h> |
|
26 #include <ctsy/serviceapi/mmtsy_ipcdefs.h> |
|
27 #include "tmockltsydata.h" |
|
28 #include <ctsy/serviceapi/gsmerror.h> |
|
29 |
|
30 #include <pcktcs.h> |
|
31 #include <pcktlist.h> |
|
32 #include "pcktretrieve.h" |
|
33 #include "CMmCommonStaticUtility.h" |
|
34 #include <ctsy/serviceapi/mmtsy_defaults.h> |
|
35 |
|
36 #define MBMS_MONITORSERVICECOUNTONE 1 |
|
37 #define MBMS_MONITORSERVICECOUNTMULTIPLE 3 |
|
38 |
|
39 CTestSuite* CCTsyUCaseMbms008::CreateSuiteL(const TDesC& aName) |
|
40 { |
|
41 SUB_SUITE; |
|
42 ADD_TEST_STEP_ISO_CPP(CCTsyUCaseMbms008, CCtsyIntegrationTestMbms0001L ); |
|
43 ADD_TEST_STEP_ISO_CPP(CCTsyUCaseMbms008, CCtsyIntegrationTestMbms0002L ); |
|
44 ADD_TEST_STEP_ISO_CPP(CCTsyUCaseMbms008, CCtsyIntegrationTestMbms0003L ); |
|
45 END_SUITE; |
|
46 } |
|
47 |
|
48 // |
|
49 // Actual test cases |
|
50 // |
|
51 |
|
52 /** |
|
53 * @SYMTestCaseID BA-CTSY-INT-MB-0014 |
|
54 * @SYMFssID BA/CTSY/PKTS-0014 |
|
55 * @SYMTestCaseDesc Support updating monitor list by adding an entry. |
|
56 * @SYMTestPriority High |
|
57 * @SYMTestActions RPacketService::NotifyMbmsNetworkServiceStatusChange, RPacketService::UpdateMbmsMonitorServiceListL |
|
58 * @SYMTestExpectedResults Pass - Service is added to the monitored service list. |
|
59 * @SYMTestType CIT |
|
60 * @SYMTestCaseDependencies live/manual |
|
61 * |
|
62 * Reason for test: Verify that services is added correctly to the monitored service list. |
|
63 * |
|
64 * @return - none |
|
65 */ |
|
66 void CCTsyUCaseMbms008::CCtsyIntegrationTestMbms0001L() |
|
67 { |
|
68 |
|
69 // |
|
70 // SET UP |
|
71 // |
|
72 |
|
73 OpenEtelServerL( EUseExtendedError ); |
|
74 CleanupStack::PushL( TCleanupItem( Cleanup, this ) ); |
|
75 OpenPhoneL(); |
|
76 |
|
77 RBuf8 data; |
|
78 CleanupClosePushL(data); |
|
79 |
|
80 RPacketService packetService; |
|
81 OpenPacketServiceL( packetService ); |
|
82 CleanupClosePushL( packetService ); |
|
83 |
|
84 TRequestStatus requestStatus; |
|
85 TRequestStatus requestStatus2; |
|
86 TRequestStatus mockLtsyStatus; |
|
87 |
|
88 // Ensure packet service status is RPacketService::EStatusAttached. |
|
89 RPacketService::TStatus sendStatus = RPacketService::EStatusAttached; |
|
90 TBool isResumed = EFalse; |
|
91 TMockLtsyData2 <RPacketService::TStatus, TBool > ltsyData(sendStatus, isResumed); |
|
92 ltsyData.SerialiseL(data); |
|
93 RPacketService::TStatus contextStatus; |
|
94 packetService.NotifyStatusChange(requestStatus2, contextStatus); |
|
95 |
|
96 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
97 iMockLTSY.CompleteL(EPacketNotifyStatusChange, KErrNone, data); // |
|
98 |
|
99 User::WaitForRequest(mockLtsyStatus); |
|
100 User::WaitForRequest(requestStatus2); |
|
101 AssertMockLtsyStatusL(); |
|
102 ASSERT_EQUALS(KErrNone, requestStatus2.Int()); |
|
103 ASSERT_EQUALS(sendStatus, contextStatus); |
|
104 |
|
105 // |
|
106 // SET UP END |
|
107 // |
|
108 |
|
109 // |
|
110 // TEST START |
|
111 // |
|
112 |
|
113 |
|
114 TInt maxAllowed = 3; |
|
115 TInt maxvalue = 3; |
|
116 |
|
117 // check maximum monitored service value . |
|
118 TMockLtsyData1<TInt> ltsyData2(maxvalue); |
|
119 data.Close(); |
|
120 ltsyData2.SerialiseL(data); |
|
121 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
122 iMockLTSY.CompleteL(EPacketEnumerateMbmsMonitorServiceList, KErrNone, data); |
|
123 User::WaitForRequest(mockLtsyStatus); |
|
124 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
125 ASSERT_EQUALS( maxvalue, maxAllowed ); |
|
126 |
|
127 CFilteringActiveScheduler scheduler; |
|
128 CActiveScheduler::Install(&scheduler); |
|
129 |
|
130 // post RPacketService::NotifyMbmsNetworkServiceAvailabilityChange |
|
131 packetService.NotifyMbmsServiceAvailabilityChange( requestStatus ); |
|
132 |
|
133 //List retriever |
|
134 CRetrievePcktMbmsMonitoredServices* monitorList = CRetrievePcktMbmsMonitoredServices::NewL(packetService); |
|
135 CleanupStack::PushL(monitorList); |
|
136 |
|
137 CActiveRetriever::ResetRequestsNumber(); |
|
138 CActiveRetriever* activeRetriever = CActiveRetriever::NewL(*monitorList); |
|
139 CleanupStack::PushL(activeRetriever); |
|
140 scheduler.AddRetrieverL(*activeRetriever); |
|
141 |
|
142 RBuf8 expectData1; |
|
143 CleanupClosePushL(expectData1); |
|
144 TInt i; |
|
145 TMockLtsyData1<TInt> expExpect1(i); |
|
146 expExpect1.SerialiseL(expectData1); |
|
147 |
|
148 RBuf8 CompleteData; |
|
149 CleanupClosePushL(CompleteData); |
|
150 |
|
151 TRequestStatus aReqStatus; |
|
152 RPacketService::TMbmsServiceAvailabilityV1 existingParams; |
|
153 |
|
154 |
|
155 CPcktMbmsMonitoredServiceList* multipleEntries = CPcktMbmsMonitoredServiceList ::NewL(); |
|
156 CleanupStack::PushL(multipleEntries); |
|
157 |
|
158 for(TInt i=0;i < MBMS_MONITORSERVICECOUNTMULTIPLE ;i++) |
|
159 { |
|
160 existingParams.iTmgi.SetServiceId(i); |
|
161 existingParams.iTmgi.SetMCC(i); |
|
162 existingParams.iTmgi.SetMNC(i); |
|
163 existingParams.iMbmsServiceMode = KBroadcast; |
|
164 existingParams.iMbmsAccessBearer = E2GBearer; |
|
165 existingParams.iMbmsAvailabilityStatus = EMbmsUnavailable; |
|
166 multipleEntries->AddEntryL( existingParams ); |
|
167 } |
|
168 |
|
169 iMockLTSY.ExpectL(EPacketUpdateMbmsMonitorServiceList, expectData1); |
|
170 iMockLTSY.CompleteL(EPacketUpdateMbmsMonitorServiceList, KErrNone, CompleteData); |
|
171 |
|
172 // PacketService::UpdateMbmsMonitorServiceListL |
|
173 packetService.UpdateMbmsMonitorServiceListL(aReqStatus, EAddEntries, multipleEntries); |
|
174 |
|
175 // wait for completion of UpdateMbmsMonitorServiceListL( |
|
176 User::WaitForRequest(aReqStatus); |
|
177 // wait for completion of NotifyMbmsServiceAvailabilityChange |
|
178 User::WaitForRequest( requestStatus ); |
|
179 AssertMockLtsyStatusL(); |
|
180 ASSERT_EQUALS( KErrNone, aReqStatus.Int() ); |
|
181 |
|
182 monitorList->Start(activeRetriever->Status()); |
|
183 activeRetriever->Activate(); |
|
184 scheduler.StartScheduler(); |
|
185 |
|
186 ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber()); |
|
187 ASSERT_EQUALS(KErrNone, activeRetriever->iStatus.Int()); |
|
188 |
|
189 CPcktMbmsMonitoredServiceList* list = monitorList->RetrieveListL(); |
|
190 CleanupStack::PushL( list ); |
|
191 |
|
192 ASSERT_EQUALS(MBMS_MONITORSERVICECOUNTMULTIPLE, list->Enumerate() ); |
|
193 |
|
194 monitorList->Start( activeRetriever->Status() ); |
|
195 activeRetriever->Activate(); |
|
196 scheduler.StartScheduler(); |
|
197 |
|
198 ASSERT_EQUALS( 0, CActiveRetriever::ResetRequestsNumber() ); |
|
199 ASSERT_EQUALS( KErrNone, activeRetriever->iStatus.Int() ); |
|
200 |
|
201 list = monitorList->RetrieveListL(); |
|
202 CleanupStack::PushL( list ); |
|
203 |
|
204 // ensure that Services is added correctly into the monitored service list |
|
205 ASSERT_TRUE( TComparator<CPcktMbmsMonitoredServiceList>::IsEqual( *multipleEntries, *list ) ); |
|
206 |
|
207 // |
|
208 // TEST END |
|
209 // |
|
210 |
|
211 AssertMockLtsyStatusL(); |
|
212 CleanupStack::PopAndDestroy( 10, this ); // packetMbmsContext, packetService, this |
|
213 } |
|
214 |
|
215 /** |
|
216 * @SYMTestCaseID BA-CTSY-INT-MB-0015 |
|
217 * @SYMFssID BA/CTSY/PKTS-0015 |
|
218 * @SYMTestCaseDesc Support updating monitor list by adding an entry. |
|
219 * @SYMTestPriority High |
|
220 * @SYMTestActions RPacketService::NotifyMbmsNetworkServiceStatusChange, RPacketService::UpdateMbmsMonitorServiceListL |
|
221 * @SYMTestExpectedResults Pass - Service is added to the monitored service list. |
|
222 * @SYMTestType CIT |
|
223 * @SYMTestCaseDependencies live/manual |
|
224 * |
|
225 * Reason for test: Verify that services is added correctly to the monitored service list. |
|
226 * |
|
227 * @return - none |
|
228 */ |
|
229 void CCTsyUCaseMbms008::CCtsyIntegrationTestMbms0002L() |
|
230 { |
|
231 |
|
232 // |
|
233 // SET UP |
|
234 // |
|
235 |
|
236 OpenEtelServerL( EUseExtendedError ); |
|
237 CleanupStack::PushL( TCleanupItem( Cleanup, this ) ); |
|
238 OpenPhoneL(); |
|
239 |
|
240 RBuf8 data; |
|
241 CleanupClosePushL(data); |
|
242 |
|
243 RPacketService packetService; |
|
244 OpenPacketServiceL( packetService ); |
|
245 CleanupClosePushL( packetService ); |
|
246 |
|
247 TRequestStatus requestStatus; |
|
248 TRequestStatus requestStatus2; |
|
249 TRequestStatus mockLtsyStatus; |
|
250 |
|
251 // Ensure packet service status is RPacketService::EStatusAttached. |
|
252 RPacketService::TStatus sendStatus = RPacketService::EStatusAttached; |
|
253 TBool isResumed = EFalse; |
|
254 TMockLtsyData2 <RPacketService::TStatus, TBool > ltsyData(sendStatus, isResumed); |
|
255 ltsyData.SerialiseL(data); |
|
256 RPacketService::TStatus contextStatus; |
|
257 packetService.NotifyStatusChange(requestStatus2, contextStatus); |
|
258 |
|
259 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
260 iMockLTSY.CompleteL(EPacketNotifyStatusChange, KErrNone, data); // |
|
261 |
|
262 User::WaitForRequest(mockLtsyStatus); |
|
263 User::WaitForRequest(requestStatus2); |
|
264 AssertMockLtsyStatusL(); |
|
265 ASSERT_EQUALS(KErrNone, requestStatus2.Int()); |
|
266 ASSERT_EQUALS(sendStatus, contextStatus); |
|
267 |
|
268 // |
|
269 // SET UP END |
|
270 // |
|
271 |
|
272 // |
|
273 // TEST START |
|
274 // |
|
275 |
|
276 TInt maxAllowed = 3; |
|
277 TInt maxvalue = 3; |
|
278 |
|
279 // check maximum monitored service value |
|
280 TMockLtsyData1<TInt> ltsyData2(maxvalue); |
|
281 data.Close(); |
|
282 ltsyData2.SerialiseL(data); |
|
283 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
284 iMockLTSY.CompleteL(EPacketEnumerateMbmsMonitorServiceList, KErrNone, data); |
|
285 User::WaitForRequest(mockLtsyStatus); |
|
286 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
287 ASSERT_EQUALS( maxvalue, maxAllowed ); |
|
288 |
|
289 CFilteringActiveScheduler scheduler; |
|
290 CActiveScheduler::Install(&scheduler); |
|
291 |
|
292 // post RPacketService::NotifyMbmsNetworkServiceAvailabilityChange |
|
293 packetService.NotifyMbmsServiceAvailabilityChange( requestStatus ); |
|
294 |
|
295 //List retriever |
|
296 CRetrievePcktMbmsMonitoredServices* monitorList = CRetrievePcktMbmsMonitoredServices::NewL(packetService); |
|
297 CleanupStack::PushL(monitorList); |
|
298 |
|
299 CActiveRetriever::ResetRequestsNumber(); |
|
300 CActiveRetriever* activeRetriever = CActiveRetriever::NewL(*monitorList); |
|
301 CleanupStack::PushL(activeRetriever); |
|
302 scheduler.AddRetrieverL(*activeRetriever); |
|
303 |
|
304 RBuf8 expectData1; |
|
305 CleanupClosePushL(expectData1); |
|
306 TInt i; |
|
307 TMockLtsyData1<TInt> expExpect1(i); |
|
308 expExpect1.SerialiseL(expectData1); |
|
309 |
|
310 RBuf8 CompleteData; |
|
311 CleanupClosePushL(CompleteData); |
|
312 |
|
313 TRequestStatus aReqStatus; |
|
314 RPacketService::TMbmsServiceAvailabilityV1 existingParams; |
|
315 |
|
316 |
|
317 CPcktMbmsMonitoredServiceList* multipleEntries = CPcktMbmsMonitoredServiceList ::NewL(); |
|
318 CleanupStack::PushL(multipleEntries); |
|
319 |
|
320 for(TInt i=0;i < MBMS_MONITORSERVICECOUNTMULTIPLE +1;i++) |
|
321 { |
|
322 existingParams.iTmgi.SetServiceId(i); |
|
323 existingParams.iTmgi.SetMCC(i); |
|
324 existingParams.iTmgi.SetMNC(i); |
|
325 existingParams.iMbmsServiceMode = KBroadcast; |
|
326 existingParams.iMbmsAccessBearer = E2GBearer; |
|
327 existingParams.iMbmsAvailabilityStatus = EMbmsUnavailable; |
|
328 multipleEntries->AddEntryL( existingParams ); |
|
329 } |
|
330 |
|
331 iMockLTSY.ExpectL(EPacketUpdateMbmsMonitorServiceList, expectData1); |
|
332 iMockLTSY.CompleteL(EPacketUpdateMbmsMonitorServiceList, KErrNone, CompleteData); |
|
333 |
|
334 // PacketService::UpdateMbmsMonitorServiceListL |
|
335 packetService.UpdateMbmsMonitorServiceListL(aReqStatus, EAddEntries, multipleEntries); |
|
336 |
|
337 // wait for completion of UpdateMbmsMonitorServiceListL( |
|
338 User::WaitForRequest(aReqStatus); |
|
339 // wait for completion of NotifyMbmsServiceAvailabilityChange |
|
340 User::WaitForRequest( requestStatus ); |
|
341 AssertMockLtsyStatusL(); |
|
342 // Ensure RPacketService::NotifyMbmsNetworkServiceStatusChange completes with status KErrOverflow |
|
343 ASSERT_EQUALS( KErrOverflow, aReqStatus.Int() ); |
|
344 |
|
345 // |
|
346 // TEST END |
|
347 // |
|
348 |
|
349 AssertMockLtsyStatusL(); |
|
350 CleanupStack::PopAndDestroy( 8, this ); // packetMbmsContext, packetService, this |
|
351 } |
|
352 |
|
353 /** |
|
354 * @SYMTestCaseID BA-CTSY-INT-MB-0016 |
|
355 * @SYMFssID BA/CTSY/PKTS-0016 |
|
356 * @SYMTestCaseDesc Support updating monitor list by adding an entry. |
|
357 * @SYMTestPriority High |
|
358 * @SYMTestActions RPacketService::NotifyMbmsNetworkServiceStatusChange, RPacketService::UpdateMbmsMonitorServiceListL |
|
359 * @SYMTestExpectedResults Pass - Service is added to the monitored service list. |
|
360 * @SYMTestType CIT |
|
361 * @SYMTestCaseDependencies live/manual |
|
362 * |
|
363 * Reason for test: Verify that services is added correctly to the monitored service list. |
|
364 * |
|
365 * @return - none |
|
366 */ |
|
367 void CCTsyUCaseMbms008::CCtsyIntegrationTestMbms0003L() |
|
368 { |
|
369 |
|
370 // |
|
371 // SET UP |
|
372 // |
|
373 |
|
374 OpenEtelServerL( EUseExtendedError ); |
|
375 CleanupStack::PushL( TCleanupItem( Cleanup, this ) ); |
|
376 OpenPhoneL(); |
|
377 |
|
378 RBuf8 data; |
|
379 CleanupClosePushL(data); |
|
380 |
|
381 RPacketService packetService; |
|
382 OpenPacketServiceL( packetService ); |
|
383 CleanupClosePushL( packetService ); |
|
384 |
|
385 TRequestStatus requestStatus; |
|
386 TRequestStatus requestStatus2; |
|
387 TRequestStatus mockLtsyStatus; |
|
388 |
|
389 // Ensure packet service status is RPacketService::EStatusAttached. |
|
390 RPacketService::TStatus sendStatus = RPacketService::EStatusAttached; |
|
391 TBool isResumed = EFalse; |
|
392 TMockLtsyData2 <RPacketService::TStatus, TBool > ltsyData(sendStatus, isResumed); |
|
393 ltsyData.SerialiseL(data); |
|
394 RPacketService::TStatus contextStatus; |
|
395 packetService.NotifyStatusChange(requestStatus2, contextStatus); |
|
396 |
|
397 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
398 iMockLTSY.CompleteL(EPacketNotifyStatusChange, KErrNone, data); // |
|
399 |
|
400 User::WaitForRequest(mockLtsyStatus); |
|
401 User::WaitForRequest(requestStatus2); |
|
402 AssertMockLtsyStatusL(); |
|
403 ASSERT_EQUALS(KErrNone, requestStatus2.Int()); |
|
404 ASSERT_EQUALS(sendStatus, contextStatus); |
|
405 |
|
406 // |
|
407 // SET UP END |
|
408 // |
|
409 |
|
410 // |
|
411 // TEST START |
|
412 // |
|
413 |
|
414 TInt maxAllowed = 3; |
|
415 TInt maxvalue = 3; |
|
416 |
|
417 // check maximum monitored service value |
|
418 TMockLtsyData1<TInt> ltsyData2(maxvalue); |
|
419 data.Close(); |
|
420 ltsyData2.SerialiseL(data); |
|
421 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
422 iMockLTSY.CompleteL(EPacketEnumerateMbmsMonitorServiceList, KErrNone, data); |
|
423 User::WaitForRequest(mockLtsyStatus); |
|
424 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
425 ASSERT_EQUALS( maxvalue, maxAllowed ); |
|
426 |
|
427 CFilteringActiveScheduler scheduler; |
|
428 CActiveScheduler::Install(&scheduler); |
|
429 |
|
430 // post RPacketService::NotifyMbmsNetworkServiceAvailabilityChange |
|
431 packetService.NotifyMbmsServiceAvailabilityChange( requestStatus ); |
|
432 |
|
433 //List retriever |
|
434 CRetrievePcktMbmsMonitoredServices* monitorList = CRetrievePcktMbmsMonitoredServices::NewL(packetService); |
|
435 CleanupStack::PushL(monitorList); |
|
436 |
|
437 CActiveRetriever::ResetRequestsNumber(); |
|
438 CActiveRetriever* activeRetriever = CActiveRetriever::NewL(*monitorList); |
|
439 CleanupStack::PushL(activeRetriever); |
|
440 scheduler.AddRetrieverL(*activeRetriever); |
|
441 |
|
442 RBuf8 expectData1; |
|
443 CleanupClosePushL(expectData1); |
|
444 TInt i; |
|
445 TMockLtsyData1<TInt> expExpect1(i); |
|
446 expExpect1.SerialiseL(expectData1); |
|
447 |
|
448 RBuf8 CompleteData; |
|
449 CleanupClosePushL(CompleteData); |
|
450 |
|
451 TRequestStatus aReqStatus; |
|
452 RPacketService::TMbmsServiceAvailabilityV1 existingParams; |
|
453 |
|
454 |
|
455 CPcktMbmsMonitoredServiceList* multipleEntries = CPcktMbmsMonitoredServiceList ::NewL(); |
|
456 CleanupStack::PushL(multipleEntries); |
|
457 |
|
458 for(TInt i=0;i < MBMS_MONITORSERVICECOUNTMULTIPLE;i++) |
|
459 { |
|
460 existingParams.iTmgi.SetServiceId(i); |
|
461 existingParams.iTmgi.SetMCC(i); |
|
462 existingParams.iTmgi.SetMNC(i); |
|
463 existingParams.iMbmsServiceMode = KBroadcast; |
|
464 existingParams.iMbmsAccessBearer = E2GBearer; |
|
465 existingParams.iMbmsAvailabilityStatus = EMbmsUnavailable; |
|
466 multipleEntries->AddEntryL( existingParams ); |
|
467 } |
|
468 |
|
469 iMockLTSY.ExpectL(EPacketUpdateMbmsMonitorServiceList, expectData1); |
|
470 iMockLTSY.CompleteL(EPacketUpdateMbmsMonitorServiceList, KErrNone, CompleteData); |
|
471 |
|
472 // PacketService::UpdateMbmsMonitorServiceListL |
|
473 packetService.UpdateMbmsMonitorServiceListL(aReqStatus, EAddEntries, multipleEntries); |
|
474 |
|
475 // wait for completion of UpdateMbmsMonitorServiceListL( |
|
476 User::WaitForRequest(aReqStatus); |
|
477 // wait for completion of NotifyMbmsServiceAvailabilityChange |
|
478 User::WaitForRequest( requestStatus ); |
|
479 AssertMockLtsyStatusL(); |
|
480 ASSERT_EQUALS( KErrNone, aReqStatus.Int() ); |
|
481 |
|
482 monitorList->Start(activeRetriever->Status()); |
|
483 activeRetriever->Activate(); |
|
484 scheduler.StartScheduler(); |
|
485 |
|
486 ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber()); |
|
487 ASSERT_EQUALS(KErrNone, activeRetriever->iStatus.Int()); |
|
488 |
|
489 CPcktMbmsMonitoredServiceList* list = monitorList->RetrieveListL(); |
|
490 CleanupStack::PushL( list ); |
|
491 |
|
492 ASSERT_EQUALS(MBMS_MONITORSERVICECOUNTMULTIPLE, list->Enumerate() ); |
|
493 |
|
494 monitorList->Start( activeRetriever->Status() ); |
|
495 activeRetriever->Activate(); |
|
496 scheduler.StartScheduler(); |
|
497 |
|
498 ASSERT_EQUALS( 0, CActiveRetriever::ResetRequestsNumber() ); |
|
499 ASSERT_EQUALS( KErrNone, activeRetriever->iStatus.Int() ); |
|
500 |
|
501 list = monitorList->RetrieveListL(); |
|
502 CleanupStack::PushL( list ); |
|
503 |
|
504 ASSERT_TRUE( TComparator<CPcktMbmsMonitoredServiceList>::IsEqual( *multipleEntries, *list ) ); |
|
505 |
|
506 //------------------------------------------------------------------------- |
|
507 // Test add entries which already exists |
|
508 //------------------------------------------------------------------------- |
|
509 |
|
510 // clear list |
|
511 iMockLTSY.ExpectL(EPacketUpdateMbmsMonitorServiceList, expectData1); |
|
512 TInt complete = 1; |
|
513 TMockLtsyData1< TInt > dataForComplete(complete); |
|
514 dataForComplete.SerialiseL(CompleteData); |
|
515 iMockLTSY.CompleteL(EPacketUpdateMbmsMonitorServiceList, KErrNone, CompleteData); |
|
516 CPcktMbmsMonitoredServiceList* nullPtr = NULL; |
|
517 packetService.UpdateMbmsMonitorServiceListL(aReqStatus, ERemoveAllEntries, nullPtr ); |
|
518 User::WaitForRequest(aReqStatus); |
|
519 ASSERT_EQUALS( KErrNone, aReqStatus.Int() ); |
|
520 |
|
521 // Add entry twice |
|
522 complete = 1; |
|
523 dataForComplete.SerialiseL(CompleteData); |
|
524 iMockLTSY.ExpectL(EPacketUpdateMbmsMonitorServiceList, expectData1); |
|
525 iMockLTSY.CompleteL(EPacketUpdateMbmsMonitorServiceList, KErrNone, CompleteData); |
|
526 |
|
527 // clear list |
|
528 CPcktMbmsMonitoredServiceList* oneEntry = CPcktMbmsMonitoredServiceList ::NewL(); |
|
529 CleanupStack::PushL(oneEntry); |
|
530 |
|
531 TInt ix = 0; |
|
532 while( oneEntry->Enumerate() > 0 ) |
|
533 { |
|
534 oneEntry->DeleteEntryL(ix); |
|
535 } |
|
536 RPacketService::TMbmsServiceAvailabilityV1 param; |
|
537 param.iTmgi.SetServiceId(0); |
|
538 oneEntry->AddEntryL( param ); |
|
539 packetService.UpdateMbmsMonitorServiceListL(requestStatus, EAddEntries, oneEntry); |
|
540 User::WaitForRequest(requestStatus); |
|
541 AssertMockLtsyStatusL(); |
|
542 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
543 |
|
544 packetService.UpdateMbmsMonitorServiceListL(requestStatus, EAddEntries, oneEntry); |
|
545 User::WaitForRequest(requestStatus); |
|
546 AssertMockLtsyStatusL(); |
|
547 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
548 |
|
549 |
|
550 monitorList->Start(activeRetriever->Status()); |
|
551 activeRetriever->Activate(); |
|
552 scheduler.StartScheduler(); |
|
553 |
|
554 ASSERT_EQUALS(0, CActiveRetriever::ResetRequestsNumber()); |
|
555 ASSERT_EQUALS(KErrNone, activeRetriever->iStatus.Int()); |
|
556 |
|
557 |
|
558 list = monitorList->RetrieveListL(); |
|
559 CleanupStack::PushL( list ); |
|
560 // ensure that Services is added correctly into the monitored service list |
|
561 ASSERT_EQUALS(MBMS_MONITORSERVICECOUNTONE, list->Enumerate() ); |
|
562 ASSERT_TRUE( TComparator<CPcktMbmsMonitoredServiceList>::IsEqual(*oneEntry, *list) ); |
|
563 |
|
564 |
|
565 // |
|
566 // TEST END |
|
567 // |
|
568 |
|
569 AssertMockLtsyStatusL(); |
|
570 CleanupStack::PopAndDestroy( 12, this ); // packetMbmsContext, packetService, this |
|
571 } |
|
572 |