|
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 test suite for MBMS Context in the Common TSY. |
|
18 */ |
|
19 |
|
20 #include "cctsymbmscontextfu.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 |
|
37 |
|
38 CTestSuite* CCTsyMbmsContextFU::CreateSuiteL(const TDesC& aName) |
|
39 { |
|
40 SUB_SUITE; |
|
41 |
|
42 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestOpenNewContext0001L); |
|
43 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestInitialiseContext0001L); |
|
44 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestInitialiseContext0002L); |
|
45 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestInitialiseContext0003L); |
|
46 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestInitialiseContext0004L); |
|
47 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestInitialiseContext0005L); |
|
48 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestSetConfig0001L); |
|
49 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestSetConfig0002L); |
|
50 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestSetConfig0003L); |
|
51 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestSetConfig0004L); |
|
52 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestSetConfig0005L); |
|
53 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestActivate0001L); |
|
54 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestActivate0002L); |
|
55 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestActivate0003L); |
|
56 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestActivate0004L); |
|
57 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestActivate0005L); |
|
58 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDeactivate0001L); |
|
59 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDeactivate0002L); |
|
60 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDeactivate0004L); |
|
61 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDeactivate0005L); |
|
62 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDelete0001L); |
|
63 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDelete0004L); |
|
64 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDelete0005L); |
|
65 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestClose0001L); |
|
66 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestGetConfig0001L); |
|
67 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestGetConfig0002L); |
|
68 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestGetConfig0003L); |
|
69 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestGetStatus0001L); |
|
70 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestGetLastErrorCause0001L); |
|
71 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyConfigChanged0001L); |
|
72 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyConfigChanged0002L); |
|
73 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyConfigChanged0003L); |
|
74 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyConfigChanged0004L); |
|
75 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyStatusChange0001L); |
|
76 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyStatusChange0002L); |
|
77 ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyStatusChange0003L); |
|
78 |
|
79 END_SUITE; |
|
80 } |
|
81 |
|
82 |
|
83 // |
|
84 // Actual test cases |
|
85 // |
|
86 |
|
87 /** |
|
88 @SYMTestCaseID BA-CTSY-MCF-PONC-0001 |
|
89 @SYMComponent telephony_ctsy |
|
90 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::OpenNewContext |
|
91 @SYMTestPriority High |
|
92 @SYMTestActions Invokes RPacketMbmsContext::OpenNewContext |
|
93 @SYMTestExpectedResults Pass |
|
94 @SYMTestType CT |
|
95 */ |
|
96 |
|
97 void CCTsyMbmsContextFU::TestOpenNewContext0001L() |
|
98 { |
|
99 OpenEtelServerL( EUseExtendedError ); |
|
100 CleanupStack::PushL( TCleanupItem( Cleanup, this ) ); |
|
101 OpenPhoneL(); |
|
102 |
|
103 RPacketService packetService; |
|
104 |
|
105 OpenPacketServiceL( packetService ); |
|
106 CleanupClosePushL( packetService ); |
|
107 |
|
108 //------------------------------------------------------------------------- |
|
109 // TEST create |
|
110 //------------------------------------------------------------------------- |
|
111 |
|
112 TInfoName contextId; |
|
113 RPacketMbmsContext packetMbmsContext; |
|
114 TInt retCode; |
|
115 |
|
116 // memory leak check |
|
117 __UHEAP_MARK; |
|
118 |
|
119 retCode = packetMbmsContext.OpenNewContext(packetService, contextId); |
|
120 ASSERT_EQUALS(KErrNone, retCode); |
|
121 |
|
122 _LIT(KContextName, "MBMS_Context_0"); |
|
123 |
|
124 ASSERT_FALSE(contextId.Compare(KContextName)); |
|
125 packetMbmsContext.Close(); |
|
126 |
|
127 __UHEAP_MARKEND; |
|
128 // end memory leak check |
|
129 |
|
130 // test maximum number of contexts allowed |
|
131 TInt count(0); |
|
132 TInt maxAllowed(0); |
|
133 |
|
134 TRequestStatus requestStatus; |
|
135 packetService.EnumerateMbmsActiveServiceList(requestStatus, count, maxAllowed); |
|
136 User::WaitForRequest( requestStatus ); |
|
137 |
|
138 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
139 |
|
140 TInt err = 0; |
|
141 TInt status = 0; |
|
142 for (TInt i = 0; i < maxAllowed; i++) |
|
143 { |
|
144 RPacketMbmsContext newPacketMbmsContext; |
|
145 TInfoName contextId; |
|
146 |
|
147 err = newPacketMbmsContext.OpenNewContext(packetService, contextId); |
|
148 ASSERT_EQUALS(KErrNone, err); |
|
149 CleanupClosePushL(newPacketMbmsContext); |
|
150 |
|
151 // check the context can be initialised |
|
152 status = InitMbmsContextL(newPacketMbmsContext, contextId); |
|
153 ASSERT_EQUALS(KErrNone, status); |
|
154 |
|
155 CleanupStack::Pop(); |
|
156 } |
|
157 |
|
158 RPacketMbmsContext OneMorePacketContext; |
|
159 TInfoName contextId1; |
|
160 |
|
161 err = OneMorePacketContext.OpenNewContext(packetService, contextId1); |
|
162 ASSERT_EQUALS(KErrOverflow, err); |
|
163 |
|
164 OneMorePacketContext.Close(); |
|
165 packetService.Close(); |
|
166 CleanupStack::PopAndDestroy(2, this); // packetService, this |
|
167 } |
|
168 |
|
169 /** |
|
170 @SYMTestCaseID BA-CTSY-MCF-PIC-0001 |
|
171 @SYMComponent telephony_ctsy |
|
172 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::InitialiseContext |
|
173 @SYMTestPriority High |
|
174 @SYMTestActions Invokes RPacketMbmsContext::InitialiseContext |
|
175 @SYMTestExpectedResults Pass |
|
176 @SYMTestType CT |
|
177 */ |
|
178 void CCTsyMbmsContextFU::TestInitialiseContext0001L() |
|
179 { |
|
180 OpenEtelServerL(EUseExtendedError); |
|
181 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
182 OpenPhoneL(); |
|
183 |
|
184 RPacketService packetService; |
|
185 OpenPacketServiceL(packetService); |
|
186 CleanupClosePushL(packetService); |
|
187 |
|
188 // Open new context |
|
189 TInfoName contextId; |
|
190 RPacketMbmsContext packetContext; |
|
191 packetContext.OpenNewContext(packetService, contextId); |
|
192 CleanupClosePushL(packetContext); |
|
193 |
|
194 //------------------------------------------------------------------------- |
|
195 // TEST A: failure to dispatch request to LTSY |
|
196 //------------------------------------------------------------------------- |
|
197 |
|
198 RBuf8 expectData; |
|
199 CleanupClosePushL(expectData); |
|
200 TMockLtsyData1<TInfoName> ltsyExpect(contextId); |
|
201 ltsyExpect.SerialiseL(expectData); |
|
202 |
|
203 // data for initialisation of the context |
|
204 TRequestStatus requestStatus; |
|
205 iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, expectData, KErrNotSupported); |
|
206 |
|
207 //initialisation of the context |
|
208 RPacketContext::TDataChannelV2 dataCh; |
|
209 TPckg<RPacketContext::TDataChannelV2> pckgInit(dataCh); |
|
210 packetContext.InitialiseContext(requestStatus, pckgInit); |
|
211 User::WaitForRequest(requestStatus); |
|
212 AssertMockLtsyStatusL(); |
|
213 ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); |
|
214 |
|
215 //------------------------------------------------------------------------- |
|
216 // TEST B: failure on completion of pending request from LTSY->CTSY |
|
217 //------------------------------------------------------------------------- |
|
218 |
|
219 RPacketContext::TDataChannelV2 retDataCh; |
|
220 |
|
221 _LIT(KDataChannelName, "DataChannel_1"); |
|
222 retDataCh.iChannelId.Copy(KDataChannelName); |
|
223 |
|
224 iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, expectData); |
|
225 |
|
226 RBuf8 data; |
|
227 CleanupClosePushL(data); |
|
228 |
|
229 TMockLtsyData2<TInfoName, RPacketContext::TDataChannelV2> ltsyData(contextId,retDataCh); |
|
230 data.Close(); |
|
231 ltsyData.SerialiseL(data); |
|
232 |
|
233 iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrGeneral, data); |
|
234 |
|
235 //initialisation of the context |
|
236 packetContext.InitialiseContext(requestStatus, pckgInit); |
|
237 User::WaitForRequest(requestStatus); |
|
238 |
|
239 ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); |
|
240 AssertMockLtsyStatusL(); |
|
241 |
|
242 //------------------------------------------------------------------------- |
|
243 // TEST C: Successful completion request of |
|
244 // RPacketContext::InitialiseContext when result is not cached. |
|
245 //------------------------------------------------------------------------- |
|
246 |
|
247 iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, expectData); |
|
248 iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrNone, data); |
|
249 |
|
250 //initialisation of the context |
|
251 packetContext.InitialiseContext(requestStatus, pckgInit); |
|
252 User::WaitForRequest(requestStatus); |
|
253 AssertMockLtsyStatusL(); |
|
254 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
255 |
|
256 RPacketContext::TDataChannelV2 dataChannel = pckgInit(); |
|
257 |
|
258 // check this |
|
259 ASSERT_TRUE(contextId.Compare(KDataChannelName)); |
|
260 |
|
261 //------------------------------------------------------------------------- |
|
262 // TEST E: Unsolicited completion of RPacketContext::InitialiseContext |
|
263 // from LTSY. |
|
264 //------------------------------------------------------------------------- |
|
265 |
|
266 TRequestStatus mockLtsyStatus; |
|
267 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
268 iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrNone, data); |
|
269 User::WaitForRequest(mockLtsyStatus); |
|
270 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
271 |
|
272 AssertMockLtsyStatusL(); |
|
273 |
|
274 CleanupStack::PopAndDestroy(5, this); // expectData, data, this, packetService, packetContext |
|
275 } |
|
276 |
|
277 /** |
|
278 @SYMTestCaseID BA-CTSY-MCF-PIC-0002 |
|
279 @SYMComponent telephony_ctsy |
|
280 @SYMTestCaseDesc Test support in CTSY for cancelling of RPacketMbmsContext::InitialiseContext |
|
281 @SYMTestPriority High |
|
282 @SYMTestActions Invokes cancelling of RPacketMbmsContext::InitialiseContext |
|
283 @SYMTestExpectedResults Pass |
|
284 @SYMTestType CT |
|
285 */ |
|
286 void CCTsyMbmsContextFU::TestInitialiseContext0002L() |
|
287 { |
|
288 OpenEtelServerL( EUseExtendedError ); |
|
289 CleanupStack::PushL( TCleanupItem( Cleanup, this ) ); |
|
290 OpenPhoneL(); |
|
291 |
|
292 RPacketService packetService; |
|
293 OpenPacketServiceL( packetService ); |
|
294 CleanupClosePushL( packetService ); |
|
295 |
|
296 TInfoName contextId; |
|
297 RPacketMbmsContext packetMbmsContext; |
|
298 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
299 CleanupClosePushL( packetMbmsContext ); |
|
300 |
|
301 TRequestStatus mockLtsyStatus; |
|
302 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
303 |
|
304 //------------------------------------------------------------------------- |
|
305 // TEST C: Successful completion request of |
|
306 // RPacketContext::InitialiseContext when result is not cached. |
|
307 //------------------------------------------------------------------------- |
|
308 |
|
309 // data for initialisation of the context |
|
310 TRequestStatus requestStatus; |
|
311 RPacketContext::TDataChannelV2 dataCh; |
|
312 TPckg<RPacketContext::TDataChannelV2> pckgInit(dataCh); |
|
313 |
|
314 RBuf8 data; |
|
315 CleanupClosePushL( data ); |
|
316 |
|
317 TMockLtsyData1< TInfoName> ltsyInit(contextId); |
|
318 ltsyInit.SerialiseL(data); |
|
319 iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, data); |
|
320 |
|
321 RBuf8 expectData; |
|
322 CleanupClosePushL( expectData ); |
|
323 |
|
324 RPacketContext::TDataChannelV2 retDataCh; |
|
325 TMockLtsyData2< TInfoName, RPacketContext::TDataChannelV2 > ltsyData(contextId, retDataCh); |
|
326 data.Close(); |
|
327 ltsyData.SerialiseL(data); |
|
328 iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrNone, data, 10); |
|
329 |
|
330 // initialisation of the context |
|
331 packetMbmsContext.InitialiseContext(requestStatus, pckgInit); |
|
332 |
|
333 // cancel request |
|
334 packetMbmsContext.CancelAsyncRequest(EPacketContextInitialiseContext); |
|
335 |
|
336 User::WaitForRequest(requestStatus); |
|
337 // CTSY has started a request and it is not possible to then cancel |
|
338 // this request. The best thing for the TSY to do in this case is to |
|
339 // proceed as though the Cancel never happened. |
|
340 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
341 |
|
342 // Wait for completion of iMockLTSY.NotifyTerminated |
|
343 User::WaitForRequest(mockLtsyStatus); |
|
344 AssertMockLtsyStatusL(); |
|
345 CleanupStack::PopAndDestroy(2); // packetContext, packetService |
|
346 CleanupStack::PopAndDestroy(3); // expectData, data, this |
|
347 } |
|
348 |
|
349 |
|
350 /** |
|
351 @SYMTestCaseID BA-CTSY-MCF-PIC-0003 |
|
352 @SYMComponent telephony_ctsy |
|
353 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::InitialiseContext with bad parameter data |
|
354 @SYMTestPriority High |
|
355 @SYMTestActions Invokes RPacketMbmsContext::InitialiseContext with bad parameter data |
|
356 @SYMTestExpectedResults Pass |
|
357 @SYMTestType CT |
|
358 */ |
|
359 void CCTsyMbmsContextFU::TestInitialiseContext0003L() |
|
360 { |
|
361 OpenEtelServerL( EUseExtendedError ); |
|
362 CleanupStack::PushL(TCleanupItem( Cleanup, this ) ); |
|
363 OpenPhoneL(); |
|
364 |
|
365 RBuf8 data; |
|
366 CleanupClosePushL( data ); |
|
367 |
|
368 RBuf8 expectData; |
|
369 CleanupClosePushL( expectData ); |
|
370 |
|
371 RPacketService packetService; |
|
372 OpenPacketServiceL( packetService ); |
|
373 CleanupClosePushL( packetService ); |
|
374 |
|
375 // Open new context |
|
376 TInfoName contextId; |
|
377 RPacketMbmsContext packetMbmsContext; |
|
378 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
379 CleanupClosePushL( packetMbmsContext ); |
|
380 |
|
381 //------------------------------------------------------------------------- |
|
382 // Test A: Test passing wrong version of parameters to |
|
383 // RPacketMbmsContext::InitialiseContext |
|
384 //------------------------------------------------------------------------- |
|
385 // data for initialisation of the context |
|
386 |
|
387 TRequestStatus requestStatus; |
|
388 RCall::TCommPort dataCh; // wrong type of data package |
|
389 TPckg<RCall::TCommPort> pckgInit( dataCh ); |
|
390 |
|
391 //initialisation of the context |
|
392 packetMbmsContext.InitialiseContext( requestStatus, pckgInit ); |
|
393 |
|
394 User::WaitForRequest( requestStatus ); |
|
395 ASSERT_EQUALS( KErrArgument, requestStatus.Int() ); |
|
396 AssertMockLtsyStatusL(); |
|
397 |
|
398 CleanupStack::PopAndDestroy( 2 ); // packetMbmsContext, packetService |
|
399 CleanupStack::PopAndDestroy( 3, this ); // expectData, data, this |
|
400 } |
|
401 |
|
402 /** |
|
403 @SYMTestCaseID BA-CTSY-MCF-PIC-0004 |
|
404 @SYMComponent telephony_ctsy |
|
405 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketMbmsContext::InitialiseContext |
|
406 @SYMTestPriority High |
|
407 @SYMTestActions Invokes multiple client requests to RPacketMbmsContext::InitialiseContext |
|
408 @SYMTestExpectedResults Pass |
|
409 @SYMTestType CT |
|
410 */ |
|
411 void CCTsyMbmsContextFU::TestInitialiseContext0004L() |
|
412 { |
|
413 OpenEtelServerL(EUseExtendedError); |
|
414 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
415 OpenPhoneL(); |
|
416 |
|
417 RPacketService packetService; |
|
418 OpenPacketServiceL(packetService); |
|
419 CleanupClosePushL(packetService); |
|
420 |
|
421 // Open new context |
|
422 TInfoName contextId; |
|
423 RPacketMbmsContext packetContext; |
|
424 packetContext.OpenNewContext(packetService, contextId); |
|
425 CleanupClosePushL(packetContext); |
|
426 |
|
427 // Open second context |
|
428 TInfoName contextId2; |
|
429 RPacketMbmsContext packetContext2; |
|
430 packetContext2.OpenNewContext(packetService, contextId2); |
|
431 CleanupClosePushL(packetContext2); |
|
432 |
|
433 //------------------------------------------------------------------------- |
|
434 // Test A: Test multiple clients requesting RPacketMbmsContext::InitialiseContext |
|
435 //------------------------------------------------------------------------- |
|
436 |
|
437 // for the first request |
|
438 RBuf8 expectData; |
|
439 CleanupClosePushL(expectData); |
|
440 |
|
441 TMockLtsyData1<TInfoName> ltsyExpect(contextId); |
|
442 ltsyExpect.SerialiseL(expectData); |
|
443 iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, expectData); |
|
444 |
|
445 RBuf8 data; |
|
446 CleanupClosePushL(data); |
|
447 |
|
448 RPacketContext::TDataChannelV2 dataCh; |
|
449 TMockLtsyData2<TInfoName, RPacketContext::TDataChannelV2> ltsyData(contextId, dataCh); |
|
450 ltsyData.SerialiseL(data); |
|
451 iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrNone, data); |
|
452 |
|
453 // for the first request |
|
454 RBuf8 expectData2; |
|
455 CleanupClosePushL(expectData2); |
|
456 |
|
457 TMockLtsyData1<TInfoName> ltsyExpect2(contextId2); |
|
458 ltsyExpect2.SerialiseL(expectData2); |
|
459 iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, expectData2); |
|
460 |
|
461 RBuf8 data2; |
|
462 CleanupClosePushL(data2); |
|
463 |
|
464 RPacketContext::TDataChannelV2 dataCh2; |
|
465 TMockLtsyData2<TInfoName, RPacketContext::TDataChannelV2> ltsyData2(contextId2, dataCh2); |
|
466 ltsyData2.SerialiseL(data2); |
|
467 iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrNone, data2); |
|
468 |
|
469 //first request |
|
470 TRequestStatus requestStatus; |
|
471 RPacketContext::TDataChannelV2 dataChannel1; |
|
472 TPckg<RPacketContext::TDataChannelV2> pckgInit1(dataChannel1); |
|
473 packetContext.InitialiseContext(requestStatus, pckgInit1); |
|
474 |
|
475 //second request |
|
476 TRequestStatus requestStatus2; |
|
477 RPacketContext::TDataChannelV2 dataChannel2; |
|
478 TPckg<RPacketContext::TDataChannelV2> pckgInit2(dataChannel2); |
|
479 packetContext2.InitialiseContext(requestStatus2, pckgInit2); |
|
480 |
|
481 User::WaitForRequest(requestStatus); |
|
482 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
483 |
|
484 User::WaitForRequest(requestStatus2); |
|
485 ASSERT_EQUALS(KErrNone, requestStatus2.Int()); |
|
486 |
|
487 AssertMockLtsyStatusL(); |
|
488 CleanupStack::PopAndDestroy(8, this); //packetContext2, packetContext, packetService, expectData, expectData2, data, data2, this |
|
489 |
|
490 } |
|
491 |
|
492 /** |
|
493 @SYMTestCaseID BA-CTSY-MCF-PIC-0005 |
|
494 @SYMComponent telephony_ctsy |
|
495 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::InitialiseContext with timeout |
|
496 @SYMTestPriority High |
|
497 @SYMTestActions Invokes RPacketMbmsContext::InitialiseContext and tests for timeout |
|
498 @SYMTestExpectedResults Pass |
|
499 @SYMTestType CT |
|
500 */ |
|
501 void CCTsyMbmsContextFU::TestInitialiseContext0005L() |
|
502 { |
|
503 |
|
504 OpenEtelServerL(EUseExtendedError); |
|
505 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
506 OpenPhoneL(); |
|
507 |
|
508 RPacketService packetService; |
|
509 OpenPacketServiceL(packetService); |
|
510 CleanupClosePushL(packetService); |
|
511 |
|
512 // Open new context |
|
513 TInfoName contextId; |
|
514 RPacketMbmsContext packetMbmsContext; |
|
515 packetMbmsContext.OpenNewContext(packetService, contextId); |
|
516 CleanupClosePushL(packetMbmsContext); |
|
517 |
|
518 RBuf8 expectData; |
|
519 CleanupClosePushL(expectData); |
|
520 |
|
521 //------------------------------------------------------------------------- |
|
522 // Test A: Test timeout of RPacketContext::InitialiseContext |
|
523 //------------------------------------------------------------------------- |
|
524 TMockLtsyData1<TInfoName> ltsyExpect(contextId); |
|
525 ltsyExpect.SerialiseL(expectData); |
|
526 |
|
527 iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, expectData); |
|
528 |
|
529 TRequestStatus requestStatus; |
|
530 RPacketContext::TDataChannelV2 dataCh; |
|
531 TPckg<RPacketContext::TDataChannelV2> pckgInit(dataCh); |
|
532 packetMbmsContext.InitialiseContext(requestStatus, pckgInit); |
|
533 |
|
534 User::WaitForRequest(requestStatus); |
|
535 ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); |
|
536 |
|
537 AssertMockLtsyStatusL(); |
|
538 CleanupStack::PopAndDestroy(4, this); //packetService, packetContext, expectData, this |
|
539 } |
|
540 |
|
541 /** |
|
542 @SYMTestCaseID BA-CTSY-MCF-PSC-0001 |
|
543 @SYMComponent telephony_ctsy |
|
544 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::SetConfig |
|
545 @SYMTestPriority High |
|
546 @SYMTestActions Invokes RPacketMbmsContext::SetConfig |
|
547 @SYMTestExpectedResults Pass |
|
548 @SYMTestType CT |
|
549 */ |
|
550 void CCTsyMbmsContextFU::TestSetConfig0001L() |
|
551 { |
|
552 |
|
553 OpenEtelServerL(EUseExtendedError); |
|
554 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
555 OpenPhoneL(); |
|
556 |
|
557 RBuf8 data; |
|
558 CleanupClosePushL(data); |
|
559 |
|
560 RBuf8 expectData; |
|
561 CleanupClosePushL(expectData); |
|
562 |
|
563 RPacketService packetService; |
|
564 OpenPacketServiceL(packetService); |
|
565 CleanupClosePushL(packetService); |
|
566 |
|
567 TInfoName contextId; |
|
568 RPacketMbmsContext mbmsContext; |
|
569 mbmsContext.OpenNewContext(packetService, contextId); |
|
570 CleanupClosePushL(mbmsContext); |
|
571 |
|
572 // initialisation of the context |
|
573 TInt status = InitMbmsContextL(mbmsContext, contextId); |
|
574 ASSERT_EQUALS(KErrNone, status); |
|
575 |
|
576 // data for SetContext |
|
577 RPacketMbmsContext::TContextConfigMbmsV1 setConfig; |
|
578 TTmgi ttmgi; |
|
579 ttmgi.SetServiceId(KMmConfigTMGI1); |
|
580 ttmgi.SetMCC(KMmConfigTmgiMMC1); |
|
581 ttmgi.SetMNC(KMmConfigTmgiMNC1); |
|
582 setConfig.iTmgi = ttmgi; |
|
583 setConfig.iMbmsAccessBearer = E2GBearer; |
|
584 setConfig.iMbmsServicePriority = EMbmsMediumServicePriority; |
|
585 setConfig.iMbmsServiceMode = KBroadcast; |
|
586 setConfig.iMbmsSessionFlag = EFalse; |
|
587 |
|
588 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig(setConfig); |
|
589 |
|
590 |
|
591 //------------------------------------------------------------------------- |
|
592 // TEST A: failure to dispatch request to LTSY |
|
593 //------------------------------------------------------------------------- |
|
594 TMockLtsyData2<RPacketMbmsContext::TContextConfigMbmsV1, TInfoName > expExpect(setConfig, contextId); |
|
595 expExpect.SerialiseL(expectData); |
|
596 iMockLTSY.ExpectL(EPacketContextSetConfig, expectData, KErrNotSupported); |
|
597 |
|
598 TRequestStatus requestStatus; |
|
599 mbmsContext.SetConfig(requestStatus, pckgConfig); |
|
600 User::WaitForRequest(requestStatus); |
|
601 |
|
602 ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); |
|
603 AssertMockLtsyStatusL(); |
|
604 |
|
605 //------------------------------------------------------------------------- |
|
606 // TEST B: failure on completion of pending request from LTSY->CTSY |
|
607 //------------------------------------------------------------------------- |
|
608 iMockLTSY.ExpectL(EPacketContextSetConfig, expectData); |
|
609 |
|
610 TMockLtsyData1<TInfoName > contexName(contextId); |
|
611 contexName.SerialiseL(data); |
|
612 iMockLTSY.CompleteL(EPacketContextSetConfig, KErrGeneral, data); |
|
613 |
|
614 mbmsContext.SetConfig(requestStatus, pckgConfig); |
|
615 User::WaitForRequest(requestStatus); |
|
616 |
|
617 ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); |
|
618 AssertMockLtsyStatusL(); |
|
619 |
|
620 //------------------------------------------------------------------------- |
|
621 // TEST C: Successful completion request of |
|
622 // RPacketContext::SetConfig when result is not cached. |
|
623 //------------------------------------------------------------------------- |
|
624 iMockLTSY.ExpectL(EPacketContextSetConfig, expectData); |
|
625 iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data); |
|
626 |
|
627 mbmsContext.SetConfig(requestStatus, pckgConfig); |
|
628 User::WaitForRequest(requestStatus); |
|
629 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
630 |
|
631 RPacketMbmsContext::TContextConfigMbmsV1 retData = pckgConfig(); |
|
632 ASSERT_EQUALS(setConfig.iMbmsAccessBearer, retData.iMbmsAccessBearer); |
|
633 ASSERT_EQUALS(setConfig.iMbmsServicePriority, retData.iMbmsServicePriority); |
|
634 ASSERT_EQUALS(setConfig.iMbmsServiceMode, retData.iMbmsServiceMode); |
|
635 ASSERT_EQUALS(setConfig.iMbmsSessionFlag, retData.iMbmsSessionFlag); |
|
636 |
|
637 AssertMockLtsyStatusL(); |
|
638 |
|
639 //-------------------------------------------- |
|
640 // failure to dispatch request for config |
|
641 //-------------------------------------------- |
|
642 iMockLTSY.ExpectL(EPacketContextSetConfig, expectData, KErrNotSupported); |
|
643 |
|
644 mbmsContext.SetConfig(requestStatus, pckgConfig); |
|
645 User::WaitForRequest(requestStatus); |
|
646 ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); |
|
647 |
|
648 AssertMockLtsyStatusL(); |
|
649 //------------------------------------------------------------------------- |
|
650 // TEST E: Unsolicited completion of RPacketContext::SetConfig |
|
651 // from LTSY. |
|
652 //------------------------------------------------------------------------- |
|
653 TRequestStatus mockLtsyStatus; |
|
654 |
|
655 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
656 iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data); |
|
657 User::WaitForRequest(mockLtsyStatus); |
|
658 |
|
659 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
660 AssertMockLtsyStatusL(); |
|
661 |
|
662 CleanupStack::PopAndDestroy(2); //packetContext, packetService |
|
663 CleanupStack::PopAndDestroy(3, this); // data, expectData, this |
|
664 } |
|
665 |
|
666 /** |
|
667 @SYMTestCaseID BA-CTSY-MCF-PSC-0002 |
|
668 @SYMComponent telephony_ctsy |
|
669 @SYMTestCaseDesc Test support in CTSY for cancelling of RPacketMbmsContext::SetConfig |
|
670 @SYMTestPriority High |
|
671 @SYMTestActions Invokes cancelling of RPacketMbmsContext::SetConfig |
|
672 @SYMTestExpectedResults Pass |
|
673 @SYMTestType CT |
|
674 */ |
|
675 void CCTsyMbmsContextFU::TestSetConfig0002L() |
|
676 { |
|
677 |
|
678 OpenEtelServerL(EUseExtendedError); |
|
679 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
680 OpenPhoneL(); |
|
681 |
|
682 RBuf8 data; |
|
683 CleanupClosePushL(data); |
|
684 |
|
685 RBuf8 expectData; |
|
686 CleanupClosePushL(expectData); |
|
687 |
|
688 RPacketService packetService; |
|
689 OpenPacketServiceL(packetService); |
|
690 CleanupClosePushL(packetService); |
|
691 |
|
692 TInfoName contextId; |
|
693 RPacketMbmsContext mbmsContext; |
|
694 mbmsContext.OpenNewContext(packetService, contextId); |
|
695 CleanupClosePushL(mbmsContext); |
|
696 |
|
697 // initialisation of the context |
|
698 TInt status = InitMbmsContextL(mbmsContext, contextId); |
|
699 ASSERT_EQUALS(KErrNone, status); |
|
700 |
|
701 TRequestStatus requestStatus; |
|
702 RPacketMbmsContext::TContextConfigMbmsV1 setConfig; |
|
703 |
|
704 //------------------------------------------------------------------------- |
|
705 // TEST C: Cancel completion request of |
|
706 // RPacketContext::SetConfig when result is not cached. |
|
707 //------------------------------------------------------------------------- |
|
708 TMockLtsyData2<RPacketMbmsContext::TContextConfigMbmsV1, TInfoName > expExpect(setConfig, contextId); |
|
709 expExpect.SerialiseL(expectData); |
|
710 iMockLTSY.ExpectL(EPacketContextSetConfig, expectData); |
|
711 |
|
712 // TODO : KHURAM FIX |
|
713 //data for CompleteL |
|
714 TMockLtsyData1<TInfoName > contexName(contextId); |
|
715 contexName.SerialiseL(data); |
|
716 iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data, 10); |
|
717 |
|
718 |
|
719 // data for SetContext |
|
720 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig(setConfig); |
|
721 mbmsContext.SetConfig(requestStatus, pckgConfig); |
|
722 mbmsContext.CancelAsyncRequest(EPacketContextSetConfig); |
|
723 User::WaitForRequest(requestStatus); |
|
724 |
|
725 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
726 AssertMockLtsyStatusL(); |
|
727 |
|
728 CleanupStack::PopAndDestroy(2); //packetContext, packetService |
|
729 CleanupStack::PopAndDestroy(3, this); // data, expectData, this |
|
730 } |
|
731 |
|
732 |
|
733 /** |
|
734 @SYMTestCaseID BA-CTSY-MCF-PSC-0003 |
|
735 @SYMComponent telephony_ctsy |
|
736 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::SetConfig with bad parameter data |
|
737 @SYMTestPriority High |
|
738 @SYMTestActions Invokes RPacketMbmsContext::SetConfig with bad parameter data |
|
739 @SYMTestExpectedResults Pass |
|
740 @SYMTestType CT |
|
741 */ |
|
742 void CCTsyMbmsContextFU::TestSetConfig0003L() |
|
743 { |
|
744 |
|
745 OpenEtelServerL(EUseExtendedError); |
|
746 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
747 OpenPhoneL(); |
|
748 |
|
749 RBuf8 data; |
|
750 CleanupClosePushL(data); |
|
751 |
|
752 RPacketService packetService; |
|
753 OpenPacketServiceL(packetService); |
|
754 CleanupClosePushL(packetService); |
|
755 |
|
756 TInfoName contextId; |
|
757 TInfoName hostCid; |
|
758 RPacketMbmsContext mbmsContext; |
|
759 mbmsContext.OpenNewContext(packetService, contextId); |
|
760 CleanupClosePushL(mbmsContext); |
|
761 |
|
762 TRequestStatus requestStatus; |
|
763 |
|
764 //------------------------------------------------ |
|
765 //set config for context that was not initialised |
|
766 //------------------------------------------------ |
|
767 |
|
768 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
769 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig(contextConfig); |
|
770 |
|
771 mbmsContext.SetConfig(requestStatus, pckgConfig); |
|
772 |
|
773 User::WaitForRequest(requestStatus); |
|
774 |
|
775 ASSERT_EQUALS(KErrNotReady, requestStatus.Int()); |
|
776 AssertMockLtsyStatusL(); |
|
777 |
|
778 CleanupStack::PopAndDestroy(2); //packetContext packetService |
|
779 CleanupStack::PopAndDestroy(2, this); // data, this |
|
780 |
|
781 } |
|
782 |
|
783 /** |
|
784 @SYMTestCaseID BA-CTSY-MCF-PSC-0004 |
|
785 @SYMComponent telephony_ctsy |
|
786 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketMbmsContext::SetConfig |
|
787 @SYMTestPriority High |
|
788 @SYMTestActions Invokes multiple client requests to RPacketMbmsContext::SetConfig |
|
789 @SYMTestExpectedResults Pass |
|
790 @SYMTestType CT |
|
791 */ |
|
792 void CCTsyMbmsContextFU::TestSetConfig0004L() |
|
793 { |
|
794 OpenEtelServerL(EUseExtendedError); |
|
795 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
796 OpenPhoneL(); |
|
797 |
|
798 RBuf8 data; |
|
799 CleanupClosePushL(data); |
|
800 |
|
801 RBuf8 data2; |
|
802 CleanupClosePushL(data2); |
|
803 |
|
804 RBuf8 expectData; |
|
805 CleanupClosePushL(expectData); |
|
806 |
|
807 RBuf8 expectData2; |
|
808 CleanupClosePushL(expectData2); |
|
809 |
|
810 // Open second client |
|
811 RTelServer telServer2; |
|
812 TInt ret = telServer2.Connect(); |
|
813 ASSERT_EQUALS(KErrNone, ret); |
|
814 CleanupClosePushL(telServer2); |
|
815 |
|
816 RMobilePhone phone2; |
|
817 ret = phone2.Open(telServer2,KMmTsyPhoneName); |
|
818 ASSERT_EQUALS(KErrNone, ret); |
|
819 CleanupClosePushL(phone2); |
|
820 |
|
821 |
|
822 RPacketService packetService; |
|
823 OpenPacketServiceL(packetService); |
|
824 CleanupClosePushL(packetService); |
|
825 |
|
826 RPacketService packetService2; |
|
827 ret = packetService2.Open(phone2); |
|
828 ASSERT_EQUALS(KErrNone, ret); |
|
829 CleanupClosePushL(packetService2); |
|
830 |
|
831 // Open first context |
|
832 TInfoName contextId; |
|
833 TInfoName hostCid; |
|
834 RPacketMbmsContext mbmsContext; |
|
835 mbmsContext.OpenNewContext(packetService, contextId); |
|
836 CleanupClosePushL(mbmsContext); |
|
837 |
|
838 // Open second context |
|
839 TInfoName contextId2; |
|
840 RPacketMbmsContext mbmsContext2; |
|
841 mbmsContext2.OpenNewContext(packetService2, contextId2); |
|
842 CleanupClosePushL(mbmsContext2); |
|
843 |
|
844 |
|
845 // initialisation of the first context |
|
846 TInt status = InitMbmsContextL(mbmsContext, contextId); |
|
847 ASSERT_EQUALS(KErrNone, status); |
|
848 |
|
849 // initialisation of the second context |
|
850 status = InitMbmsContextL(mbmsContext2, contextId2); |
|
851 ASSERT_EQUALS(KErrNone, status); |
|
852 |
|
853 TRequestStatus mockLtsyStatus; |
|
854 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
855 |
|
856 //------------------------------------------------------------------------- |
|
857 // Test A: Test multiple clients requesting RPacketContext::SetConfig |
|
858 //------------------------------------------------------------------------- |
|
859 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
860 TTmgi ttmgi; |
|
861 ttmgi.SetServiceId(KMmConfigTMGI1); |
|
862 ttmgi.SetMCC(KMmConfigTmgiMMC1); |
|
863 ttmgi.SetMCC(KMmConfigTmgiMNC1); |
|
864 contextConfig.iTmgi = ttmgi; |
|
865 contextConfig.iMbmsAccessBearer = E2GBearer; |
|
866 contextConfig.iMbmsServicePriority = EMbmsMediumServicePriority; |
|
867 contextConfig.iMbmsServiceMode = KBroadcast; |
|
868 contextConfig.iMbmsSessionFlag = EFalse; |
|
869 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig(contextConfig); |
|
870 // for the first ExpectL |
|
871 TMockLtsyData2<RPacketMbmsContext::TContextConfigMbmsV1, TInfoName > expExpect(contextConfig, contextId); |
|
872 expExpect.SerialiseL(expectData); |
|
873 |
|
874 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig2; |
|
875 TTmgi ttmgi2; |
|
876 ttmgi2.SetServiceId(KMmConfigTMGI2); |
|
877 ttmgi2.SetMCC(KMmConfigTmgiMMC2); |
|
878 ttmgi2.SetMCC(KMmConfigTmgiMNC2); |
|
879 contextConfig2.iTmgi = ttmgi; |
|
880 contextConfig2.iMbmsAccessBearer = E3GBearer; |
|
881 contextConfig2.iMbmsServicePriority = EMbmsHighServicePriority; |
|
882 contextConfig2.iMbmsServiceMode = KSelectedBroadcast; |
|
883 contextConfig2.iMbmsSessionFlag = ETrue; |
|
884 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig2(contextConfig2); |
|
885 // for the second ExpectL |
|
886 TMockLtsyData2<RPacketMbmsContext::TContextConfigMbmsV1, TInfoName > expExpect2(contextConfig2, contextId2); |
|
887 expExpect2.SerialiseL(expectData2); |
|
888 |
|
889 // for the first CompleteL |
|
890 TMockLtsyData1< TInfoName > ltsyData(contextId); |
|
891 ltsyData.SerialiseL(data); |
|
892 |
|
893 // for the second CompleteL |
|
894 TMockLtsyData1< TInfoName > ltsyData2(contextId2); |
|
895 ltsyData2.SerialiseL(data2); |
|
896 |
|
897 TRequestStatus requestStatus; |
|
898 iMockLTSY.ExpectL(EPacketContextSetConfig, expectData); |
|
899 iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data, 10); |
|
900 |
|
901 TRequestStatus requestStatus2; |
|
902 iMockLTSY.ExpectL(EPacketContextSetConfig, expectData2); |
|
903 iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, data2, 10); |
|
904 |
|
905 mbmsContext.SetConfig(requestStatus, pckgConfig); |
|
906 mbmsContext2.SetConfig(requestStatus2, pckgConfig2); |
|
907 |
|
908 User::WaitForRequest(requestStatus); |
|
909 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
910 User::WaitForRequest(requestStatus2); |
|
911 ASSERT_EQUALS(KErrNone, requestStatus2.Int()); |
|
912 |
|
913 RPacketMbmsContext::TContextConfigMbmsV1 ret1 = pckgConfig(); |
|
914 RPacketMbmsContext::TContextConfigMbmsV1 ret2 = pckgConfig2(); |
|
915 |
|
916 ASSERT_EQUALS(ret1.iMbmsAccessBearer, contextConfig.iMbmsAccessBearer); |
|
917 ASSERT_EQUALS(ret1.iMbmsServicePriority, contextConfig.iMbmsServicePriority); |
|
918 ASSERT_EQUALS(ret1.iMbmsServiceMode, contextConfig.iMbmsServiceMode); |
|
919 ASSERT_EQUALS(ret1.iMbmsSessionFlag, contextConfig.iMbmsSessionFlag); |
|
920 |
|
921 ASSERT_EQUALS(ret2.iMbmsAccessBearer, contextConfig2.iMbmsAccessBearer); |
|
922 ASSERT_EQUALS(ret2.iMbmsServicePriority, contextConfig2.iMbmsServicePriority); |
|
923 ASSERT_EQUALS(ret2.iMbmsServiceMode, contextConfig2.iMbmsServiceMode); |
|
924 ASSERT_EQUALS(ret2.iMbmsSessionFlag, contextConfig2.iMbmsSessionFlag); |
|
925 |
|
926 User::WaitForRequest(mockLtsyStatus); |
|
927 |
|
928 // packetContext, packetService, packetContext2, packetService2 |
|
929 //one2, telServer2, data2, |
|
930 CleanupStack::PopAndDestroy(2); //expectData2, expectData |
|
931 CleanupStack::PopAndDestroy(9, this); // data, this |
|
932 } |
|
933 |
|
934 /** |
|
935 @SYMTestCaseID BA-CTSY-MCF-PSC-0005 |
|
936 @SYMComponent telephony_ctsy |
|
937 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::SetConfig with timeout |
|
938 @SYMTestPriority High |
|
939 @SYMTestActions Invokes RPacketMbmsContext::SetConfig and tests for timeout |
|
940 @SYMTestExpectedResults Pass |
|
941 @SYMTestType CT |
|
942 */ |
|
943 void CCTsyMbmsContextFU::TestSetConfig0005L() |
|
944 { |
|
945 |
|
946 OpenEtelServerL(EUseExtendedError); |
|
947 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
948 OpenPhoneL(); |
|
949 |
|
950 RBuf8 data; |
|
951 CleanupClosePushL(data); |
|
952 |
|
953 RBuf8 expectData; |
|
954 CleanupClosePushL(expectData); |
|
955 |
|
956 //------------------------------------------------------------------------- |
|
957 // Test A: Test timeout of RPacketContext::SetConfig |
|
958 //------------------------------------------------------------------------- |
|
959 |
|
960 RPacketService packetService; |
|
961 OpenPacketServiceL(packetService); |
|
962 CleanupClosePushL(packetService); |
|
963 |
|
964 TInfoName contextId; |
|
965 RPacketMbmsContext mbmsContext; |
|
966 mbmsContext.OpenNewContext(packetService, contextId); |
|
967 CleanupClosePushL(mbmsContext); |
|
968 |
|
969 // initialisation of the first context |
|
970 TInt status = InitMbmsContextL(mbmsContext, contextId); |
|
971 ASSERT_EQUALS(KErrNone, status); |
|
972 |
|
973 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
974 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig(contextConfig); |
|
975 TMockLtsyData2<RPacketMbmsContext::TContextConfigMbmsV1, TInfoName > expExpect(contextConfig, contextId); |
|
976 expExpect.SerialiseL(expectData); |
|
977 |
|
978 TRequestStatus requestStatus; |
|
979 |
|
980 TMockLtsyData1<TInfoName > contexName(contextId); |
|
981 contexName.SerialiseL(data); |
|
982 |
|
983 iMockLTSY.ExpectL(EPacketContextSetConfig, expectData); |
|
984 |
|
985 mbmsContext.SetConfig(requestStatus, pckgConfig); |
|
986 |
|
987 User::WaitForRequest(requestStatus); |
|
988 |
|
989 ASSERT_EQUALS(KErrTimedOut, requestStatus.Int()); |
|
990 AssertMockLtsyStatusL(); |
|
991 |
|
992 |
|
993 CleanupStack::PopAndDestroy(2); //packetContext packetService, |
|
994 CleanupStack::PopAndDestroy(3, this); // data, expectData, this |
|
995 } |
|
996 |
|
997 /** |
|
998 @SYMTestCaseID BA-CTSY-MCF-PA-0001 |
|
999 @SYMComponent telephony_ctsy |
|
1000 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::Activate |
|
1001 @SYMTestPriority High |
|
1002 @SYMTestActions Invokes RPacketMbmsContext::Activate |
|
1003 @SYMTestExpectedResults Pass |
|
1004 @SYMTestType CT |
|
1005 */ |
|
1006 void CCTsyMbmsContextFU::TestActivate0001L() |
|
1007 { |
|
1008 OpenEtelServerL( EUseExtendedError ); |
|
1009 CleanupStack::PushL( TCleanupItem( Cleanup, this ) ); |
|
1010 OpenPhoneL(); |
|
1011 |
|
1012 RBuf8 data; |
|
1013 CleanupClosePushL( data ); |
|
1014 |
|
1015 RBuf8 data2; |
|
1016 CleanupClosePushL( data2 ); |
|
1017 |
|
1018 RBuf8 expectData; |
|
1019 CleanupClosePushL( expectData ); |
|
1020 |
|
1021 RBuf8 expectData2; |
|
1022 CleanupClosePushL( expectData2 ); |
|
1023 |
|
1024 RPacketService packetService; |
|
1025 OpenPacketServiceL( packetService ); |
|
1026 CleanupClosePushL( packetService ); |
|
1027 |
|
1028 //------------------------------------------------------------------------- |
|
1029 // TEST create |
|
1030 //------------------------------------------------------------------------- |
|
1031 |
|
1032 TInfoName contextId; |
|
1033 RPacketMbmsContext packetMbmsContext; |
|
1034 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
1035 CleanupClosePushL( packetMbmsContext ); |
|
1036 |
|
1037 TRequestStatus requestStatus; |
|
1038 |
|
1039 //------------------------------------------------------------------------- |
|
1040 // TEST initialise |
|
1041 //------------------------------------------------------------------------- |
|
1042 |
|
1043 // initialisation of the context |
|
1044 TInt status = InitMbmsContextL( packetMbmsContext, contextId ); |
|
1045 ASSERT_EQUALS( KErrNone, status ); |
|
1046 |
|
1047 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
1048 status = SetMbmsConfigL(packetMbmsContext, contextId, contextConfig); |
|
1049 |
|
1050 TMockLtsyData1 <TInfoName> expData(contextId); |
|
1051 expData.SerialiseL(expectData); |
|
1052 |
|
1053 |
|
1054 TMockLtsyData2< TInfoName, RPacketMbmsContext::TContextConfigMbmsV1 > ltsyData1(contextId, contextConfig); |
|
1055 ltsyData1.SerialiseL(data); |
|
1056 |
|
1057 //------------------------------------------------------------------------- |
|
1058 // TEST A: failure to dispatch request to LTSY |
|
1059 //------------------------------------------------------------------------- |
|
1060 |
|
1061 iMockLTSY.ExpectL(EPacketContextActivate, expectData, KErrNotSupported); |
|
1062 |
|
1063 packetMbmsContext.Activate(requestStatus); |
|
1064 User::WaitForRequest(requestStatus); |
|
1065 AssertMockLtsyStatusL(); |
|
1066 ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); |
|
1067 |
|
1068 //------------------------------------------------------------------------- |
|
1069 // TEST B: failure on completion of pending request from LTSY->CTSY |
|
1070 //------------------------------------------------------------------------- |
|
1071 TMockLtsyData1 <TInfoName> expData2(contextId); |
|
1072 expData2.SerialiseL(expectData2); |
|
1073 |
|
1074 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig2; |
|
1075 TMockLtsyData2< TInfoName, RPacketMbmsContext::TContextConfigMbmsV1 > ltsyData2(contextId, contextConfig2); |
|
1076 ltsyData2.SerialiseL(data2); |
|
1077 |
|
1078 iMockLTSY.ExpectL(EPacketContextActivate, expectData2); |
|
1079 iMockLTSY.CompleteL(EPacketContextActivate, KErrGeneral, data2); |
|
1080 |
|
1081 packetMbmsContext.Activate(requestStatus); |
|
1082 User::WaitForRequest(requestStatus); |
|
1083 AssertMockLtsyStatusL(); |
|
1084 ASSERT_EQUALS(KErrGeneral, requestStatus.Int()); |
|
1085 |
|
1086 //------------------------------------------------------------------------- |
|
1087 // TEST C: Successful completion request of activate context |
|
1088 //------------------------------------------------------------------------- |
|
1089 iMockLTSY.ExpectL(EPacketContextActivate, expectData); |
|
1090 iMockLTSY.CompleteL(EPacketContextActivate, KErrNone, data); |
|
1091 |
|
1092 packetMbmsContext.Activate(requestStatus); |
|
1093 User::WaitForRequest(requestStatus); |
|
1094 AssertMockLtsyStatusL(); |
|
1095 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
1096 |
|
1097 //------------------------------------------------------------------------- |
|
1098 // TEST E: Unsolicited completion of RPacketContext::Activate |
|
1099 // from LTSY. |
|
1100 //------------------------------------------------------------------------- |
|
1101 |
|
1102 TRequestStatus mockLtsyStatus; |
|
1103 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
1104 |
|
1105 iMockLTSY.CompleteL(EPacketContextActivate, KErrNone, data); |
|
1106 User::WaitForRequest(mockLtsyStatus); |
|
1107 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
1108 AssertMockLtsyStatusL(); |
|
1109 |
|
1110 CleanupStack::PopAndDestroy( 4 ); // data, data2, expectData |
|
1111 CleanupStack::PopAndDestroy( 3, this ); // packetMbmsContext, packetService, this |
|
1112 } |
|
1113 |
|
1114 /** |
|
1115 @SYMTestCaseID BA-CTSY-MCF-PA-0002 |
|
1116 @SYMComponent telephony_ctsy |
|
1117 @SYMTestCaseDesc Test support in CTSY for cancelling of RPacketMbmsContext::Activate |
|
1118 @SYMTestPriority High |
|
1119 @SYMTestActions Invokes cancelling of RPacketMbmsContext::Activate |
|
1120 @SYMTestExpectedResults Pass |
|
1121 @SYMTestType CT |
|
1122 */ |
|
1123 void CCTsyMbmsContextFU::TestActivate0002L() |
|
1124 { |
|
1125 |
|
1126 OpenEtelServerL(EUseExtendedError); |
|
1127 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
1128 OpenPhoneL(); |
|
1129 |
|
1130 RBuf8 data; |
|
1131 CleanupClosePushL(data); |
|
1132 |
|
1133 RBuf8 expectData; |
|
1134 CleanupClosePushL(expectData); |
|
1135 |
|
1136 RPacketService packetService; |
|
1137 OpenPacketServiceL(packetService); |
|
1138 CleanupClosePushL(packetService); |
|
1139 |
|
1140 // Open new context |
|
1141 TInfoName contextId; |
|
1142 RPacketMbmsContext mbmsContext; |
|
1143 mbmsContext.OpenNewContext(packetService, contextId); |
|
1144 CleanupClosePushL(mbmsContext); |
|
1145 |
|
1146 // initialisation of the context |
|
1147 TInt status = InitMbmsContextL(mbmsContext, contextId); |
|
1148 ASSERT_EQUALS(KErrNone, status); |
|
1149 |
|
1150 // Configure context |
|
1151 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
1152 status = SetMbmsConfigL(mbmsContext, contextId, contextConfig); |
|
1153 |
|
1154 //------------------------------------------------------------------------- |
|
1155 // Test cancelling of RPacketContext::Activate |
|
1156 //------------------------------------------------------------------------- |
|
1157 TMockLtsyData1 <TInfoName> expData(contextId); |
|
1158 expData.SerialiseL(expectData); |
|
1159 |
|
1160 TRequestStatus requestStatus; |
|
1161 TMockLtsyData2< TInfoName, RPacketMbmsContext::TContextConfigMbmsV1 > ltsyData1(contextId, contextConfig); |
|
1162 ltsyData1.SerialiseL(data); |
|
1163 iMockLTSY.ExpectL(EPacketContextActivate, expectData); |
|
1164 iMockLTSY.CompleteL(EPacketContextActivate, KErrNone, data, 10); |
|
1165 |
|
1166 mbmsContext.Activate(requestStatus); |
|
1167 mbmsContext.CancelAsyncRequest(EPacketContextActivate); |
|
1168 |
|
1169 User::WaitForRequest(requestStatus); |
|
1170 AssertMockLtsyStatusL(); |
|
1171 // TSY has started a request and it is not possible to then cancel |
|
1172 // this request. The best thing for the TSY to do in this case is to |
|
1173 // proceed as though the Cancel never happened. |
|
1174 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
1175 |
|
1176 CleanupStack::PopAndDestroy(2); // packetContext, packetService |
|
1177 CleanupStack::PopAndDestroy(3); // this, expectData, data |
|
1178 } |
|
1179 |
|
1180 /** |
|
1181 @SYMTestCaseID BA-CTSY-MCF-PA-0003 |
|
1182 @SYMComponent telephony_ctsy |
|
1183 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::Activate with bad parameter data |
|
1184 @SYMTestPriority High |
|
1185 @SYMTestActions Invokes RPacketMbmsContext::Activate with bad parameter data |
|
1186 @SYMTestExpectedResults Pass |
|
1187 @SYMTestType CT |
|
1188 */ |
|
1189 void CCTsyMbmsContextFU::TestActivate0003L() |
|
1190 { |
|
1191 OpenEtelServerL( EUseExtendedError ); |
|
1192 CleanupStack::PushL(TCleanupItem( Cleanup, this ) ); |
|
1193 OpenPhoneL(); |
|
1194 |
|
1195 RPacketService packetService; |
|
1196 OpenPacketServiceL( packetService ); |
|
1197 CleanupClosePushL( packetService ); |
|
1198 |
|
1199 // Open new context |
|
1200 TInfoName contextId; |
|
1201 RPacketMbmsContext packetMbmsContext; |
|
1202 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
1203 CleanupClosePushL( packetMbmsContext ); |
|
1204 |
|
1205 // ----------------------------------------------------------------------- |
|
1206 // call Activate without initialisation of the context |
|
1207 // ----------------------------------------------------------------------- |
|
1208 |
|
1209 TRequestStatus requestStatus; |
|
1210 packetMbmsContext.Activate( requestStatus ); |
|
1211 User::WaitForRequest( requestStatus ); |
|
1212 AssertMockLtsyStatusL(); |
|
1213 ASSERT_EQUALS( KErrArgument, requestStatus.Int() ); |
|
1214 |
|
1215 CleanupStack::PopAndDestroy( 3, this ); //packetMbmsContext, packetService, this |
|
1216 |
|
1217 } |
|
1218 |
|
1219 /** |
|
1220 @SYMTestCaseID BA-CTSY-MCF-PA-0004 |
|
1221 @SYMComponent telephony_ctsy |
|
1222 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketMbmsContext::Activate |
|
1223 @SYMTestPriority High |
|
1224 @SYMTestActions Invokes multiple client requests to RPacketMbmsContext::Activate |
|
1225 @SYMTestExpectedResults Pass |
|
1226 @SYMTestType CT |
|
1227 */ |
|
1228 void CCTsyMbmsContextFU::TestActivate0004L() |
|
1229 { |
|
1230 OpenEtelServerL( EUseExtendedError ); |
|
1231 CleanupStack::PushL( TCleanupItem( Cleanup, this ) ); |
|
1232 OpenPhoneL(); |
|
1233 |
|
1234 RBuf8 data; |
|
1235 CleanupClosePushL( data ); |
|
1236 |
|
1237 RBuf8 expectData; |
|
1238 CleanupClosePushL( expectData ); |
|
1239 |
|
1240 RBuf8 data2; |
|
1241 CleanupClosePushL( data2 ); |
|
1242 |
|
1243 RBuf8 expectData2; |
|
1244 CleanupClosePushL( expectData2 ); |
|
1245 |
|
1246 // Open second client |
|
1247 RTelServer telServer2; |
|
1248 TInt ret = telServer2.Connect(); |
|
1249 ASSERT_EQUALS( KErrNone, ret ); |
|
1250 CleanupClosePushL( telServer2 ); |
|
1251 |
|
1252 RMobilePhone phone2; |
|
1253 ret = phone2.Open( telServer2, KMmTsyPhoneName ); |
|
1254 ASSERT_EQUALS( KErrNone, ret ); |
|
1255 CleanupClosePushL( phone2 ); |
|
1256 |
|
1257 // Open PacketService for the first client |
|
1258 RPacketService packetService; |
|
1259 OpenPacketServiceL( packetService ); |
|
1260 CleanupClosePushL( packetService ); |
|
1261 |
|
1262 // Open PacketService for the second client |
|
1263 RPacketService packetService2; |
|
1264 packetService2.Open( phone2 ); |
|
1265 CleanupClosePushL( packetService2 ); |
|
1266 |
|
1267 // Open first context |
|
1268 TInfoName contextId; |
|
1269 RPacketMbmsContext packetMbmsContext; |
|
1270 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
1271 CleanupClosePushL( packetMbmsContext ); |
|
1272 |
|
1273 // initialisation of the first context |
|
1274 TInt status = InitMbmsContextL( packetMbmsContext, contextId ); |
|
1275 ASSERT_EQUALS( KErrNone, status ); |
|
1276 AssertMockLtsyStatusL(); |
|
1277 |
|
1278 |
|
1279 // Configure context |
|
1280 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
1281 status = SetMbmsConfigL(packetMbmsContext, contextId, contextConfig); |
|
1282 ASSERT_EQUALS( KErrNone, status ); |
|
1283 AssertMockLtsyStatusL(); |
|
1284 |
|
1285 // Open second context |
|
1286 TInfoName contextId2; |
|
1287 RPacketMbmsContext packetMbmsContext2; |
|
1288 packetMbmsContext2.OpenNewContext( packetService2, contextId2 ); |
|
1289 CleanupClosePushL( packetMbmsContext2 ); |
|
1290 AssertMockLtsyStatusL(); |
|
1291 |
|
1292 // initialisation of the second context |
|
1293 status = InitMbmsContextL( packetMbmsContext2, contextId2 ); |
|
1294 ASSERT_EQUALS( KErrNone, status ); |
|
1295 AssertMockLtsyStatusL(); |
|
1296 |
|
1297 // Configure context2 |
|
1298 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig2; |
|
1299 status = SetMbmsConfigL(packetMbmsContext2, contextId2, contextConfig2); |
|
1300 ASSERT_EQUALS( KErrNone, status ); |
|
1301 AssertMockLtsyStatusL(); |
|
1302 //------------------------------------------------------------------------- |
|
1303 // Test A: Test multiple clients requesting RPacketMbmsContext::Activate |
|
1304 //------------------------------------------------------------------------- |
|
1305 |
|
1306 // data for ExpectL for first client |
|
1307 TMockLtsyData1 <TInfoName> expData( contextId ); |
|
1308 expData.SerialiseL( expectData ); |
|
1309 |
|
1310 // data for CompleteL for first client |
|
1311 TMockLtsyData2< TInfoName, RPacketMbmsContext::TContextConfigMbmsV1 > ltsyData1( contextId, contextConfig ); |
|
1312 ltsyData1.SerialiseL( data ); |
|
1313 |
|
1314 // data for ExpectL for second client |
|
1315 TMockLtsyData1 <TInfoName> expData2( contextId2 ); |
|
1316 expData2.SerialiseL( expectData2 ); |
|
1317 |
|
1318 // data for CompleteL for second client |
|
1319 TMockLtsyData2< TInfoName, RPacketMbmsContext::TContextConfigMbmsV1 > ltsyData2( contextId2, contextConfig2 ); |
|
1320 ltsyData2.SerialiseL( data2 ); |
|
1321 |
|
1322 // first request |
|
1323 TRequestStatus requestStatus; |
|
1324 iMockLTSY.ExpectL( EPacketContextActivate, expectData ); |
|
1325 iMockLTSY.CompleteL( EPacketContextActivate, KErrNone, data ); |
|
1326 packetMbmsContext.Activate( requestStatus ); |
|
1327 |
|
1328 // second request |
|
1329 TRequestStatus requestStatus2; |
|
1330 iMockLTSY.ExpectL( EPacketContextActivate, expectData2 ); |
|
1331 iMockLTSY.CompleteL( EPacketContextActivate, KErrNone, data2 ); |
|
1332 packetMbmsContext2.Activate( requestStatus2 ); |
|
1333 |
|
1334 // wait for first answer |
|
1335 User::WaitForRequest( requestStatus ); |
|
1336 ASSERT_EQUALS( KErrNone, requestStatus.Int() ); |
|
1337 |
|
1338 // wait for the second answer |
|
1339 User::WaitForRequest( requestStatus2 ); |
|
1340 AssertMockLtsyStatusL(); |
|
1341 ASSERT_EQUALS( KErrNone, requestStatus2.Int() ); |
|
1342 |
|
1343 CleanupStack::PopAndDestroy( 11, this ); // ... phone2, telServer2, expectData, data, this |
|
1344 } |
|
1345 |
|
1346 /** |
|
1347 @SYMTestCaseID BA-CTSY-MCF-PA-0005 |
|
1348 @SYMComponent telephony_ctsy |
|
1349 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::Activate with timeout |
|
1350 @SYMTestPriority High |
|
1351 @SYMTestActions Invokes RPacketMbmsContext::Activate and tests for timeout |
|
1352 @SYMTestExpectedResults Pass |
|
1353 @SYMTestType CT |
|
1354 */ |
|
1355 void CCTsyMbmsContextFU::TestActivate0005L() |
|
1356 { |
|
1357 OpenEtelServerL( EUseExtendedError ); |
|
1358 CleanupStack::PushL(TCleanupItem( Cleanup, this ) ); |
|
1359 OpenPhoneL(); |
|
1360 |
|
1361 RPacketService packetService; |
|
1362 OpenPacketServiceL( packetService ); |
|
1363 CleanupClosePushL( packetService ); |
|
1364 |
|
1365 RBuf8 data; |
|
1366 CleanupClosePushL( data ); |
|
1367 |
|
1368 RBuf8 expectData; |
|
1369 CleanupClosePushL( expectData ); |
|
1370 |
|
1371 // Open new context |
|
1372 TInfoName contextId; |
|
1373 RPacketMbmsContext packetMbmsContext; |
|
1374 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
1375 CleanupClosePushL( packetMbmsContext ); |
|
1376 |
|
1377 // initialisation of the context |
|
1378 TInt status = InitMbmsContextL( packetMbmsContext, contextId ); |
|
1379 ASSERT_EQUALS( KErrNone, status ); |
|
1380 |
|
1381 // Configure context |
|
1382 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
1383 status = SetMbmsConfigL(packetMbmsContext, contextId, contextConfig); |
|
1384 ASSERT_EQUALS( KErrNone, status ); |
|
1385 |
|
1386 //------------------------------------------------------------------------- |
|
1387 // Test A: Test timeout of RPacketMbmsContext::Activate |
|
1388 //------------------------------------------------------------------------- |
|
1389 TMockLtsyData1 <TInfoName> expData( contextId ); |
|
1390 expData.SerialiseL( expectData ); |
|
1391 |
|
1392 iMockLTSY.ExpectL( EPacketContextActivate, expectData ); |
|
1393 |
|
1394 TRequestStatus requestStatus; |
|
1395 packetMbmsContext.Activate( requestStatus ); |
|
1396 User::WaitForRequest( requestStatus ); |
|
1397 AssertMockLtsyStatusL(); |
|
1398 ASSERT_EQUALS( KErrTimedOut, requestStatus.Int() ); |
|
1399 |
|
1400 CleanupStack::PopAndDestroy( 5, this ); // data, expectData, packetMbmsContext, packetService, this |
|
1401 } |
|
1402 |
|
1403 /** |
|
1404 @SYMTestCaseID BA-CTSY-MCF-PD-0001 |
|
1405 @SYMComponent telephony_ctsy |
|
1406 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::Deactivate |
|
1407 @SYMTestPriority High |
|
1408 @SYMTestActions Invokes RPacketMbmsContext::Deactivate |
|
1409 @SYMTestExpectedResults Pass |
|
1410 @SYMTestType CT |
|
1411 */ |
|
1412 void CCTsyMbmsContextFU::TestDeactivate0001L() |
|
1413 { |
|
1414 OpenEtelServerL( EUseExtendedError ); |
|
1415 CleanupStack::PushL(TCleanupItem( Cleanup, this ) ); |
|
1416 OpenPhoneL(); |
|
1417 |
|
1418 RBuf8 data; |
|
1419 CleanupClosePushL( data ); |
|
1420 |
|
1421 RPacketService packetService; |
|
1422 OpenPacketServiceL( packetService ); |
|
1423 CleanupClosePushL( packetService ); |
|
1424 |
|
1425 // Open new context |
|
1426 TInfoName contextId; |
|
1427 RPacketMbmsContext packetMbmsContext; |
|
1428 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
1429 CleanupClosePushL( packetMbmsContext ); |
|
1430 |
|
1431 // initialisation of the context |
|
1432 TInt status = InitMbmsContextL(packetMbmsContext, contextId); |
|
1433 ASSERT_EQUALS(KErrNone, status); |
|
1434 |
|
1435 // Configure context |
|
1436 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
1437 status = SetMbmsConfigL(packetMbmsContext, contextId, contextConfig); |
|
1438 ASSERT_EQUALS( KErrNone, status ); |
|
1439 |
|
1440 // activate context |
|
1441 status = SetMbmsActiveL(packetMbmsContext, contextConfig, contextId); |
|
1442 ASSERT_EQUALS(KErrNone, status); |
|
1443 |
|
1444 //------------------------------------------------------------------------- |
|
1445 // TEST A: failure to dispatch request to LTSY |
|
1446 //------------------------------------------------------------------------- |
|
1447 |
|
1448 CFilteringActiveScheduler scheduler; |
|
1449 CActiveScheduler::Install(&scheduler); |
|
1450 |
|
1451 RPacketMbmsContext::CMbmsSession* aSession = RPacketMbmsContext::CMbmsSession::NewL(); |
|
1452 CleanupStack::PushL(aSession); |
|
1453 |
|
1454 CRetrievePcktMbmsSessionList* aSessionlist = CRetrievePcktMbmsSessionList::NewL(packetMbmsContext, *aSession); |
|
1455 CleanupStack::PushL(aSessionlist); |
|
1456 |
|
1457 CActiveRetriever::ResetRequestsNumber(); |
|
1458 CActiveRetriever retriever(*aSessionlist); |
|
1459 |
|
1460 scheduler.AddRetrieverL(retriever); |
|
1461 |
|
1462 aSessionlist->Start( retriever.Status() ); |
|
1463 retriever.Activate(); |
|
1464 scheduler.StartScheduler(); |
|
1465 |
|
1466 TMockLtsyData2 <TInfoName, RPacketMbmsContext::CMbmsSession*> ltsyData( contextId, aSession); |
|
1467 ltsyData.SerialiseL( data ); |
|
1468 iMockLTSY.ExpectL( EPacketContextDeactivate, data, KErrNotFound ); |
|
1469 |
|
1470 TRequestStatus requestStatus; |
|
1471 packetMbmsContext.Deactivate(requestStatus); |
|
1472 User::WaitForRequest( requestStatus ); |
|
1473 ASSERT_EQUALS( KErrNotFound, requestStatus.Int()); |
|
1474 |
|
1475 AssertMockLtsyStatusL(); |
|
1476 |
|
1477 //------------------------------------------------------------------------- |
|
1478 // TEST B: failure on completion of pending request from LTSY->CTSY |
|
1479 //------------------------------------------------------------------------- |
|
1480 |
|
1481 RBuf8 expectData; |
|
1482 CleanupClosePushL( expectData ); |
|
1483 |
|
1484 TMockLtsyData1 <TInfoName> ltsyData1( contextId); |
|
1485 ltsyData1.SerialiseL(expectData); |
|
1486 |
|
1487 iMockLTSY.ExpectL( EPacketContextDeactivate, data ); |
|
1488 iMockLTSY.CompleteL( EPacketContextDeactivate, KErrGeneral, expectData ); |
|
1489 |
|
1490 packetMbmsContext.Deactivate( requestStatus ); |
|
1491 User::WaitForRequest( requestStatus ); |
|
1492 AssertMockLtsyStatusL(); |
|
1493 ASSERT_EQUALS( KErrGeneral, requestStatus.Int() ); |
|
1494 |
|
1495 |
|
1496 iMockLTSY.ExpectL( EPacketContextDeactivate, data ); |
|
1497 iMockLTSY.CompleteL( EPacketContextDeactivate, KErrMbmsImpreciseServiceEntries, data ); |
|
1498 |
|
1499 packetMbmsContext.Deactivate( requestStatus ); |
|
1500 User::WaitForRequest( requestStatus ); |
|
1501 AssertMockLtsyStatusL(); |
|
1502 ASSERT_EQUALS( KErrMbmsImpreciseServiceEntries, requestStatus.Int() ); |
|
1503 |
|
1504 |
|
1505 |
|
1506 |
|
1507 //------------------------------------------------------------------------- |
|
1508 // TEST C: Successful completion request of |
|
1509 // RPacketMbmsContext::Deactivate when result is not cached. |
|
1510 //------------------------------------------------------------------------- |
|
1511 iMockLTSY.ExpectL( EPacketContextDeactivate, data ); |
|
1512 iMockLTSY.CompleteL( EPacketContextDeactivate, KErrNone, expectData ); |
|
1513 |
|
1514 packetMbmsContext.Deactivate( requestStatus ); |
|
1515 User::WaitForRequest( requestStatus ); |
|
1516 AssertMockLtsyStatusL(); |
|
1517 ASSERT_EQUALS( KErrNone, requestStatus.Int() ); |
|
1518 |
|
1519 //------------------------------------------------------------------------- |
|
1520 // TEST E: Unsolicited completion of RPacketMbmsContext::Deactivate |
|
1521 // from LTSY. |
|
1522 //------------------------------------------------------------------------- |
|
1523 TRequestStatus mockLtsyStatus; |
|
1524 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
1525 iMockLTSY.CompleteL( EPacketContextDeactivate, KErrNone, expectData ); |
|
1526 User::WaitForRequest( mockLtsyStatus ); |
|
1527 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
1528 |
|
1529 AssertMockLtsyStatusL(); |
|
1530 CleanupStack::PopAndDestroy( 4 ); // packetMbmsContext, packetService |
|
1531 CleanupStack::PopAndDestroy( 3, this ); // data, this |
|
1532 } |
|
1533 |
|
1534 /** |
|
1535 @SYMTestCaseID BA-CTSY-MCF-PD-0002 |
|
1536 @SYMComponent telephony_ctsy |
|
1537 @SYMTestCaseDesc Test support in CTSY for cancelling of RPacketMbmsContext::Deactivate |
|
1538 @SYMTestPriority High |
|
1539 @SYMTestActions Invokes cancelling of RPacketMbmsContext::Deactivate |
|
1540 @SYMTestExpectedResults Pass |
|
1541 @SYMTestType CT |
|
1542 */ |
|
1543 void CCTsyMbmsContextFU::TestDeactivate0002L() |
|
1544 { |
|
1545 // This test should test cancellation of Deactivate |
|
1546 OpenEtelServerL( EUseExtendedError ); |
|
1547 CleanupStack::PushL(TCleanupItem( Cleanup, this ) ); |
|
1548 OpenPhoneL(); |
|
1549 |
|
1550 RPacketService packetService; |
|
1551 OpenPacketServiceL( packetService ); |
|
1552 CleanupClosePushL( packetService ); |
|
1553 |
|
1554 // Open new context |
|
1555 TInfoName contextId; |
|
1556 RPacketMbmsContext packetMbmsContext; |
|
1557 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
1558 CleanupClosePushL( packetMbmsContext ); |
|
1559 |
|
1560 RBuf8 data; |
|
1561 CleanupClosePushL( data ); |
|
1562 |
|
1563 RBuf8 expectData; |
|
1564 CleanupClosePushL(expectData); |
|
1565 |
|
1566 // initialisation of the context |
|
1567 TInt status = InitMbmsContextL(packetMbmsContext, contextId); |
|
1568 ASSERT_EQUALS(KErrNone, status); |
|
1569 |
|
1570 |
|
1571 // Configure context |
|
1572 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
1573 status = SetMbmsConfigL(packetMbmsContext, contextId, contextConfig); |
|
1574 ASSERT_EQUALS( KErrNone, status ); |
|
1575 |
|
1576 // activate context |
|
1577 status = SetMbmsActiveL(packetMbmsContext, contextConfig, contextId); |
|
1578 ASSERT_EQUALS(KErrNone, status); |
|
1579 |
|
1580 //------------------------------------------------------------------------- |
|
1581 // Test cancelling of RPacketMbmsContext::Deactivate |
|
1582 //------------------------------------------------------------------------- |
|
1583 |
|
1584 CFilteringActiveScheduler scheduler; |
|
1585 CActiveScheduler::Install(&scheduler); |
|
1586 |
|
1587 RPacketMbmsContext::CMbmsSession* aSession = RPacketMbmsContext::CMbmsSession::NewL(); |
|
1588 CleanupStack::PushL(aSession); |
|
1589 |
|
1590 CRetrievePcktMbmsSessionList* aSessionlist = CRetrievePcktMbmsSessionList::NewL(packetMbmsContext, *aSession); |
|
1591 CleanupStack::PushL(aSessionlist); |
|
1592 |
|
1593 CActiveRetriever::ResetRequestsNumber(); |
|
1594 CActiveRetriever retriever(*aSessionlist); |
|
1595 |
|
1596 scheduler.AddRetrieverL(retriever); |
|
1597 |
|
1598 aSessionlist->Start( retriever.Status() ); |
|
1599 retriever.Activate(); |
|
1600 scheduler.StartScheduler(); |
|
1601 |
|
1602 |
|
1603 TMockLtsyData2 <TInfoName, RPacketMbmsContext::CMbmsSession* > ltsyData( contextId, aSession); |
|
1604 ltsyData.SerialiseL( data ); |
|
1605 |
|
1606 TMockLtsyData1 <TInfoName> ltsyData1(contextId); |
|
1607 ltsyData1.SerialiseL(expectData); |
|
1608 |
|
1609 iMockLTSY.ExpectL( EPacketContextDeactivate, data ); |
|
1610 iMockLTSY.CompleteL( EPacketContextDeactivate, KErrNone, expectData, 10 ); |
|
1611 |
|
1612 TRequestStatus requestStatus; |
|
1613 |
|
1614 packetMbmsContext.Deactivate( requestStatus ); |
|
1615 packetMbmsContext.CancelAsyncRequest( EPacketContextDeactivate ); |
|
1616 User::WaitForRequest( requestStatus ); |
|
1617 |
|
1618 // CTSY has started a request and it is not possible to then cancel |
|
1619 // this request. The best thing for the TSY to do in this case is to |
|
1620 // proceed as though the Cancel never happened. |
|
1621 ASSERT_EQUALS( KErrNone, requestStatus.Int() ); |
|
1622 |
|
1623 AssertMockLtsyStatusL(); |
|
1624 CleanupStack::PopAndDestroy( 4 ); // packetMbmsContext, packetService |
|
1625 CleanupStack::PopAndDestroy( 3 ); // data, this |
|
1626 } |
|
1627 |
|
1628 /** |
|
1629 @SYMTestCaseID BA-CTSY-MCF-PD-0004 |
|
1630 @SYMComponent telephony_ctsy |
|
1631 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketMbmsContext::Deactivate |
|
1632 @SYMTestPriority High |
|
1633 @SYMTestActions Invokes multiple client requests to RPacketMbmsContext::Deactivate |
|
1634 @SYMTestExpectedResults Pass |
|
1635 @SYMTestType CT |
|
1636 */ |
|
1637 void CCTsyMbmsContextFU::TestDeactivate0004L() |
|
1638 { |
|
1639 OpenEtelServerL( EUseExtendedError ); |
|
1640 CleanupStack::PushL(TCleanupItem( Cleanup, this ) ); |
|
1641 OpenPhoneL(); |
|
1642 |
|
1643 RBuf8 data; |
|
1644 CleanupClosePushL( data ); |
|
1645 |
|
1646 RBuf8 data2; |
|
1647 CleanupClosePushL( data2 ); |
|
1648 |
|
1649 RBuf8 expectData; |
|
1650 CleanupClosePushL( expectData ); |
|
1651 |
|
1652 RBuf8 expectData2; |
|
1653 CleanupClosePushL( expectData2 ); |
|
1654 |
|
1655 |
|
1656 // Open second client |
|
1657 RTelServer telServer2; |
|
1658 TInt ret = telServer2.Connect(); |
|
1659 ASSERT_EQUALS( KErrNone, ret ); |
|
1660 CleanupClosePushL( telServer2 ); |
|
1661 |
|
1662 RMobilePhone phone2; |
|
1663 ret = phone2.Open( iTelServer, KMmTsyPhoneName ); |
|
1664 ASSERT_EQUALS( KErrNone, ret ); |
|
1665 CleanupClosePushL( phone2 ); |
|
1666 |
|
1667 RPacketService packetService; |
|
1668 OpenPacketServiceL( packetService ); |
|
1669 CleanupClosePushL( packetService ); |
|
1670 |
|
1671 RPacketService packetService2; |
|
1672 ret = packetService2.Open( phone2 ); |
|
1673 ASSERT_EQUALS( KErrNone, ret ); |
|
1674 CleanupClosePushL( packetService2 ); |
|
1675 |
|
1676 // Open first context |
|
1677 TInfoName contextId; |
|
1678 RPacketMbmsContext packetMbmsContext; |
|
1679 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
1680 CleanupClosePushL( packetMbmsContext ); |
|
1681 |
|
1682 // Open second context |
|
1683 TInfoName contextId2; |
|
1684 RPacketMbmsContext packetMbmsContext2; |
|
1685 packetMbmsContext2.OpenNewContext( packetService2, contextId2 ); |
|
1686 CleanupClosePushL( packetMbmsContext2 ); |
|
1687 |
|
1688 TRequestStatus mockLtsyStatus; |
|
1689 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
1690 |
|
1691 //------------------------------------------------------------------------- |
|
1692 // Test A: Test multiple clients requesting RPacketMbmsContext::Deactivate |
|
1693 //------------------------------------------------------------------------- |
|
1694 |
|
1695 // initialisation of the context |
|
1696 TInt status = InitMbmsContextL(packetMbmsContext, contextId); |
|
1697 ASSERT_EQUALS(KErrNone, status); |
|
1698 |
|
1699 // initialisation of the context |
|
1700 status = InitMbmsContextL(packetMbmsContext2, contextId2); |
|
1701 ASSERT_EQUALS(KErrNone, status); |
|
1702 |
|
1703 |
|
1704 // Configure context |
|
1705 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
1706 status = SetMbmsConfigL(packetMbmsContext, contextId, contextConfig); |
|
1707 ASSERT_EQUALS( KErrNone, status ); |
|
1708 |
|
1709 status = SetMbmsConfigL(packetMbmsContext2, contextId2, contextConfig); |
|
1710 ASSERT_EQUALS( KErrNone, status ); |
|
1711 |
|
1712 // activate context |
|
1713 status = SetMbmsActiveL(packetMbmsContext, contextConfig, contextId); |
|
1714 ASSERT_EQUALS(KErrNone, status); |
|
1715 |
|
1716 status = SetMbmsActiveL(packetMbmsContext2, contextConfig, contextId2); |
|
1717 ASSERT_EQUALS(KErrNone, status); |
|
1718 |
|
1719 CFilteringActiveScheduler scheduler; |
|
1720 CActiveScheduler::Install(&scheduler); |
|
1721 |
|
1722 RPacketMbmsContext::CMbmsSession* aSession = RPacketMbmsContext::CMbmsSession::NewL(); |
|
1723 CleanupStack::PushL(aSession); |
|
1724 |
|
1725 CRetrievePcktMbmsSessionList* aSessionlist = CRetrievePcktMbmsSessionList::NewL(packetMbmsContext, *aSession); |
|
1726 CleanupStack::PushL(aSessionlist); |
|
1727 |
|
1728 CActiveRetriever::ResetRequestsNumber(); |
|
1729 CActiveRetriever retriever(*aSessionlist); |
|
1730 |
|
1731 scheduler.AddRetrieverL(retriever); |
|
1732 |
|
1733 aSessionlist->Start( retriever.Status() ); |
|
1734 retriever.Activate(); |
|
1735 scheduler.StartScheduler(); |
|
1736 TMockLtsyData2 <TInfoName, RPacketMbmsContext::CMbmsSession* > ltsyData( contextId, aSession); |
|
1737 ltsyData.SerialiseL( data ); |
|
1738 |
|
1739 |
|
1740 RPacketMbmsContext::CMbmsSession* aSession2 = RPacketMbmsContext::CMbmsSession::NewL(); |
|
1741 CleanupStack::PushL(aSession2); |
|
1742 |
|
1743 CRetrievePcktMbmsSessionList* aSessionlist2 = CRetrievePcktMbmsSessionList::NewL(packetMbmsContext2, *aSession2); |
|
1744 CleanupStack::PushL(aSessionlist2); |
|
1745 |
|
1746 CActiveRetriever::ResetRequestsNumber(); |
|
1747 CActiveRetriever retriever1(*aSessionlist2); |
|
1748 |
|
1749 scheduler.AddRetrieverL(retriever1); |
|
1750 |
|
1751 aSessionlist->Start( retriever1.Status() ); |
|
1752 retriever1.Activate(); |
|
1753 scheduler.StartScheduler(); |
|
1754 |
|
1755 TMockLtsyData2 <TInfoName, RPacketMbmsContext::CMbmsSession* > ltsyData2( contextId2, aSession2); |
|
1756 ltsyData2.SerialiseL( data2 ); |
|
1757 |
|
1758 iMockLTSY.ExpectL( EPacketContextDeactivate, data ); |
|
1759 |
|
1760 TMockLtsyData1 <TInfoName> ltsyData3(contextId); |
|
1761 ltsyData3.SerialiseL(expectData); |
|
1762 |
|
1763 iMockLTSY.CompleteL( EPacketContextDeactivate, KErrNone, expectData, 5 ); |
|
1764 |
|
1765 iMockLTSY.ExpectL( EPacketContextDeactivate, data2 ); |
|
1766 |
|
1767 TMockLtsyData1 <TInfoName> ltsyData4(contextId2); |
|
1768 ltsyData4.SerialiseL(expectData2); |
|
1769 |
|
1770 iMockLTSY.CompleteL( EPacketContextDeactivate, KErrNone, expectData2, 5 ); |
|
1771 |
|
1772 TRequestStatus requestStatus; |
|
1773 packetMbmsContext.Deactivate( requestStatus ); |
|
1774 |
|
1775 TRequestStatus requestStatus2; |
|
1776 packetMbmsContext2.Deactivate( requestStatus2 ); |
|
1777 |
|
1778 User::WaitForRequest( requestStatus ); |
|
1779 ASSERT_EQUALS(KErrNone, requestStatus.Int() ); |
|
1780 User::WaitForRequest( requestStatus2 ); |
|
1781 ASSERT_EQUALS( KErrNone, requestStatus2.Int() ); |
|
1782 |
|
1783 CleanupStack::PopAndDestroy(15, this); // phone2, telServer2, data, data2, this |
|
1784 } |
|
1785 |
|
1786 /** |
|
1787 @SYMTestCaseID BA-CTSY-MCF-PD-0005 |
|
1788 @SYMComponent telephony_ctsy |
|
1789 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::Deactivate with timeout |
|
1790 @SYMTestPriority High |
|
1791 @SYMTestActions Invokes RPacketMbmsContext::Deactivate and tests for timeout |
|
1792 @SYMTestExpectedResults Pass |
|
1793 @SYMTestType CT |
|
1794 */ |
|
1795 void CCTsyMbmsContextFU::TestDeactivate0005L() |
|
1796 { |
|
1797 OpenEtelServerL( EUseExtendedError ); |
|
1798 CleanupStack::PushL(TCleanupItem( Cleanup, this ) ); |
|
1799 OpenPhoneL(); |
|
1800 |
|
1801 RBuf8 data; |
|
1802 CleanupClosePushL( data ); |
|
1803 |
|
1804 RPacketService packetService; |
|
1805 OpenPacketServiceL( packetService ); |
|
1806 CleanupClosePushL( packetService ); |
|
1807 |
|
1808 // Open new context |
|
1809 TInfoName contextId; |
|
1810 RPacketMbmsContext packetMbmsContext; |
|
1811 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
1812 CleanupClosePushL( packetMbmsContext ); |
|
1813 |
|
1814 //------------------------------------------------------------------------- |
|
1815 // Test A: Test timeout of RPacketMbmsContext::Deactivate |
|
1816 //------------------------------------------------------------------------- |
|
1817 TRequestStatus requestStatus; |
|
1818 |
|
1819 CFilteringActiveScheduler scheduler; |
|
1820 CActiveScheduler::Install(&scheduler); |
|
1821 |
|
1822 RPacketMbmsContext::CMbmsSession* aSession = RPacketMbmsContext::CMbmsSession::NewL(); |
|
1823 CleanupStack::PushL(aSession); |
|
1824 |
|
1825 CRetrievePcktMbmsSessionList* aSessionlist = CRetrievePcktMbmsSessionList::NewL(packetMbmsContext, *aSession); |
|
1826 CleanupStack::PushL(aSessionlist); |
|
1827 |
|
1828 CActiveRetriever::ResetRequestsNumber(); |
|
1829 CActiveRetriever retriever(*aSessionlist); |
|
1830 |
|
1831 scheduler.AddRetrieverL(retriever); |
|
1832 |
|
1833 aSessionlist->Start( retriever.Status() ); |
|
1834 retriever.Activate(); |
|
1835 scheduler.StartScheduler(); |
|
1836 |
|
1837 TMockLtsyData2 <TInfoName, RPacketMbmsContext::CMbmsSession* > ltsyData( contextId, aSession); |
|
1838 ltsyData.SerialiseL( data ); |
|
1839 |
|
1840 // initialisation of the context |
|
1841 TInt status = InitMbmsContextL(packetMbmsContext, contextId); |
|
1842 ASSERT_EQUALS(KErrNone, status); |
|
1843 |
|
1844 // Configure context |
|
1845 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
1846 status = SetMbmsConfigL(packetMbmsContext, contextId, contextConfig); |
|
1847 ASSERT_EQUALS( KErrNone, status ); |
|
1848 |
|
1849 // activate context |
|
1850 status = SetMbmsActiveL(packetMbmsContext, contextConfig, contextId); |
|
1851 ASSERT_EQUALS(KErrNone, status); |
|
1852 |
|
1853 iMockLTSY.ExpectL( EPacketContextDeactivate, data ); |
|
1854 packetMbmsContext.Deactivate( requestStatus ); |
|
1855 |
|
1856 User::WaitForRequest( requestStatus ); |
|
1857 ASSERT_EQUALS( KErrTimedOut, requestStatus.Int() ); |
|
1858 |
|
1859 AssertMockLtsyStatusL(); |
|
1860 CleanupStack::PopAndDestroy( 4 ); // packetMbmsContext, packetService |
|
1861 CleanupStack::PopAndDestroy( 2, this ); // data, this |
|
1862 } |
|
1863 |
|
1864 |
|
1865 /** |
|
1866 @SYMTestCaseID BA-CTSY-MCF-PDE-0001 |
|
1867 @SYMComponent telephony_ctsy |
|
1868 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::Delete |
|
1869 @SYMTestPriority High |
|
1870 @SYMTestActions Invokes RPacketMbmsContext::Delete |
|
1871 @SYMTestExpectedResults Pass |
|
1872 @SYMTestType CT |
|
1873 */ |
|
1874 void CCTsyMbmsContextFU::TestDelete0001L() |
|
1875 { |
|
1876 OpenEtelServerL( EUseExtendedError ); |
|
1877 CleanupStack::PushL( TCleanupItem( Cleanup, this ) ); |
|
1878 OpenPhoneL(); |
|
1879 |
|
1880 RBuf8 data; |
|
1881 CleanupClosePushL( data ); |
|
1882 |
|
1883 RBuf8 outData; |
|
1884 CleanupClosePushL( outData ); |
|
1885 |
|
1886 RBuf8 servData; |
|
1887 CleanupClosePushL( servData ); |
|
1888 |
|
1889 RBuf8 expectData; |
|
1890 CleanupClosePushL( expectData ); |
|
1891 |
|
1892 RPacketService packetService; |
|
1893 OpenPacketServiceL( packetService ); |
|
1894 CleanupClosePushL( packetService ); |
|
1895 |
|
1896 // Open new context |
|
1897 TInfoName contextId; |
|
1898 RPacketMbmsContext packetMbmsContext; |
|
1899 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
1900 CleanupClosePushL( packetMbmsContext ); |
|
1901 |
|
1902 TRequestStatus requestStatus; |
|
1903 TMockLtsyData1<TInfoName > ltsyData( contextId ); |
|
1904 ltsyData.SerialiseL( data ); |
|
1905 |
|
1906 //------------------------------------------------------------------------- |
|
1907 // Send Delete request when ContextStatus is Unknown |
|
1908 //------------------------------------------------------------------------- |
|
1909 |
|
1910 packetMbmsContext.Delete( requestStatus ); |
|
1911 |
|
1912 User::WaitForRequest( requestStatus ); |
|
1913 ASSERT_EQUALS( KErrNotReady, requestStatus.Int() ); |
|
1914 AssertMockLtsyStatusL(); |
|
1915 |
|
1916 //------------------------------------------------------------------------- |
|
1917 // activate context properly |
|
1918 //------------------------------------------------------------------------- |
|
1919 |
|
1920 // initialisation of the context |
|
1921 TInt status = InitMbmsContextL(packetMbmsContext, contextId); |
|
1922 ASSERT_EQUALS(KErrNone, status); |
|
1923 |
|
1924 // Configure context |
|
1925 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
1926 status = SetMbmsConfigL(packetMbmsContext, contextId, contextConfig); |
|
1927 ASSERT_EQUALS( KErrNone, status ); |
|
1928 |
|
1929 // activate context |
|
1930 status = SetMbmsActiveL(packetMbmsContext, contextConfig, contextId); |
|
1931 ASSERT_EQUALS(KErrNone, status); |
|
1932 |
|
1933 // deactivate |
|
1934 status = SetMbmsDeactiveL(packetMbmsContext, contextId); |
|
1935 ASSERT_EQUALS(KErrNone, status); |
|
1936 |
|
1937 //------------------------------------------------------------------------- |
|
1938 // TEST E: Unsolicited completion of RPacketMbmsContext::Delete |
|
1939 // from LTSY. |
|
1940 //------------------------------------------------------------------------- |
|
1941 |
|
1942 TRequestStatus mockLtsyStatus; |
|
1943 |
|
1944 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
1945 // send completion |
|
1946 iMockLTSY.CompleteL( EPacketContextDelete, KErrNone, data ); |
|
1947 // wait for completion |
|
1948 User::WaitForRequest( mockLtsyStatus ); |
|
1949 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
1950 AssertMockLtsyStatusL(); |
|
1951 |
|
1952 //------------------------------------------------------------------------- |
|
1953 // TEST A: failure to dispatch request to LTSY |
|
1954 //------------------------------------------------------------------------- |
|
1955 TMockLtsyData1<TInfoName> expData( contextId ); |
|
1956 expData.SerialiseL( expectData ); |
|
1957 |
|
1958 iMockLTSY.ExpectL( EPacketContextDelete, expectData, KErrNotSupported ); |
|
1959 |
|
1960 packetMbmsContext.Delete( requestStatus ); |
|
1961 |
|
1962 User::WaitForRequest( requestStatus ); |
|
1963 ASSERT_EQUALS( KErrNotSupported, requestStatus.Int() ); |
|
1964 AssertMockLtsyStatusL(); |
|
1965 |
|
1966 //------------------------------------------------------------------------- |
|
1967 // TEST B: failure on completion of pending request from LTSY->CTSY |
|
1968 //------------------------------------------------------------------------- |
|
1969 iMockLTSY.ExpectL ( EPacketContextDelete, expectData ); |
|
1970 iMockLTSY.CompleteL( EPacketContextDelete, KErrGeneral, data ); |
|
1971 |
|
1972 packetMbmsContext.Delete( requestStatus ); |
|
1973 |
|
1974 User::WaitForRequest( requestStatus ); |
|
1975 ASSERT_EQUALS(KErrGeneral, requestStatus.Int() ); |
|
1976 AssertMockLtsyStatusL(); |
|
1977 |
|
1978 //------------------------------------------------------------------------- |
|
1979 // TEST C: Successful completion request of |
|
1980 // RPacketMbmsContext::Delete when result is not cached. |
|
1981 //------------------------------------------------------------------------- |
|
1982 |
|
1983 // remove context succefully |
|
1984 iMockLTSY.ExpectL( EPacketContextDelete, data ); |
|
1985 iMockLTSY.CompleteL( EPacketContextDelete, KErrNone, data ); |
|
1986 packetMbmsContext.Delete( requestStatus ); |
|
1987 |
|
1988 User::WaitForRequest( requestStatus ); |
|
1989 ASSERT_EQUALS( KErrNone, requestStatus.Int() ); |
|
1990 AssertMockLtsyStatusL(); |
|
1991 |
|
1992 CleanupStack::PopAndDestroy( 7, this ); //packetMbmsContext, packetService, expectData, data, this |
|
1993 } |
|
1994 |
|
1995 /** |
|
1996 @SYMTestCaseID BA-CTSY-MCF-PDE-0004 |
|
1997 @SYMComponent telephony_ctsy |
|
1998 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketMbmsContext::Delete |
|
1999 @SYMTestPriority High |
|
2000 @SYMTestActions Invokes multiple client requests to RPacketMbmsContext::Delete |
|
2001 @SYMTestExpectedResults Pass |
|
2002 @SYMTestType CT |
|
2003 */ |
|
2004 void CCTsyMbmsContextFU::TestDelete0004L() |
|
2005 { |
|
2006 OpenEtelServerL( EUseExtendedError ); |
|
2007 CleanupStack::PushL(TCleanupItem( Cleanup, this ) ); |
|
2008 OpenPhoneL(); |
|
2009 |
|
2010 RBuf8 data; |
|
2011 CleanupClosePushL( data ); |
|
2012 |
|
2013 RBuf8 data2; |
|
2014 CleanupClosePushL( data2 ); |
|
2015 |
|
2016 RBuf8 expectData; |
|
2017 CleanupClosePushL( expectData ); |
|
2018 |
|
2019 RBuf8 expectData2; |
|
2020 CleanupClosePushL( expectData2 ); |
|
2021 |
|
2022 // Open second client |
|
2023 RTelServer telServer2; |
|
2024 TInt ret = telServer2.Connect(); |
|
2025 ASSERT_EQUALS( KErrNone, ret ); |
|
2026 CleanupClosePushL( telServer2 ); |
|
2027 |
|
2028 RMobilePhone phone2; |
|
2029 ret = phone2.Open( iTelServer, KMmTsyPhoneName ); |
|
2030 ASSERT_EQUALS( KErrNone, ret ); |
|
2031 CleanupClosePushL( phone2 ); |
|
2032 |
|
2033 RPacketService packetService; |
|
2034 OpenPacketServiceL( packetService ); |
|
2035 CleanupClosePushL( packetService ); |
|
2036 |
|
2037 RPacketService packetService2; |
|
2038 ret = packetService2.Open( phone2 ); |
|
2039 ASSERT_EQUALS( KErrNone, ret ); |
|
2040 CleanupClosePushL( packetService2 ); |
|
2041 |
|
2042 // Open first context |
|
2043 TInfoName contextId; |
|
2044 RPacketMbmsContext packetMbmsContext; |
|
2045 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
2046 CleanupClosePushL( packetMbmsContext ); |
|
2047 |
|
2048 // Open second context |
|
2049 TInfoName contextId2; |
|
2050 RPacketMbmsContext packetMbmsContext2; |
|
2051 packetMbmsContext2.OpenNewContext( packetService2, contextId2 ); |
|
2052 CleanupClosePushL( packetMbmsContext2 ); |
|
2053 |
|
2054 // initialise context's first |
|
2055 TInt status = InitMbmsContextL( packetMbmsContext, contextId ); |
|
2056 ASSERT_EQUALS( KErrNone, status ); |
|
2057 |
|
2058 TInt status2 = InitMbmsContextL( packetMbmsContext2, contextId2 ); |
|
2059 ASSERT_EQUALS( KErrNone, status2 ); |
|
2060 |
|
2061 // Configure context |
|
2062 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
2063 status = SetMbmsConfigL(packetMbmsContext, contextId, contextConfig); |
|
2064 ASSERT_EQUALS( KErrNone, status ); |
|
2065 |
|
2066 // Configure context 2 |
|
2067 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig2; |
|
2068 status = SetMbmsConfigL(packetMbmsContext2, contextId2, contextConfig2); |
|
2069 ASSERT_EQUALS( KErrNone, status ); |
|
2070 |
|
2071 |
|
2072 // activate context |
|
2073 status = SetMbmsActiveL(packetMbmsContext, contextConfig, contextId); |
|
2074 ASSERT_EQUALS(KErrNone, status); |
|
2075 |
|
2076 // activate context |
|
2077 status2 = SetMbmsActiveL(packetMbmsContext2, contextConfig2, contextId2); |
|
2078 ASSERT_EQUALS(KErrNone, status2); |
|
2079 |
|
2080 // deactivate |
|
2081 status = SetMbmsDeactiveL(packetMbmsContext, contextId); |
|
2082 ASSERT_EQUALS(KErrNone, status); |
|
2083 |
|
2084 status2 = SetMbmsDeactiveL(packetMbmsContext2, contextId2); |
|
2085 ASSERT_EQUALS(KErrNone, status2); |
|
2086 |
|
2087 //------------------------------------------------------------------------- |
|
2088 // Test A: Test multiple clients requesting RPacketMbmsContext::Delete |
|
2089 //------------------------------------------------------------------------- |
|
2090 |
|
2091 // data for first CompleteL |
|
2092 TMockLtsyData1<TInfoName> ltsyData( contextId ); |
|
2093 ltsyData.SerialiseL( data ); |
|
2094 |
|
2095 // data for second CompleteL |
|
2096 TMockLtsyData1<TInfoName> ltsyData2( contextId2 ); |
|
2097 ltsyData2.SerialiseL( data2 ); |
|
2098 |
|
2099 // for the first request |
|
2100 TRequestStatus requestStatus; |
|
2101 TMockLtsyData1<TInfoName> expData( contextId ); |
|
2102 expData.SerialiseL( expectData ); |
|
2103 |
|
2104 // for the second request |
|
2105 TRequestStatus requestStatus2; |
|
2106 TMockLtsyData1<TInfoName> expData2( contextId2 ); |
|
2107 expData2.SerialiseL( expectData2 ); |
|
2108 |
|
2109 iMockLTSY.ExpectL( EPacketContextDelete, expectData ); |
|
2110 iMockLTSY.CompleteL( EPacketContextDelete, KErrNone, data ); |
|
2111 iMockLTSY.ExpectL( EPacketContextDelete, expectData2 ); |
|
2112 iMockLTSY.CompleteL( EPacketContextDelete, KErrNone, data2 ); |
|
2113 |
|
2114 // send first request |
|
2115 packetMbmsContext.Delete( requestStatus ); |
|
2116 |
|
2117 // send second request |
|
2118 packetMbmsContext2.Delete( requestStatus2 ); |
|
2119 |
|
2120 // wait for first answer |
|
2121 User::WaitForRequest( requestStatus ); |
|
2122 ASSERT_EQUALS( KErrNone, requestStatus.Int() ); |
|
2123 |
|
2124 // wait for second answer |
|
2125 User::WaitForRequest( requestStatus2 ); |
|
2126 ASSERT_EQUALS( KErrNone, requestStatus2.Int() ); |
|
2127 |
|
2128 AssertMockLtsyStatusL(); |
|
2129 |
|
2130 CleanupStack::PopAndDestroy( 2 ); // expectData2, expectData |
|
2131 CleanupStack::PopAndDestroy( 9, this ); //packetMbmsContext2, packetMbmsContext, packetService2, packetService, phone2, telServer2, data, data2, this |
|
2132 } |
|
2133 |
|
2134 /** |
|
2135 @SYMTestCaseID BA-CTSY-MCF-PDE-0005 |
|
2136 @SYMComponent telephony_ctsy |
|
2137 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::Delete with timeout |
|
2138 @SYMTestPriority High |
|
2139 @SYMTestActions Invokes RPacketMbmsContext::Delete and tests for timeout |
|
2140 @SYMTestExpectedResults Pass |
|
2141 @SYMTestType CT |
|
2142 */ |
|
2143 void CCTsyMbmsContextFU::TestDelete0005L() |
|
2144 { |
|
2145 OpenEtelServerL( EUseExtendedError ); |
|
2146 CleanupStack::PushL(TCleanupItem( Cleanup,this ) ); |
|
2147 OpenPhoneL(); |
|
2148 |
|
2149 RBuf8 data; |
|
2150 CleanupClosePushL( data ); |
|
2151 |
|
2152 RBuf8 expectData; |
|
2153 CleanupClosePushL( expectData ); |
|
2154 |
|
2155 RPacketService packetService; |
|
2156 OpenPacketServiceL( packetService ); |
|
2157 CleanupClosePushL( packetService ); |
|
2158 |
|
2159 // Open new context |
|
2160 TInfoName contextId; |
|
2161 RPacketMbmsContext packetMbmsContext; |
|
2162 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
2163 CleanupClosePushL( packetMbmsContext ); |
|
2164 |
|
2165 // initialise context |
|
2166 TInt status = InitMbmsContextL( packetMbmsContext, contextId ); |
|
2167 ASSERT_EQUALS( KErrNone, status ); |
|
2168 |
|
2169 // Configure context |
|
2170 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
2171 status = SetMbmsConfigL(packetMbmsContext, contextId, contextConfig); |
|
2172 ASSERT_EQUALS( KErrNone, status ); |
|
2173 |
|
2174 // activate context |
|
2175 status = SetMbmsActiveL(packetMbmsContext, contextConfig, contextId); |
|
2176 ASSERT_EQUALS(KErrNone, status); |
|
2177 |
|
2178 // deactivate |
|
2179 status = SetMbmsDeactiveL(packetMbmsContext, contextId); |
|
2180 ASSERT_EQUALS(KErrNone, status); |
|
2181 |
|
2182 //------------------------------------------------------------------------- |
|
2183 // Test A: Test timeout of RPacketMbmsContext::Delete |
|
2184 //------------------------------------------------------------------------- |
|
2185 TRequestStatus requestStatus; |
|
2186 TMockLtsyData1<TInfoName> expData( contextId ); |
|
2187 expData.SerialiseL( expectData ); |
|
2188 iMockLTSY.ExpectL( EPacketContextDelete, expectData ); |
|
2189 |
|
2190 packetMbmsContext.Delete( requestStatus ); |
|
2191 |
|
2192 User::WaitForRequest( requestStatus ); |
|
2193 ASSERT_EQUALS( KErrTimedOut, requestStatus.Int() ); |
|
2194 AssertMockLtsyStatusL(); |
|
2195 |
|
2196 CleanupStack::PopAndDestroy( 5, this ); //packetMbmsContext, packetService, data, expectData, this |
|
2197 } |
|
2198 |
|
2199 |
|
2200 /** |
|
2201 @SYMTestCaseID BA-CTSY-MCF-PC-0001 |
|
2202 @SYMComponent telephony_ctsy |
|
2203 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::Close |
|
2204 @SYMTestPriority |
|
2205 @SYMTestActions Invokes RPacketMbmsContext::Close |
|
2206 @SYMTestExpectedResults Pass |
|
2207 @SYMTestType |
|
2208 */ |
|
2209 void CCTsyMbmsContextFU::TestClose0001L() |
|
2210 { |
|
2211 OpenEtelServerL( EUseExtendedError ); |
|
2212 CleanupStack::PushL(TCleanupItem( Cleanup,this ) ); |
|
2213 OpenPhoneL(); |
|
2214 |
|
2215 RBuf8 data; |
|
2216 CleanupClosePushL( data ); |
|
2217 |
|
2218 RBuf8 expectData; |
|
2219 CleanupClosePushL( expectData ); |
|
2220 |
|
2221 RPacketService packetService; |
|
2222 OpenPacketServiceL( packetService ); |
|
2223 CleanupClosePushL( packetService ); |
|
2224 |
|
2225 // Open new context |
|
2226 TInfoName contextId; |
|
2227 RPacketMbmsContext packetMbmsContext; |
|
2228 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
2229 CleanupClosePushL( packetMbmsContext ); |
|
2230 |
|
2231 // initialise context |
|
2232 TInt status = InitMbmsContextL( packetMbmsContext, contextId ); |
|
2233 ASSERT_EQUALS( KErrNone, status ); |
|
2234 |
|
2235 // Configure context |
|
2236 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
2237 status = SetMbmsConfigL(packetMbmsContext, contextId, contextConfig); |
|
2238 ASSERT_EQUALS( KErrNone, status ); |
|
2239 |
|
2240 // activate context |
|
2241 status = SetMbmsActiveL(packetMbmsContext, contextConfig, contextId); |
|
2242 ASSERT_EQUALS(KErrNone, status); |
|
2243 |
|
2244 // deactivate |
|
2245 status = SetMbmsDeactiveL(packetMbmsContext, contextId); |
|
2246 ASSERT_EQUALS(KErrNone, status); |
|
2247 |
|
2248 // delete context |
|
2249 status = SetMbmsDeleteL(packetMbmsContext, contextId); |
|
2250 ASSERT_EQUALS(KErrNone, status); |
|
2251 |
|
2252 // and finally close context |
|
2253 TRequestStatus requestStatus; |
|
2254 |
|
2255 packetMbmsContext.Close( ); |
|
2256 |
|
2257 AssertMockLtsyStatusL(); |
|
2258 ASSERT_EQUALS(KErrNone, KErrNone); |
|
2259 |
|
2260 CleanupStack::PopAndDestroy( 5, this ); |
|
2261 } |
|
2262 |
|
2263 /** |
|
2264 @SYMTestCaseID BA-CTSY-MCF-PGC-0001 |
|
2265 @SYMComponent telephony_ctsy |
|
2266 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::GetConfig |
|
2267 @SYMTestPriority High |
|
2268 @SYMTestActions Invokes RPacketMbmsContext::GetConfig |
|
2269 @SYMTestExpectedResults Pass |
|
2270 @SYMTestType CT |
|
2271 */ |
|
2272 void CCTsyMbmsContextFU::TestGetConfig0001L() |
|
2273 { |
|
2274 OpenEtelServerL(EUseExtendedError); |
|
2275 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
2276 OpenPhoneL(); |
|
2277 |
|
2278 RBuf8 data; |
|
2279 CleanupClosePushL(data); |
|
2280 |
|
2281 RBuf8 expectData; |
|
2282 CleanupClosePushL(expectData); |
|
2283 |
|
2284 RPacketService packetService; |
|
2285 OpenPacketServiceL(packetService); |
|
2286 CleanupClosePushL(packetService); |
|
2287 |
|
2288 // Open new context |
|
2289 TInfoName contextId; |
|
2290 RPacketMbmsContext packetContext; |
|
2291 packetContext.OpenNewContext(packetService, contextId); |
|
2292 CleanupClosePushL(packetContext); |
|
2293 |
|
2294 TRequestStatus requestStatus; |
|
2295 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
2296 |
|
2297 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig(contextConfig); |
|
2298 |
|
2299 TTmgi ttmgi; |
|
2300 ttmgi.SetServiceId(KMmConfigTMGI1); |
|
2301 ttmgi.SetMCC(KMmConfigTmgiMMC1); |
|
2302 ttmgi.SetMCC(KMmConfigTmgiMNC1); |
|
2303 |
|
2304 contextConfig.iTmgi = ttmgi; |
|
2305 contextConfig.iMbmsAccessBearer = E2GBearer; |
|
2306 contextConfig.iMbmsServicePriority = EMbmsMediumServicePriority; |
|
2307 contextConfig.iMbmsServiceMode = KBroadcast; |
|
2308 contextConfig.iMbmsSessionFlag = EFalse; |
|
2309 |
|
2310 TInt status = InitMbmsContextL( packetContext, contextId ); |
|
2311 ASSERT_EQUALS( KErrNone, status ); |
|
2312 |
|
2313 status = SetMbmsConfigL(packetContext, contextId, contextConfig); |
|
2314 |
|
2315 RPacketMbmsContext::TContextConfigMbmsV1 retContextConfig; |
|
2316 |
|
2317 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> retPckgConfig(retContextConfig); |
|
2318 |
|
2319 packetContext.GetConfig(requestStatus, retPckgConfig); |
|
2320 |
|
2321 User::WaitForRequest(requestStatus); |
|
2322 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
2323 |
|
2324 ASSERT_EQUALS( contextConfig.iTmgi.GetServiceId(), contextConfig.iTmgi.GetServiceId()); |
|
2325 ASSERT_EQUALS( contextConfig.iTmgi.GetMCC(), contextConfig.iTmgi.GetMCC()); |
|
2326 ASSERT_EQUALS( contextConfig.iTmgi.GetMNC(), contextConfig.iTmgi.GetMNC()); |
|
2327 ASSERT_EQUALS( contextConfig.iMbmsAccessBearer, contextConfig.iMbmsAccessBearer); |
|
2328 ASSERT_EQUALS( contextConfig.iMbmsServicePriority, retContextConfig.iMbmsServicePriority); |
|
2329 ASSERT_EQUALS( contextConfig.iMbmsServiceMode, retContextConfig.iMbmsServiceMode); |
|
2330 ASSERT_EQUALS( contextConfig.iMbmsSessionFlag, retContextConfig.iMbmsSessionFlag); |
|
2331 |
|
2332 CleanupStack::PopAndDestroy(5, this); // packetService1, this |
|
2333 } |
|
2334 |
|
2335 /** |
|
2336 @SYMTestCaseID BA-CTSY-MCF-PGC-0002 |
|
2337 @SYMComponent telephony_ctsy |
|
2338 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketMbmsContext::GetConfig |
|
2339 @SYMTestPriority High |
|
2340 @SYMTestActions Invokes multiple client requests to RPacketMbmsContext::GetConfig |
|
2341 @SYMTestExpectedResults Pass |
|
2342 @SYMTestType CT |
|
2343 */ |
|
2344 void CCTsyMbmsContextFU::TestGetConfig0002L() |
|
2345 { |
|
2346 |
|
2347 OpenEtelServerL( EUseExtendedError ); |
|
2348 CleanupStack::PushL(TCleanupItem( Cleanup, this ) ); |
|
2349 OpenPhoneL(); |
|
2350 |
|
2351 RBuf8 data; |
|
2352 CleanupClosePushL( data ); |
|
2353 |
|
2354 RBuf8 data2; |
|
2355 CleanupClosePushL( data2 ); |
|
2356 |
|
2357 // Open second client |
|
2358 RTelServer telServer2; |
|
2359 TInt ret = telServer2.Connect(); |
|
2360 ASSERT_EQUALS( KErrNone, ret ); |
|
2361 CleanupClosePushL( telServer2 ); |
|
2362 |
|
2363 RMobilePhone phone2; |
|
2364 ret = phone2.Open( iTelServer, KMmTsyPhoneName ); |
|
2365 ASSERT_EQUALS( KErrNone, ret ); |
|
2366 CleanupClosePushL( phone2 ); |
|
2367 |
|
2368 RPacketService packetService; |
|
2369 OpenPacketServiceL( packetService ); |
|
2370 CleanupClosePushL( packetService ); |
|
2371 |
|
2372 RPacketService packetService2; |
|
2373 ret = packetService2.Open( phone2 ); |
|
2374 ASSERT_EQUALS( KErrNone, ret ); |
|
2375 CleanupClosePushL( packetService2 ); |
|
2376 |
|
2377 // Open first context |
|
2378 TInfoName contextId; |
|
2379 RPacketMbmsContext packetMbmsContext; |
|
2380 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
2381 CleanupClosePushL( packetMbmsContext ); |
|
2382 |
|
2383 // Open second context |
|
2384 TInfoName contextId2; |
|
2385 RPacketMbmsContext packetMbmsContext2; |
|
2386 packetMbmsContext2.OpenNewContext( packetService2, contextId2 ); |
|
2387 CleanupClosePushL( packetMbmsContext2 ); |
|
2388 |
|
2389 TRequestStatus mockLtsyStatus; |
|
2390 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
2391 |
|
2392 //------------------------------------------------------------------------- |
|
2393 // Test A: Test multiple clients requesting RPacketMbmsContext::GetConfig |
|
2394 //------------------------------------------------------------------------- |
|
2395 |
|
2396 // If this API is flow controlled by Etel or if this API is |
|
2397 // synchronous, remove this test completely. |
|
2398 |
|
2399 TRequestStatus requestStatus; |
|
2400 TMockLtsyData1<TInfoName > ltsyData( contextId ); |
|
2401 ltsyData.SerialiseL( data ); |
|
2402 |
|
2403 // data for second context |
|
2404 TRequestStatus requestStatus2; |
|
2405 TMockLtsyData1<TInfoName > ltsyData2( contextId2 ); |
|
2406 ltsyData2.SerialiseL( data2 ); |
|
2407 |
|
2408 // initialisation of the context |
|
2409 TInt status = InitMbmsContextL(packetMbmsContext, contextId); |
|
2410 ASSERT_EQUALS(KErrNone, status); |
|
2411 |
|
2412 TInt status2 = InitMbmsContextL(packetMbmsContext2, contextId2); |
|
2413 ASSERT_EQUALS(KErrNone, status2); |
|
2414 |
|
2415 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
2416 // activate context |
|
2417 status = SetMbmsActiveL(packetMbmsContext, contextConfig, contextId); |
|
2418 ASSERT_EQUALS(KErrNone, status); |
|
2419 |
|
2420 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig2; |
|
2421 // activate context |
|
2422 status2 = SetMbmsActiveL(packetMbmsContext2, contextConfig2, contextId2); |
|
2423 ASSERT_EQUALS(KErrNone, status2); |
|
2424 |
|
2425 // ----------------------------------------------------------------------- |
|
2426 // initialise parameters |
|
2427 // ----------------------------------------------------------------------- |
|
2428 |
|
2429 // first context is selected and high priority |
|
2430 TTmgi ttmgi; |
|
2431 ttmgi.SetServiceId(KMmConfigTMGI1); |
|
2432 ttmgi.SetMCC(KMmConfigTmgiMMC1); |
|
2433 ttmgi.SetMCC(KMmConfigTmgiMNC1); |
|
2434 |
|
2435 contextConfig.iTmgi = ttmgi; |
|
2436 contextConfig.iMbmsSessionFlag = ETrue; |
|
2437 contextConfig.iMbmsServicePriority = EMbmsHighServicePriority; |
|
2438 contextConfig.iMbmsServiceMode = KSelectedBroadcast; |
|
2439 contextConfig.iMbmsAccessBearer = E3GBearer; |
|
2440 |
|
2441 // second context |
|
2442 |
|
2443 TTmgi ttmgi2; |
|
2444 ttmgi2.SetServiceId(KMmConfigTMGI2); |
|
2445 ttmgi2.SetMCC(KMmConfigTmgiMMC2); |
|
2446 ttmgi2.SetMCC(KMmConfigTmgiMNC2); |
|
2447 |
|
2448 contextConfig2.iTmgi = ttmgi2; |
|
2449 contextConfig2.iMbmsSessionFlag = EFalse; |
|
2450 contextConfig2.iMbmsServicePriority = EMbmsLowServicePriority; |
|
2451 contextConfig2.iMbmsServiceMode = KBroadcast; |
|
2452 contextConfig2.iMbmsAccessBearer = E3GBearer; |
|
2453 |
|
2454 status = SetMbmsConfigL( packetMbmsContext, contextId, contextConfig ); |
|
2455 ASSERT_EQUALS(KErrNone, status); |
|
2456 |
|
2457 status2 = SetMbmsConfigL( packetMbmsContext2, contextId2, contextConfig2 ); |
|
2458 ASSERT_EQUALS(KErrNone, status2); |
|
2459 |
|
2460 // ----------------------------------------------------------------------- |
|
2461 // get parameters |
|
2462 // ----------------------------------------------------------------------- |
|
2463 RPacketMbmsContext::TContextConfigMbmsV1 getConfig; |
|
2464 RPacketMbmsContext::TContextConfigMbmsV1 getConfig2; |
|
2465 |
|
2466 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig(getConfig); |
|
2467 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig2(getConfig2); |
|
2468 |
|
2469 // send first request |
|
2470 packetMbmsContext.GetConfig(requestStatus, pckgConfig); |
|
2471 // send second request |
|
2472 packetMbmsContext2.GetConfig(requestStatus2, pckgConfig2); |
|
2473 |
|
2474 |
|
2475 // wait for the both answers |
|
2476 User::WaitForRequest(requestStatus); |
|
2477 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
2478 User::WaitForRequest( requestStatus2 ); |
|
2479 ASSERT_EQUALS( KErrNone, requestStatus2.Int() ); |
|
2480 |
|
2481 ASSERT_EQUALS(KMmConfigTMGI1, getConfig.iTmgi.GetServiceId()); |
|
2482 ASSERT_TRUE(getConfig.iMbmsSessionFlag); |
|
2483 ASSERT_EQUALS(EMbmsHighServicePriority, getConfig.iMbmsServicePriority ); |
|
2484 ASSERT_EQUALS(KSelectedBroadcast, getConfig.iMbmsServiceMode); |
|
2485 ASSERT_EQUALS(E3GBearer, getConfig.iMbmsAccessBearer); |
|
2486 |
|
2487 ASSERT_EQUALS(KMmConfigTMGI2, getConfig2.iTmgi.GetServiceId()); |
|
2488 ASSERT_TRUE(!getConfig2.iMbmsSessionFlag); |
|
2489 ASSERT_EQUALS(EMbmsLowServicePriority, getConfig2.iMbmsServicePriority); |
|
2490 ASSERT_EQUALS(KBroadcast, getConfig2.iMbmsServiceMode); |
|
2491 ASSERT_EQUALS(E3GBearer, getConfig2.iMbmsAccessBearer); |
|
2492 |
|
2493 CleanupStack::PopAndDestroy(4); // packetMbmsContext, packetService, packetMbmsContext2, packetService2 |
|
2494 CleanupStack::PopAndDestroy(5, this); // phone2, telServer2, data, data2, this |
|
2495 |
|
2496 } |
|
2497 |
|
2498 /** |
|
2499 @SYMTestCaseID BA-CTSY-MCF-PGC-0003 |
|
2500 @SYMComponent telephony_ctsy |
|
2501 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::GetConfig with bad parameter data |
|
2502 @SYMTestPriority High |
|
2503 @SYMTestActions Invokes RPacketMbmsContext::GetConfig with bad parameter data |
|
2504 @SYMTestExpectedResults Pass |
|
2505 @SYMTestType CT |
|
2506 */ |
|
2507 void CCTsyMbmsContextFU::TestGetConfig0003L() |
|
2508 { |
|
2509 OpenEtelServerL(EUseExtendedError); |
|
2510 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
2511 OpenPhoneL(); |
|
2512 |
|
2513 RPacketService packetService; |
|
2514 OpenPacketServiceL(packetService); |
|
2515 CleanupClosePushL(packetService); |
|
2516 |
|
2517 // Open new context |
|
2518 TInfoName contextId; |
|
2519 RPacketMbmsContext packetContext; |
|
2520 packetContext.OpenNewContext(packetService, contextId); |
|
2521 CleanupClosePushL(packetContext); |
|
2522 |
|
2523 TRequestStatus requestStatus; |
|
2524 RPacketContext::TContextConfigGPRS contextConfig; |
|
2525 TPckg<RPacketContext::TContextConfigGPRS> pckgConfig(contextConfig); |
|
2526 |
|
2527 TInt status = InitMbmsContextL( packetContext, contextId ); |
|
2528 ASSERT_EQUALS( KErrNone, status ); |
|
2529 |
|
2530 packetContext.GetConfig(requestStatus, pckgConfig); |
|
2531 |
|
2532 User::WaitForRequest(requestStatus); |
|
2533 ASSERT_EQUALS(KErrArgument, requestStatus.Int()); |
|
2534 |
|
2535 CleanupStack::PopAndDestroy(3); //this, packetService packetContext |
|
2536 } |
|
2537 |
|
2538 /** |
|
2539 @SYMTestCaseID BA-CTSY-MCF-PGS-0001 |
|
2540 @SYMComponent telephony_ctsy |
|
2541 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::GetStatus |
|
2542 @SYMTestPriority High |
|
2543 @SYMTestActions Invokes RPacketMbmsContext::GetStatus |
|
2544 @SYMTestExpectedResults Pass |
|
2545 @SYMTestType CT |
|
2546 */ |
|
2547 void CCTsyMbmsContextFU::TestGetStatus0001L() |
|
2548 { |
|
2549 OpenEtelServerL(EUseExtendedError); |
|
2550 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
2551 OpenPhoneL(); |
|
2552 |
|
2553 RBuf8 data; |
|
2554 CleanupClosePushL(data); |
|
2555 |
|
2556 RBuf8 expectData; |
|
2557 CleanupClosePushL( expectData ); |
|
2558 |
|
2559 RPacketService packetService; |
|
2560 OpenPacketServiceL(packetService); |
|
2561 CleanupClosePushL(packetService); |
|
2562 |
|
2563 TInfoName contextId; |
|
2564 RPacketMbmsContext mbmsContext; |
|
2565 mbmsContext.OpenNewContext(packetService, contextId); |
|
2566 CleanupClosePushL(mbmsContext); |
|
2567 |
|
2568 // test 1: context not inited |
|
2569 RPacketContext::TContextStatus contextStatus; |
|
2570 mbmsContext.GetStatus(contextStatus); |
|
2571 ASSERT_EQUALS(RPacketContext::EStatusUnknown, contextStatus); |
|
2572 |
|
2573 // initialisation of the context |
|
2574 TInt status = InitMbmsContextL(mbmsContext, contextId); |
|
2575 ASSERT_EQUALS(KErrNone, status); |
|
2576 |
|
2577 // test2: context inited |
|
2578 mbmsContext.GetStatus(contextStatus); |
|
2579 ASSERT_EQUALS(RPacketContext::EStatusInactive, contextStatus); |
|
2580 |
|
2581 TMockLtsyData1 <TInfoName> expData(contextId); |
|
2582 expData.SerialiseL(expectData); |
|
2583 |
|
2584 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
2585 TMockLtsyData2< TInfoName, RPacketMbmsContext::TContextConfigMbmsV1 > ltsyData1(contextId, contextConfig); |
|
2586 ltsyData1.SerialiseL(data); |
|
2587 |
|
2588 iMockLTSY.ExpectL(EPacketContextActivate, expectData); |
|
2589 iMockLTSY.CompleteL(EPacketContextActivate, KErrNone, data); |
|
2590 |
|
2591 TRequestStatus requestStatus; |
|
2592 mbmsContext.Activate(requestStatus); |
|
2593 User::WaitForRequest(requestStatus); |
|
2594 AssertMockLtsyStatusL(); |
|
2595 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
2596 |
|
2597 // test3: context activated |
|
2598 mbmsContext.GetStatus(contextStatus); |
|
2599 ASSERT_EQUALS(RPacketContext::EStatusActive, contextStatus); |
|
2600 |
|
2601 CleanupStack::PopAndDestroy(2); //packetContext, packetService |
|
2602 CleanupStack::PopAndDestroy(3, this); // data,expectData, this |
|
2603 } |
|
2604 |
|
2605 /** |
|
2606 @SYMTestCaseID BA-CTSY-MCF-PGLEC-0001 |
|
2607 @SYMComponent telephony_ctsy |
|
2608 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::GetLastErrorCause |
|
2609 @SYMTestPriority High |
|
2610 @SYMTestActions Invokes RPacketMbmsContext::GetLastErrorCause |
|
2611 @SYMTestExpectedResults Pass |
|
2612 @SYMTestType CT |
|
2613 */ |
|
2614 void CCTsyMbmsContextFU::TestGetLastErrorCause0001L() |
|
2615 { |
|
2616 |
|
2617 OpenEtelServerL(EUseExtendedError); |
|
2618 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
2619 OpenPhoneL(); |
|
2620 |
|
2621 RPacketService packetService; |
|
2622 OpenPacketServiceL(packetService); |
|
2623 CleanupClosePushL(packetService); |
|
2624 |
|
2625 // Open new context |
|
2626 TInfoName contextId; |
|
2627 RPacketMbmsContext mbmsContext; |
|
2628 mbmsContext.OpenNewContext(packetService, contextId); |
|
2629 CleanupClosePushL(mbmsContext); |
|
2630 |
|
2631 RBuf8 data; |
|
2632 CleanupClosePushL(data); |
|
2633 |
|
2634 // initialise context |
|
2635 TInt status = InitMbmsContextL( mbmsContext, contextId ); |
|
2636 ASSERT_EQUALS( KErrNone, status ); |
|
2637 |
|
2638 // Configure context |
|
2639 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
2640 status = SetMbmsConfigL(mbmsContext, contextId, contextConfig); |
|
2641 ASSERT_EQUALS( KErrNone, status ); |
|
2642 |
|
2643 //------------------------------------------------------------------------- |
|
2644 // TEST A: failure to dispatch request to LTSY |
|
2645 //------------------------------------------------------------------------- |
|
2646 |
|
2647 TInt error; |
|
2648 status = mbmsContext.GetLastErrorCause(error); |
|
2649 ASSERT_EQUALS(KErrNone, status); |
|
2650 ASSERT_EQUALS(KErrNone, error); |
|
2651 |
|
2652 //------------------------------------------------------------------------- |
|
2653 // TEST B: Emulate some error |
|
2654 //------------------------------------------------------------------------- |
|
2655 |
|
2656 // Set context in to Activating state |
|
2657 TContextMisc completeMisc; |
|
2658 completeMisc.iStatus = RPacketContext::EStatusActivating; |
|
2659 TMockLtsyData2 <TInfoName, TContextMisc> ltsyData1(contextId, completeMisc); |
|
2660 data.Close(); |
|
2661 ltsyData1.SerialiseL(data); |
|
2662 |
|
2663 TRequestStatus mockLtsyStatus; |
|
2664 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
2665 //send completion |
|
2666 iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data); |
|
2667 // wait for completion |
|
2668 User::WaitForRequest(mockLtsyStatus); |
|
2669 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
2670 |
|
2671 // Emulate an error |
|
2672 completeMisc.iStatus = RPacketContext::EStatusActive; |
|
2673 TMockLtsyData2 <TInfoName, TContextMisc> ltsyData(contextId, completeMisc); |
|
2674 data.Close(); |
|
2675 ltsyData.SerialiseL(data); |
|
2676 |
|
2677 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
2678 //send completion |
|
2679 iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrGeneral, data); |
|
2680 // wait for completion |
|
2681 User::WaitForRequest(mockLtsyStatus); |
|
2682 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
2683 |
|
2684 // Get the error |
|
2685 status = mbmsContext.GetLastErrorCause(error); |
|
2686 ASSERT_EQUALS(KErrNone, status); |
|
2687 ASSERT_EQUALS(KErrGeneral, error); |
|
2688 |
|
2689 AssertMockLtsyStatusL(); |
|
2690 CleanupStack::PopAndDestroy(4, this); // packetContext, mbmsService, data, this |
|
2691 |
|
2692 } |
|
2693 |
|
2694 /** |
|
2695 @SYMTestCaseID BA-CTSY-MCF-PNCC-0001 |
|
2696 @SYMComponent telephony_ctsy |
|
2697 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::NotifyConfigChanged |
|
2698 @SYMTestPriority High |
|
2699 @SYMTestActions Invokes RPacketMbmsContext::NotifyConfigChanged |
|
2700 @SYMTestExpectedResults Pass |
|
2701 @SYMTestType CT |
|
2702 */ |
|
2703 void CCTsyMbmsContextFU::TestNotifyConfigChanged0001L() |
|
2704 { |
|
2705 OpenEtelServerL( EUseExtendedError ); |
|
2706 CleanupStack::PushL( TCleanupItem( Cleanup, this ) ); |
|
2707 OpenPhoneL(); |
|
2708 |
|
2709 RBuf8 data; |
|
2710 CleanupClosePushL( data ); |
|
2711 |
|
2712 RPacketService packetService; |
|
2713 OpenPacketServiceL( packetService ); |
|
2714 CleanupClosePushL( packetService ); |
|
2715 |
|
2716 // Open new context |
|
2717 TInfoName contextId; |
|
2718 RPacketMbmsContext packetMbmsContext; |
|
2719 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
2720 CleanupClosePushL( packetMbmsContext ); |
|
2721 |
|
2722 // initialisation of the context |
|
2723 TInt status = InitMbmsContextL(packetMbmsContext, contextId); |
|
2724 ASSERT_EQUALS(KErrNone, status); |
|
2725 |
|
2726 TRequestStatus mockLtsyStatus; |
|
2727 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
2728 |
|
2729 //------------------------------------------------------------------------- |
|
2730 // TEST C: Successful completion request of |
|
2731 // RPacketMbmsContext::NotifyConfigChanged when result is not cached. |
|
2732 //------------------------------------------------------------------------- |
|
2733 // data for NotifyConfigChanged |
|
2734 TRequestStatus requestStatus; |
|
2735 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
2736 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig( contextConfig ); |
|
2737 |
|
2738 //data for ComleteL |
|
2739 RPacketMbmsContext::TContextConfigMbmsV1 configComplete; |
|
2740 |
|
2741 TTmgi ttmgi; |
|
2742 ttmgi.SetServiceId(KMmConfigTMGI1); |
|
2743 ttmgi.SetMCC(KMmConfigTmgiMMC1); |
|
2744 ttmgi.SetMNC(KMmConfigTmgiMNC1); |
|
2745 |
|
2746 configComplete.iTmgi = ttmgi; |
|
2747 configComplete.iMbmsAccessBearer = E2GBearer; |
|
2748 configComplete.iMbmsServicePriority = EMbmsMediumServicePriority; |
|
2749 configComplete.iMbmsServiceMode = KBroadcast; |
|
2750 configComplete.iMbmsSessionFlag = EFalse; |
|
2751 |
|
2752 TMockLtsyData2<TInfoName, RPacketMbmsContext::TContextConfigMbmsV1> ltsyData( contextId, configComplete ); |
|
2753 ltsyData.SerialiseL( data ); |
|
2754 |
|
2755 // send request |
|
2756 packetMbmsContext.NotifyConfigChanged( requestStatus, pckgConfig ); |
|
2757 |
|
2758 // sent completion |
|
2759 iMockLTSY.CompleteL( ECtsyPacketMbmsContextNotifyConfigChanged, KErrNone, data ); |
|
2760 // wait for completion |
|
2761 User::WaitForRequest( mockLtsyStatus ); |
|
2762 |
|
2763 // wait for request |
|
2764 User::WaitForRequest( requestStatus ); |
|
2765 AssertMockLtsyStatusL(); |
|
2766 ASSERT_EQUALS( KErrNone, requestStatus.Int() ); |
|
2767 |
|
2768 ASSERT_EQUALS( configComplete.iTmgi.GetServiceId(), contextConfig.iTmgi.GetServiceId()); |
|
2769 ASSERT_EQUALS( configComplete.iTmgi.GetMCC(), contextConfig.iTmgi.GetMCC()); |
|
2770 ASSERT_EQUALS( configComplete.iTmgi.GetMNC(), contextConfig.iTmgi.GetMNC()); |
|
2771 ASSERT_EQUALS( configComplete.iMbmsAccessBearer, contextConfig.iMbmsAccessBearer); |
|
2772 ASSERT_EQUALS( configComplete.iMbmsServicePriority, contextConfig.iMbmsServicePriority); |
|
2773 ASSERT_EQUALS( configComplete.iMbmsServiceMode, contextConfig.iMbmsServiceMode); |
|
2774 ASSERT_EQUALS( configComplete.iMbmsSessionFlag, contextConfig.iMbmsSessionFlag); |
|
2775 |
|
2776 |
|
2777 //------------------------------------------------------------------------- |
|
2778 // TEST E: Unsolicited completion of RPacketMbmsContext::NotifyConfigChanged |
|
2779 // from LTSY. |
|
2780 //------------------------------------------------------------------------- |
|
2781 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
2782 // sent completion |
|
2783 iMockLTSY.CompleteL( ECtsyPacketMbmsContextNotifyConfigChanged, KErrNone, data ); |
|
2784 // wait for completion |
|
2785 User::WaitForRequest( mockLtsyStatus ); |
|
2786 AssertMockLtsyStatusL(); |
|
2787 ASSERT_EQUALS( KErrNone, mockLtsyStatus.Int() ); |
|
2788 |
|
2789 CleanupStack::PopAndDestroy( 2 ); // packetService, packetMbmsContext |
|
2790 CleanupStack::PopAndDestroy( 2, this ); // data, this |
|
2791 } |
|
2792 |
|
2793 /** |
|
2794 @SYMTestCaseID BA-CTSY-MCF-PNCC-0002 |
|
2795 @SYMComponent telephony_ctsy |
|
2796 @SYMTestCaseDesc Test support in CTSY for cancelling of RPacketMbmsContext::NotifyConfigChanged |
|
2797 @SYMTestPriority High |
|
2798 @SYMTestActions Invokes cancelling of RPacketMbmsContext::NotifyConfigChanged |
|
2799 @SYMTestExpectedResults Pass |
|
2800 @SYMTestType CT |
|
2801 */ |
|
2802 void CCTsyMbmsContextFU::TestNotifyConfigChanged0002L() |
|
2803 { |
|
2804 // This test should test cancellation of NotifyConfigChanged |
|
2805 // If this API does not have a cancel, the test step should be completely removed. |
|
2806 |
|
2807 OpenEtelServerL( EUseExtendedError ); |
|
2808 CleanupStack::PushL(TCleanupItem( Cleanup, this ) ); |
|
2809 OpenPhoneL(); |
|
2810 |
|
2811 RBuf8 data; |
|
2812 CleanupClosePushL( data ); |
|
2813 |
|
2814 RPacketService packetService; |
|
2815 OpenPacketServiceL( packetService ); |
|
2816 CleanupClosePushL( packetService ); |
|
2817 |
|
2818 // Open new context |
|
2819 TInfoName contextId; |
|
2820 RPacketMbmsContext packetMbmsContext; |
|
2821 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
2822 CleanupClosePushL( packetMbmsContext ); |
|
2823 |
|
2824 TRequestStatus mockLtsyStatus; |
|
2825 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
2826 |
|
2827 //------------------------------------------------------------------------- |
|
2828 // Test cancelling of RPacketMbmsContext::NotifyConfigChanged |
|
2829 //------------------------------------------------------------------------- |
|
2830 // data for NotifyConfigChanged |
|
2831 TRequestStatus requestStatus; |
|
2832 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig; |
|
2833 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig( contextConfig ); |
|
2834 |
|
2835 //data for ComleteL |
|
2836 RPacketMbmsContext::TContextConfigMbmsV1 configComplete; |
|
2837 |
|
2838 TTmgi ttmgi; |
|
2839 ttmgi.SetServiceId(KMmConfigTMGI1); |
|
2840 ttmgi.SetMCC(KMmConfigTmgiMMC1); |
|
2841 ttmgi.SetMNC(KMmConfigTmgiMNC1); |
|
2842 |
|
2843 configComplete.iTmgi = ttmgi; |
|
2844 configComplete.iMbmsAccessBearer = E2GBearer; |
|
2845 configComplete.iMbmsServicePriority = EMbmsMediumServicePriority; |
|
2846 configComplete.iMbmsServiceMode = KBroadcast; |
|
2847 configComplete.iMbmsSessionFlag = EFalse; |
|
2848 |
|
2849 TMockLtsyData2 <TInfoName, RPacketMbmsContext::TContextConfigMbmsV1> ltsyData( contextId, configComplete ); |
|
2850 ltsyData.SerialiseL( data ); |
|
2851 |
|
2852 // send request |
|
2853 packetMbmsContext.NotifyConfigChanged( requestStatus, pckgConfig ); |
|
2854 //send cancellation |
|
2855 packetMbmsContext.CancelAsyncRequest( ECtsyPacketMbmsContextNotifyConfigChanged ); |
|
2856 |
|
2857 // sent completion |
|
2858 iMockLTSY.CompleteL( ECtsyPacketMbmsContextNotifyConfigChanged, KErrNone, data ); |
|
2859 // wait for completion |
|
2860 User::WaitForRequest( mockLtsyStatus ); |
|
2861 |
|
2862 // wait for request |
|
2863 User::WaitForRequest( requestStatus ); |
|
2864 AssertMockLtsyStatusL(); |
|
2865 ASSERT_TRUE( KErrCancel == requestStatus.Int() || KErrNone == requestStatus.Int()); |
|
2866 |
|
2867 CleanupStack::PopAndDestroy( 2 ); // packetService, packetMbmsContext |
|
2868 CleanupStack::PopAndDestroy( 2 ); // data, this |
|
2869 } |
|
2870 |
|
2871 /** |
|
2872 @SYMTestCaseID BA-CTSY-MCF-PNCC-0003 |
|
2873 @SYMComponent telephony_ctsy |
|
2874 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::NotifyConfigChanged with bad parameter data |
|
2875 @SYMTestPriority High |
|
2876 @SYMTestActions Invokes RPacketMbmsContext::NotifyConfigChanged with bad parameter data |
|
2877 @SYMTestExpectedResults Pass |
|
2878 @SYMTestType CT |
|
2879 */ |
|
2880 void CCTsyMbmsContextFU::TestNotifyConfigChanged0003L() |
|
2881 { |
|
2882 // This test should test sending bad parameter data for NotifyConfigChanged |
|
2883 // If this API does not have any parameters, then remove this test completely. |
|
2884 |
|
2885 OpenEtelServerL( EUseExtendedError ); |
|
2886 CleanupStack::PushL(TCleanupItem( Cleanup,this ) ); |
|
2887 OpenPhoneL(); |
|
2888 |
|
2889 RBuf8 data; |
|
2890 CleanupClosePushL( data ); |
|
2891 |
|
2892 RPacketService packetService; |
|
2893 OpenPacketServiceL( packetService ); |
|
2894 CleanupClosePushL( packetService ); |
|
2895 |
|
2896 // Open new context |
|
2897 TInfoName contextId; |
|
2898 RPacketMbmsContext packetMbmsContext; |
|
2899 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
2900 CleanupClosePushL( packetMbmsContext ); |
|
2901 |
|
2902 TRequestStatus mockLtsyStatus; |
|
2903 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
2904 |
|
2905 //------------------------------------------------------------------------- |
|
2906 // Test A: Test passing wrong version of parameters to |
|
2907 // RPacketMbmsContext::NotifyConfigChanged |
|
2908 //------------------------------------------------------------------------- |
|
2909 // data for NotifyConfigChanged |
|
2910 TRequestStatus requestStatus; |
|
2911 RPacketMbmsContext::TContextConfigCDMA contextConfig; |
|
2912 TPckg<RPacketMbmsContext::TContextConfigCDMA> pckgConfig( contextConfig ); |
|
2913 |
|
2914 // send request |
|
2915 packetMbmsContext.NotifyConfigChanged( requestStatus, pckgConfig ); |
|
2916 |
|
2917 // wait for request |
|
2918 User::WaitForRequest(requestStatus ); |
|
2919 AssertMockLtsyStatusL(); |
|
2920 ASSERT_EQUALS( KErrNotSupported, requestStatus.Int() ); |
|
2921 |
|
2922 // Done ! |
|
2923 CleanupStack::PopAndDestroy( 2 ); // packetMbmsService, packetContext |
|
2924 CleanupStack::PopAndDestroy( 2, this ); // data, this |
|
2925 } |
|
2926 |
|
2927 /** |
|
2928 @SYMTestCaseID BA-CTSY-MCF-PNCC-0004 |
|
2929 @SYMComponent telephony_ctsy |
|
2930 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketMbmsContext::NotifyConfigChanged |
|
2931 @SYMTestPriority High |
|
2932 @SYMTestActions Invokes multiple client requests to RPacketMbmsContext::NotifyConfigChanged |
|
2933 @SYMTestExpectedResults Pass |
|
2934 @SYMTestType CT |
|
2935 */ |
|
2936 void CCTsyMbmsContextFU::TestNotifyConfigChanged0004L() |
|
2937 { |
|
2938 OpenEtelServerL( EUseExtendedError ); |
|
2939 CleanupStack::PushL( TCleanupItem( Cleanup, this ) ); |
|
2940 OpenPhoneL(); |
|
2941 |
|
2942 RBuf8 data; |
|
2943 CleanupClosePushL( data ); |
|
2944 |
|
2945 RBuf8 data2; |
|
2946 CleanupClosePushL( data2 ); |
|
2947 |
|
2948 // Open second client |
|
2949 RTelServer telServer2; |
|
2950 TInt ret = telServer2.Connect(); |
|
2951 ASSERT_EQUALS( KErrNone, ret ); |
|
2952 CleanupClosePushL( telServer2 ); |
|
2953 |
|
2954 RMobilePhone phone2; |
|
2955 ret = phone2.Open( iTelServer, KMmTsyPhoneName ); |
|
2956 ASSERT_EQUALS( KErrNone, ret ); |
|
2957 CleanupClosePushL( phone2 ); |
|
2958 |
|
2959 RPacketService packetService; |
|
2960 OpenPacketServiceL( packetService ); |
|
2961 CleanupClosePushL( packetService ); |
|
2962 |
|
2963 RPacketService packetService2; |
|
2964 ret = packetService2.Open( phone2 ); |
|
2965 ASSERT_EQUALS( KErrNone, ret ); |
|
2966 CleanupClosePushL( packetService2 ); |
|
2967 |
|
2968 // Open first context |
|
2969 TInfoName contextId; |
|
2970 RPacketMbmsContext packetMbmsContext; |
|
2971 packetMbmsContext.OpenNewContext( packetService, contextId ); |
|
2972 CleanupClosePushL( packetMbmsContext ); |
|
2973 |
|
2974 |
|
2975 // Open second context |
|
2976 TInfoName contextId2; |
|
2977 RPacketMbmsContext packetMbmsContext2; |
|
2978 packetMbmsContext2.OpenNewContext( packetService2, contextId2 ); |
|
2979 CleanupClosePushL( packetMbmsContext2 ); |
|
2980 |
|
2981 TRequestStatus mockLtsyStatus; |
|
2982 iMockLTSY.NotifyTerminated( mockLtsyStatus ); |
|
2983 |
|
2984 |
|
2985 //------------------------------------------------------------------------- |
|
2986 // Test A: Test multiple clients requesting RPacketMbmsContext::NotifyConfigChanged |
|
2987 //------------------------------------------------------------------------- |
|
2988 |
|
2989 // If this API is flow controlled by Etel or if this API is |
|
2990 // synchronous, remove this test completely. |
|
2991 |
|
2992 // To write this test: |
|
2993 // If this API has parameters which have different versions, then each |
|
2994 // client in this test should use a different version of parameter. |
|
2995 // Otherwise, they should use the same version. |
|
2996 // All versions of parameters should be used. i.e. If there are three |
|
2997 // versions of a parameter, there should be three clients, one using |
|
2998 // each one. If the parameter does not have different versions, use |
|
2999 // two clients each using the same version. |
|
3000 |
|
3001 // data for NotifyConfigChanged 1 |
|
3002 TRequestStatus requestStatus; |
|
3003 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig1; |
|
3004 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig1( contextConfig1 ); |
|
3005 |
|
3006 //data for CompleteL 1 |
|
3007 RPacketMbmsContext::TContextConfigMbmsV1 configComplete1; |
|
3008 |
|
3009 TTmgi ttmgi; |
|
3010 ttmgi.SetServiceId(KMmConfigTMGI1); |
|
3011 ttmgi.SetMCC(KMmConfigTmgiMMC1); |
|
3012 ttmgi.SetMNC(KMmConfigTmgiMNC1); |
|
3013 |
|
3014 configComplete1.iTmgi = ttmgi; |
|
3015 configComplete1.iMbmsAccessBearer = E2GBearer; |
|
3016 configComplete1.iMbmsServicePriority = EMbmsMediumServicePriority; |
|
3017 configComplete1.iMbmsServiceMode = KBroadcast; |
|
3018 configComplete1.iMbmsSessionFlag = EFalse; |
|
3019 TMockLtsyData2<TInfoName, RPacketMbmsContext::TContextConfigMbmsV1> ltsyData( contextId, configComplete1 ); |
|
3020 ltsyData.SerialiseL( data ); |
|
3021 |
|
3022 // data for NotifyConfigChanged 2 |
|
3023 TRequestStatus requestStatus2; |
|
3024 RPacketMbmsContext::TContextConfigMbmsV1 contextConfig2; |
|
3025 TPckg<RPacketMbmsContext::TContextConfigMbmsV1> pckgConfig2( contextConfig2 ); |
|
3026 |
|
3027 //data for CompleteL 2 |
|
3028 RPacketMbmsContext::TContextConfigMbmsV1 configComplete2; |
|
3029 |
|
3030 configComplete2.iTmgi = ttmgi; |
|
3031 configComplete2.iMbmsAccessBearer = E2GBearer; |
|
3032 configComplete2.iMbmsServicePriority = EMbmsHighServicePriority; |
|
3033 configComplete2.iMbmsServiceMode = KSelectedBroadcast; |
|
3034 configComplete2.iMbmsSessionFlag = ETrue; |
|
3035 |
|
3036 TMockLtsyData2<TInfoName, RPacketMbmsContext::TContextConfigMbmsV1> ltsyData2( contextId2, configComplete2 ); |
|
3037 ltsyData2.SerialiseL( data2 ); |
|
3038 |
|
3039 // send first request |
|
3040 packetMbmsContext.NotifyConfigChanged( requestStatus, pckgConfig1 ); |
|
3041 |
|
3042 // send second request |
|
3043 packetMbmsContext2.NotifyConfigChanged( requestStatus2, pckgConfig2 ); |
|
3044 |
|
3045 // sent first completion |
|
3046 iMockLTSY.CompleteL( ECtsyPacketMbmsContextNotifyConfigChanged, KErrNone, data ); |
|
3047 |
|
3048 // sent second completion |
|
3049 iMockLTSY.CompleteL( ECtsyPacketMbmsContextNotifyConfigChanged, KErrNone, data2 ); |
|
3050 |
|
3051 |
|
3052 // wait for completion |
|
3053 User::WaitForRequest( mockLtsyStatus ); |
|
3054 |
|
3055 |
|
3056 // wait for first answer |
|
3057 User::WaitForRequest( requestStatus ); |
|
3058 |
|
3059 // wait for second answer |
|
3060 User::WaitForRequest( requestStatus2 ); |
|
3061 AssertMockLtsyStatusL(); |
|
3062 |
|
3063 ASSERT_EQUALS( KErrNone, requestStatus.Int() ); |
|
3064 ASSERT_EQUALS( configComplete1.iTmgi.GetServiceId(), contextConfig1.iTmgi.GetServiceId()); |
|
3065 ASSERT_EQUALS( configComplete1.iTmgi.GetMCC(), contextConfig1.iTmgi.GetMCC()); |
|
3066 ASSERT_EQUALS( configComplete1.iTmgi.GetMNC(), contextConfig1.iTmgi.GetMNC()); |
|
3067 ASSERT_EQUALS( configComplete1.iMbmsAccessBearer, contextConfig1.iMbmsAccessBearer); |
|
3068 ASSERT_EQUALS( configComplete1.iMbmsServicePriority, contextConfig1.iMbmsServicePriority); |
|
3069 ASSERT_EQUALS( configComplete1.iMbmsServiceMode, contextConfig1.iMbmsServiceMode); |
|
3070 ASSERT_EQUALS( configComplete1.iMbmsSessionFlag, contextConfig1.iMbmsSessionFlag); |
|
3071 |
|
3072 |
|
3073 ASSERT_EQUALS( KErrNone, requestStatus2.Int() ); |
|
3074 |
|
3075 ASSERT_EQUALS( configComplete2.iTmgi.GetServiceId(), contextConfig2.iTmgi.GetServiceId()); |
|
3076 ASSERT_EQUALS( configComplete2.iTmgi.GetMCC(), contextConfig2.iTmgi.GetMCC()); |
|
3077 ASSERT_EQUALS( configComplete2.iTmgi.GetMNC(), contextConfig2.iTmgi.GetMNC()); |
|
3078 ASSERT_EQUALS( configComplete2.iMbmsAccessBearer, contextConfig2.iMbmsAccessBearer); |
|
3079 ASSERT_EQUALS( configComplete2.iMbmsServicePriority, contextConfig2.iMbmsServicePriority); |
|
3080 ASSERT_EQUALS( configComplete2.iMbmsServiceMode, contextConfig2.iMbmsServiceMode); |
|
3081 ASSERT_EQUALS( configComplete2.iMbmsSessionFlag, contextConfig2.iMbmsSessionFlag); |
|
3082 |
|
3083 |
|
3084 // Done ! |
|
3085 CleanupStack::PopAndDestroy( 9, this ); //packetMbmsContext2, packetMbmsContext, packetService2, packetService, phone2, telServer2, data, data2 this |
|
3086 } |
|
3087 |
|
3088 /** |
|
3089 @SYMTestCaseID |
|
3090 @SYMComponent telephony_ctsy |
|
3091 @SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::NotifyStatusChange |
|
3092 @SYMTestPriority High |
|
3093 @SYMTestActions Invokes RPacketMbmsContext::NotifyStatusChange |
|
3094 @SYMTestExpectedResults Pass |
|
3095 @SYMTestType CT |
|
3096 */ |
|
3097 void CCTsyMbmsContextFU::TestNotifyStatusChange0001L() |
|
3098 { |
|
3099 |
|
3100 OpenEtelServerL(EUseExtendedError); |
|
3101 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
3102 OpenPhoneL(); |
|
3103 |
|
3104 RBuf8 data; |
|
3105 CleanupClosePushL(data); |
|
3106 |
|
3107 RPacketService packetService; |
|
3108 OpenPacketServiceL(packetService); |
|
3109 CleanupClosePushL(packetService); |
|
3110 |
|
3111 // Open new context |
|
3112 TInfoName contextId; |
|
3113 RPacketMbmsContext mbmsContext; |
|
3114 mbmsContext.OpenNewContext(packetService, contextId); |
|
3115 CleanupClosePushL(mbmsContext); |
|
3116 |
|
3117 TRequestStatus mockLtsyStatus; |
|
3118 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
3119 |
|
3120 // data for NotifyStatusChange |
|
3121 TRequestStatus requestStatus; |
|
3122 RPacketContext::TContextStatus contextStatus; |
|
3123 |
|
3124 //------------------------------------------------------------------------- |
|
3125 // TEST C: Successful completion request of |
|
3126 // RPacketContext::NotifyStatusChange when result is not cached. |
|
3127 //------------------------------------------------------------------------- |
|
3128 //data for CompleteL |
|
3129 TContextMisc completeMisc; |
|
3130 completeMisc.iStatus = RPacketContext::EStatusActive; |
|
3131 TMockLtsyData2 <TInfoName, TContextMisc> ltsyData(contextId, completeMisc); |
|
3132 ltsyData.SerialiseL(data); |
|
3133 //send request |
|
3134 mbmsContext.NotifyStatusChange(requestStatus, contextStatus); |
|
3135 //send completion |
|
3136 iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data); |
|
3137 // wait for completion |
|
3138 User::WaitForRequest(mockLtsyStatus); |
|
3139 |
|
3140 // wait for NotifyStatusChange |
|
3141 User::WaitForRequest(requestStatus); |
|
3142 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
3143 ASSERT_EQUALS(completeMisc.iStatus, contextStatus); |
|
3144 AssertMockLtsyStatusL(); |
|
3145 |
|
3146 //------------------------------------------------------------------------- |
|
3147 // TEST E: Unsolicited completion of RPacketContext::NotifyStatusChange |
|
3148 // from LTSY. |
|
3149 //------------------------------------------------------------------------- |
|
3150 //data for ComleteL |
|
3151 completeMisc.iStatus = RPacketContext::EStatusInactive; |
|
3152 TMockLtsyData2 <TInfoName, TContextMisc> ltsyData1(contextId, completeMisc); |
|
3153 data.Close(); |
|
3154 ltsyData1.SerialiseL(data); |
|
3155 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
3156 //send completion |
|
3157 iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data); |
|
3158 // wait for completion |
|
3159 User::WaitForRequest(mockLtsyStatus); |
|
3160 ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int()); |
|
3161 |
|
3162 AssertMockLtsyStatusL(); |
|
3163 CleanupStack::PopAndDestroy(2); // packetContext, packetService |
|
3164 CleanupStack::PopAndDestroy(2, this); // data, this |
|
3165 |
|
3166 } |
|
3167 |
|
3168 /** |
|
3169 @SYMTestCaseID BA-CTSY-MCF-PNSC-0002 |
|
3170 @SYMComponent telephony_ctsy |
|
3171 @SYMTestCaseDesc Test support in CTSY for cancelling of RPacketMbmsContext::NotifyStatusChange |
|
3172 @SYMTestPriority High |
|
3173 @SYMTestActions Invokes cancelling of RPacketMbmsContext::NotifyStatusChange |
|
3174 @SYMTestExpectedResults Pass |
|
3175 @SYMTestType CT |
|
3176 */ |
|
3177 void CCTsyMbmsContextFU::TestNotifyStatusChange0002L() |
|
3178 { |
|
3179 |
|
3180 // This test should test cancellation of NotifyStatusChange |
|
3181 // If this API does not have a cancel, the test step should be completely removed. |
|
3182 |
|
3183 OpenEtelServerL(EUseExtendedError); |
|
3184 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
3185 OpenPhoneL(); |
|
3186 |
|
3187 RBuf8 data; |
|
3188 CleanupClosePushL(data); |
|
3189 |
|
3190 RPacketService packetService; |
|
3191 OpenPacketServiceL(packetService); |
|
3192 CleanupClosePushL(packetService); |
|
3193 |
|
3194 // Open new context |
|
3195 TInfoName contextId; |
|
3196 RPacketMbmsContext mbmsContext; |
|
3197 mbmsContext.OpenNewContext(packetService, contextId); |
|
3198 CleanupClosePushL(mbmsContext); |
|
3199 |
|
3200 TRequestStatus mockLtsyStatus; |
|
3201 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
3202 |
|
3203 // data for NotifyStatusChange |
|
3204 TRequestStatus requestStatus; |
|
3205 RPacketContext::TContextStatus contextStatus; |
|
3206 |
|
3207 //------------------------------------------------------------------------- |
|
3208 // Test cancelling of RPacketContext::NotifyStatusChange |
|
3209 //------------------------------------------------------------------------- |
|
3210 //data for ComleteL |
|
3211 TContextMisc completeMisc; |
|
3212 completeMisc.iStatus = RPacketContext::EStatusInactive; |
|
3213 TMockLtsyData2 <TInfoName, TContextMisc> ltsyData(contextId, completeMisc); |
|
3214 ltsyData.SerialiseL(data); |
|
3215 //send request |
|
3216 mbmsContext.NotifyStatusChange(requestStatus, contextStatus); |
|
3217 // send canceling... |
|
3218 mbmsContext.CancelAsyncRequest(EPacketContextNotifyStatusChange); |
|
3219 |
|
3220 //send completion |
|
3221 iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data); |
|
3222 // wait for completion |
|
3223 User::WaitForRequest(mockLtsyStatus); |
|
3224 |
|
3225 // wait for NotifyStatusChange |
|
3226 User::WaitForRequest(requestStatus); |
|
3227 ASSERT_EQUALS(KErrCancel, requestStatus.Int()); |
|
3228 |
|
3229 // Wait for completion of iMockLTSY.NotifyTerminated |
|
3230 CleanupStack::PopAndDestroy(2); // packetContext, packetService |
|
3231 CleanupStack::PopAndDestroy(2); // data, this |
|
3232 |
|
3233 } |
|
3234 |
|
3235 /** |
|
3236 @SYMTestCaseID BA-CTSY-MCF-PNSC-0003 |
|
3237 @SYMComponent telephony_ctsy |
|
3238 @SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketMbmsContext::NotifyStatusChange |
|
3239 @SYMTestPriority High |
|
3240 @SYMTestActions Invokes multiple client requests to RPacketMbmsContext::NotifyStatusChange |
|
3241 @SYMTestExpectedResults Pass |
|
3242 @SYMTestType CT |
|
3243 */ |
|
3244 void CCTsyMbmsContextFU::TestNotifyStatusChange0003L() |
|
3245 { |
|
3246 |
|
3247 OpenEtelServerL(EUseExtendedError); |
|
3248 CleanupStack::PushL(TCleanupItem(Cleanup,this)); |
|
3249 OpenPhoneL(); |
|
3250 |
|
3251 RBuf8 data; |
|
3252 CleanupClosePushL(data); |
|
3253 |
|
3254 RBuf8 data2; |
|
3255 CleanupClosePushL(data2); |
|
3256 |
|
3257 // Open second client |
|
3258 RTelServer telServer2; |
|
3259 TInt ret = telServer2.Connect(); |
|
3260 ASSERT_EQUALS(KErrNone, ret); |
|
3261 CleanupClosePushL(telServer2); |
|
3262 |
|
3263 RMobilePhone phone2; |
|
3264 ret = phone2.Open(iTelServer,KMmTsyPhoneName); |
|
3265 ASSERT_EQUALS(KErrNone, ret); |
|
3266 CleanupClosePushL(phone2); |
|
3267 |
|
3268 RPacketService packetService; |
|
3269 OpenPacketServiceL(packetService); |
|
3270 CleanupClosePushL(packetService); |
|
3271 |
|
3272 RPacketService packetService2; |
|
3273 ret = packetService2.Open(phone2); |
|
3274 ASSERT_EQUALS(KErrNone, ret); |
|
3275 CleanupClosePushL(packetService2); |
|
3276 |
|
3277 // Open first context |
|
3278 TInfoName contextId; |
|
3279 RPacketMbmsContext mbmsContext; |
|
3280 mbmsContext.OpenNewContext(packetService, contextId); |
|
3281 CleanupClosePushL(mbmsContext); |
|
3282 |
|
3283 // Open second context |
|
3284 TInfoName contextId2; |
|
3285 RPacketMbmsContext mbmsContext2; |
|
3286 mbmsContext2.OpenNewContext(packetService2, contextId2); |
|
3287 CleanupClosePushL(mbmsContext2); |
|
3288 |
|
3289 TRequestStatus mockLtsyStatus; |
|
3290 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
3291 |
|
3292 |
|
3293 //------------------------------------------------------------------------- |
|
3294 // Test A: Test multiple clients requesting RPacketContext::NotifyStatusChange |
|
3295 //------------------------------------------------------------------------- |
|
3296 |
|
3297 // If this API is flow controlled by Etel or if this API is |
|
3298 // synchronous, remove this test completely. |
|
3299 |
|
3300 // To write this test: |
|
3301 // If this API has parameters which have different versions, then each |
|
3302 // client in this test should use a different version of parameter. |
|
3303 // Otherwise, they should use the same version. |
|
3304 // All versions of parameters should be used. i.e. If there are three |
|
3305 // versions of a parameter, there should be three clients, one using |
|
3306 // each one. If the parameter does not have different versions, use |
|
3307 // two clients each using the same version. |
|
3308 |
|
3309 //data for ComleteL for first context |
|
3310 TContextMisc completeMisc; |
|
3311 completeMisc.iStatus = RPacketContext::EStatusInactive; |
|
3312 TMockLtsyData2 <TInfoName, TContextMisc> ltsyData(contextId, completeMisc); |
|
3313 ltsyData.SerialiseL(data); |
|
3314 |
|
3315 //data for ComleteL for second context |
|
3316 TContextMisc completeMisc2; |
|
3317 completeMisc2.iStatus = RPacketContext::EStatusSuspended; |
|
3318 TMockLtsyData2 <TInfoName, TContextMisc> ltsyData2(contextId2, completeMisc2); |
|
3319 ltsyData2.SerialiseL(data2); |
|
3320 |
|
3321 // initialize data for first context's NotifyStatusChange |
|
3322 TRequestStatus requestStatus; |
|
3323 RPacketContext::TContextStatus contextStatus; |
|
3324 |
|
3325 // initialize data for second context's NotifyStatusChange |
|
3326 TRequestStatus requestStatus2; |
|
3327 RPacketContext::TContextStatus contextStatus2; |
|
3328 |
|
3329 //send first request |
|
3330 mbmsContext.NotifyStatusChange(requestStatus, contextStatus); |
|
3331 |
|
3332 //send second request |
|
3333 mbmsContext2.NotifyStatusChange(requestStatus2, contextStatus2); |
|
3334 |
|
3335 //send completion for first comtext |
|
3336 iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data); |
|
3337 // wait for completion |
|
3338 User::WaitForRequest(mockLtsyStatus); |
|
3339 |
|
3340 // wait for first context NotifyStatusChange |
|
3341 User::WaitForRequest(requestStatus); |
|
3342 ASSERT_EQUALS(KErrNone, requestStatus.Int()); |
|
3343 ASSERT_EQUALS(completeMisc.iStatus, contextStatus); |
|
3344 |
|
3345 |
|
3346 iMockLTSY.NotifyTerminated(mockLtsyStatus); |
|
3347 //send completion for second comtext |
|
3348 iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data2); |
|
3349 // wait for completion |
|
3350 User::WaitForRequest(mockLtsyStatus); |
|
3351 |
|
3352 // wait for second context NotifyStatusChange |
|
3353 User::WaitForRequest(requestStatus2); |
|
3354 ASSERT_EQUALS(KErrNone, requestStatus2.Int()); |
|
3355 ASSERT_EQUALS(completeMisc2.iStatus, contextStatus2); |
|
3356 |
|
3357 AssertMockLtsyStatusL(); |
|
3358 |
|
3359 // Done ! |
|
3360 CleanupStack::PopAndDestroy(4);// packetContext2, packetContext, packetService2, packetService |
|
3361 CleanupStack::PopAndDestroy(5, this); // phone2, telServer2, data, data2, this |
|
3362 |
|
3363 } |