|
1 // Copyright (c) 2007-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 // Test step definitions for the CustomAPI functional unit. |
|
15 // |
|
16 // |
|
17 |
|
18 /** |
|
19 @internalTechnology |
|
20 */ |
|
21 |
|
22 #include "cctsyintegrationtestcustomapi.h" |
|
23 |
|
24 #include <ctsy/rmmcustomapi.h> |
|
25 |
|
26 |
|
27 CCTSYIntegrationTestCustomAPIBase::CCTSYIntegrationTestCustomAPIBase(CEtelSessionMgr& aEtelSessionMgr) |
|
28 : CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), iCustomApiTsyTestHelper(*this) |
|
29 /** |
|
30 * Constructor |
|
31 */ |
|
32 { |
|
33 } |
|
34 |
|
35 CCTSYIntegrationTestCustomAPIBase::~CCTSYIntegrationTestCustomAPIBase() |
|
36 /* |
|
37 * Destructor |
|
38 */ |
|
39 { |
|
40 } |
|
41 |
|
42 |
|
43 CCTSYIntegrationTestCustomAPI0001::CCTSYIntegrationTestCustomAPI0001(CEtelSessionMgr& aEtelSessionMgr) |
|
44 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
45 /** |
|
46 * Constructor. |
|
47 */ |
|
48 { |
|
49 SetTestStepName(CCTSYIntegrationTestCustomAPI0001::GetTestStepName()); |
|
50 } |
|
51 |
|
52 CCTSYIntegrationTestCustomAPI0001::~CCTSYIntegrationTestCustomAPI0001() |
|
53 /** |
|
54 * Destructor. |
|
55 */ |
|
56 { |
|
57 } |
|
58 |
|
59 TVerdict CCTSYIntegrationTestCustomAPI0001::doTestStepL() |
|
60 /** |
|
61 * @SYMTestCaseID BA-CTSY-INT-CAPI-0001 |
|
62 * @SYMFssID BA/CTSY/CAPI-0001 |
|
63 * @SYMTestCaseDesc Test calling RMmCustomAPI::SetDriveMode |
|
64 * @SYMTestPriority High |
|
65 * @SYMTestActions |
|
66 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
67 * @SYMTestType CIT |
|
68 * @SYMTestCaseDependencies live/automatic |
|
69 * |
|
70 * Reason for test: Test calling RMmCustomAPI::SetDriveMode |
|
71 * |
|
72 * @return - TVerdict code |
|
73 */ |
|
74 { |
|
75 |
|
76 // |
|
77 // SET UP |
|
78 // |
|
79 |
|
80 RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone); |
|
81 RMmCustomAPI& customApi = iEtelSessionMgr.GetCustomApiL(KMainServer, KMainPhone, KMainCustomApi); |
|
82 |
|
83 // |
|
84 // SET UP END |
|
85 // |
|
86 |
|
87 StartTest(); |
|
88 |
|
89 // |
|
90 // TEST START |
|
91 // |
|
92 |
|
93 |
|
94 // Test calling RMmCustomAPI::SetDriveMode |
|
95 TExtEtelRequestStatus setDriveModeStatus(customApi, ECustomSetDriveModeIPC); |
|
96 CleanupStack::PushL(setDriveModeStatus); |
|
97 RMmCustomAPI::TSetDriveMode driveMode = RMmCustomAPI::EActivateDriveMode; |
|
98 customApi.SetDriveMode(setDriveModeStatus, driveMode); |
|
99 ASSERT_EQUALS(WaitForRequestWithTimeOut(setDriveModeStatus, ETimeMedium), KErrNone, _L("RMmCustomAPI::SetDriveMode timed out")); |
|
100 ASSERT_EQUALS(setDriveModeStatus.Int(), KErrNone, _L("RMmCustomAPI::SetDriveMode returned an error")); |
|
101 |
|
102 |
|
103 // |
|
104 // TEST END |
|
105 // |
|
106 |
|
107 StartCleanup(); |
|
108 |
|
109 // setDriveModeStatus |
|
110 CleanupStack::PopAndDestroy(1, &setDriveModeStatus); |
|
111 |
|
112 return TestStepResult(); |
|
113 } |
|
114 |
|
115 TPtrC CCTSYIntegrationTestCustomAPI0001::GetTestStepName() |
|
116 /** |
|
117 * @return The test step name. |
|
118 */ |
|
119 { |
|
120 return _L("CCTSYIntegrationTestCustomAPI0001"); |
|
121 } |
|
122 |
|
123 |
|
124 |
|
125 CCTSYIntegrationTestCustomAPI0002::CCTSYIntegrationTestCustomAPI0002(CEtelSessionMgr& aEtelSessionMgr) |
|
126 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
127 /** |
|
128 * Constructor. |
|
129 */ |
|
130 { |
|
131 SetTestStepName(CCTSYIntegrationTestCustomAPI0002::GetTestStepName()); |
|
132 } |
|
133 |
|
134 CCTSYIntegrationTestCustomAPI0002::~CCTSYIntegrationTestCustomAPI0002() |
|
135 /** |
|
136 * Destructor. |
|
137 */ |
|
138 { |
|
139 } |
|
140 |
|
141 TVerdict CCTSYIntegrationTestCustomAPI0002::doTestStepL() |
|
142 /** |
|
143 * @SYMTestCaseID BA-CTSY-INT-CAPI-0002 |
|
144 * @SYMFssID BA/CTSY/CAPI-0002 |
|
145 * @SYMTestCaseDesc Test calling RMmCustomAPI::ActivateSimLock |
|
146 * @SYMTestPriority High |
|
147 * @SYMTestActions |
|
148 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
149 * @SYMTestType CIT |
|
150 * @SYMTestCaseDependencies live/automatic |
|
151 * |
|
152 * Reason for test: Test calling RMmCustomAPI::ActivateSimLock |
|
153 * |
|
154 * @return - TVerdict code |
|
155 */ |
|
156 { |
|
157 |
|
158 // |
|
159 // SET UP |
|
160 // |
|
161 |
|
162 |
|
163 |
|
164 // |
|
165 // SET UP END |
|
166 // |
|
167 |
|
168 StartTest(); |
|
169 |
|
170 // |
|
171 // TEST START |
|
172 // |
|
173 |
|
174 |
|
175 // Test calling RMmCustomAPI::ActivateSimLock |
|
176 |
|
177 |
|
178 // |
|
179 // TEST END |
|
180 // |
|
181 |
|
182 StartCleanup(); |
|
183 |
|
184 // Put any required test clean up here, then remove this comment |
|
185 |
|
186 return TestStepResult(); |
|
187 } |
|
188 |
|
189 TPtrC CCTSYIntegrationTestCustomAPI0002::GetTestStepName() |
|
190 /** |
|
191 * @return The test step name. |
|
192 */ |
|
193 { |
|
194 return _L("CCTSYIntegrationTestCustomAPI0002"); |
|
195 } |
|
196 |
|
197 |
|
198 |
|
199 CCTSYIntegrationTestCustomAPI0003::CCTSYIntegrationTestCustomAPI0003(CEtelSessionMgr& aEtelSessionMgr) |
|
200 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
201 /** |
|
202 * Constructor. |
|
203 */ |
|
204 { |
|
205 SetTestStepName(CCTSYIntegrationTestCustomAPI0003::GetTestStepName()); |
|
206 } |
|
207 |
|
208 CCTSYIntegrationTestCustomAPI0003::~CCTSYIntegrationTestCustomAPI0003() |
|
209 /** |
|
210 * Destructor. |
|
211 */ |
|
212 { |
|
213 } |
|
214 |
|
215 TVerdict CCTSYIntegrationTestCustomAPI0003::doTestStepL() |
|
216 /** |
|
217 * @SYMTestCaseID BA-CTSY-INT-CAPI-0003 |
|
218 * @SYMFssID BA/CTSY/CAPI-0003 |
|
219 * @SYMTestCaseDesc Test calling RMmCustomAPI::DeActivateSimLock |
|
220 * @SYMTestPriority High |
|
221 * @SYMTestActions |
|
222 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
223 * @SYMTestType CIT |
|
224 * @SYMTestCaseDependencies live/automatic |
|
225 * |
|
226 * Reason for test: Test calling RMmCustomAPI::DeActivateSimLock |
|
227 * |
|
228 * @return - TVerdict code |
|
229 */ |
|
230 { |
|
231 |
|
232 // |
|
233 // SET UP |
|
234 // |
|
235 |
|
236 |
|
237 |
|
238 // |
|
239 // SET UP END |
|
240 // |
|
241 |
|
242 StartTest(); |
|
243 |
|
244 // |
|
245 // TEST START |
|
246 // |
|
247 |
|
248 |
|
249 // Test calling RMmCustomAPI::DeActivateSimLock |
|
250 |
|
251 |
|
252 // |
|
253 // TEST END |
|
254 // |
|
255 |
|
256 StartCleanup(); |
|
257 |
|
258 // Put any required test clean up here, then remove this comment |
|
259 |
|
260 return TestStepResult(); |
|
261 } |
|
262 |
|
263 TPtrC CCTSYIntegrationTestCustomAPI0003::GetTestStepName() |
|
264 /** |
|
265 * @return The test step name. |
|
266 */ |
|
267 { |
|
268 return _L("CCTSYIntegrationTestCustomAPI0003"); |
|
269 } |
|
270 |
|
271 |
|
272 |
|
273 CCTSYIntegrationTestCustomAPI0004::CCTSYIntegrationTestCustomAPI0004(CEtelSessionMgr& aEtelSessionMgr) |
|
274 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
275 /** |
|
276 * Constructor. |
|
277 */ |
|
278 { |
|
279 SetTestStepName(CCTSYIntegrationTestCustomAPI0004::GetTestStepName()); |
|
280 } |
|
281 |
|
282 CCTSYIntegrationTestCustomAPI0004::~CCTSYIntegrationTestCustomAPI0004() |
|
283 /** |
|
284 * Destructor. |
|
285 */ |
|
286 { |
|
287 } |
|
288 |
|
289 TVerdict CCTSYIntegrationTestCustomAPI0004::doTestStepL() |
|
290 /** |
|
291 * @SYMTestCaseID BA-CTSY-INT-CAPI-0004 |
|
292 * @SYMFssID BA/CTSY/CAPI-0004 |
|
293 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifyDtmfEvent |
|
294 * @SYMTestPriority High |
|
295 * @SYMTestActions |
|
296 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
297 * @SYMTestType CIT |
|
298 * @SYMTestCaseDependencies live/automatic |
|
299 * |
|
300 * Reason for test: Test calling RMmCustomAPI::NotifyDtmfEvent |
|
301 * |
|
302 * @return - TVerdict code |
|
303 */ |
|
304 { |
|
305 |
|
306 // |
|
307 // SET UP |
|
308 // |
|
309 |
|
310 |
|
311 |
|
312 // |
|
313 // SET UP END |
|
314 // |
|
315 |
|
316 StartTest(); |
|
317 |
|
318 // |
|
319 // TEST START |
|
320 // |
|
321 |
|
322 |
|
323 // Test calling RMmCustomAPI::NotifyDtmfEvent |
|
324 |
|
325 |
|
326 // |
|
327 // TEST END |
|
328 // |
|
329 |
|
330 StartCleanup(); |
|
331 |
|
332 // Put any required test clean up here, then remove this comment |
|
333 |
|
334 return TestStepResult(); |
|
335 } |
|
336 |
|
337 TPtrC CCTSYIntegrationTestCustomAPI0004::GetTestStepName() |
|
338 /** |
|
339 * @return The test step name. |
|
340 */ |
|
341 { |
|
342 return _L("CCTSYIntegrationTestCustomAPI0004"); |
|
343 } |
|
344 |
|
345 |
|
346 |
|
347 CCTSYIntegrationTestCustomAPI0005::CCTSYIntegrationTestCustomAPI0005(CEtelSessionMgr& aEtelSessionMgr) |
|
348 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
349 /** |
|
350 * Constructor. |
|
351 */ |
|
352 { |
|
353 SetTestStepName(CCTSYIntegrationTestCustomAPI0005::GetTestStepName()); |
|
354 } |
|
355 |
|
356 CCTSYIntegrationTestCustomAPI0005::~CCTSYIntegrationTestCustomAPI0005() |
|
357 /** |
|
358 * Destructor. |
|
359 */ |
|
360 { |
|
361 } |
|
362 |
|
363 TVerdict CCTSYIntegrationTestCustomAPI0005::doTestStepL() |
|
364 /** |
|
365 * @SYMTestCaseID BA-CTSY-INT-CAPI-0005 |
|
366 * @SYMFssID BA/CTSY/CAPI-0005 |
|
367 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetDiagnosticOctets |
|
368 * @SYMTestPriority High |
|
369 * @SYMTestActions |
|
370 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
371 * @SYMTestType CIT |
|
372 * @SYMTestCaseDependencies live/automatic |
|
373 * |
|
374 * Reason for test: Test calling RMmCustomAPI::GetDiagnosticOctets |
|
375 * |
|
376 * @return - TVerdict code |
|
377 */ |
|
378 { |
|
379 |
|
380 // |
|
381 // SET UP |
|
382 // |
|
383 |
|
384 |
|
385 |
|
386 // |
|
387 // SET UP END |
|
388 // |
|
389 |
|
390 StartTest(); |
|
391 |
|
392 // |
|
393 // TEST START |
|
394 // |
|
395 |
|
396 |
|
397 // Test calling RMmCustomAPI::GetDiagnosticOctets |
|
398 |
|
399 |
|
400 // |
|
401 // TEST END |
|
402 // |
|
403 |
|
404 StartCleanup(); |
|
405 |
|
406 // Put any required test clean up here, then remove this comment |
|
407 |
|
408 return TestStepResult(); |
|
409 } |
|
410 |
|
411 TPtrC CCTSYIntegrationTestCustomAPI0005::GetTestStepName() |
|
412 /** |
|
413 * @return The test step name. |
|
414 */ |
|
415 { |
|
416 return _L("CCTSYIntegrationTestCustomAPI0005"); |
|
417 } |
|
418 |
|
419 |
|
420 |
|
421 CCTSYIntegrationTestCustomAPI0006::CCTSYIntegrationTestCustomAPI0006(CEtelSessionMgr& aEtelSessionMgr) |
|
422 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
423 /** |
|
424 * Constructor. |
|
425 */ |
|
426 { |
|
427 SetTestStepName(CCTSYIntegrationTestCustomAPI0006::GetTestStepName()); |
|
428 } |
|
429 |
|
430 CCTSYIntegrationTestCustomAPI0006::~CCTSYIntegrationTestCustomAPI0006() |
|
431 /** |
|
432 * Destructor. |
|
433 */ |
|
434 { |
|
435 } |
|
436 |
|
437 TVerdict CCTSYIntegrationTestCustomAPI0006::doTestStepL() |
|
438 /** |
|
439 * @SYMTestCaseID BA-CTSY-INT-CAPI-0006 |
|
440 * @SYMFssID BA/CTSY/CAPI-0006 |
|
441 * @SYMTestCaseDesc Test calling RMmCustomAPI::SetAlsBlocked |
|
442 * @SYMTestPriority High |
|
443 * @SYMTestActions |
|
444 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
445 * @SYMTestType CIT |
|
446 * @SYMTestCaseDependencies live/manual |
|
447 * |
|
448 * Reason for test: Test calling RMmCustomAPI::SetAlsBlocked |
|
449 * |
|
450 * @return - TVerdict code |
|
451 */ |
|
452 { |
|
453 |
|
454 // |
|
455 // SET UP |
|
456 // |
|
457 |
|
458 |
|
459 |
|
460 // |
|
461 // SET UP END |
|
462 // |
|
463 |
|
464 StartTest(); |
|
465 |
|
466 // |
|
467 // TEST START |
|
468 // |
|
469 |
|
470 |
|
471 // Test calling RMmCustomAPI::SetAlsBlocked |
|
472 |
|
473 |
|
474 // |
|
475 // TEST END |
|
476 // |
|
477 |
|
478 StartCleanup(); |
|
479 |
|
480 // Put any required test clean up here, then remove this comment |
|
481 |
|
482 return TestStepResult(); |
|
483 } |
|
484 |
|
485 TPtrC CCTSYIntegrationTestCustomAPI0006::GetTestStepName() |
|
486 /** |
|
487 * @return The test step name. |
|
488 */ |
|
489 { |
|
490 return _L("CCTSYIntegrationTestCustomAPI0006"); |
|
491 } |
|
492 |
|
493 |
|
494 |
|
495 CCTSYIntegrationTestCustomAPI0007::CCTSYIntegrationTestCustomAPI0007(CEtelSessionMgr& aEtelSessionMgr) |
|
496 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
497 /** |
|
498 * Constructor. |
|
499 */ |
|
500 { |
|
501 SetTestStepName(CCTSYIntegrationTestCustomAPI0007::GetTestStepName()); |
|
502 } |
|
503 |
|
504 CCTSYIntegrationTestCustomAPI0007::~CCTSYIntegrationTestCustomAPI0007() |
|
505 /** |
|
506 * Destructor. |
|
507 */ |
|
508 { |
|
509 } |
|
510 |
|
511 TVerdict CCTSYIntegrationTestCustomAPI0007::doTestStepL() |
|
512 /** |
|
513 * @SYMTestCaseID BA-CTSY-INT-CAPI-0007 |
|
514 * @SYMFssID BA/CTSY/CAPI-0007 |
|
515 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetAlsBlocked |
|
516 * @SYMTestPriority High |
|
517 * @SYMTestActions |
|
518 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
519 * @SYMTestType CIT |
|
520 * @SYMTestCaseDependencies live/manual |
|
521 * |
|
522 * Reason for test: Test calling RMmCustomAPI::GetAlsBlocked |
|
523 * |
|
524 * @return - TVerdict code |
|
525 */ |
|
526 { |
|
527 |
|
528 // |
|
529 // SET UP |
|
530 // |
|
531 |
|
532 |
|
533 |
|
534 // |
|
535 // SET UP END |
|
536 // |
|
537 |
|
538 StartTest(); |
|
539 |
|
540 // |
|
541 // TEST START |
|
542 // |
|
543 |
|
544 |
|
545 // Test calling RMmCustomAPI::GetAlsBlocked |
|
546 |
|
547 |
|
548 // |
|
549 // TEST END |
|
550 // |
|
551 |
|
552 StartCleanup(); |
|
553 |
|
554 // Put any required test clean up here, then remove this comment |
|
555 |
|
556 return TestStepResult(); |
|
557 } |
|
558 |
|
559 TPtrC CCTSYIntegrationTestCustomAPI0007::GetTestStepName() |
|
560 /** |
|
561 * @return The test step name. |
|
562 */ |
|
563 { |
|
564 return _L("CCTSYIntegrationTestCustomAPI0007"); |
|
565 } |
|
566 |
|
567 |
|
568 |
|
569 CCTSYIntegrationTestCustomAPI0008::CCTSYIntegrationTestCustomAPI0008(CEtelSessionMgr& aEtelSessionMgr) |
|
570 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
571 /** |
|
572 * Constructor. |
|
573 */ |
|
574 { |
|
575 SetTestStepName(CCTSYIntegrationTestCustomAPI0008::GetTestStepName()); |
|
576 } |
|
577 |
|
578 CCTSYIntegrationTestCustomAPI0008::~CCTSYIntegrationTestCustomAPI0008() |
|
579 /** |
|
580 * Destructor. |
|
581 */ |
|
582 { |
|
583 } |
|
584 |
|
585 TVerdict CCTSYIntegrationTestCustomAPI0008::doTestStepL() |
|
586 /** |
|
587 * @SYMTestCaseID BA-CTSY-INT-CAPI-0008 |
|
588 * @SYMFssID BA/CTSY/CAPI-0008 |
|
589 * @SYMTestCaseDesc Test calling RMmCustomAPI::CheckAlsPpSupport |
|
590 * @SYMTestPriority High |
|
591 * @SYMTestActions |
|
592 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
593 * @SYMTestType CIT |
|
594 * @SYMTestCaseDependencies live/manual |
|
595 * |
|
596 * Reason for test: Test calling RMmCustomAPI::CheckAlsPpSupport |
|
597 * |
|
598 * @return - TVerdict code |
|
599 */ |
|
600 { |
|
601 |
|
602 // |
|
603 // SET UP |
|
604 // |
|
605 |
|
606 |
|
607 |
|
608 // |
|
609 // SET UP END |
|
610 // |
|
611 |
|
612 StartTest(); |
|
613 |
|
614 // |
|
615 // TEST START |
|
616 // |
|
617 |
|
618 |
|
619 // Test calling RMmCustomAPI::CheckAlsPpSupport |
|
620 |
|
621 |
|
622 // |
|
623 // TEST END |
|
624 // |
|
625 |
|
626 StartCleanup(); |
|
627 |
|
628 // Put any required test clean up here, then remove this comment |
|
629 |
|
630 return TestStepResult(); |
|
631 } |
|
632 |
|
633 TPtrC CCTSYIntegrationTestCustomAPI0008::GetTestStepName() |
|
634 /** |
|
635 * @return The test step name. |
|
636 */ |
|
637 { |
|
638 return _L("CCTSYIntegrationTestCustomAPI0008"); |
|
639 } |
|
640 |
|
641 |
|
642 |
|
643 CCTSYIntegrationTestCustomAPI0009::CCTSYIntegrationTestCustomAPI0009(CEtelSessionMgr& aEtelSessionMgr) |
|
644 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
645 /** |
|
646 * Constructor. |
|
647 */ |
|
648 { |
|
649 SetTestStepName(CCTSYIntegrationTestCustomAPI0009::GetTestStepName()); |
|
650 } |
|
651 |
|
652 CCTSYIntegrationTestCustomAPI0009::~CCTSYIntegrationTestCustomAPI0009() |
|
653 /** |
|
654 * Destructor. |
|
655 */ |
|
656 { |
|
657 } |
|
658 |
|
659 TVerdict CCTSYIntegrationTestCustomAPI0009::doTestStepL() |
|
660 /** |
|
661 * @SYMTestCaseID BA-CTSY-INT-CAPI-0009 |
|
662 * @SYMFssID BA/CTSY/CAPI-0009 |
|
663 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetRemoteAlertingToneStatus |
|
664 * @SYMTestPriority High |
|
665 * @SYMTestActions |
|
666 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
667 * @SYMTestType CIT |
|
668 * @SYMTestCaseDependencies live/automatic |
|
669 * |
|
670 * Reason for test: Test calling RMmCustomAPI::GetRemoteAlertingToneStatus |
|
671 * |
|
672 * @return - TVerdict code |
|
673 */ |
|
674 { |
|
675 |
|
676 // |
|
677 // SET UP |
|
678 // |
|
679 |
|
680 |
|
681 |
|
682 // |
|
683 // SET UP END |
|
684 // |
|
685 |
|
686 StartTest(); |
|
687 |
|
688 // |
|
689 // TEST START |
|
690 // |
|
691 |
|
692 |
|
693 // Test calling RMmCustomAPI::GetRemoteAlertingToneStatus |
|
694 |
|
695 |
|
696 // |
|
697 // TEST END |
|
698 // |
|
699 |
|
700 StartCleanup(); |
|
701 |
|
702 // Put any required test clean up here, then remove this comment |
|
703 |
|
704 return TestStepResult(); |
|
705 } |
|
706 |
|
707 TPtrC CCTSYIntegrationTestCustomAPI0009::GetTestStepName() |
|
708 /** |
|
709 * @return The test step name. |
|
710 */ |
|
711 { |
|
712 return _L("CCTSYIntegrationTestCustomAPI0009"); |
|
713 } |
|
714 |
|
715 |
|
716 |
|
717 CCTSYIntegrationTestCustomAPI0010::CCTSYIntegrationTestCustomAPI0010(CEtelSessionMgr& aEtelSessionMgr) |
|
718 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
719 /** |
|
720 * Constructor. |
|
721 */ |
|
722 { |
|
723 SetTestStepName(CCTSYIntegrationTestCustomAPI0010::GetTestStepName()); |
|
724 } |
|
725 |
|
726 CCTSYIntegrationTestCustomAPI0010::~CCTSYIntegrationTestCustomAPI0010() |
|
727 /** |
|
728 * Destructor. |
|
729 */ |
|
730 { |
|
731 } |
|
732 |
|
733 TVerdict CCTSYIntegrationTestCustomAPI0010::doTestStepL() |
|
734 /** |
|
735 * @SYMTestCaseID BA-CTSY-INT-CAPI-0010 |
|
736 * @SYMFssID BA/CTSY/CAPI-0010 |
|
737 * @SYMTestCaseDesc Test calling RMmCustomAPI::CallOrigin |
|
738 * @SYMTestPriority High |
|
739 * @SYMTestActions |
|
740 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
741 * @SYMTestType CIT |
|
742 * @SYMTestCaseDependencies live/automatic |
|
743 * |
|
744 * Reason for test: Test calling RMmCustomAPI::CallOrigin |
|
745 * |
|
746 * @return - TVerdict code |
|
747 */ |
|
748 { |
|
749 |
|
750 // |
|
751 // SET UP |
|
752 // |
|
753 |
|
754 |
|
755 |
|
756 // |
|
757 // SET UP END |
|
758 // |
|
759 |
|
760 StartTest(); |
|
761 |
|
762 // |
|
763 // TEST START |
|
764 // |
|
765 |
|
766 |
|
767 // Test calling RMmCustomAPI::CallOrigin |
|
768 |
|
769 |
|
770 // |
|
771 // TEST END |
|
772 // |
|
773 |
|
774 StartCleanup(); |
|
775 |
|
776 // Put any required test clean up here, then remove this comment |
|
777 |
|
778 return TestStepResult(); |
|
779 } |
|
780 |
|
781 TPtrC CCTSYIntegrationTestCustomAPI0010::GetTestStepName() |
|
782 /** |
|
783 * @return The test step name. |
|
784 */ |
|
785 { |
|
786 return _L("CCTSYIntegrationTestCustomAPI0010"); |
|
787 } |
|
788 |
|
789 |
|
790 |
|
791 CCTSYIntegrationTestCustomAPI0011::CCTSYIntegrationTestCustomAPI0011(CEtelSessionMgr& aEtelSessionMgr) |
|
792 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
793 /** |
|
794 * Constructor. |
|
795 */ |
|
796 { |
|
797 SetTestStepName(CCTSYIntegrationTestCustomAPI0011::GetTestStepName()); |
|
798 } |
|
799 |
|
800 CCTSYIntegrationTestCustomAPI0011::~CCTSYIntegrationTestCustomAPI0011() |
|
801 /** |
|
802 * Destructor. |
|
803 */ |
|
804 { |
|
805 } |
|
806 |
|
807 TVerdict CCTSYIntegrationTestCustomAPI0011::doTestStepL() |
|
808 /** |
|
809 * @SYMTestCaseID BA-CTSY-INT-CAPI-0011 |
|
810 * @SYMFssID BA/CTSY/CAPI-0011 |
|
811 * @SYMTestCaseDesc Test calling RMmCustomAPI::TerminateCall |
|
812 * @SYMTestPriority High |
|
813 * @SYMTestActions |
|
814 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
815 * @SYMTestType CIT |
|
816 * @SYMTestCaseDependencies live/automatic |
|
817 * |
|
818 * Reason for test: Test calling RMmCustomAPI::TerminateCall |
|
819 * |
|
820 * @return - TVerdict code |
|
821 */ |
|
822 { |
|
823 |
|
824 // |
|
825 // SET UP |
|
826 // |
|
827 |
|
828 |
|
829 |
|
830 // |
|
831 // SET UP END |
|
832 // |
|
833 |
|
834 StartTest(); |
|
835 |
|
836 // |
|
837 // TEST START |
|
838 // |
|
839 |
|
840 |
|
841 // Test calling RMmCustomAPI::TerminateCall |
|
842 |
|
843 |
|
844 // |
|
845 // TEST END |
|
846 // |
|
847 |
|
848 StartCleanup(); |
|
849 |
|
850 // Put any required test clean up here, then remove this comment |
|
851 |
|
852 return TestStepResult(); |
|
853 } |
|
854 |
|
855 TPtrC CCTSYIntegrationTestCustomAPI0011::GetTestStepName() |
|
856 /** |
|
857 * @return The test step name. |
|
858 */ |
|
859 { |
|
860 return _L("CCTSYIntegrationTestCustomAPI0011"); |
|
861 } |
|
862 |
|
863 |
|
864 |
|
865 CCTSYIntegrationTestCustomAPI0012::CCTSYIntegrationTestCustomAPI0012(CEtelSessionMgr& aEtelSessionMgr) |
|
866 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
867 /** |
|
868 * Constructor. |
|
869 */ |
|
870 { |
|
871 SetTestStepName(CCTSYIntegrationTestCustomAPI0012::GetTestStepName()); |
|
872 } |
|
873 |
|
874 CCTSYIntegrationTestCustomAPI0012::~CCTSYIntegrationTestCustomAPI0012() |
|
875 /** |
|
876 * Destructor. |
|
877 */ |
|
878 { |
|
879 } |
|
880 |
|
881 TVerdict CCTSYIntegrationTestCustomAPI0012::doTestStepL() |
|
882 /** |
|
883 * @SYMTestCaseID BA-CTSY-INT-CAPI-0012 |
|
884 * @SYMFssID BA/CTSY/CAPI-0012 |
|
885 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifyAlsBlockedChanged |
|
886 * @SYMTestPriority High |
|
887 * @SYMTestActions |
|
888 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
889 * @SYMTestType CIT |
|
890 * @SYMTestCaseDependencies live/manual |
|
891 * |
|
892 * Reason for test: Test calling RMmCustomAPI::NotifyAlsBlockedChanged |
|
893 * |
|
894 * @return - TVerdict code |
|
895 */ |
|
896 { |
|
897 |
|
898 // |
|
899 // SET UP |
|
900 // |
|
901 |
|
902 |
|
903 |
|
904 // |
|
905 // SET UP END |
|
906 // |
|
907 |
|
908 StartTest(); |
|
909 |
|
910 // |
|
911 // TEST START |
|
912 // |
|
913 |
|
914 |
|
915 // Test calling RMmCustomAPI::NotifyAlsBlockedChanged |
|
916 |
|
917 |
|
918 // |
|
919 // TEST END |
|
920 // |
|
921 |
|
922 StartCleanup(); |
|
923 |
|
924 // Put any required test clean up here, then remove this comment |
|
925 |
|
926 return TestStepResult(); |
|
927 } |
|
928 |
|
929 TPtrC CCTSYIntegrationTestCustomAPI0012::GetTestStepName() |
|
930 /** |
|
931 * @return The test step name. |
|
932 */ |
|
933 { |
|
934 return _L("CCTSYIntegrationTestCustomAPI0012"); |
|
935 } |
|
936 |
|
937 |
|
938 |
|
939 CCTSYIntegrationTestCustomAPI0013::CCTSYIntegrationTestCustomAPI0013(CEtelSessionMgr& aEtelSessionMgr) |
|
940 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
941 /** |
|
942 * Constructor. |
|
943 */ |
|
944 { |
|
945 SetTestStepName(CCTSYIntegrationTestCustomAPI0013::GetTestStepName()); |
|
946 } |
|
947 |
|
948 CCTSYIntegrationTestCustomAPI0013::~CCTSYIntegrationTestCustomAPI0013() |
|
949 /** |
|
950 * Destructor. |
|
951 */ |
|
952 { |
|
953 } |
|
954 |
|
955 TVerdict CCTSYIntegrationTestCustomAPI0013::doTestStepL() |
|
956 /** |
|
957 * @SYMTestCaseID BA-CTSY-INT-CAPI-0013 |
|
958 * @SYMFssID BA/CTSY/CAPI-0013 |
|
959 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetCipheringInfo |
|
960 * @SYMTestPriority High |
|
961 * @SYMTestActions |
|
962 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
963 * @SYMTestType CIT |
|
964 * @SYMTestCaseDependencies live/automatic |
|
965 * |
|
966 * Reason for test: Test calling RMmCustomAPI::GetCipheringInfo |
|
967 * |
|
968 * @return - TVerdict code |
|
969 */ |
|
970 { |
|
971 |
|
972 // |
|
973 // SET UP |
|
974 // |
|
975 |
|
976 |
|
977 |
|
978 // |
|
979 // SET UP END |
|
980 // |
|
981 |
|
982 StartTest(); |
|
983 |
|
984 // |
|
985 // TEST START |
|
986 // |
|
987 |
|
988 |
|
989 // Test calling RMmCustomAPI::GetCipheringInfo |
|
990 |
|
991 |
|
992 // |
|
993 // TEST END |
|
994 // |
|
995 |
|
996 StartCleanup(); |
|
997 |
|
998 // Put any required test clean up here, then remove this comment |
|
999 |
|
1000 return TestStepResult(); |
|
1001 } |
|
1002 |
|
1003 TPtrC CCTSYIntegrationTestCustomAPI0013::GetTestStepName() |
|
1004 /** |
|
1005 * @return The test step name. |
|
1006 */ |
|
1007 { |
|
1008 return _L("CCTSYIntegrationTestCustomAPI0013"); |
|
1009 } |
|
1010 |
|
1011 |
|
1012 |
|
1013 CCTSYIntegrationTestCustomAPI0014::CCTSYIntegrationTestCustomAPI0014(CEtelSessionMgr& aEtelSessionMgr) |
|
1014 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1015 /** |
|
1016 * Constructor. |
|
1017 */ |
|
1018 { |
|
1019 SetTestStepName(CCTSYIntegrationTestCustomAPI0014::GetTestStepName()); |
|
1020 } |
|
1021 |
|
1022 CCTSYIntegrationTestCustomAPI0014::~CCTSYIntegrationTestCustomAPI0014() |
|
1023 /** |
|
1024 * Destructor. |
|
1025 */ |
|
1026 { |
|
1027 } |
|
1028 |
|
1029 TVerdict CCTSYIntegrationTestCustomAPI0014::doTestStepL() |
|
1030 /** |
|
1031 * @SYMTestCaseID BA-CTSY-INT-CAPI-0014 |
|
1032 * @SYMFssID BA/CTSY/CAPI-0014 |
|
1033 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifyCipheringInfoChange |
|
1034 * @SYMTestPriority High |
|
1035 * @SYMTestActions |
|
1036 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1037 * @SYMTestType CIT |
|
1038 * @SYMTestCaseDependencies simulated/manual |
|
1039 * |
|
1040 * Reason for test: Test calling RMmCustomAPI::NotifyCipheringInfoChange |
|
1041 * |
|
1042 * @return - TVerdict code |
|
1043 */ |
|
1044 { |
|
1045 |
|
1046 // |
|
1047 // SET UP |
|
1048 // |
|
1049 |
|
1050 |
|
1051 |
|
1052 // |
|
1053 // SET UP END |
|
1054 // |
|
1055 |
|
1056 StartTest(); |
|
1057 |
|
1058 // |
|
1059 // TEST START |
|
1060 // |
|
1061 |
|
1062 |
|
1063 // Test calling RMmCustomAPI::NotifyCipheringInfoChange |
|
1064 |
|
1065 |
|
1066 // |
|
1067 // TEST END |
|
1068 // |
|
1069 |
|
1070 StartCleanup(); |
|
1071 |
|
1072 // Put any required test clean up here, then remove this comment |
|
1073 |
|
1074 return TestStepResult(); |
|
1075 } |
|
1076 |
|
1077 TPtrC CCTSYIntegrationTestCustomAPI0014::GetTestStepName() |
|
1078 /** |
|
1079 * @return The test step name. |
|
1080 */ |
|
1081 { |
|
1082 return _L("CCTSYIntegrationTestCustomAPI0014"); |
|
1083 } |
|
1084 |
|
1085 |
|
1086 |
|
1087 CCTSYIntegrationTestCustomAPI0015::CCTSYIntegrationTestCustomAPI0015(CEtelSessionMgr& aEtelSessionMgr) |
|
1088 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1089 /** |
|
1090 * Constructor. |
|
1091 */ |
|
1092 { |
|
1093 SetTestStepName(CCTSYIntegrationTestCustomAPI0015::GetTestStepName()); |
|
1094 } |
|
1095 |
|
1096 CCTSYIntegrationTestCustomAPI0015::~CCTSYIntegrationTestCustomAPI0015() |
|
1097 /** |
|
1098 * Destructor. |
|
1099 */ |
|
1100 { |
|
1101 } |
|
1102 |
|
1103 TVerdict CCTSYIntegrationTestCustomAPI0015::doTestStepL() |
|
1104 /** |
|
1105 * @SYMTestCaseID BA-CTSY-INT-CAPI-0015 |
|
1106 * @SYMFssID BA/CTSY/CAPI-0015 |
|
1107 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifyNSPSStatus |
|
1108 * @SYMTestPriority High |
|
1109 * @SYMTestActions |
|
1110 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1111 * @SYMTestType CIT |
|
1112 * @SYMTestCaseDependencies simulated/manual |
|
1113 * |
|
1114 * Reason for test: Test calling RMmCustomAPI::NotifyNSPSStatus |
|
1115 * |
|
1116 * @return - TVerdict code |
|
1117 */ |
|
1118 { |
|
1119 |
|
1120 // |
|
1121 // SET UP |
|
1122 // |
|
1123 |
|
1124 |
|
1125 |
|
1126 // |
|
1127 // SET UP END |
|
1128 // |
|
1129 |
|
1130 StartTest(); |
|
1131 |
|
1132 // |
|
1133 // TEST START |
|
1134 // |
|
1135 |
|
1136 |
|
1137 // Test calling RMmCustomAPI::NotifyNSPSStatus |
|
1138 |
|
1139 |
|
1140 // |
|
1141 // TEST END |
|
1142 // |
|
1143 |
|
1144 StartCleanup(); |
|
1145 |
|
1146 // Put any required test clean up here, then remove this comment |
|
1147 |
|
1148 return TestStepResult(); |
|
1149 } |
|
1150 |
|
1151 TPtrC CCTSYIntegrationTestCustomAPI0015::GetTestStepName() |
|
1152 /** |
|
1153 * @return The test step name. |
|
1154 */ |
|
1155 { |
|
1156 return _L("CCTSYIntegrationTestCustomAPI0015"); |
|
1157 } |
|
1158 |
|
1159 |
|
1160 |
|
1161 CCTSYIntegrationTestCustomAPI0016::CCTSYIntegrationTestCustomAPI0016(CEtelSessionMgr& aEtelSessionMgr) |
|
1162 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1163 /** |
|
1164 * Constructor. |
|
1165 */ |
|
1166 { |
|
1167 SetTestStepName(CCTSYIntegrationTestCustomAPI0016::GetTestStepName()); |
|
1168 } |
|
1169 |
|
1170 CCTSYIntegrationTestCustomAPI0016::~CCTSYIntegrationTestCustomAPI0016() |
|
1171 /** |
|
1172 * Destructor. |
|
1173 */ |
|
1174 { |
|
1175 } |
|
1176 |
|
1177 TVerdict CCTSYIntegrationTestCustomAPI0016::doTestStepL() |
|
1178 /** |
|
1179 * @SYMTestCaseID BA-CTSY-INT-CAPI-0016 |
|
1180 * @SYMFssID BA/CTSY/CAPI-0016 |
|
1181 * @SYMTestCaseDesc Test calling RMmCustomAPI::NetWakeup |
|
1182 * @SYMTestPriority High |
|
1183 * @SYMTestActions |
|
1184 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1185 * @SYMTestType CIT |
|
1186 * @SYMTestCaseDependencies live/automatic |
|
1187 * |
|
1188 * Reason for test: Test calling RMmCustomAPI::NetWakeup |
|
1189 * |
|
1190 * @return - TVerdict code |
|
1191 */ |
|
1192 { |
|
1193 |
|
1194 // |
|
1195 // SET UP |
|
1196 // |
|
1197 |
|
1198 |
|
1199 |
|
1200 // |
|
1201 // SET UP END |
|
1202 // |
|
1203 |
|
1204 StartTest(); |
|
1205 |
|
1206 // |
|
1207 // TEST START |
|
1208 // |
|
1209 |
|
1210 |
|
1211 // Test calling RMmCustomAPI::NetWakeup |
|
1212 |
|
1213 |
|
1214 // |
|
1215 // TEST END |
|
1216 // |
|
1217 |
|
1218 StartCleanup(); |
|
1219 |
|
1220 // Put any required test clean up here, then remove this comment |
|
1221 |
|
1222 return TestStepResult(); |
|
1223 } |
|
1224 |
|
1225 TPtrC CCTSYIntegrationTestCustomAPI0016::GetTestStepName() |
|
1226 /** |
|
1227 * @return The test step name. |
|
1228 */ |
|
1229 { |
|
1230 return _L("CCTSYIntegrationTestCustomAPI0016"); |
|
1231 } |
|
1232 |
|
1233 |
|
1234 |
|
1235 CCTSYIntegrationTestCustomAPI0017::CCTSYIntegrationTestCustomAPI0017(CEtelSessionMgr& aEtelSessionMgr) |
|
1236 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1237 /** |
|
1238 * Constructor. |
|
1239 */ |
|
1240 { |
|
1241 SetTestStepName(CCTSYIntegrationTestCustomAPI0017::GetTestStepName()); |
|
1242 } |
|
1243 |
|
1244 CCTSYIntegrationTestCustomAPI0017::~CCTSYIntegrationTestCustomAPI0017() |
|
1245 /** |
|
1246 * Destructor. |
|
1247 */ |
|
1248 { |
|
1249 } |
|
1250 |
|
1251 TVerdict CCTSYIntegrationTestCustomAPI0017::doTestStepL() |
|
1252 /** |
|
1253 * @SYMTestCaseID BA-CTSY-INT-CAPI-0017 |
|
1254 * @SYMFssID BA/CTSY/CAPI-0017 |
|
1255 * @SYMTestCaseDesc Test calling RMmCustomAPI::ReadViagHomeZoneParams |
|
1256 * @SYMTestPriority High |
|
1257 * @SYMTestActions |
|
1258 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1259 * @SYMTestType CIT |
|
1260 * @SYMTestCaseDependencies simulated/manual |
|
1261 * |
|
1262 * Reason for test: Test calling RMmCustomAPI::ReadViagHomeZoneParams |
|
1263 * |
|
1264 * @return - TVerdict code |
|
1265 */ |
|
1266 { |
|
1267 |
|
1268 // |
|
1269 // SET UP |
|
1270 // |
|
1271 |
|
1272 |
|
1273 |
|
1274 // |
|
1275 // SET UP END |
|
1276 // |
|
1277 |
|
1278 StartTest(); |
|
1279 |
|
1280 // |
|
1281 // TEST START |
|
1282 // |
|
1283 |
|
1284 |
|
1285 // Test calling RMmCustomAPI::ReadViagHomeZoneParams |
|
1286 |
|
1287 |
|
1288 // |
|
1289 // TEST END |
|
1290 // |
|
1291 |
|
1292 StartCleanup(); |
|
1293 |
|
1294 // Put any required test clean up here, then remove this comment |
|
1295 |
|
1296 return TestStepResult(); |
|
1297 } |
|
1298 |
|
1299 TPtrC CCTSYIntegrationTestCustomAPI0017::GetTestStepName() |
|
1300 /** |
|
1301 * @return The test step name. |
|
1302 */ |
|
1303 { |
|
1304 return _L("CCTSYIntegrationTestCustomAPI0017"); |
|
1305 } |
|
1306 |
|
1307 |
|
1308 |
|
1309 CCTSYIntegrationTestCustomAPI0018::CCTSYIntegrationTestCustomAPI0018(CEtelSessionMgr& aEtelSessionMgr) |
|
1310 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1311 /** |
|
1312 * Constructor. |
|
1313 */ |
|
1314 { |
|
1315 SetTestStepName(CCTSYIntegrationTestCustomAPI0018::GetTestStepName()); |
|
1316 } |
|
1317 |
|
1318 CCTSYIntegrationTestCustomAPI0018::~CCTSYIntegrationTestCustomAPI0018() |
|
1319 /** |
|
1320 * Destructor. |
|
1321 */ |
|
1322 { |
|
1323 } |
|
1324 |
|
1325 TVerdict CCTSYIntegrationTestCustomAPI0018::doTestStepL() |
|
1326 /** |
|
1327 * @SYMTestCaseID BA-CTSY-INT-CAPI-0018 |
|
1328 * @SYMFssID BA/CTSY/CAPI-0018 |
|
1329 * @SYMTestCaseDesc Test calling RMmCustomAPI::ReadViagHomeZoneCache |
|
1330 * @SYMTestPriority High |
|
1331 * @SYMTestActions |
|
1332 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1333 * @SYMTestType CIT |
|
1334 * @SYMTestCaseDependencies simulated/manual |
|
1335 * |
|
1336 * Reason for test: Test calling RMmCustomAPI::ReadViagHomeZoneCache |
|
1337 * |
|
1338 * @return - TVerdict code |
|
1339 */ |
|
1340 { |
|
1341 |
|
1342 // |
|
1343 // SET UP |
|
1344 // |
|
1345 |
|
1346 |
|
1347 |
|
1348 // |
|
1349 // SET UP END |
|
1350 // |
|
1351 |
|
1352 StartTest(); |
|
1353 |
|
1354 // |
|
1355 // TEST START |
|
1356 // |
|
1357 |
|
1358 |
|
1359 // Test calling RMmCustomAPI::ReadViagHomeZoneCache |
|
1360 |
|
1361 |
|
1362 // |
|
1363 // TEST END |
|
1364 // |
|
1365 |
|
1366 StartCleanup(); |
|
1367 |
|
1368 // Put any required test clean up here, then remove this comment |
|
1369 |
|
1370 return TestStepResult(); |
|
1371 } |
|
1372 |
|
1373 TPtrC CCTSYIntegrationTestCustomAPI0018::GetTestStepName() |
|
1374 /** |
|
1375 * @return The test step name. |
|
1376 */ |
|
1377 { |
|
1378 return _L("CCTSYIntegrationTestCustomAPI0018"); |
|
1379 } |
|
1380 |
|
1381 |
|
1382 |
|
1383 CCTSYIntegrationTestCustomAPI0019::CCTSYIntegrationTestCustomAPI0019(CEtelSessionMgr& aEtelSessionMgr) |
|
1384 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1385 /** |
|
1386 * Constructor. |
|
1387 */ |
|
1388 { |
|
1389 SetTestStepName(CCTSYIntegrationTestCustomAPI0019::GetTestStepName()); |
|
1390 } |
|
1391 |
|
1392 CCTSYIntegrationTestCustomAPI0019::~CCTSYIntegrationTestCustomAPI0019() |
|
1393 /** |
|
1394 * Destructor. |
|
1395 */ |
|
1396 { |
|
1397 } |
|
1398 |
|
1399 TVerdict CCTSYIntegrationTestCustomAPI0019::doTestStepL() |
|
1400 /** |
|
1401 * @SYMTestCaseID BA-CTSY-INT-CAPI-0019 |
|
1402 * @SYMFssID BA/CTSY/CAPI-0019 |
|
1403 * @SYMTestCaseDesc Test calling RMmCustomAPI::WriteViagHomeZoneCache |
|
1404 * @SYMTestPriority High |
|
1405 * @SYMTestActions |
|
1406 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1407 * @SYMTestType CIT |
|
1408 * @SYMTestCaseDependencies simulated/manual |
|
1409 * |
|
1410 * Reason for test: Test calling RMmCustomAPI::WriteViagHomeZoneCache |
|
1411 * |
|
1412 * @return - TVerdict code |
|
1413 */ |
|
1414 { |
|
1415 |
|
1416 // |
|
1417 // SET UP |
|
1418 // |
|
1419 |
|
1420 |
|
1421 |
|
1422 // |
|
1423 // SET UP END |
|
1424 // |
|
1425 |
|
1426 StartTest(); |
|
1427 |
|
1428 // |
|
1429 // TEST START |
|
1430 // |
|
1431 |
|
1432 |
|
1433 // Test calling RMmCustomAPI::WriteViagHomeZoneCache |
|
1434 |
|
1435 |
|
1436 // |
|
1437 // TEST END |
|
1438 // |
|
1439 |
|
1440 StartCleanup(); |
|
1441 |
|
1442 // Put any required test clean up here, then remove this comment |
|
1443 |
|
1444 return TestStepResult(); |
|
1445 } |
|
1446 |
|
1447 TPtrC CCTSYIntegrationTestCustomAPI0019::GetTestStepName() |
|
1448 /** |
|
1449 * @return The test step name. |
|
1450 */ |
|
1451 { |
|
1452 return _L("CCTSYIntegrationTestCustomAPI0019"); |
|
1453 } |
|
1454 |
|
1455 |
|
1456 |
|
1457 CCTSYIntegrationTestCustomAPI0020::CCTSYIntegrationTestCustomAPI0020(CEtelSessionMgr& aEtelSessionMgr) |
|
1458 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1459 /** |
|
1460 * Constructor. |
|
1461 */ |
|
1462 { |
|
1463 SetTestStepName(CCTSYIntegrationTestCustomAPI0020::GetTestStepName()); |
|
1464 } |
|
1465 |
|
1466 CCTSYIntegrationTestCustomAPI0020::~CCTSYIntegrationTestCustomAPI0020() |
|
1467 /** |
|
1468 * Destructor. |
|
1469 */ |
|
1470 { |
|
1471 } |
|
1472 |
|
1473 TVerdict CCTSYIntegrationTestCustomAPI0020::doTestStepL() |
|
1474 /** |
|
1475 * @SYMTestCaseID BA-CTSY-INT-CAPI-0020 |
|
1476 * @SYMFssID BA/CTSY/CAPI-0020 |
|
1477 * @SYMTestCaseDesc Test calling RMmCustomAPI::ClearCallBlackList |
|
1478 * @SYMTestPriority High |
|
1479 * @SYMTestActions |
|
1480 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1481 * @SYMTestType CIT |
|
1482 * @SYMTestCaseDependencies live/automatic |
|
1483 * |
|
1484 * Reason for test: Test calling RMmCustomAPI::ClearCallBlackList |
|
1485 * |
|
1486 * @return - TVerdict code |
|
1487 */ |
|
1488 { |
|
1489 |
|
1490 // |
|
1491 // SET UP |
|
1492 // |
|
1493 |
|
1494 |
|
1495 |
|
1496 // |
|
1497 // SET UP END |
|
1498 // |
|
1499 |
|
1500 StartTest(); |
|
1501 |
|
1502 // |
|
1503 // TEST START |
|
1504 // |
|
1505 |
|
1506 |
|
1507 // Test calling RMmCustomAPI::ClearCallBlackList |
|
1508 |
|
1509 |
|
1510 // |
|
1511 // TEST END |
|
1512 // |
|
1513 |
|
1514 StartCleanup(); |
|
1515 |
|
1516 // Put any required test clean up here, then remove this comment |
|
1517 |
|
1518 return TestStepResult(); |
|
1519 } |
|
1520 |
|
1521 TPtrC CCTSYIntegrationTestCustomAPI0020::GetTestStepName() |
|
1522 /** |
|
1523 * @return The test step name. |
|
1524 */ |
|
1525 { |
|
1526 return _L("CCTSYIntegrationTestCustomAPI0020"); |
|
1527 } |
|
1528 |
|
1529 |
|
1530 |
|
1531 CCTSYIntegrationTestCustomAPI0021::CCTSYIntegrationTestCustomAPI0021(CEtelSessionMgr& aEtelSessionMgr) |
|
1532 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1533 /** |
|
1534 * Constructor. |
|
1535 */ |
|
1536 { |
|
1537 SetTestStepName(CCTSYIntegrationTestCustomAPI0021::GetTestStepName()); |
|
1538 } |
|
1539 |
|
1540 CCTSYIntegrationTestCustomAPI0021::~CCTSYIntegrationTestCustomAPI0021() |
|
1541 /** |
|
1542 * Destructor. |
|
1543 */ |
|
1544 { |
|
1545 } |
|
1546 |
|
1547 TVerdict CCTSYIntegrationTestCustomAPI0021::doTestStepL() |
|
1548 /** |
|
1549 * @SYMTestCaseID BA-CTSY-INT-CAPI-0021 |
|
1550 * @SYMFssID BA/CTSY/CAPI-0021 |
|
1551 * @SYMTestCaseDesc Test calling RMmCustomAPI::SsAdditionalInfoNotification |
|
1552 * @SYMTestPriority High |
|
1553 * @SYMTestActions |
|
1554 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1555 * @SYMTestType CIT |
|
1556 * @SYMTestCaseDependencies simulated/manual |
|
1557 * |
|
1558 * Reason for test: Test calling RMmCustomAPI::SsAdditionalInfoNotification |
|
1559 * |
|
1560 * @return - TVerdict code |
|
1561 */ |
|
1562 { |
|
1563 |
|
1564 // |
|
1565 // SET UP |
|
1566 // |
|
1567 |
|
1568 |
|
1569 |
|
1570 // |
|
1571 // SET UP END |
|
1572 // |
|
1573 |
|
1574 StartTest(); |
|
1575 |
|
1576 // |
|
1577 // TEST START |
|
1578 // |
|
1579 |
|
1580 |
|
1581 // Test calling RMmCustomAPI::SsAdditionalInfoNotification |
|
1582 |
|
1583 |
|
1584 // |
|
1585 // TEST END |
|
1586 // |
|
1587 |
|
1588 StartCleanup(); |
|
1589 |
|
1590 // Put any required test clean up here, then remove this comment |
|
1591 |
|
1592 return TestStepResult(); |
|
1593 } |
|
1594 |
|
1595 TPtrC CCTSYIntegrationTestCustomAPI0021::GetTestStepName() |
|
1596 /** |
|
1597 * @return The test step name. |
|
1598 */ |
|
1599 { |
|
1600 return _L("CCTSYIntegrationTestCustomAPI0021"); |
|
1601 } |
|
1602 |
|
1603 |
|
1604 |
|
1605 CCTSYIntegrationTestCustomAPI0022::CCTSYIntegrationTestCustomAPI0022(CEtelSessionMgr& aEtelSessionMgr) |
|
1606 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1607 /** |
|
1608 * Constructor. |
|
1609 */ |
|
1610 { |
|
1611 SetTestStepName(CCTSYIntegrationTestCustomAPI0022::GetTestStepName()); |
|
1612 } |
|
1613 |
|
1614 CCTSYIntegrationTestCustomAPI0022::~CCTSYIntegrationTestCustomAPI0022() |
|
1615 /** |
|
1616 * Destructor. |
|
1617 */ |
|
1618 { |
|
1619 } |
|
1620 |
|
1621 TVerdict CCTSYIntegrationTestCustomAPI0022::doTestStepL() |
|
1622 /** |
|
1623 * @SYMTestCaseID BA-CTSY-INT-CAPI-0022 |
|
1624 * @SYMFssID BA/CTSY/CAPI-0022 |
|
1625 * @SYMTestCaseDesc Test calling RMmCustomAPI::SsRequestCompleteNotification |
|
1626 * @SYMTestPriority High |
|
1627 * @SYMTestActions |
|
1628 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1629 * @SYMTestType CIT |
|
1630 * @SYMTestCaseDependencies live/automatic |
|
1631 * |
|
1632 * Reason for test: Test calling RMmCustomAPI::SsRequestCompleteNotification |
|
1633 * |
|
1634 * @return - TVerdict code |
|
1635 */ |
|
1636 { |
|
1637 |
|
1638 // |
|
1639 // SET UP |
|
1640 // |
|
1641 |
|
1642 |
|
1643 |
|
1644 // |
|
1645 // SET UP END |
|
1646 // |
|
1647 |
|
1648 StartTest(); |
|
1649 |
|
1650 // |
|
1651 // TEST START |
|
1652 // |
|
1653 |
|
1654 |
|
1655 // Test calling RMmCustomAPI::SsRequestCompleteNotification |
|
1656 |
|
1657 |
|
1658 // |
|
1659 // TEST END |
|
1660 // |
|
1661 |
|
1662 StartCleanup(); |
|
1663 |
|
1664 // Put any required test clean up here, then remove this comment |
|
1665 |
|
1666 return TestStepResult(); |
|
1667 } |
|
1668 |
|
1669 TPtrC CCTSYIntegrationTestCustomAPI0022::GetTestStepName() |
|
1670 /** |
|
1671 * @return The test step name. |
|
1672 */ |
|
1673 { |
|
1674 return _L("CCTSYIntegrationTestCustomAPI0022"); |
|
1675 } |
|
1676 |
|
1677 |
|
1678 |
|
1679 CCTSYIntegrationTestCustomAPI0023::CCTSYIntegrationTestCustomAPI0023(CEtelSessionMgr& aEtelSessionMgr) |
|
1680 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1681 /** |
|
1682 * Constructor. |
|
1683 */ |
|
1684 { |
|
1685 SetTestStepName(CCTSYIntegrationTestCustomAPI0023::GetTestStepName()); |
|
1686 } |
|
1687 |
|
1688 CCTSYIntegrationTestCustomAPI0023::~CCTSYIntegrationTestCustomAPI0023() |
|
1689 /** |
|
1690 * Destructor. |
|
1691 */ |
|
1692 { |
|
1693 } |
|
1694 |
|
1695 TVerdict CCTSYIntegrationTestCustomAPI0023::doTestStepL() |
|
1696 /** |
|
1697 * @SYMTestCaseID BA-CTSY-INT-CAPI-0023 |
|
1698 * @SYMFssID BA/CTSY/CAPI-0023 |
|
1699 * @SYMTestCaseDesc Test calling RMmCustomAPI::IsBlocked |
|
1700 * @SYMTestPriority High |
|
1701 * @SYMTestActions |
|
1702 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1703 * @SYMTestType CIT |
|
1704 * @SYMTestCaseDependencies live/automatic |
|
1705 * |
|
1706 * Reason for test: Test calling RMmCustomAPI::IsBlocked |
|
1707 * |
|
1708 * @return - TVerdict code |
|
1709 */ |
|
1710 { |
|
1711 |
|
1712 // |
|
1713 // SET UP |
|
1714 // |
|
1715 |
|
1716 |
|
1717 |
|
1718 // |
|
1719 // SET UP END |
|
1720 // |
|
1721 |
|
1722 StartTest(); |
|
1723 |
|
1724 // |
|
1725 // TEST START |
|
1726 // |
|
1727 |
|
1728 |
|
1729 // Test calling RMmCustomAPI::IsBlocked |
|
1730 |
|
1731 |
|
1732 // |
|
1733 // TEST END |
|
1734 // |
|
1735 |
|
1736 StartCleanup(); |
|
1737 |
|
1738 // Put any required test clean up here, then remove this comment |
|
1739 |
|
1740 return TestStepResult(); |
|
1741 } |
|
1742 |
|
1743 TPtrC CCTSYIntegrationTestCustomAPI0023::GetTestStepName() |
|
1744 /** |
|
1745 * @return The test step name. |
|
1746 */ |
|
1747 { |
|
1748 return _L("CCTSYIntegrationTestCustomAPI0023"); |
|
1749 } |
|
1750 |
|
1751 |
|
1752 |
|
1753 CCTSYIntegrationTestCustomAPI0024::CCTSYIntegrationTestCustomAPI0024(CEtelSessionMgr& aEtelSessionMgr) |
|
1754 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1755 /** |
|
1756 * Constructor. |
|
1757 */ |
|
1758 { |
|
1759 SetTestStepName(CCTSYIntegrationTestCustomAPI0024::GetTestStepName()); |
|
1760 } |
|
1761 |
|
1762 CCTSYIntegrationTestCustomAPI0024::~CCTSYIntegrationTestCustomAPI0024() |
|
1763 /** |
|
1764 * Destructor. |
|
1765 */ |
|
1766 { |
|
1767 } |
|
1768 |
|
1769 TVerdict CCTSYIntegrationTestCustomAPI0024::doTestStepL() |
|
1770 /** |
|
1771 * @SYMTestCaseID BA-CTSY-INT-CAPI-0024 |
|
1772 * @SYMFssID BA/CTSY/CAPI-0024 |
|
1773 * @SYMTestCaseDesc Test calling RMmCustomAPI::CheckSecurityCode |
|
1774 * @SYMTestPriority High |
|
1775 * @SYMTestActions |
|
1776 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1777 * @SYMTestType CIT |
|
1778 * @SYMTestCaseDependencies live/automatic |
|
1779 * |
|
1780 * Reason for test: Test calling RMmCustomAPI::CheckSecurityCode |
|
1781 * |
|
1782 * @return - TVerdict code |
|
1783 */ |
|
1784 { |
|
1785 |
|
1786 // |
|
1787 // SET UP |
|
1788 // |
|
1789 |
|
1790 |
|
1791 |
|
1792 // |
|
1793 // SET UP END |
|
1794 // |
|
1795 |
|
1796 StartTest(); |
|
1797 |
|
1798 // |
|
1799 // TEST START |
|
1800 // |
|
1801 |
|
1802 |
|
1803 // Test calling RMmCustomAPI::CheckSecurityCode |
|
1804 |
|
1805 |
|
1806 // |
|
1807 // TEST END |
|
1808 // |
|
1809 |
|
1810 StartCleanup(); |
|
1811 |
|
1812 // Put any required test clean up here, then remove this comment |
|
1813 |
|
1814 return TestStepResult(); |
|
1815 } |
|
1816 |
|
1817 TPtrC CCTSYIntegrationTestCustomAPI0024::GetTestStepName() |
|
1818 /** |
|
1819 * @return The test step name. |
|
1820 */ |
|
1821 { |
|
1822 return _L("CCTSYIntegrationTestCustomAPI0024"); |
|
1823 } |
|
1824 |
|
1825 |
|
1826 |
|
1827 CCTSYIntegrationTestCustomAPI0025::CCTSYIntegrationTestCustomAPI0025(CEtelSessionMgr& aEtelSessionMgr) |
|
1828 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1829 /** |
|
1830 * Constructor. |
|
1831 */ |
|
1832 { |
|
1833 SetTestStepName(CCTSYIntegrationTestCustomAPI0025::GetTestStepName()); |
|
1834 } |
|
1835 |
|
1836 CCTSYIntegrationTestCustomAPI0025::~CCTSYIntegrationTestCustomAPI0025() |
|
1837 /** |
|
1838 * Destructor. |
|
1839 */ |
|
1840 { |
|
1841 } |
|
1842 |
|
1843 TVerdict CCTSYIntegrationTestCustomAPI0025::doTestStepL() |
|
1844 /** |
|
1845 * @SYMTestCaseID BA-CTSY-INT-CAPI-0025 |
|
1846 * @SYMFssID BA/CTSY/CAPI-0025 |
|
1847 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetActivePin |
|
1848 * @SYMTestPriority High |
|
1849 * @SYMTestActions |
|
1850 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1851 * @SYMTestType CIT |
|
1852 * @SYMTestCaseDependencies live/automatic |
|
1853 * |
|
1854 * Reason for test: Test calling RMmCustomAPI::GetActivePin |
|
1855 * |
|
1856 * @return - TVerdict code |
|
1857 */ |
|
1858 { |
|
1859 |
|
1860 // |
|
1861 // SET UP |
|
1862 // |
|
1863 |
|
1864 |
|
1865 |
|
1866 // |
|
1867 // SET UP END |
|
1868 // |
|
1869 |
|
1870 StartTest(); |
|
1871 |
|
1872 // |
|
1873 // TEST START |
|
1874 // |
|
1875 |
|
1876 |
|
1877 // Test calling RMmCustomAPI::GetActivePin |
|
1878 |
|
1879 |
|
1880 // |
|
1881 // TEST END |
|
1882 // |
|
1883 |
|
1884 StartCleanup(); |
|
1885 |
|
1886 // Put any required test clean up here, then remove this comment |
|
1887 |
|
1888 return TestStepResult(); |
|
1889 } |
|
1890 |
|
1891 TPtrC CCTSYIntegrationTestCustomAPI0025::GetTestStepName() |
|
1892 /** |
|
1893 * @return The test step name. |
|
1894 */ |
|
1895 { |
|
1896 return _L("CCTSYIntegrationTestCustomAPI0025"); |
|
1897 } |
|
1898 |
|
1899 |
|
1900 |
|
1901 CCTSYIntegrationTestCustomAPI0026::CCTSYIntegrationTestCustomAPI0026(CEtelSessionMgr& aEtelSessionMgr) |
|
1902 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1903 /** |
|
1904 * Constructor. |
|
1905 */ |
|
1906 { |
|
1907 SetTestStepName(CCTSYIntegrationTestCustomAPI0026::GetTestStepName()); |
|
1908 } |
|
1909 |
|
1910 CCTSYIntegrationTestCustomAPI0026::~CCTSYIntegrationTestCustomAPI0026() |
|
1911 /** |
|
1912 * Destructor. |
|
1913 */ |
|
1914 { |
|
1915 } |
|
1916 |
|
1917 TVerdict CCTSYIntegrationTestCustomAPI0026::doTestStepL() |
|
1918 /** |
|
1919 * @SYMTestCaseID BA-CTSY-INT-CAPI-0026 |
|
1920 * @SYMFssID BA/CTSY/CAPI-0026 |
|
1921 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetAirTimeDuration |
|
1922 * @SYMTestPriority High |
|
1923 * @SYMTestActions |
|
1924 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1925 * @SYMTestType CIT |
|
1926 * @SYMTestCaseDependencies live/automatic |
|
1927 * |
|
1928 * Reason for test: Test calling RMmCustomAPI::GetAirTimeDuration |
|
1929 * |
|
1930 * @return - TVerdict code |
|
1931 */ |
|
1932 { |
|
1933 |
|
1934 // |
|
1935 // SET UP |
|
1936 // |
|
1937 |
|
1938 |
|
1939 |
|
1940 // |
|
1941 // SET UP END |
|
1942 // |
|
1943 |
|
1944 StartTest(); |
|
1945 |
|
1946 // |
|
1947 // TEST START |
|
1948 // |
|
1949 |
|
1950 |
|
1951 // Test calling RMmCustomAPI::GetAirTimeDuration |
|
1952 |
|
1953 |
|
1954 // |
|
1955 // TEST END |
|
1956 // |
|
1957 |
|
1958 StartCleanup(); |
|
1959 |
|
1960 // Put any required test clean up here, then remove this comment |
|
1961 |
|
1962 return TestStepResult(); |
|
1963 } |
|
1964 |
|
1965 TPtrC CCTSYIntegrationTestCustomAPI0026::GetTestStepName() |
|
1966 /** |
|
1967 * @return The test step name. |
|
1968 */ |
|
1969 { |
|
1970 return _L("CCTSYIntegrationTestCustomAPI0026"); |
|
1971 } |
|
1972 |
|
1973 |
|
1974 |
|
1975 CCTSYIntegrationTestCustomAPI0027::CCTSYIntegrationTestCustomAPI0027(CEtelSessionMgr& aEtelSessionMgr) |
|
1976 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
1977 /** |
|
1978 * Constructor. |
|
1979 */ |
|
1980 { |
|
1981 SetTestStepName(CCTSYIntegrationTestCustomAPI0027::GetTestStepName()); |
|
1982 } |
|
1983 |
|
1984 CCTSYIntegrationTestCustomAPI0027::~CCTSYIntegrationTestCustomAPI0027() |
|
1985 /** |
|
1986 * Destructor. |
|
1987 */ |
|
1988 { |
|
1989 } |
|
1990 |
|
1991 TVerdict CCTSYIntegrationTestCustomAPI0027::doTestStepL() |
|
1992 /** |
|
1993 * @SYMTestCaseID BA-CTSY-INT-CAPI-0027 |
|
1994 * @SYMFssID BA/CTSY/CAPI-0027 |
|
1995 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetNetworkProviderName |
|
1996 * @SYMTestPriority High |
|
1997 * @SYMTestActions |
|
1998 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
1999 * @SYMTestType CIT |
|
2000 * @SYMTestCaseDependencies live/automatic |
|
2001 * |
|
2002 * Reason for test: Test calling RMmCustomAPI::GetNetworkProviderName |
|
2003 * |
|
2004 * @return - TVerdict code |
|
2005 */ |
|
2006 { |
|
2007 |
|
2008 // |
|
2009 // SET UP |
|
2010 // |
|
2011 |
|
2012 |
|
2013 |
|
2014 // |
|
2015 // SET UP END |
|
2016 // |
|
2017 |
|
2018 StartTest(); |
|
2019 |
|
2020 // |
|
2021 // TEST START |
|
2022 // |
|
2023 |
|
2024 |
|
2025 // Test calling RMmCustomAPI::GetNetworkProviderName |
|
2026 |
|
2027 |
|
2028 // |
|
2029 // TEST END |
|
2030 // |
|
2031 |
|
2032 StartCleanup(); |
|
2033 |
|
2034 // Put any required test clean up here, then remove this comment |
|
2035 |
|
2036 return TestStepResult(); |
|
2037 } |
|
2038 |
|
2039 TPtrC CCTSYIntegrationTestCustomAPI0027::GetTestStepName() |
|
2040 /** |
|
2041 * @return The test step name. |
|
2042 */ |
|
2043 { |
|
2044 return _L("CCTSYIntegrationTestCustomAPI0027"); |
|
2045 } |
|
2046 |
|
2047 |
|
2048 |
|
2049 CCTSYIntegrationTestCustomAPI0028::CCTSYIntegrationTestCustomAPI0028(CEtelSessionMgr& aEtelSessionMgr) |
|
2050 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2051 /** |
|
2052 * Constructor. |
|
2053 */ |
|
2054 { |
|
2055 SetTestStepName(CCTSYIntegrationTestCustomAPI0028::GetTestStepName()); |
|
2056 } |
|
2057 |
|
2058 CCTSYIntegrationTestCustomAPI0028::~CCTSYIntegrationTestCustomAPI0028() |
|
2059 /** |
|
2060 * Destructor. |
|
2061 */ |
|
2062 { |
|
2063 } |
|
2064 |
|
2065 TVerdict CCTSYIntegrationTestCustomAPI0028::doTestStepL() |
|
2066 /** |
|
2067 * @SYMTestCaseID BA-CTSY-INT-CAPI-0028 |
|
2068 * @SYMFssID BA/CTSY/CAPI-0028 |
|
2069 * @SYMTestCaseDesc Test calling RMmCustomAPI::CheckEmergencyNumber |
|
2070 * @SYMTestPriority High |
|
2071 * @SYMTestActions |
|
2072 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2073 * @SYMTestType CIT |
|
2074 * @SYMTestCaseDependencies live/automatic |
|
2075 * |
|
2076 * Reason for test: Test calling RMmCustomAPI::CheckEmergencyNumber |
|
2077 * |
|
2078 * @return - TVerdict code |
|
2079 */ |
|
2080 { |
|
2081 |
|
2082 // |
|
2083 // SET UP |
|
2084 // |
|
2085 |
|
2086 |
|
2087 |
|
2088 // |
|
2089 // SET UP END |
|
2090 // |
|
2091 |
|
2092 StartTest(); |
|
2093 |
|
2094 // |
|
2095 // TEST START |
|
2096 // |
|
2097 |
|
2098 |
|
2099 // Test calling RMmCustomAPI::CheckEmergencyNumber |
|
2100 |
|
2101 |
|
2102 // |
|
2103 // TEST END |
|
2104 // |
|
2105 |
|
2106 StartCleanup(); |
|
2107 |
|
2108 // Put any required test clean up here, then remove this comment |
|
2109 |
|
2110 return TestStepResult(); |
|
2111 } |
|
2112 |
|
2113 TPtrC CCTSYIntegrationTestCustomAPI0028::GetTestStepName() |
|
2114 /** |
|
2115 * @return The test step name. |
|
2116 */ |
|
2117 { |
|
2118 return _L("CCTSYIntegrationTestCustomAPI0028"); |
|
2119 } |
|
2120 |
|
2121 |
|
2122 |
|
2123 CCTSYIntegrationTestCustomAPI0029::CCTSYIntegrationTestCustomAPI0029(CEtelSessionMgr& aEtelSessionMgr) |
|
2124 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2125 /** |
|
2126 * Constructor. |
|
2127 */ |
|
2128 { |
|
2129 SetTestStepName(CCTSYIntegrationTestCustomAPI0029::GetTestStepName()); |
|
2130 } |
|
2131 |
|
2132 CCTSYIntegrationTestCustomAPI0029::~CCTSYIntegrationTestCustomAPI0029() |
|
2133 /** |
|
2134 * Destructor. |
|
2135 */ |
|
2136 { |
|
2137 } |
|
2138 |
|
2139 TVerdict CCTSYIntegrationTestCustomAPI0029::doTestStepL() |
|
2140 /** |
|
2141 * @SYMTestCaseID BA-CTSY-INT-CAPI-0029 |
|
2142 * @SYMFssID BA/CTSY/CAPI-0029 |
|
2143 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifyPndCacheReady |
|
2144 * @SYMTestPriority High |
|
2145 * @SYMTestActions |
|
2146 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2147 * @SYMTestType CIT |
|
2148 * @SYMTestCaseDependencies live/automatic |
|
2149 * |
|
2150 * Reason for test: Test calling RMmCustomAPI::NotifyPndCacheReady |
|
2151 * |
|
2152 * @return - TVerdict code |
|
2153 */ |
|
2154 { |
|
2155 |
|
2156 // |
|
2157 // SET UP |
|
2158 // |
|
2159 |
|
2160 |
|
2161 |
|
2162 // |
|
2163 // SET UP END |
|
2164 // |
|
2165 |
|
2166 StartTest(); |
|
2167 |
|
2168 // |
|
2169 // TEST START |
|
2170 // |
|
2171 |
|
2172 |
|
2173 // Test calling RMmCustomAPI::NotifyPndCacheReady |
|
2174 |
|
2175 |
|
2176 // |
|
2177 // TEST END |
|
2178 // |
|
2179 |
|
2180 StartCleanup(); |
|
2181 |
|
2182 // Put any required test clean up here, then remove this comment |
|
2183 |
|
2184 return TestStepResult(); |
|
2185 } |
|
2186 |
|
2187 TPtrC CCTSYIntegrationTestCustomAPI0029::GetTestStepName() |
|
2188 /** |
|
2189 * @return The test step name. |
|
2190 */ |
|
2191 { |
|
2192 return _L("CCTSYIntegrationTestCustomAPI0029"); |
|
2193 } |
|
2194 |
|
2195 |
|
2196 |
|
2197 CCTSYIntegrationTestCustomAPI0030::CCTSYIntegrationTestCustomAPI0030(CEtelSessionMgr& aEtelSessionMgr) |
|
2198 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2199 /** |
|
2200 * Constructor. |
|
2201 */ |
|
2202 { |
|
2203 SetTestStepName(CCTSYIntegrationTestCustomAPI0030::GetTestStepName()); |
|
2204 } |
|
2205 |
|
2206 CCTSYIntegrationTestCustomAPI0030::~CCTSYIntegrationTestCustomAPI0030() |
|
2207 /** |
|
2208 * Destructor. |
|
2209 */ |
|
2210 { |
|
2211 } |
|
2212 |
|
2213 TVerdict CCTSYIntegrationTestCustomAPI0030::doTestStepL() |
|
2214 /** |
|
2215 * @SYMTestCaseID BA-CTSY-INT-CAPI-0030 |
|
2216 * @SYMFssID BA/CTSY/CAPI-0030 |
|
2217 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetPndCacheStatus |
|
2218 * @SYMTestPriority High |
|
2219 * @SYMTestActions |
|
2220 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2221 * @SYMTestType CIT |
|
2222 * @SYMTestCaseDependencies live/automatic |
|
2223 * |
|
2224 * Reason for test: Test calling RMmCustomAPI::GetPndCacheStatus |
|
2225 * |
|
2226 * @return - TVerdict code |
|
2227 */ |
|
2228 { |
|
2229 |
|
2230 // |
|
2231 // SET UP |
|
2232 // |
|
2233 |
|
2234 |
|
2235 |
|
2236 // |
|
2237 // SET UP END |
|
2238 // |
|
2239 |
|
2240 StartTest(); |
|
2241 |
|
2242 // |
|
2243 // TEST START |
|
2244 // |
|
2245 |
|
2246 |
|
2247 // Test calling RMmCustomAPI::GetPndCacheStatus |
|
2248 |
|
2249 |
|
2250 // |
|
2251 // TEST END |
|
2252 // |
|
2253 |
|
2254 StartCleanup(); |
|
2255 |
|
2256 // Put any required test clean up here, then remove this comment |
|
2257 |
|
2258 return TestStepResult(); |
|
2259 } |
|
2260 |
|
2261 TPtrC CCTSYIntegrationTestCustomAPI0030::GetTestStepName() |
|
2262 /** |
|
2263 * @return The test step name. |
|
2264 */ |
|
2265 { |
|
2266 return _L("CCTSYIntegrationTestCustomAPI0030"); |
|
2267 } |
|
2268 |
|
2269 |
|
2270 |
|
2271 CCTSYIntegrationTestCustomAPI0031::CCTSYIntegrationTestCustomAPI0031(CEtelSessionMgr& aEtelSessionMgr) |
|
2272 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2273 /** |
|
2274 * Constructor. |
|
2275 */ |
|
2276 { |
|
2277 SetTestStepName(CCTSYIntegrationTestCustomAPI0031::GetTestStepName()); |
|
2278 } |
|
2279 |
|
2280 CCTSYIntegrationTestCustomAPI0031::~CCTSYIntegrationTestCustomAPI0031() |
|
2281 /** |
|
2282 * Destructor. |
|
2283 */ |
|
2284 { |
|
2285 } |
|
2286 |
|
2287 TVerdict CCTSYIntegrationTestCustomAPI0031::doTestStepL() |
|
2288 /** |
|
2289 * @SYMTestCaseID BA-CTSY-INT-CAPI-0031 |
|
2290 * @SYMFssID BA/CTSY/CAPI-0031 |
|
2291 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetOperatorName |
|
2292 * @SYMTestPriority High |
|
2293 * @SYMTestActions |
|
2294 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2295 * @SYMTestType CIT |
|
2296 * @SYMTestCaseDependencies live/automatic |
|
2297 * |
|
2298 * Reason for test: Test calling RMmCustomAPI::GetOperatorName |
|
2299 * |
|
2300 * @return - TVerdict code |
|
2301 */ |
|
2302 { |
|
2303 |
|
2304 // |
|
2305 // SET UP |
|
2306 // |
|
2307 |
|
2308 |
|
2309 |
|
2310 // |
|
2311 // SET UP END |
|
2312 // |
|
2313 |
|
2314 StartTest(); |
|
2315 |
|
2316 // |
|
2317 // TEST START |
|
2318 // |
|
2319 |
|
2320 |
|
2321 // Test calling RMmCustomAPI::GetOperatorName |
|
2322 |
|
2323 |
|
2324 // |
|
2325 // TEST END |
|
2326 // |
|
2327 |
|
2328 StartCleanup(); |
|
2329 |
|
2330 // Put any required test clean up here, then remove this comment |
|
2331 |
|
2332 return TestStepResult(); |
|
2333 } |
|
2334 |
|
2335 TPtrC CCTSYIntegrationTestCustomAPI0031::GetTestStepName() |
|
2336 /** |
|
2337 * @return The test step name. |
|
2338 */ |
|
2339 { |
|
2340 return _L("CCTSYIntegrationTestCustomAPI0031"); |
|
2341 } |
|
2342 |
|
2343 |
|
2344 |
|
2345 CCTSYIntegrationTestCustomAPI0032::CCTSYIntegrationTestCustomAPI0032(CEtelSessionMgr& aEtelSessionMgr) |
|
2346 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2347 /** |
|
2348 * Constructor. |
|
2349 */ |
|
2350 { |
|
2351 SetTestStepName(CCTSYIntegrationTestCustomAPI0032::GetTestStepName()); |
|
2352 } |
|
2353 |
|
2354 CCTSYIntegrationTestCustomAPI0032::~CCTSYIntegrationTestCustomAPI0032() |
|
2355 /** |
|
2356 * Destructor. |
|
2357 */ |
|
2358 { |
|
2359 } |
|
2360 |
|
2361 TVerdict CCTSYIntegrationTestCustomAPI0032::doTestStepL() |
|
2362 /** |
|
2363 * @SYMTestCaseID BA-CTSY-INT-CAPI-0032 |
|
2364 * @SYMFssID BA/CTSY/CAPI-0032 |
|
2365 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetProgrammableOperatorLogo |
|
2366 * @SYMTestPriority High |
|
2367 * @SYMTestActions |
|
2368 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2369 * @SYMTestType CIT |
|
2370 * @SYMTestCaseDependencies live/automatic |
|
2371 * |
|
2372 * Reason for test: Test calling RMmCustomAPI::GetProgrammableOperatorLogo |
|
2373 * |
|
2374 * @return - TVerdict code |
|
2375 */ |
|
2376 { |
|
2377 |
|
2378 // |
|
2379 // SET UP |
|
2380 // |
|
2381 |
|
2382 |
|
2383 |
|
2384 // |
|
2385 // SET UP END |
|
2386 // |
|
2387 |
|
2388 StartTest(); |
|
2389 |
|
2390 // |
|
2391 // TEST START |
|
2392 // |
|
2393 |
|
2394 |
|
2395 // Test calling RMmCustomAPI::GetProgrammableOperatorLogo |
|
2396 |
|
2397 |
|
2398 // |
|
2399 // TEST END |
|
2400 // |
|
2401 |
|
2402 StartCleanup(); |
|
2403 |
|
2404 // Put any required test clean up here, then remove this comment |
|
2405 |
|
2406 return TestStepResult(); |
|
2407 } |
|
2408 |
|
2409 TPtrC CCTSYIntegrationTestCustomAPI0032::GetTestStepName() |
|
2410 /** |
|
2411 * @return The test step name. |
|
2412 */ |
|
2413 { |
|
2414 return _L("CCTSYIntegrationTestCustomAPI0032"); |
|
2415 } |
|
2416 |
|
2417 |
|
2418 |
|
2419 CCTSYIntegrationTestCustomAPI0033::CCTSYIntegrationTestCustomAPI0033(CEtelSessionMgr& aEtelSessionMgr) |
|
2420 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2421 /** |
|
2422 * Constructor. |
|
2423 */ |
|
2424 { |
|
2425 SetTestStepName(CCTSYIntegrationTestCustomAPI0033::GetTestStepName()); |
|
2426 } |
|
2427 |
|
2428 CCTSYIntegrationTestCustomAPI0033::~CCTSYIntegrationTestCustomAPI0033() |
|
2429 /** |
|
2430 * Destructor. |
|
2431 */ |
|
2432 { |
|
2433 } |
|
2434 |
|
2435 TVerdict CCTSYIntegrationTestCustomAPI0033::doTestStepL() |
|
2436 /** |
|
2437 * @SYMTestCaseID BA-CTSY-INT-CAPI-0033 |
|
2438 * @SYMFssID BA/CTSY/CAPI-0033 |
|
2439 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifyProgrammableOperatorLogoChange |
|
2440 * @SYMTestPriority High |
|
2441 * @SYMTestActions |
|
2442 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2443 * @SYMTestType CIT |
|
2444 * @SYMTestCaseDependencies simulated/manual |
|
2445 * |
|
2446 * Reason for test: Test calling RMmCustomAPI::NotifyProgrammableOperatorLogoChange |
|
2447 * |
|
2448 * @return - TVerdict code |
|
2449 */ |
|
2450 { |
|
2451 |
|
2452 // |
|
2453 // SET UP |
|
2454 // |
|
2455 |
|
2456 |
|
2457 |
|
2458 // |
|
2459 // SET UP END |
|
2460 // |
|
2461 |
|
2462 StartTest(); |
|
2463 |
|
2464 // |
|
2465 // TEST START |
|
2466 // |
|
2467 |
|
2468 |
|
2469 // Test calling RMmCustomAPI::NotifyProgrammableOperatorLogoChange |
|
2470 |
|
2471 |
|
2472 // |
|
2473 // TEST END |
|
2474 // |
|
2475 |
|
2476 StartCleanup(); |
|
2477 |
|
2478 // Put any required test clean up here, then remove this comment |
|
2479 |
|
2480 return TestStepResult(); |
|
2481 } |
|
2482 |
|
2483 TPtrC CCTSYIntegrationTestCustomAPI0033::GetTestStepName() |
|
2484 /** |
|
2485 * @return The test step name. |
|
2486 */ |
|
2487 { |
|
2488 return _L("CCTSYIntegrationTestCustomAPI0033"); |
|
2489 } |
|
2490 |
|
2491 |
|
2492 |
|
2493 CCTSYIntegrationTestCustomAPI0034::CCTSYIntegrationTestCustomAPI0034(CEtelSessionMgr& aEtelSessionMgr) |
|
2494 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2495 /** |
|
2496 * Constructor. |
|
2497 */ |
|
2498 { |
|
2499 SetTestStepName(CCTSYIntegrationTestCustomAPI0034::GetTestStepName()); |
|
2500 } |
|
2501 |
|
2502 CCTSYIntegrationTestCustomAPI0034::~CCTSYIntegrationTestCustomAPI0034() |
|
2503 /** |
|
2504 * Destructor. |
|
2505 */ |
|
2506 { |
|
2507 } |
|
2508 |
|
2509 TVerdict CCTSYIntegrationTestCustomAPI0034::doTestStepL() |
|
2510 /** |
|
2511 * @SYMTestCaseID BA-CTSY-INT-CAPI-0034 |
|
2512 * @SYMFssID BA/CTSY/CAPI-0034 |
|
2513 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifySsNetworkEvent |
|
2514 * @SYMTestPriority High |
|
2515 * @SYMTestActions |
|
2516 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2517 * @SYMTestType CIT |
|
2518 * @SYMTestCaseDependencies simulated/manual |
|
2519 * |
|
2520 * Reason for test: Test calling RMmCustomAPI::NotifySsNetworkEvent |
|
2521 * |
|
2522 * @return - TVerdict code |
|
2523 */ |
|
2524 { |
|
2525 |
|
2526 // |
|
2527 // SET UP |
|
2528 // |
|
2529 |
|
2530 |
|
2531 |
|
2532 // |
|
2533 // SET UP END |
|
2534 // |
|
2535 |
|
2536 StartTest(); |
|
2537 |
|
2538 // |
|
2539 // TEST START |
|
2540 // |
|
2541 |
|
2542 |
|
2543 // Test calling RMmCustomAPI::NotifySsNetworkEvent |
|
2544 |
|
2545 |
|
2546 // |
|
2547 // TEST END |
|
2548 // |
|
2549 |
|
2550 StartCleanup(); |
|
2551 |
|
2552 // Put any required test clean up here, then remove this comment |
|
2553 |
|
2554 return TestStepResult(); |
|
2555 } |
|
2556 |
|
2557 TPtrC CCTSYIntegrationTestCustomAPI0034::GetTestStepName() |
|
2558 /** |
|
2559 * @return The test step name. |
|
2560 */ |
|
2561 { |
|
2562 return _L("CCTSYIntegrationTestCustomAPI0034"); |
|
2563 } |
|
2564 |
|
2565 |
|
2566 |
|
2567 CCTSYIntegrationTestCustomAPI0035::CCTSYIntegrationTestCustomAPI0035(CEtelSessionMgr& aEtelSessionMgr) |
|
2568 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2569 /** |
|
2570 * Constructor. |
|
2571 */ |
|
2572 { |
|
2573 SetTestStepName(CCTSYIntegrationTestCustomAPI0035::GetTestStepName()); |
|
2574 } |
|
2575 |
|
2576 CCTSYIntegrationTestCustomAPI0035::~CCTSYIntegrationTestCustomAPI0035() |
|
2577 /** |
|
2578 * Destructor. |
|
2579 */ |
|
2580 { |
|
2581 } |
|
2582 |
|
2583 TVerdict CCTSYIntegrationTestCustomAPI0035::doTestStepL() |
|
2584 /** |
|
2585 * @SYMTestCaseID BA-CTSY-INT-CAPI-0035 |
|
2586 * @SYMFssID BA/CTSY/CAPI-0035 |
|
2587 * @SYMTestCaseDesc Test calling RMmCustomAPI::CancelUssdSession |
|
2588 * @SYMTestPriority High |
|
2589 * @SYMTestActions |
|
2590 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2591 * @SYMTestType CIT |
|
2592 * @SYMTestCaseDependencies live/automatic |
|
2593 * |
|
2594 * Reason for test: Test calling RMmCustomAPI::CancelUssdSession |
|
2595 * |
|
2596 * @return - TVerdict code |
|
2597 */ |
|
2598 { |
|
2599 |
|
2600 // |
|
2601 // SET UP |
|
2602 // |
|
2603 |
|
2604 |
|
2605 |
|
2606 // |
|
2607 // SET UP END |
|
2608 // |
|
2609 |
|
2610 StartTest(); |
|
2611 |
|
2612 // |
|
2613 // TEST START |
|
2614 // |
|
2615 |
|
2616 |
|
2617 // Test calling RMmCustomAPI::CancelUssdSession |
|
2618 |
|
2619 |
|
2620 // |
|
2621 // TEST END |
|
2622 // |
|
2623 |
|
2624 StartCleanup(); |
|
2625 |
|
2626 // Put any required test clean up here, then remove this comment |
|
2627 |
|
2628 return TestStepResult(); |
|
2629 } |
|
2630 |
|
2631 TPtrC CCTSYIntegrationTestCustomAPI0035::GetTestStepName() |
|
2632 /** |
|
2633 * @return The test step name. |
|
2634 */ |
|
2635 { |
|
2636 return _L("CCTSYIntegrationTestCustomAPI0035"); |
|
2637 } |
|
2638 |
|
2639 |
|
2640 |
|
2641 CCTSYIntegrationTestCustomAPI0036::CCTSYIntegrationTestCustomAPI0036(CEtelSessionMgr& aEtelSessionMgr) |
|
2642 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2643 /** |
|
2644 * Constructor. |
|
2645 */ |
|
2646 { |
|
2647 SetTestStepName(CCTSYIntegrationTestCustomAPI0036::GetTestStepName()); |
|
2648 } |
|
2649 |
|
2650 CCTSYIntegrationTestCustomAPI0036::~CCTSYIntegrationTestCustomAPI0036() |
|
2651 /** |
|
2652 * Destructor. |
|
2653 */ |
|
2654 { |
|
2655 } |
|
2656 |
|
2657 TVerdict CCTSYIntegrationTestCustomAPI0036::doTestStepL() |
|
2658 /** |
|
2659 * @SYMTestCaseID BA-CTSY-INT-CAPI-0036 |
|
2660 * @SYMFssID BA/CTSY/CAPI-0036 |
|
2661 * @SYMTestCaseDesc Test calling RMmCustomAPI::SatRefreshCompleteNotification - no implementation in CTSY |
|
2662 * @SYMTestPriority High |
|
2663 * @SYMTestActions |
|
2664 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2665 * @SYMTestType CIT |
|
2666 * @SYMTestCaseDependencies live/automatic |
|
2667 * |
|
2668 * Reason for test: Test calling RMmCustomAPI::SatRefreshCompleteNotification - no implementation in CTSY |
|
2669 * |
|
2670 * @return - TVerdict code |
|
2671 */ |
|
2672 { |
|
2673 |
|
2674 // |
|
2675 // SET UP |
|
2676 // |
|
2677 |
|
2678 |
|
2679 |
|
2680 // |
|
2681 // SET UP END |
|
2682 // |
|
2683 |
|
2684 StartTest(); |
|
2685 |
|
2686 // |
|
2687 // TEST START |
|
2688 // |
|
2689 |
|
2690 |
|
2691 // Test calling RMmCustomAPI::SatRefreshCompleteNotification - no implementation in CTSY |
|
2692 |
|
2693 |
|
2694 // |
|
2695 // TEST END |
|
2696 // |
|
2697 |
|
2698 StartCleanup(); |
|
2699 |
|
2700 // Put any required test clean up here, then remove this comment |
|
2701 |
|
2702 return TestStepResult(); |
|
2703 } |
|
2704 |
|
2705 TPtrC CCTSYIntegrationTestCustomAPI0036::GetTestStepName() |
|
2706 /** |
|
2707 * @return The test step name. |
|
2708 */ |
|
2709 { |
|
2710 return _L("CCTSYIntegrationTestCustomAPI0036"); |
|
2711 } |
|
2712 |
|
2713 |
|
2714 |
|
2715 CCTSYIntegrationTestCustomAPI0037::CCTSYIntegrationTestCustomAPI0037(CEtelSessionMgr& aEtelSessionMgr) |
|
2716 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2717 /** |
|
2718 * Constructor. |
|
2719 */ |
|
2720 { |
|
2721 SetTestStepName(CCTSYIntegrationTestCustomAPI0037::GetTestStepName()); |
|
2722 } |
|
2723 |
|
2724 CCTSYIntegrationTestCustomAPI0037::~CCTSYIntegrationTestCustomAPI0037() |
|
2725 /** |
|
2726 * Destructor. |
|
2727 */ |
|
2728 { |
|
2729 } |
|
2730 |
|
2731 TVerdict CCTSYIntegrationTestCustomAPI0037::doTestStepL() |
|
2732 /** |
|
2733 * @SYMTestCaseID BA-CTSY-INT-CAPI-0037 |
|
2734 * @SYMFssID BA/CTSY/CAPI-0037 |
|
2735 * @SYMTestCaseDesc Test calling RMmCustomAPI::CheckTwoDigitDialSupport |
|
2736 * @SYMTestPriority High |
|
2737 * @SYMTestActions |
|
2738 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2739 * @SYMTestType CIT |
|
2740 * @SYMTestCaseDependencies live/automatic |
|
2741 * |
|
2742 * Reason for test: Test calling RMmCustomAPI::CheckTwoDigitDialSupport |
|
2743 * |
|
2744 * @return - TVerdict code |
|
2745 */ |
|
2746 { |
|
2747 |
|
2748 // |
|
2749 // SET UP |
|
2750 // |
|
2751 |
|
2752 |
|
2753 |
|
2754 // |
|
2755 // SET UP END |
|
2756 // |
|
2757 |
|
2758 StartTest(); |
|
2759 |
|
2760 // |
|
2761 // TEST START |
|
2762 // |
|
2763 |
|
2764 |
|
2765 // Test calling RMmCustomAPI::CheckTwoDigitDialSupport |
|
2766 |
|
2767 |
|
2768 // |
|
2769 // TEST END |
|
2770 // |
|
2771 |
|
2772 StartCleanup(); |
|
2773 |
|
2774 // Put any required test clean up here, then remove this comment |
|
2775 |
|
2776 return TestStepResult(); |
|
2777 } |
|
2778 |
|
2779 TPtrC CCTSYIntegrationTestCustomAPI0037::GetTestStepName() |
|
2780 /** |
|
2781 * @return The test step name. |
|
2782 */ |
|
2783 { |
|
2784 return _L("CCTSYIntegrationTestCustomAPI0037"); |
|
2785 } |
|
2786 |
|
2787 |
|
2788 |
|
2789 CCTSYIntegrationTestCustomAPI0038::CCTSYIntegrationTestCustomAPI0038(CEtelSessionMgr& aEtelSessionMgr) |
|
2790 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2791 /** |
|
2792 * Constructor. |
|
2793 */ |
|
2794 { |
|
2795 SetTestStepName(CCTSYIntegrationTestCustomAPI0038::GetTestStepName()); |
|
2796 } |
|
2797 |
|
2798 CCTSYIntegrationTestCustomAPI0038::~CCTSYIntegrationTestCustomAPI0038() |
|
2799 /** |
|
2800 * Destructor. |
|
2801 */ |
|
2802 { |
|
2803 } |
|
2804 |
|
2805 TVerdict CCTSYIntegrationTestCustomAPI0038::doTestStepL() |
|
2806 /** |
|
2807 * @SYMTestCaseID BA-CTSY-INT-CAPI-0038 |
|
2808 * @SYMFssID BA/CTSY/CAPI-0038 |
|
2809 * @SYMTestCaseDesc Test calling RMmCustomAPI::ResetNetServer |
|
2810 * @SYMTestPriority High |
|
2811 * @SYMTestActions |
|
2812 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2813 * @SYMTestType CIT |
|
2814 * @SYMTestCaseDependencies live/automatic |
|
2815 * |
|
2816 * Reason for test: Test calling RMmCustomAPI::ResetNetServer |
|
2817 * |
|
2818 * @return - TVerdict code |
|
2819 */ |
|
2820 { |
|
2821 |
|
2822 // |
|
2823 // SET UP |
|
2824 // |
|
2825 |
|
2826 |
|
2827 |
|
2828 // |
|
2829 // SET UP END |
|
2830 // |
|
2831 |
|
2832 StartTest(); |
|
2833 |
|
2834 // |
|
2835 // TEST START |
|
2836 // |
|
2837 |
|
2838 |
|
2839 // Test calling RMmCustomAPI::ResetNetServer |
|
2840 |
|
2841 |
|
2842 // |
|
2843 // TEST END |
|
2844 // |
|
2845 |
|
2846 StartCleanup(); |
|
2847 |
|
2848 // Put any required test clean up here, then remove this comment |
|
2849 |
|
2850 return TestStepResult(); |
|
2851 } |
|
2852 |
|
2853 TPtrC CCTSYIntegrationTestCustomAPI0038::GetTestStepName() |
|
2854 /** |
|
2855 * @return The test step name. |
|
2856 */ |
|
2857 { |
|
2858 return _L("CCTSYIntegrationTestCustomAPI0038"); |
|
2859 } |
|
2860 |
|
2861 |
|
2862 |
|
2863 CCTSYIntegrationTestCustomAPI0039::CCTSYIntegrationTestCustomAPI0039(CEtelSessionMgr& aEtelSessionMgr) |
|
2864 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2865 /** |
|
2866 * Constructor. |
|
2867 */ |
|
2868 { |
|
2869 SetTestStepName(CCTSYIntegrationTestCustomAPI0039::GetTestStepName()); |
|
2870 } |
|
2871 |
|
2872 CCTSYIntegrationTestCustomAPI0039::~CCTSYIntegrationTestCustomAPI0039() |
|
2873 /** |
|
2874 * Destructor. |
|
2875 */ |
|
2876 { |
|
2877 } |
|
2878 |
|
2879 TVerdict CCTSYIntegrationTestCustomAPI0039::doTestStepL() |
|
2880 /** |
|
2881 * @SYMTestCaseID BA-CTSY-INT-CAPI-0039 |
|
2882 * @SYMFssID BA/CTSY/CAPI-0039 |
|
2883 * @SYMTestCaseDesc Test calling RMmCustomAPI::ReleaseFile |
|
2884 * @SYMTestPriority High |
|
2885 * @SYMTestActions |
|
2886 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2887 * @SYMTestType CIT |
|
2888 * @SYMTestCaseDependencies live/automatic |
|
2889 * |
|
2890 * Reason for test: Test calling RMmCustomAPI::ReleaseFile |
|
2891 * |
|
2892 * @return - TVerdict code |
|
2893 */ |
|
2894 { |
|
2895 |
|
2896 // |
|
2897 // SET UP |
|
2898 // |
|
2899 |
|
2900 |
|
2901 |
|
2902 // |
|
2903 // SET UP END |
|
2904 // |
|
2905 |
|
2906 StartTest(); |
|
2907 |
|
2908 // |
|
2909 // TEST START |
|
2910 // |
|
2911 |
|
2912 |
|
2913 // Test calling RMmCustomAPI::ReleaseFile |
|
2914 |
|
2915 |
|
2916 // |
|
2917 // TEST END |
|
2918 // |
|
2919 |
|
2920 StartCleanup(); |
|
2921 |
|
2922 // Put any required test clean up here, then remove this comment |
|
2923 |
|
2924 return TestStepResult(); |
|
2925 } |
|
2926 |
|
2927 TPtrC CCTSYIntegrationTestCustomAPI0039::GetTestStepName() |
|
2928 /** |
|
2929 * @return The test step name. |
|
2930 */ |
|
2931 { |
|
2932 return _L("CCTSYIntegrationTestCustomAPI0039"); |
|
2933 } |
|
2934 |
|
2935 |
|
2936 |
|
2937 CCTSYIntegrationTestCustomAPI0040::CCTSYIntegrationTestCustomAPI0040(CEtelSessionMgr& aEtelSessionMgr) |
|
2938 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
2939 /** |
|
2940 * Constructor. |
|
2941 */ |
|
2942 { |
|
2943 SetTestStepName(CCTSYIntegrationTestCustomAPI0040::GetTestStepName()); |
|
2944 } |
|
2945 |
|
2946 CCTSYIntegrationTestCustomAPI0040::~CCTSYIntegrationTestCustomAPI0040() |
|
2947 /** |
|
2948 * Destructor. |
|
2949 */ |
|
2950 { |
|
2951 } |
|
2952 |
|
2953 TVerdict CCTSYIntegrationTestCustomAPI0040::doTestStepL() |
|
2954 /** |
|
2955 * @SYMTestCaseID BA-CTSY-INT-CAPI-0040 |
|
2956 * @SYMFssID BA/CTSY/CAPI-0040 |
|
2957 * @SYMTestCaseDesc Test calling RMmCustomAPI::RestartFile |
|
2958 * @SYMTestPriority High |
|
2959 * @SYMTestActions |
|
2960 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
2961 * @SYMTestType CIT |
|
2962 * @SYMTestCaseDependencies live/automatic |
|
2963 * |
|
2964 * Reason for test: Test calling RMmCustomAPI::RestartFile |
|
2965 * |
|
2966 * @return - TVerdict code |
|
2967 */ |
|
2968 { |
|
2969 |
|
2970 // |
|
2971 // SET UP |
|
2972 // |
|
2973 |
|
2974 |
|
2975 |
|
2976 // |
|
2977 // SET UP END |
|
2978 // |
|
2979 |
|
2980 StartTest(); |
|
2981 |
|
2982 // |
|
2983 // TEST START |
|
2984 // |
|
2985 |
|
2986 |
|
2987 // Test calling RMmCustomAPI::RestartFile |
|
2988 |
|
2989 |
|
2990 // |
|
2991 // TEST END |
|
2992 // |
|
2993 |
|
2994 StartCleanup(); |
|
2995 |
|
2996 // Put any required test clean up here, then remove this comment |
|
2997 |
|
2998 return TestStepResult(); |
|
2999 } |
|
3000 |
|
3001 TPtrC CCTSYIntegrationTestCustomAPI0040::GetTestStepName() |
|
3002 /** |
|
3003 * @return The test step name. |
|
3004 */ |
|
3005 { |
|
3006 return _L("CCTSYIntegrationTestCustomAPI0040"); |
|
3007 } |
|
3008 |
|
3009 |
|
3010 |
|
3011 CCTSYIntegrationTestCustomAPI0041::CCTSYIntegrationTestCustomAPI0041(CEtelSessionMgr& aEtelSessionMgr) |
|
3012 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3013 /** |
|
3014 * Constructor. |
|
3015 */ |
|
3016 { |
|
3017 SetTestStepName(CCTSYIntegrationTestCustomAPI0041::GetTestStepName()); |
|
3018 } |
|
3019 |
|
3020 CCTSYIntegrationTestCustomAPI0041::~CCTSYIntegrationTestCustomAPI0041() |
|
3021 /** |
|
3022 * Destructor. |
|
3023 */ |
|
3024 { |
|
3025 } |
|
3026 |
|
3027 TVerdict CCTSYIntegrationTestCustomAPI0041::doTestStepL() |
|
3028 /** |
|
3029 * @SYMTestCaseID BA-CTSY-INT-CAPI-0041 |
|
3030 * @SYMFssID BA/CTSY/CAPI-0041 |
|
3031 * @SYMTestCaseDesc Test calling RMmCustomAPI::StartSimCbTopicBrowsing |
|
3032 * @SYMTestPriority High |
|
3033 * @SYMTestActions |
|
3034 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3035 * @SYMTestType CIT |
|
3036 * @SYMTestCaseDependencies live/automatic |
|
3037 * |
|
3038 * Reason for test: Test calling RMmCustomAPI::StartSimCbTopicBrowsing |
|
3039 * |
|
3040 * @return - TVerdict code |
|
3041 */ |
|
3042 { |
|
3043 |
|
3044 // |
|
3045 // SET UP |
|
3046 // |
|
3047 |
|
3048 |
|
3049 |
|
3050 // |
|
3051 // SET UP END |
|
3052 // |
|
3053 |
|
3054 StartTest(); |
|
3055 |
|
3056 // |
|
3057 // TEST START |
|
3058 // |
|
3059 |
|
3060 |
|
3061 // Test calling RMmCustomAPI::StartSimCbTopicBrowsing |
|
3062 |
|
3063 |
|
3064 // |
|
3065 // TEST END |
|
3066 // |
|
3067 |
|
3068 StartCleanup(); |
|
3069 |
|
3070 // Put any required test clean up here, then remove this comment |
|
3071 |
|
3072 return TestStepResult(); |
|
3073 } |
|
3074 |
|
3075 TPtrC CCTSYIntegrationTestCustomAPI0041::GetTestStepName() |
|
3076 /** |
|
3077 * @return The test step name. |
|
3078 */ |
|
3079 { |
|
3080 return _L("CCTSYIntegrationTestCustomAPI0041"); |
|
3081 } |
|
3082 |
|
3083 |
|
3084 |
|
3085 CCTSYIntegrationTestCustomAPI0042::CCTSYIntegrationTestCustomAPI0042(CEtelSessionMgr& aEtelSessionMgr) |
|
3086 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3087 /** |
|
3088 * Constructor. |
|
3089 */ |
|
3090 { |
|
3091 SetTestStepName(CCTSYIntegrationTestCustomAPI0042::GetTestStepName()); |
|
3092 } |
|
3093 |
|
3094 CCTSYIntegrationTestCustomAPI0042::~CCTSYIntegrationTestCustomAPI0042() |
|
3095 /** |
|
3096 * Destructor. |
|
3097 */ |
|
3098 { |
|
3099 } |
|
3100 |
|
3101 TVerdict CCTSYIntegrationTestCustomAPI0042::doTestStepL() |
|
3102 /** |
|
3103 * @SYMTestCaseID BA-CTSY-INT-CAPI-0042 |
|
3104 * @SYMFssID BA/CTSY/CAPI-0042 |
|
3105 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetNextSimCbTopic |
|
3106 * @SYMTestPriority High |
|
3107 * @SYMTestActions |
|
3108 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3109 * @SYMTestType CIT |
|
3110 * @SYMTestCaseDependencies live/automatic |
|
3111 * |
|
3112 * Reason for test: Test calling RMmCustomAPI::GetNextSimCbTopic |
|
3113 * |
|
3114 * @return - TVerdict code |
|
3115 */ |
|
3116 { |
|
3117 |
|
3118 // |
|
3119 // SET UP |
|
3120 // |
|
3121 |
|
3122 |
|
3123 |
|
3124 // |
|
3125 // SET UP END |
|
3126 // |
|
3127 |
|
3128 StartTest(); |
|
3129 |
|
3130 // |
|
3131 // TEST START |
|
3132 // |
|
3133 |
|
3134 |
|
3135 // Test calling RMmCustomAPI::GetNextSimCbTopic |
|
3136 |
|
3137 |
|
3138 // |
|
3139 // TEST END |
|
3140 // |
|
3141 |
|
3142 StartCleanup(); |
|
3143 |
|
3144 // Put any required test clean up here, then remove this comment |
|
3145 |
|
3146 return TestStepResult(); |
|
3147 } |
|
3148 |
|
3149 TPtrC CCTSYIntegrationTestCustomAPI0042::GetTestStepName() |
|
3150 /** |
|
3151 * @return The test step name. |
|
3152 */ |
|
3153 { |
|
3154 return _L("CCTSYIntegrationTestCustomAPI0042"); |
|
3155 } |
|
3156 |
|
3157 |
|
3158 |
|
3159 CCTSYIntegrationTestCustomAPI0043::CCTSYIntegrationTestCustomAPI0043(CEtelSessionMgr& aEtelSessionMgr) |
|
3160 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3161 /** |
|
3162 * Constructor. |
|
3163 */ |
|
3164 { |
|
3165 SetTestStepName(CCTSYIntegrationTestCustomAPI0043::GetTestStepName()); |
|
3166 } |
|
3167 |
|
3168 CCTSYIntegrationTestCustomAPI0043::~CCTSYIntegrationTestCustomAPI0043() |
|
3169 /** |
|
3170 * Destructor. |
|
3171 */ |
|
3172 { |
|
3173 } |
|
3174 |
|
3175 TVerdict CCTSYIntegrationTestCustomAPI0043::doTestStepL() |
|
3176 /** |
|
3177 * @SYMTestCaseID BA-CTSY-INT-CAPI-0043 |
|
3178 * @SYMFssID BA/CTSY/CAPI-0043 |
|
3179 * @SYMTestCaseDesc Test calling RMmCustomAPI::DeleteSimCbTopic |
|
3180 * @SYMTestPriority High |
|
3181 * @SYMTestActions |
|
3182 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3183 * @SYMTestType CIT |
|
3184 * @SYMTestCaseDependencies live/automatic |
|
3185 * |
|
3186 * Reason for test: Test calling RMmCustomAPI::DeleteSimCbTopic |
|
3187 * |
|
3188 * @return - TVerdict code |
|
3189 */ |
|
3190 { |
|
3191 |
|
3192 // |
|
3193 // SET UP |
|
3194 // |
|
3195 |
|
3196 |
|
3197 |
|
3198 // |
|
3199 // SET UP END |
|
3200 // |
|
3201 |
|
3202 StartTest(); |
|
3203 |
|
3204 // |
|
3205 // TEST START |
|
3206 // |
|
3207 |
|
3208 |
|
3209 // Test calling RMmCustomAPI::DeleteSimCbTopic |
|
3210 |
|
3211 |
|
3212 // |
|
3213 // TEST END |
|
3214 // |
|
3215 |
|
3216 StartCleanup(); |
|
3217 |
|
3218 // Put any required test clean up here, then remove this comment |
|
3219 |
|
3220 return TestStepResult(); |
|
3221 } |
|
3222 |
|
3223 TPtrC CCTSYIntegrationTestCustomAPI0043::GetTestStepName() |
|
3224 /** |
|
3225 * @return The test step name. |
|
3226 */ |
|
3227 { |
|
3228 return _L("CCTSYIntegrationTestCustomAPI0043"); |
|
3229 } |
|
3230 |
|
3231 |
|
3232 |
|
3233 CCTSYIntegrationTestCustomAPI0044::CCTSYIntegrationTestCustomAPI0044(CEtelSessionMgr& aEtelSessionMgr) |
|
3234 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3235 /** |
|
3236 * Constructor. |
|
3237 */ |
|
3238 { |
|
3239 SetTestStepName(CCTSYIntegrationTestCustomAPI0044::GetTestStepName()); |
|
3240 } |
|
3241 |
|
3242 CCTSYIntegrationTestCustomAPI0044::~CCTSYIntegrationTestCustomAPI0044() |
|
3243 /** |
|
3244 * Destructor. |
|
3245 */ |
|
3246 { |
|
3247 } |
|
3248 |
|
3249 TVerdict CCTSYIntegrationTestCustomAPI0044::doTestStepL() |
|
3250 /** |
|
3251 * @SYMTestCaseID BA-CTSY-INT-CAPI-0044 |
|
3252 * @SYMFssID BA/CTSY/CAPI-0044 |
|
3253 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifyNetworkConnectionFailure |
|
3254 * @SYMTestPriority High |
|
3255 * @SYMTestActions |
|
3256 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3257 * @SYMTestType CIT |
|
3258 * @SYMTestCaseDependencies simulated/manual |
|
3259 * |
|
3260 * Reason for test: Test calling RMmCustomAPI::NotifyNetworkConnectionFailure |
|
3261 * |
|
3262 * @return - TVerdict code |
|
3263 */ |
|
3264 { |
|
3265 |
|
3266 // |
|
3267 // SET UP |
|
3268 // |
|
3269 |
|
3270 |
|
3271 |
|
3272 // |
|
3273 // SET UP END |
|
3274 // |
|
3275 |
|
3276 StartTest(); |
|
3277 |
|
3278 // |
|
3279 // TEST START |
|
3280 // |
|
3281 |
|
3282 |
|
3283 // Test calling RMmCustomAPI::NotifyNetworkConnectionFailure |
|
3284 |
|
3285 |
|
3286 // |
|
3287 // TEST END |
|
3288 // |
|
3289 |
|
3290 StartCleanup(); |
|
3291 |
|
3292 // Put any required test clean up here, then remove this comment |
|
3293 |
|
3294 return TestStepResult(); |
|
3295 } |
|
3296 |
|
3297 TPtrC CCTSYIntegrationTestCustomAPI0044::GetTestStepName() |
|
3298 /** |
|
3299 * @return The test step name. |
|
3300 */ |
|
3301 { |
|
3302 return _L("CCTSYIntegrationTestCustomAPI0044"); |
|
3303 } |
|
3304 |
|
3305 |
|
3306 |
|
3307 CCTSYIntegrationTestCustomAPI0045::CCTSYIntegrationTestCustomAPI0045(CEtelSessionMgr& aEtelSessionMgr) |
|
3308 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3309 /** |
|
3310 * Constructor. |
|
3311 */ |
|
3312 { |
|
3313 SetTestStepName(CCTSYIntegrationTestCustomAPI0045::GetTestStepName()); |
|
3314 } |
|
3315 |
|
3316 CCTSYIntegrationTestCustomAPI0045::~CCTSYIntegrationTestCustomAPI0045() |
|
3317 /** |
|
3318 * Destructor. |
|
3319 */ |
|
3320 { |
|
3321 } |
|
3322 |
|
3323 TVerdict CCTSYIntegrationTestCustomAPI0045::doTestStepL() |
|
3324 /** |
|
3325 * @SYMTestCaseID BA-CTSY-INT-CAPI-0045 |
|
3326 * @SYMFssID BA/CTSY/CAPI-0045 |
|
3327 * @SYMTestCaseDesc Test calling RMmCustomAPI::SendAPDUReq |
|
3328 * @SYMTestPriority High |
|
3329 * @SYMTestActions |
|
3330 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3331 * @SYMTestType CIT |
|
3332 * @SYMTestCaseDependencies live/manual |
|
3333 * |
|
3334 * Reason for test: Test calling RMmCustomAPI::SendAPDUReq |
|
3335 * |
|
3336 * @return - TVerdict code |
|
3337 */ |
|
3338 { |
|
3339 |
|
3340 // |
|
3341 // SET UP |
|
3342 // |
|
3343 |
|
3344 |
|
3345 |
|
3346 // |
|
3347 // SET UP END |
|
3348 // |
|
3349 |
|
3350 StartTest(); |
|
3351 |
|
3352 // |
|
3353 // TEST START |
|
3354 // |
|
3355 |
|
3356 |
|
3357 // Test calling RMmCustomAPI::SendAPDUReq |
|
3358 |
|
3359 |
|
3360 // |
|
3361 // TEST END |
|
3362 // |
|
3363 |
|
3364 StartCleanup(); |
|
3365 |
|
3366 // Put any required test clean up here, then remove this comment |
|
3367 |
|
3368 return TestStepResult(); |
|
3369 } |
|
3370 |
|
3371 TPtrC CCTSYIntegrationTestCustomAPI0045::GetTestStepName() |
|
3372 /** |
|
3373 * @return The test step name. |
|
3374 */ |
|
3375 { |
|
3376 return _L("CCTSYIntegrationTestCustomAPI0045"); |
|
3377 } |
|
3378 |
|
3379 |
|
3380 |
|
3381 CCTSYIntegrationTestCustomAPI0046::CCTSYIntegrationTestCustomAPI0046(CEtelSessionMgr& aEtelSessionMgr) |
|
3382 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3383 /** |
|
3384 * Constructor. |
|
3385 */ |
|
3386 { |
|
3387 SetTestStepName(CCTSYIntegrationTestCustomAPI0046::GetTestStepName()); |
|
3388 } |
|
3389 |
|
3390 CCTSYIntegrationTestCustomAPI0046::~CCTSYIntegrationTestCustomAPI0046() |
|
3391 /** |
|
3392 * Destructor. |
|
3393 */ |
|
3394 { |
|
3395 } |
|
3396 |
|
3397 TVerdict CCTSYIntegrationTestCustomAPI0046::doTestStepL() |
|
3398 /** |
|
3399 * @SYMTestCaseID BA-CTSY-INT-CAPI-0046 |
|
3400 * @SYMFssID BA/CTSY/CAPI-0046 |
|
3401 * @SYMTestCaseDesc Test calling RMmCustomAPI::DisablePhoneLock |
|
3402 * @SYMTestPriority High |
|
3403 * @SYMTestActions |
|
3404 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3405 * @SYMTestType CIT |
|
3406 * @SYMTestCaseDependencies live/automatic |
|
3407 * |
|
3408 * Reason for test: Test calling RMmCustomAPI::DisablePhoneLock |
|
3409 * |
|
3410 * @return - TVerdict code |
|
3411 */ |
|
3412 { |
|
3413 |
|
3414 // |
|
3415 // SET UP |
|
3416 // |
|
3417 |
|
3418 |
|
3419 |
|
3420 // |
|
3421 // SET UP END |
|
3422 // |
|
3423 |
|
3424 StartTest(); |
|
3425 |
|
3426 // |
|
3427 // TEST START |
|
3428 // |
|
3429 |
|
3430 |
|
3431 // Test calling RMmCustomAPI::DisablePhoneLock |
|
3432 |
|
3433 |
|
3434 // |
|
3435 // TEST END |
|
3436 // |
|
3437 |
|
3438 StartCleanup(); |
|
3439 |
|
3440 // Put any required test clean up here, then remove this comment |
|
3441 |
|
3442 return TestStepResult(); |
|
3443 } |
|
3444 |
|
3445 TPtrC CCTSYIntegrationTestCustomAPI0046::GetTestStepName() |
|
3446 /** |
|
3447 * @return The test step name. |
|
3448 */ |
|
3449 { |
|
3450 return _L("CCTSYIntegrationTestCustomAPI0046"); |
|
3451 } |
|
3452 |
|
3453 |
|
3454 |
|
3455 CCTSYIntegrationTestCustomAPI0047::CCTSYIntegrationTestCustomAPI0047(CEtelSessionMgr& aEtelSessionMgr) |
|
3456 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3457 /** |
|
3458 * Constructor. |
|
3459 */ |
|
3460 { |
|
3461 SetTestStepName(CCTSYIntegrationTestCustomAPI0047::GetTestStepName()); |
|
3462 } |
|
3463 |
|
3464 CCTSYIntegrationTestCustomAPI0047::~CCTSYIntegrationTestCustomAPI0047() |
|
3465 /** |
|
3466 * Destructor. |
|
3467 */ |
|
3468 { |
|
3469 } |
|
3470 |
|
3471 TVerdict CCTSYIntegrationTestCustomAPI0047::doTestStepL() |
|
3472 /** |
|
3473 * @SYMTestCaseID BA-CTSY-INT-CAPI-0047 |
|
3474 * @SYMFssID BA/CTSY/CAPI-0047 |
|
3475 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifyEGprsInfoChange |
|
3476 * @SYMTestPriority High |
|
3477 * @SYMTestActions |
|
3478 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3479 * @SYMTestType CIT |
|
3480 * @SYMTestCaseDependencies simulated/manual |
|
3481 * |
|
3482 * Reason for test: Test calling RMmCustomAPI::NotifyEGprsInfoChange |
|
3483 * |
|
3484 * @return - TVerdict code |
|
3485 */ |
|
3486 { |
|
3487 |
|
3488 // |
|
3489 // SET UP |
|
3490 // |
|
3491 |
|
3492 |
|
3493 |
|
3494 // |
|
3495 // SET UP END |
|
3496 // |
|
3497 |
|
3498 StartTest(); |
|
3499 |
|
3500 // |
|
3501 // TEST START |
|
3502 // |
|
3503 |
|
3504 |
|
3505 // Test calling RMmCustomAPI::NotifyEGprsInfoChange |
|
3506 |
|
3507 |
|
3508 // |
|
3509 // TEST END |
|
3510 // |
|
3511 |
|
3512 StartCleanup(); |
|
3513 |
|
3514 // Put any required test clean up here, then remove this comment |
|
3515 |
|
3516 return TestStepResult(); |
|
3517 } |
|
3518 |
|
3519 TPtrC CCTSYIntegrationTestCustomAPI0047::GetTestStepName() |
|
3520 /** |
|
3521 * @return The test step name. |
|
3522 */ |
|
3523 { |
|
3524 return _L("CCTSYIntegrationTestCustomAPI0047"); |
|
3525 } |
|
3526 |
|
3527 |
|
3528 |
|
3529 CCTSYIntegrationTestCustomAPI0048::CCTSYIntegrationTestCustomAPI0048(CEtelSessionMgr& aEtelSessionMgr) |
|
3530 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3531 /** |
|
3532 * Constructor. |
|
3533 */ |
|
3534 { |
|
3535 SetTestStepName(CCTSYIntegrationTestCustomAPI0048::GetTestStepName()); |
|
3536 } |
|
3537 |
|
3538 CCTSYIntegrationTestCustomAPI0048::~CCTSYIntegrationTestCustomAPI0048() |
|
3539 /** |
|
3540 * Destructor. |
|
3541 */ |
|
3542 { |
|
3543 } |
|
3544 |
|
3545 TVerdict CCTSYIntegrationTestCustomAPI0048::doTestStepL() |
|
3546 /** |
|
3547 * @SYMTestCaseID BA-CTSY-INT-CAPI-0048 |
|
3548 * @SYMFssID BA/CTSY/CAPI-0048 |
|
3549 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetEGprsInfo |
|
3550 * @SYMTestPriority High |
|
3551 * @SYMTestActions |
|
3552 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3553 * @SYMTestType CIT |
|
3554 * @SYMTestCaseDependencies live/automatic |
|
3555 * |
|
3556 * Reason for test: Test calling RMmCustomAPI::GetEGprsInfo |
|
3557 * |
|
3558 * @return - TVerdict code |
|
3559 */ |
|
3560 { |
|
3561 |
|
3562 // |
|
3563 // SET UP |
|
3564 // |
|
3565 |
|
3566 |
|
3567 |
|
3568 // |
|
3569 // SET UP END |
|
3570 // |
|
3571 |
|
3572 StartTest(); |
|
3573 |
|
3574 // |
|
3575 // TEST START |
|
3576 // |
|
3577 |
|
3578 |
|
3579 // Test calling RMmCustomAPI::GetEGprsInfo |
|
3580 |
|
3581 |
|
3582 // |
|
3583 // TEST END |
|
3584 // |
|
3585 |
|
3586 StartCleanup(); |
|
3587 |
|
3588 // Put any required test clean up here, then remove this comment |
|
3589 |
|
3590 return TestStepResult(); |
|
3591 } |
|
3592 |
|
3593 TPtrC CCTSYIntegrationTestCustomAPI0048::GetTestStepName() |
|
3594 /** |
|
3595 * @return The test step name. |
|
3596 */ |
|
3597 { |
|
3598 return _L("CCTSYIntegrationTestCustomAPI0048"); |
|
3599 } |
|
3600 |
|
3601 |
|
3602 |
|
3603 CCTSYIntegrationTestCustomAPI0049::CCTSYIntegrationTestCustomAPI0049(CEtelSessionMgr& aEtelSessionMgr) |
|
3604 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3605 /** |
|
3606 * Constructor. |
|
3607 */ |
|
3608 { |
|
3609 SetTestStepName(CCTSYIntegrationTestCustomAPI0049::GetTestStepName()); |
|
3610 } |
|
3611 |
|
3612 CCTSYIntegrationTestCustomAPI0049::~CCTSYIntegrationTestCustomAPI0049() |
|
3613 /** |
|
3614 * Destructor. |
|
3615 */ |
|
3616 { |
|
3617 } |
|
3618 |
|
3619 TVerdict CCTSYIntegrationTestCustomAPI0049::doTestStepL() |
|
3620 /** |
|
3621 * @SYMTestCaseID BA-CTSY-INT-CAPI-0049 |
|
3622 * @SYMFssID BA/CTSY/CAPI-0049 |
|
3623 * @SYMTestCaseDesc Test calling RMmCustomAPI::ReadSimFile |
|
3624 * @SYMTestPriority High |
|
3625 * @SYMTestActions |
|
3626 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3627 * @SYMTestType CIT |
|
3628 * @SYMTestCaseDependencies live/automatic |
|
3629 * |
|
3630 * Reason for test: Test calling RMmCustomAPI::ReadSimFile |
|
3631 * |
|
3632 * @return - TVerdict code |
|
3633 */ |
|
3634 { |
|
3635 |
|
3636 // |
|
3637 // SET UP |
|
3638 // |
|
3639 |
|
3640 |
|
3641 |
|
3642 // |
|
3643 // SET UP END |
|
3644 // |
|
3645 |
|
3646 StartTest(); |
|
3647 |
|
3648 // |
|
3649 // TEST START |
|
3650 // |
|
3651 |
|
3652 |
|
3653 // Test calling RMmCustomAPI::ReadSimFile |
|
3654 |
|
3655 |
|
3656 // |
|
3657 // TEST END |
|
3658 // |
|
3659 |
|
3660 StartCleanup(); |
|
3661 |
|
3662 // Put any required test clean up here, then remove this comment |
|
3663 |
|
3664 return TestStepResult(); |
|
3665 } |
|
3666 |
|
3667 TPtrC CCTSYIntegrationTestCustomAPI0049::GetTestStepName() |
|
3668 /** |
|
3669 * @return The test step name. |
|
3670 */ |
|
3671 { |
|
3672 return _L("CCTSYIntegrationTestCustomAPI0049"); |
|
3673 } |
|
3674 |
|
3675 |
|
3676 |
|
3677 CCTSYIntegrationTestCustomAPI0050::CCTSYIntegrationTestCustomAPI0050(CEtelSessionMgr& aEtelSessionMgr) |
|
3678 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3679 /** |
|
3680 * Constructor. |
|
3681 */ |
|
3682 { |
|
3683 SetTestStepName(CCTSYIntegrationTestCustomAPI0050::GetTestStepName()); |
|
3684 } |
|
3685 |
|
3686 CCTSYIntegrationTestCustomAPI0050::~CCTSYIntegrationTestCustomAPI0050() |
|
3687 /** |
|
3688 * Destructor. |
|
3689 */ |
|
3690 { |
|
3691 } |
|
3692 |
|
3693 TVerdict CCTSYIntegrationTestCustomAPI0050::doTestStepL() |
|
3694 /** |
|
3695 * @SYMTestCaseID BA-CTSY-INT-CAPI-0050 |
|
3696 * @SYMFssID BA/CTSY/CAPI-0050 |
|
3697 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetLifeTime |
|
3698 * @SYMTestPriority High |
|
3699 * @SYMTestActions |
|
3700 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3701 * @SYMTestType CIT |
|
3702 * @SYMTestCaseDependencies live/automatic |
|
3703 * |
|
3704 * Reason for test: Test calling RMmCustomAPI::GetLifeTime |
|
3705 * |
|
3706 * @return - TVerdict code |
|
3707 */ |
|
3708 { |
|
3709 |
|
3710 // |
|
3711 // SET UP |
|
3712 // |
|
3713 |
|
3714 RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone); |
|
3715 RMmCustomAPI& customApi = iEtelSessionMgr.GetCustomApiL(KMainServer, KMainPhone, KMainCustomApi); |
|
3716 |
|
3717 // |
|
3718 // SET UP END |
|
3719 // |
|
3720 |
|
3721 StartTest(); |
|
3722 |
|
3723 // |
|
3724 // TEST START |
|
3725 // |
|
3726 |
|
3727 // Test calling RMmCustomAPI::GetLifeTime |
|
3728 TExtEtelRequestStatus getLifeTimeStatus(customApi, ECustomGetLifeTimeIPC); |
|
3729 CleanupStack::PushL(getLifeTimeStatus); |
|
3730 RMmCustomAPI::TLifeTimeData ltData; |
|
3731 TPckg<RMmCustomAPI::TLifeTimeData> ltPckg(ltData); |
|
3732 customApi.GetLifeTime(getLifeTimeStatus, ltPckg); |
|
3733 |
|
3734 ASSERT_EQUALS(WaitForRequestWithTimeOut(getLifeTimeStatus, ETimeLong), KErrNone, _L("RMmCustomAPI::GetLifeTime timed out")); |
|
3735 ASSERT_EQUALS(getLifeTimeStatus.Int(), KErrNone, _L("RMmCustomAPI::GetLifeTime returned an error")); |
|
3736 |
|
3737 // |
|
3738 // TEST END |
|
3739 // |
|
3740 |
|
3741 StartCleanup(); |
|
3742 |
|
3743 CleanupStack::PopAndDestroy(1, &getLifeTimeStatus); |
|
3744 |
|
3745 return TestStepResult(); |
|
3746 } |
|
3747 |
|
3748 TPtrC CCTSYIntegrationTestCustomAPI0050::GetTestStepName() |
|
3749 /** |
|
3750 * @return The test step name. |
|
3751 */ |
|
3752 { |
|
3753 return _L("CCTSYIntegrationTestCustomAPI0050"); |
|
3754 } |
|
3755 |
|
3756 |
|
3757 |
|
3758 CCTSYIntegrationTestCustomAPI0051::CCTSYIntegrationTestCustomAPI0051(CEtelSessionMgr& aEtelSessionMgr) |
|
3759 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3760 /** |
|
3761 * Constructor. |
|
3762 */ |
|
3763 { |
|
3764 SetTestStepName(CCTSYIntegrationTestCustomAPI0051::GetTestStepName()); |
|
3765 } |
|
3766 |
|
3767 CCTSYIntegrationTestCustomAPI0051::~CCTSYIntegrationTestCustomAPI0051() |
|
3768 /** |
|
3769 * Destructor. |
|
3770 */ |
|
3771 { |
|
3772 } |
|
3773 |
|
3774 TVerdict CCTSYIntegrationTestCustomAPI0051::doTestStepL() |
|
3775 /** |
|
3776 * @SYMTestCaseID BA-CTSY-INT-CAPI-0051 |
|
3777 * @SYMFssID BA/CTSY/CAPI-0051 |
|
3778 * @SYMTestCaseDesc Test calling RMmCustomAPI::Get3GPBInfo - probably stands for Get 3G phone book info |
|
3779 * @SYMTestPriority High |
|
3780 * @SYMTestActions |
|
3781 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3782 * @SYMTestType CIT |
|
3783 * @SYMTestCaseDependencies live/automatic |
|
3784 * |
|
3785 * Reason for test: Test calling RMmCustomAPI::Get3GPBInfo - probably stands for Get 3G phone book info |
|
3786 * |
|
3787 * @return - TVerdict code |
|
3788 */ |
|
3789 { |
|
3790 |
|
3791 // |
|
3792 // SET UP |
|
3793 // |
|
3794 |
|
3795 |
|
3796 |
|
3797 // |
|
3798 // SET UP END |
|
3799 // |
|
3800 |
|
3801 StartTest(); |
|
3802 |
|
3803 // |
|
3804 // TEST START |
|
3805 // |
|
3806 |
|
3807 |
|
3808 // Test calling RMmCustomAPI::Get3GPBInfo - probably stands for Get 3G phone book info |
|
3809 |
|
3810 |
|
3811 // |
|
3812 // TEST END |
|
3813 // |
|
3814 |
|
3815 StartCleanup(); |
|
3816 |
|
3817 // Put any required test clean up here, then remove this comment |
|
3818 |
|
3819 return TestStepResult(); |
|
3820 } |
|
3821 |
|
3822 TPtrC CCTSYIntegrationTestCustomAPI0051::GetTestStepName() |
|
3823 /** |
|
3824 * @return The test step name. |
|
3825 */ |
|
3826 { |
|
3827 return _L("CCTSYIntegrationTestCustomAPI0051"); |
|
3828 } |
|
3829 |
|
3830 |
|
3831 |
|
3832 CCTSYIntegrationTestCustomAPI0052::CCTSYIntegrationTestCustomAPI0052(CEtelSessionMgr& aEtelSessionMgr) |
|
3833 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3834 /** |
|
3835 * Constructor. |
|
3836 */ |
|
3837 { |
|
3838 SetTestStepName(CCTSYIntegrationTestCustomAPI0052::GetTestStepName()); |
|
3839 } |
|
3840 |
|
3841 CCTSYIntegrationTestCustomAPI0052::~CCTSYIntegrationTestCustomAPI0052() |
|
3842 /** |
|
3843 * Destructor. |
|
3844 */ |
|
3845 { |
|
3846 } |
|
3847 |
|
3848 TVerdict CCTSYIntegrationTestCustomAPI0052::doTestStepL() |
|
3849 /** |
|
3850 * @SYMTestCaseID BA-CTSY-INT-CAPI-0052 |
|
3851 * @SYMFssID BA/CTSY/CAPI-0052 |
|
3852 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetSystemNetworkModes |
|
3853 * @SYMTestPriority High |
|
3854 * @SYMTestActions |
|
3855 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3856 * @SYMTestType CIT |
|
3857 * @SYMTestCaseDependencies live/automatic |
|
3858 * |
|
3859 * Reason for test: Test calling RMmCustomAPI::GetSystemNetworkModes |
|
3860 * |
|
3861 * @return - TVerdict code |
|
3862 */ |
|
3863 { |
|
3864 |
|
3865 // |
|
3866 // SET UP |
|
3867 // |
|
3868 |
|
3869 |
|
3870 |
|
3871 // |
|
3872 // SET UP END |
|
3873 // |
|
3874 |
|
3875 StartTest(); |
|
3876 |
|
3877 // |
|
3878 // TEST START |
|
3879 // |
|
3880 |
|
3881 |
|
3882 // Test calling RMmCustomAPI::GetSystemNetworkModes |
|
3883 |
|
3884 |
|
3885 // |
|
3886 // TEST END |
|
3887 // |
|
3888 |
|
3889 StartCleanup(); |
|
3890 |
|
3891 // Put any required test clean up here, then remove this comment |
|
3892 |
|
3893 return TestStepResult(); |
|
3894 } |
|
3895 |
|
3896 TPtrC CCTSYIntegrationTestCustomAPI0052::GetTestStepName() |
|
3897 /** |
|
3898 * @return The test step name. |
|
3899 */ |
|
3900 { |
|
3901 return _L("CCTSYIntegrationTestCustomAPI0052"); |
|
3902 } |
|
3903 |
|
3904 |
|
3905 |
|
3906 CCTSYIntegrationTestCustomAPI0053::CCTSYIntegrationTestCustomAPI0053(CEtelSessionMgr& aEtelSessionMgr) |
|
3907 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3908 /** |
|
3909 * Constructor. |
|
3910 */ |
|
3911 { |
|
3912 SetTestStepName(CCTSYIntegrationTestCustomAPI0053::GetTestStepName()); |
|
3913 } |
|
3914 |
|
3915 CCTSYIntegrationTestCustomAPI0053::~CCTSYIntegrationTestCustomAPI0053() |
|
3916 /** |
|
3917 * Destructor. |
|
3918 */ |
|
3919 { |
|
3920 } |
|
3921 |
|
3922 TVerdict CCTSYIntegrationTestCustomAPI0053::doTestStepL() |
|
3923 /** |
|
3924 * @SYMTestCaseID BA-CTSY-INT-CAPI-0053 |
|
3925 * @SYMFssID BA/CTSY/CAPI-0053 |
|
3926 * @SYMTestCaseDesc Test calling RMmCustomAPI::SetSystemNetworkMode |
|
3927 * @SYMTestPriority High |
|
3928 * @SYMTestActions |
|
3929 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
3930 * @SYMTestType CIT |
|
3931 * @SYMTestCaseDependencies live/automatic |
|
3932 * |
|
3933 * Reason for test: Test calling RMmCustomAPI::SetSystemNetworkMode |
|
3934 * |
|
3935 * @return - TVerdict code |
|
3936 */ |
|
3937 { |
|
3938 |
|
3939 // |
|
3940 // SET UP |
|
3941 // |
|
3942 |
|
3943 |
|
3944 |
|
3945 // |
|
3946 // SET UP END |
|
3947 // |
|
3948 |
|
3949 StartTest(); |
|
3950 |
|
3951 // |
|
3952 // TEST START |
|
3953 // |
|
3954 |
|
3955 |
|
3956 // Test calling RMmCustomAPI::SetSystemNetworkMode |
|
3957 |
|
3958 |
|
3959 // |
|
3960 // TEST END |
|
3961 // |
|
3962 |
|
3963 StartCleanup(); |
|
3964 |
|
3965 // Put any required test clean up here, then remove this comment |
|
3966 |
|
3967 return TestStepResult(); |
|
3968 } |
|
3969 |
|
3970 TPtrC CCTSYIntegrationTestCustomAPI0053::GetTestStepName() |
|
3971 /** |
|
3972 * @return The test step name. |
|
3973 */ |
|
3974 { |
|
3975 return _L("CCTSYIntegrationTestCustomAPI0053"); |
|
3976 } |
|
3977 |
|
3978 |
|
3979 |
|
3980 CCTSYIntegrationTestCustomAPI0054::CCTSYIntegrationTestCustomAPI0054(CEtelSessionMgr& aEtelSessionMgr) |
|
3981 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
3982 /** |
|
3983 * Constructor. |
|
3984 */ |
|
3985 { |
|
3986 SetTestStepName(CCTSYIntegrationTestCustomAPI0054::GetTestStepName()); |
|
3987 } |
|
3988 |
|
3989 CCTSYIntegrationTestCustomAPI0054::~CCTSYIntegrationTestCustomAPI0054() |
|
3990 /** |
|
3991 * Destructor. |
|
3992 */ |
|
3993 { |
|
3994 } |
|
3995 |
|
3996 TVerdict CCTSYIntegrationTestCustomAPI0054::doTestStepL() |
|
3997 /** |
|
3998 * @SYMTestCaseID BA-CTSY-INT-CAPI-0054 |
|
3999 * @SYMFssID BA/CTSY/CAPI-0054 |
|
4000 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetCurrentSystemNetworkModes |
|
4001 * @SYMTestPriority High |
|
4002 * @SYMTestActions |
|
4003 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4004 * @SYMTestType CIT |
|
4005 * @SYMTestCaseDependencies live/automatic |
|
4006 * |
|
4007 * Reason for test: Test calling RMmCustomAPI::GetCurrentSystemNetworkModes |
|
4008 * |
|
4009 * @return - TVerdict code |
|
4010 */ |
|
4011 { |
|
4012 |
|
4013 // |
|
4014 // SET UP |
|
4015 // |
|
4016 |
|
4017 |
|
4018 |
|
4019 // |
|
4020 // SET UP END |
|
4021 // |
|
4022 |
|
4023 StartTest(); |
|
4024 |
|
4025 // |
|
4026 // TEST START |
|
4027 // |
|
4028 |
|
4029 |
|
4030 // Test calling RMmCustomAPI::GetCurrentSystemNetworkModes |
|
4031 |
|
4032 |
|
4033 // |
|
4034 // TEST END |
|
4035 // |
|
4036 |
|
4037 StartCleanup(); |
|
4038 |
|
4039 // Put any required test clean up here, then remove this comment |
|
4040 |
|
4041 return TestStepResult(); |
|
4042 } |
|
4043 |
|
4044 TPtrC CCTSYIntegrationTestCustomAPI0054::GetTestStepName() |
|
4045 /** |
|
4046 * @return The test step name. |
|
4047 */ |
|
4048 { |
|
4049 return _L("CCTSYIntegrationTestCustomAPI0054"); |
|
4050 } |
|
4051 |
|
4052 |
|
4053 |
|
4054 CCTSYIntegrationTestCustomAPI0055::CCTSYIntegrationTestCustomAPI0055(CEtelSessionMgr& aEtelSessionMgr) |
|
4055 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4056 /** |
|
4057 * Constructor. |
|
4058 */ |
|
4059 { |
|
4060 SetTestStepName(CCTSYIntegrationTestCustomAPI0055::GetTestStepName()); |
|
4061 } |
|
4062 |
|
4063 CCTSYIntegrationTestCustomAPI0055::~CCTSYIntegrationTestCustomAPI0055() |
|
4064 /** |
|
4065 * Destructor. |
|
4066 */ |
|
4067 { |
|
4068 } |
|
4069 |
|
4070 TVerdict CCTSYIntegrationTestCustomAPI0055::doTestStepL() |
|
4071 /** |
|
4072 * @SYMTestCaseID BA-CTSY-INT-CAPI-0055 |
|
4073 * @SYMFssID BA/CTSY/CAPI-0055 |
|
4074 * @SYMTestCaseDesc Test calling RMmCustomAPI::PowerSimOn |
|
4075 * @SYMTestPriority High |
|
4076 * @SYMTestActions |
|
4077 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4078 * @SYMTestType CIT |
|
4079 * @SYMTestCaseDependencies live/automatic |
|
4080 * |
|
4081 * Reason for test: Test calling RMmCustomAPI::PowerSimOn |
|
4082 * |
|
4083 * @return - TVerdict code |
|
4084 */ |
|
4085 { |
|
4086 |
|
4087 // |
|
4088 // SET UP |
|
4089 // |
|
4090 |
|
4091 |
|
4092 |
|
4093 // |
|
4094 // SET UP END |
|
4095 // |
|
4096 |
|
4097 StartTest(); |
|
4098 |
|
4099 // |
|
4100 // TEST START |
|
4101 // |
|
4102 |
|
4103 |
|
4104 // Test calling RMmCustomAPI::PowerSimOn |
|
4105 |
|
4106 |
|
4107 // |
|
4108 // TEST END |
|
4109 // |
|
4110 |
|
4111 StartCleanup(); |
|
4112 |
|
4113 // Put any required test clean up here, then remove this comment |
|
4114 |
|
4115 return TestStepResult(); |
|
4116 } |
|
4117 |
|
4118 TPtrC CCTSYIntegrationTestCustomAPI0055::GetTestStepName() |
|
4119 /** |
|
4120 * @return The test step name. |
|
4121 */ |
|
4122 { |
|
4123 return _L("CCTSYIntegrationTestCustomAPI0055"); |
|
4124 } |
|
4125 |
|
4126 |
|
4127 |
|
4128 CCTSYIntegrationTestCustomAPI0056::CCTSYIntegrationTestCustomAPI0056(CEtelSessionMgr& aEtelSessionMgr) |
|
4129 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4130 /** |
|
4131 * Constructor. |
|
4132 */ |
|
4133 { |
|
4134 SetTestStepName(CCTSYIntegrationTestCustomAPI0056::GetTestStepName()); |
|
4135 } |
|
4136 |
|
4137 CCTSYIntegrationTestCustomAPI0056::~CCTSYIntegrationTestCustomAPI0056() |
|
4138 /** |
|
4139 * Destructor. |
|
4140 */ |
|
4141 { |
|
4142 } |
|
4143 |
|
4144 TVerdict CCTSYIntegrationTestCustomAPI0056::doTestStepL() |
|
4145 /** |
|
4146 * @SYMTestCaseID BA-CTSY-INT-CAPI-0056 |
|
4147 * @SYMFssID BA/CTSY/CAPI-0056 |
|
4148 * @SYMTestCaseDesc Test calling RMmCustomAPI::PowerSimOff |
|
4149 * @SYMTestPriority High |
|
4150 * @SYMTestActions |
|
4151 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4152 * @SYMTestType CIT |
|
4153 * @SYMTestCaseDependencies live/automatic |
|
4154 * |
|
4155 * Reason for test: Test calling RMmCustomAPI::PowerSimOff |
|
4156 * |
|
4157 * @return - TVerdict code |
|
4158 */ |
|
4159 { |
|
4160 |
|
4161 // |
|
4162 // SET UP |
|
4163 // |
|
4164 |
|
4165 |
|
4166 |
|
4167 // |
|
4168 // SET UP END |
|
4169 // |
|
4170 |
|
4171 StartTest(); |
|
4172 |
|
4173 // |
|
4174 // TEST START |
|
4175 // |
|
4176 |
|
4177 |
|
4178 // Test calling RMmCustomAPI::PowerSimOff |
|
4179 |
|
4180 |
|
4181 // |
|
4182 // TEST END |
|
4183 // |
|
4184 |
|
4185 StartCleanup(); |
|
4186 |
|
4187 // Put any required test clean up here, then remove this comment |
|
4188 |
|
4189 return TestStepResult(); |
|
4190 } |
|
4191 |
|
4192 TPtrC CCTSYIntegrationTestCustomAPI0056::GetTestStepName() |
|
4193 /** |
|
4194 * @return The test step name. |
|
4195 */ |
|
4196 { |
|
4197 return _L("CCTSYIntegrationTestCustomAPI0056"); |
|
4198 } |
|
4199 |
|
4200 |
|
4201 |
|
4202 CCTSYIntegrationTestCustomAPI0057::CCTSYIntegrationTestCustomAPI0057(CEtelSessionMgr& aEtelSessionMgr) |
|
4203 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4204 /** |
|
4205 * Constructor. |
|
4206 */ |
|
4207 { |
|
4208 SetTestStepName(CCTSYIntegrationTestCustomAPI0057::GetTestStepName()); |
|
4209 } |
|
4210 |
|
4211 CCTSYIntegrationTestCustomAPI0057::~CCTSYIntegrationTestCustomAPI0057() |
|
4212 /** |
|
4213 * Destructor. |
|
4214 */ |
|
4215 { |
|
4216 } |
|
4217 |
|
4218 TVerdict CCTSYIntegrationTestCustomAPI0057::doTestStepL() |
|
4219 /** |
|
4220 * @SYMTestCaseID BA-CTSY-INT-CAPI-0057 |
|
4221 * @SYMFssID BA/CTSY/CAPI-0057 |
|
4222 * @SYMTestCaseDesc Test calling RMmCustomAPI::SimWarmReset |
|
4223 * @SYMTestPriority High |
|
4224 * @SYMTestActions |
|
4225 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4226 * @SYMTestType CIT |
|
4227 * @SYMTestCaseDependencies live/automatic |
|
4228 * |
|
4229 * Reason for test: Test calling RMmCustomAPI::SimWarmReset |
|
4230 * |
|
4231 * @return - TVerdict code |
|
4232 */ |
|
4233 { |
|
4234 |
|
4235 // |
|
4236 // SET UP |
|
4237 // |
|
4238 |
|
4239 |
|
4240 |
|
4241 // |
|
4242 // SET UP END |
|
4243 // |
|
4244 |
|
4245 StartTest(); |
|
4246 |
|
4247 // |
|
4248 // TEST START |
|
4249 // |
|
4250 |
|
4251 |
|
4252 // Test calling RMmCustomAPI::SimWarmReset |
|
4253 |
|
4254 |
|
4255 // |
|
4256 // TEST END |
|
4257 // |
|
4258 |
|
4259 StartCleanup(); |
|
4260 |
|
4261 // Put any required test clean up here, then remove this comment |
|
4262 |
|
4263 return TestStepResult(); |
|
4264 } |
|
4265 |
|
4266 TPtrC CCTSYIntegrationTestCustomAPI0057::GetTestStepName() |
|
4267 /** |
|
4268 * @return The test step name. |
|
4269 */ |
|
4270 { |
|
4271 return _L("CCTSYIntegrationTestCustomAPI0057"); |
|
4272 } |
|
4273 |
|
4274 |
|
4275 |
|
4276 CCTSYIntegrationTestCustomAPI0058::CCTSYIntegrationTestCustomAPI0058(CEtelSessionMgr& aEtelSessionMgr) |
|
4277 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4278 /** |
|
4279 * Constructor. |
|
4280 */ |
|
4281 { |
|
4282 SetTestStepName(CCTSYIntegrationTestCustomAPI0058::GetTestStepName()); |
|
4283 } |
|
4284 |
|
4285 CCTSYIntegrationTestCustomAPI0058::~CCTSYIntegrationTestCustomAPI0058() |
|
4286 /** |
|
4287 * Destructor. |
|
4288 */ |
|
4289 { |
|
4290 } |
|
4291 |
|
4292 TVerdict CCTSYIntegrationTestCustomAPI0058::doTestStepL() |
|
4293 /** |
|
4294 * @SYMTestCaseID BA-CTSY-INT-CAPI-0058 |
|
4295 * @SYMFssID BA/CTSY/CAPI-0058 |
|
4296 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetATR |
|
4297 * @SYMTestPriority High |
|
4298 * @SYMTestActions |
|
4299 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4300 * @SYMTestType CIT |
|
4301 * @SYMTestCaseDependencies live/automatic |
|
4302 * |
|
4303 * Reason for test: Test calling RMmCustomAPI::GetATR |
|
4304 * |
|
4305 * @return - TVerdict code |
|
4306 */ |
|
4307 { |
|
4308 |
|
4309 // |
|
4310 // SET UP |
|
4311 // |
|
4312 |
|
4313 |
|
4314 |
|
4315 // |
|
4316 // SET UP END |
|
4317 // |
|
4318 |
|
4319 StartTest(); |
|
4320 |
|
4321 // |
|
4322 // TEST START |
|
4323 // |
|
4324 |
|
4325 |
|
4326 // Test calling RMmCustomAPI::GetATR |
|
4327 |
|
4328 |
|
4329 // |
|
4330 // TEST END |
|
4331 // |
|
4332 |
|
4333 StartCleanup(); |
|
4334 |
|
4335 // Put any required test clean up here, then remove this comment |
|
4336 |
|
4337 return TestStepResult(); |
|
4338 } |
|
4339 |
|
4340 TPtrC CCTSYIntegrationTestCustomAPI0058::GetTestStepName() |
|
4341 /** |
|
4342 * @return The test step name. |
|
4343 */ |
|
4344 { |
|
4345 return _L("CCTSYIntegrationTestCustomAPI0058"); |
|
4346 } |
|
4347 |
|
4348 |
|
4349 |
|
4350 CCTSYIntegrationTestCustomAPI0059::CCTSYIntegrationTestCustomAPI0059(CEtelSessionMgr& aEtelSessionMgr) |
|
4351 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4352 /** |
|
4353 * Constructor. |
|
4354 */ |
|
4355 { |
|
4356 SetTestStepName(CCTSYIntegrationTestCustomAPI0059::GetTestStepName()); |
|
4357 } |
|
4358 |
|
4359 CCTSYIntegrationTestCustomAPI0059::~CCTSYIntegrationTestCustomAPI0059() |
|
4360 /** |
|
4361 * Destructor. |
|
4362 */ |
|
4363 { |
|
4364 } |
|
4365 |
|
4366 TVerdict CCTSYIntegrationTestCustomAPI0059::doTestStepL() |
|
4367 /** |
|
4368 * @SYMTestCaseID BA-CTSY-INT-CAPI-0059 |
|
4369 * @SYMFssID BA/CTSY/CAPI-0059 |
|
4370 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetSimCardReaderStatus |
|
4371 * @SYMTestPriority High |
|
4372 * @SYMTestActions |
|
4373 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4374 * @SYMTestType CIT |
|
4375 * @SYMTestCaseDependencies live/automatic |
|
4376 * |
|
4377 * Reason for test: Test calling RMmCustomAPI::GetSimCardReaderStatus |
|
4378 * |
|
4379 * @return - TVerdict code |
|
4380 */ |
|
4381 { |
|
4382 |
|
4383 // |
|
4384 // SET UP |
|
4385 // |
|
4386 |
|
4387 |
|
4388 |
|
4389 // |
|
4390 // SET UP END |
|
4391 // |
|
4392 |
|
4393 StartTest(); |
|
4394 |
|
4395 // |
|
4396 // TEST START |
|
4397 // |
|
4398 |
|
4399 |
|
4400 // Test calling RMmCustomAPI::GetSimCardReaderStatus |
|
4401 |
|
4402 |
|
4403 // |
|
4404 // TEST END |
|
4405 // |
|
4406 |
|
4407 StartCleanup(); |
|
4408 |
|
4409 // Put any required test clean up here, then remove this comment |
|
4410 |
|
4411 return TestStepResult(); |
|
4412 } |
|
4413 |
|
4414 TPtrC CCTSYIntegrationTestCustomAPI0059::GetTestStepName() |
|
4415 /** |
|
4416 * @return The test step name. |
|
4417 */ |
|
4418 { |
|
4419 return _L("CCTSYIntegrationTestCustomAPI0059"); |
|
4420 } |
|
4421 |
|
4422 |
|
4423 |
|
4424 CCTSYIntegrationTestCustomAPI0060::CCTSYIntegrationTestCustomAPI0060(CEtelSessionMgr& aEtelSessionMgr) |
|
4425 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4426 /** |
|
4427 * Constructor. |
|
4428 */ |
|
4429 { |
|
4430 SetTestStepName(CCTSYIntegrationTestCustomAPI0060::GetTestStepName()); |
|
4431 } |
|
4432 |
|
4433 CCTSYIntegrationTestCustomAPI0060::~CCTSYIntegrationTestCustomAPI0060() |
|
4434 /** |
|
4435 * Destructor. |
|
4436 */ |
|
4437 { |
|
4438 } |
|
4439 |
|
4440 TVerdict CCTSYIntegrationTestCustomAPI0060::doTestStepL() |
|
4441 /** |
|
4442 * @SYMTestCaseID BA-CTSY-INT-CAPI-0060 |
|
4443 * @SYMFssID BA/CTSY/CAPI-0060 |
|
4444 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifySimCardStatus |
|
4445 * @SYMTestPriority High |
|
4446 * @SYMTestActions |
|
4447 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4448 * @SYMTestType CIT |
|
4449 * @SYMTestCaseDependencies live/manual |
|
4450 * |
|
4451 * Reason for test: Test calling RMmCustomAPI::NotifySimCardStatus |
|
4452 * |
|
4453 * @return - TVerdict code |
|
4454 */ |
|
4455 { |
|
4456 |
|
4457 // |
|
4458 // SET UP |
|
4459 // |
|
4460 |
|
4461 |
|
4462 |
|
4463 // |
|
4464 // SET UP END |
|
4465 // |
|
4466 |
|
4467 StartTest(); |
|
4468 |
|
4469 // |
|
4470 // TEST START |
|
4471 // |
|
4472 |
|
4473 |
|
4474 // Test calling RMmCustomAPI::NotifySimCardStatus |
|
4475 |
|
4476 |
|
4477 // |
|
4478 // TEST END |
|
4479 // |
|
4480 |
|
4481 StartCleanup(); |
|
4482 |
|
4483 // Put any required test clean up here, then remove this comment |
|
4484 |
|
4485 return TestStepResult(); |
|
4486 } |
|
4487 |
|
4488 TPtrC CCTSYIntegrationTestCustomAPI0060::GetTestStepName() |
|
4489 /** |
|
4490 * @return The test step name. |
|
4491 */ |
|
4492 { |
|
4493 return _L("CCTSYIntegrationTestCustomAPI0060"); |
|
4494 } |
|
4495 |
|
4496 |
|
4497 |
|
4498 CCTSYIntegrationTestCustomAPI0061::CCTSYIntegrationTestCustomAPI0061(CEtelSessionMgr& aEtelSessionMgr) |
|
4499 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4500 /** |
|
4501 * Constructor. |
|
4502 */ |
|
4503 { |
|
4504 SetTestStepName(CCTSYIntegrationTestCustomAPI0061::GetTestStepName()); |
|
4505 } |
|
4506 |
|
4507 CCTSYIntegrationTestCustomAPI0061::~CCTSYIntegrationTestCustomAPI0061() |
|
4508 /** |
|
4509 * Destructor. |
|
4510 */ |
|
4511 { |
|
4512 } |
|
4513 |
|
4514 TVerdict CCTSYIntegrationTestCustomAPI0061::doTestStepL() |
|
4515 /** |
|
4516 * @SYMTestCaseID BA-CTSY-INT-CAPI-0061 |
|
4517 * @SYMFssID BA/CTSY/CAPI-0061 |
|
4518 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetWlanSimAuthenticationData |
|
4519 * @SYMTestPriority High |
|
4520 * @SYMTestActions |
|
4521 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4522 * @SYMTestType CIT |
|
4523 * @SYMTestCaseDependencies live/automatic |
|
4524 * |
|
4525 * Reason for test: Test calling RMmCustomAPI::GetWlanSimAuthenticationData |
|
4526 * |
|
4527 * @return - TVerdict code |
|
4528 */ |
|
4529 { |
|
4530 |
|
4531 // |
|
4532 // SET UP |
|
4533 // |
|
4534 |
|
4535 |
|
4536 |
|
4537 // |
|
4538 // SET UP END |
|
4539 // |
|
4540 |
|
4541 StartTest(); |
|
4542 |
|
4543 // |
|
4544 // TEST START |
|
4545 // |
|
4546 |
|
4547 |
|
4548 // Test calling RMmCustomAPI::GetWlanSimAuthenticationData |
|
4549 |
|
4550 |
|
4551 // |
|
4552 // TEST END |
|
4553 // |
|
4554 |
|
4555 StartCleanup(); |
|
4556 |
|
4557 // Put any required test clean up here, then remove this comment |
|
4558 |
|
4559 return TestStepResult(); |
|
4560 } |
|
4561 |
|
4562 TPtrC CCTSYIntegrationTestCustomAPI0061::GetTestStepName() |
|
4563 /** |
|
4564 * @return The test step name. |
|
4565 */ |
|
4566 { |
|
4567 return _L("CCTSYIntegrationTestCustomAPI0061"); |
|
4568 } |
|
4569 |
|
4570 |
|
4571 |
|
4572 CCTSYIntegrationTestCustomAPI0062::CCTSYIntegrationTestCustomAPI0062(CEtelSessionMgr& aEtelSessionMgr) |
|
4573 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4574 /** |
|
4575 * Constructor. |
|
4576 */ |
|
4577 { |
|
4578 SetTestStepName(CCTSYIntegrationTestCustomAPI0062::GetTestStepName()); |
|
4579 } |
|
4580 |
|
4581 CCTSYIntegrationTestCustomAPI0062::~CCTSYIntegrationTestCustomAPI0062() |
|
4582 /** |
|
4583 * Destructor. |
|
4584 */ |
|
4585 { |
|
4586 } |
|
4587 |
|
4588 TVerdict CCTSYIntegrationTestCustomAPI0062::doTestStepL() |
|
4589 /** |
|
4590 * @SYMTestCaseID BA-CTSY-INT-CAPI-0062 |
|
4591 * @SYMFssID BA/CTSY/CAPI-0062 |
|
4592 * @SYMTestCaseDesc Test calling RMmCustomAPI::SetSimMessageStatusRead |
|
4593 * @SYMTestPriority High |
|
4594 * @SYMTestActions |
|
4595 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4596 * @SYMTestType CIT |
|
4597 * @SYMTestCaseDependencies live/automatic |
|
4598 * |
|
4599 * Reason for test: Test calling RMmCustomAPI::SetSimMessageStatusRead |
|
4600 * |
|
4601 * @return - TVerdict code |
|
4602 */ |
|
4603 { |
|
4604 |
|
4605 // |
|
4606 // SET UP |
|
4607 // |
|
4608 |
|
4609 |
|
4610 |
|
4611 // |
|
4612 // SET UP END |
|
4613 // |
|
4614 |
|
4615 StartTest(); |
|
4616 |
|
4617 // |
|
4618 // TEST START |
|
4619 // |
|
4620 |
|
4621 |
|
4622 // Test calling RMmCustomAPI::SetSimMessageStatusRead |
|
4623 |
|
4624 |
|
4625 // |
|
4626 // TEST END |
|
4627 // |
|
4628 |
|
4629 StartCleanup(); |
|
4630 |
|
4631 // Put any required test clean up here, then remove this comment |
|
4632 |
|
4633 return TestStepResult(); |
|
4634 } |
|
4635 |
|
4636 TPtrC CCTSYIntegrationTestCustomAPI0062::GetTestStepName() |
|
4637 /** |
|
4638 * @return The test step name. |
|
4639 */ |
|
4640 { |
|
4641 return _L("CCTSYIntegrationTestCustomAPI0062"); |
|
4642 } |
|
4643 |
|
4644 |
|
4645 |
|
4646 CCTSYIntegrationTestCustomAPI0063::CCTSYIntegrationTestCustomAPI0063(CEtelSessionMgr& aEtelSessionMgr) |
|
4647 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4648 /** |
|
4649 * Constructor. |
|
4650 */ |
|
4651 { |
|
4652 SetTestStepName(CCTSYIntegrationTestCustomAPI0063::GetTestStepName()); |
|
4653 } |
|
4654 |
|
4655 CCTSYIntegrationTestCustomAPI0063::~CCTSYIntegrationTestCustomAPI0063() |
|
4656 /** |
|
4657 * Destructor. |
|
4658 */ |
|
4659 { |
|
4660 } |
|
4661 |
|
4662 TVerdict CCTSYIntegrationTestCustomAPI0063::doTestStepL() |
|
4663 /** |
|
4664 * @SYMTestCaseID BA-CTSY-INT-CAPI-0063 |
|
4665 * @SYMFssID BA/CTSY/CAPI-0063 |
|
4666 * @SYMTestCaseDesc Test calling RMmCustomAPI::WriteViagHomeZoneUHZIUESettings |
|
4667 * @SYMTestPriority High |
|
4668 * @SYMTestActions |
|
4669 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4670 * @SYMTestType CIT |
|
4671 * @SYMTestCaseDependencies simulated/manual |
|
4672 * |
|
4673 * Reason for test: Test calling RMmCustomAPI::WriteViagHomeZoneUHZIUESettings |
|
4674 * |
|
4675 * @return - TVerdict code |
|
4676 */ |
|
4677 { |
|
4678 |
|
4679 // |
|
4680 // SET UP |
|
4681 // |
|
4682 |
|
4683 |
|
4684 |
|
4685 // |
|
4686 // SET UP END |
|
4687 // |
|
4688 |
|
4689 StartTest(); |
|
4690 |
|
4691 // |
|
4692 // TEST START |
|
4693 // |
|
4694 |
|
4695 |
|
4696 // Test calling RMmCustomAPI::WriteViagHomeZoneUHZIUESettings |
|
4697 |
|
4698 |
|
4699 // |
|
4700 // TEST END |
|
4701 // |
|
4702 |
|
4703 StartCleanup(); |
|
4704 |
|
4705 // Put any required test clean up here, then remove this comment |
|
4706 |
|
4707 return TestStepResult(); |
|
4708 } |
|
4709 |
|
4710 TPtrC CCTSYIntegrationTestCustomAPI0063::GetTestStepName() |
|
4711 /** |
|
4712 * @return The test step name. |
|
4713 */ |
|
4714 { |
|
4715 return _L("CCTSYIntegrationTestCustomAPI0063"); |
|
4716 } |
|
4717 |
|
4718 |
|
4719 |
|
4720 CCTSYIntegrationTestCustomAPI0064::CCTSYIntegrationTestCustomAPI0064(CEtelSessionMgr& aEtelSessionMgr) |
|
4721 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4722 /** |
|
4723 * Constructor. |
|
4724 */ |
|
4725 { |
|
4726 SetTestStepName(CCTSYIntegrationTestCustomAPI0064::GetTestStepName()); |
|
4727 } |
|
4728 |
|
4729 CCTSYIntegrationTestCustomAPI0064::~CCTSYIntegrationTestCustomAPI0064() |
|
4730 /** |
|
4731 * Destructor. |
|
4732 */ |
|
4733 { |
|
4734 } |
|
4735 |
|
4736 TVerdict CCTSYIntegrationTestCustomAPI0064::doTestStepL() |
|
4737 /** |
|
4738 * @SYMTestCaseID BA-CTSY-INT-CAPI-0064 |
|
4739 * @SYMFssID BA/CTSY/CAPI-0064 |
|
4740 * @SYMTestCaseDesc Test calling RMmCustomAPI::SetAlwaysOn |
|
4741 * @SYMTestPriority High |
|
4742 * @SYMTestActions |
|
4743 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4744 * @SYMTestType CIT |
|
4745 * @SYMTestCaseDependencies live/automatic |
|
4746 * |
|
4747 * Reason for test: Test calling RMmCustomAPI::SetAlwaysOn |
|
4748 * |
|
4749 * @return - TVerdict code |
|
4750 */ |
|
4751 { |
|
4752 |
|
4753 // |
|
4754 // SET UP |
|
4755 // |
|
4756 |
|
4757 |
|
4758 |
|
4759 // |
|
4760 // SET UP END |
|
4761 // |
|
4762 |
|
4763 StartTest(); |
|
4764 |
|
4765 // |
|
4766 // TEST START |
|
4767 // |
|
4768 |
|
4769 |
|
4770 // Test calling RMmCustomAPI::SetAlwaysOn |
|
4771 |
|
4772 |
|
4773 // |
|
4774 // TEST END |
|
4775 // |
|
4776 |
|
4777 StartCleanup(); |
|
4778 |
|
4779 // Put any required test clean up here, then remove this comment |
|
4780 |
|
4781 return TestStepResult(); |
|
4782 } |
|
4783 |
|
4784 TPtrC CCTSYIntegrationTestCustomAPI0064::GetTestStepName() |
|
4785 /** |
|
4786 * @return The test step name. |
|
4787 */ |
|
4788 { |
|
4789 return _L("CCTSYIntegrationTestCustomAPI0064"); |
|
4790 } |
|
4791 |
|
4792 |
|
4793 |
|
4794 CCTSYIntegrationTestCustomAPI0065::CCTSYIntegrationTestCustomAPI0065(CEtelSessionMgr& aEtelSessionMgr) |
|
4795 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4796 /** |
|
4797 * Constructor. |
|
4798 */ |
|
4799 { |
|
4800 SetTestStepName(CCTSYIntegrationTestCustomAPI0065::GetTestStepName()); |
|
4801 } |
|
4802 |
|
4803 CCTSYIntegrationTestCustomAPI0065::~CCTSYIntegrationTestCustomAPI0065() |
|
4804 /** |
|
4805 * Destructor. |
|
4806 */ |
|
4807 { |
|
4808 } |
|
4809 |
|
4810 TVerdict CCTSYIntegrationTestCustomAPI0065::doTestStepL() |
|
4811 /** |
|
4812 * @SYMTestCaseID BA-CTSY-INT-CAPI-0065 |
|
4813 * @SYMFssID BA/CTSY/CAPI-0065 |
|
4814 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifyRauEvent |
|
4815 * @SYMTestPriority High |
|
4816 * @SYMTestActions |
|
4817 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4818 * @SYMTestType CIT |
|
4819 * @SYMTestCaseDependencies simulated/manual |
|
4820 * |
|
4821 * Reason for test: Test calling RMmCustomAPI::NotifyRauEvent |
|
4822 * |
|
4823 * @return - TVerdict code |
|
4824 */ |
|
4825 { |
|
4826 |
|
4827 // |
|
4828 // SET UP |
|
4829 // |
|
4830 |
|
4831 |
|
4832 |
|
4833 // |
|
4834 // SET UP END |
|
4835 // |
|
4836 |
|
4837 StartTest(); |
|
4838 |
|
4839 // |
|
4840 // TEST START |
|
4841 // |
|
4842 |
|
4843 |
|
4844 // Test calling RMmCustomAPI::NotifyRauEvent |
|
4845 |
|
4846 |
|
4847 // |
|
4848 // TEST END |
|
4849 // |
|
4850 |
|
4851 StartCleanup(); |
|
4852 |
|
4853 // Put any required test clean up here, then remove this comment |
|
4854 |
|
4855 return TestStepResult(); |
|
4856 } |
|
4857 |
|
4858 TPtrC CCTSYIntegrationTestCustomAPI0065::GetTestStepName() |
|
4859 /** |
|
4860 * @return The test step name. |
|
4861 */ |
|
4862 { |
|
4863 return _L("CCTSYIntegrationTestCustomAPI0065"); |
|
4864 } |
|
4865 |
|
4866 |
|
4867 |
|
4868 CCTSYIntegrationTestCustomAPI0066::CCTSYIntegrationTestCustomAPI0066(CEtelSessionMgr& aEtelSessionMgr) |
|
4869 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4870 /** |
|
4871 * Constructor. |
|
4872 */ |
|
4873 { |
|
4874 SetTestStepName(CCTSYIntegrationTestCustomAPI0066::GetTestStepName()); |
|
4875 } |
|
4876 |
|
4877 CCTSYIntegrationTestCustomAPI0066::~CCTSYIntegrationTestCustomAPI0066() |
|
4878 /** |
|
4879 * Destructor. |
|
4880 */ |
|
4881 { |
|
4882 } |
|
4883 |
|
4884 TVerdict CCTSYIntegrationTestCustomAPI0066::doTestStepL() |
|
4885 /** |
|
4886 * @SYMTestCaseID BA-CTSY-INT-CAPI-0066 |
|
4887 * @SYMFssID BA/CTSY/CAPI-0066 |
|
4888 * @SYMTestCaseDesc Test calling RMmCustomAPI::ReadHSxPAStatus |
|
4889 * @SYMTestPriority High |
|
4890 * @SYMTestActions |
|
4891 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4892 * @SYMTestType CIT |
|
4893 * @SYMTestCaseDependencies live/automatic |
|
4894 * |
|
4895 * Reason for test: Test calling RMmCustomAPI::ReadHSxPAStatus |
|
4896 * |
|
4897 * @return - TVerdict code |
|
4898 */ |
|
4899 { |
|
4900 |
|
4901 // |
|
4902 // SET UP |
|
4903 // |
|
4904 |
|
4905 |
|
4906 |
|
4907 // |
|
4908 // SET UP END |
|
4909 // |
|
4910 |
|
4911 StartTest(); |
|
4912 |
|
4913 // |
|
4914 // TEST START |
|
4915 // |
|
4916 |
|
4917 |
|
4918 // Test calling RMmCustomAPI::ReadHSxPAStatus |
|
4919 |
|
4920 |
|
4921 // |
|
4922 // TEST END |
|
4923 // |
|
4924 |
|
4925 StartCleanup(); |
|
4926 |
|
4927 // Put any required test clean up here, then remove this comment |
|
4928 |
|
4929 return TestStepResult(); |
|
4930 } |
|
4931 |
|
4932 TPtrC CCTSYIntegrationTestCustomAPI0066::GetTestStepName() |
|
4933 /** |
|
4934 * @return The test step name. |
|
4935 */ |
|
4936 { |
|
4937 return _L("CCTSYIntegrationTestCustomAPI0066"); |
|
4938 } |
|
4939 |
|
4940 |
|
4941 |
|
4942 CCTSYIntegrationTestCustomAPI0067::CCTSYIntegrationTestCustomAPI0067(CEtelSessionMgr& aEtelSessionMgr) |
|
4943 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
4944 /** |
|
4945 * Constructor. |
|
4946 */ |
|
4947 { |
|
4948 SetTestStepName(CCTSYIntegrationTestCustomAPI0067::GetTestStepName()); |
|
4949 } |
|
4950 |
|
4951 CCTSYIntegrationTestCustomAPI0067::~CCTSYIntegrationTestCustomAPI0067() |
|
4952 /** |
|
4953 * Destructor. |
|
4954 */ |
|
4955 { |
|
4956 } |
|
4957 |
|
4958 TVerdict CCTSYIntegrationTestCustomAPI0067::doTestStepL() |
|
4959 /** |
|
4960 * @SYMTestCaseID BA-CTSY-INT-CAPI-0067 |
|
4961 * @SYMFssID BA/CTSY/CAPI-0067 |
|
4962 * @SYMTestCaseDesc Test calling RMmCustomAPI::WriteHSxPAStatus |
|
4963 * @SYMTestPriority High |
|
4964 * @SYMTestActions |
|
4965 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
4966 * @SYMTestType CIT |
|
4967 * @SYMTestCaseDependencies live/automatic |
|
4968 * |
|
4969 * Reason for test: Test calling RMmCustomAPI::WriteHSxPAStatus |
|
4970 * |
|
4971 * @return - TVerdict code |
|
4972 */ |
|
4973 { |
|
4974 |
|
4975 // |
|
4976 // SET UP |
|
4977 // |
|
4978 |
|
4979 |
|
4980 |
|
4981 // |
|
4982 // SET UP END |
|
4983 // |
|
4984 |
|
4985 StartTest(); |
|
4986 |
|
4987 // |
|
4988 // TEST START |
|
4989 // |
|
4990 |
|
4991 |
|
4992 // Test calling RMmCustomAPI::WriteHSxPAStatus |
|
4993 |
|
4994 |
|
4995 // |
|
4996 // TEST END |
|
4997 // |
|
4998 |
|
4999 StartCleanup(); |
|
5000 |
|
5001 // Put any required test clean up here, then remove this comment |
|
5002 |
|
5003 return TestStepResult(); |
|
5004 } |
|
5005 |
|
5006 TPtrC CCTSYIntegrationTestCustomAPI0067::GetTestStepName() |
|
5007 /** |
|
5008 * @return The test step name. |
|
5009 */ |
|
5010 { |
|
5011 return _L("CCTSYIntegrationTestCustomAPI0067"); |
|
5012 } |
|
5013 |
|
5014 |
|
5015 |
|
5016 CCTSYIntegrationTestCustomAPI0068::CCTSYIntegrationTestCustomAPI0068(CEtelSessionMgr& aEtelSessionMgr) |
|
5017 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
5018 /** |
|
5019 * Constructor. |
|
5020 */ |
|
5021 { |
|
5022 SetTestStepName(CCTSYIntegrationTestCustomAPI0068::GetTestStepName()); |
|
5023 } |
|
5024 |
|
5025 CCTSYIntegrationTestCustomAPI0068::~CCTSYIntegrationTestCustomAPI0068() |
|
5026 /** |
|
5027 * Destructor. |
|
5028 */ |
|
5029 { |
|
5030 } |
|
5031 |
|
5032 TVerdict CCTSYIntegrationTestCustomAPI0068::doTestStepL() |
|
5033 /** |
|
5034 * @SYMTestCaseID BA-CTSY-INT-CAPI-0068 |
|
5035 * @SYMFssID BA/CTSY/CAPI-0068 |
|
5036 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifyHSxPAStatus |
|
5037 * @SYMTestPriority High |
|
5038 * @SYMTestActions |
|
5039 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
5040 * @SYMTestType CIT |
|
5041 * @SYMTestCaseDependencies live/automatic |
|
5042 * |
|
5043 * Reason for test: Test calling RMmCustomAPI::NotifyHSxPAStatus |
|
5044 * |
|
5045 * @return - TVerdict code |
|
5046 */ |
|
5047 { |
|
5048 |
|
5049 // |
|
5050 // SET UP |
|
5051 // |
|
5052 |
|
5053 |
|
5054 |
|
5055 // |
|
5056 // SET UP END |
|
5057 // |
|
5058 |
|
5059 StartTest(); |
|
5060 |
|
5061 // |
|
5062 // TEST START |
|
5063 // |
|
5064 |
|
5065 |
|
5066 // Test calling RMmCustomAPI::NotifyHSxPAStatus |
|
5067 |
|
5068 |
|
5069 // |
|
5070 // TEST END |
|
5071 // |
|
5072 |
|
5073 StartCleanup(); |
|
5074 |
|
5075 // Put any required test clean up here, then remove this comment |
|
5076 |
|
5077 return TestStepResult(); |
|
5078 } |
|
5079 |
|
5080 TPtrC CCTSYIntegrationTestCustomAPI0068::GetTestStepName() |
|
5081 /** |
|
5082 * @return The test step name. |
|
5083 */ |
|
5084 { |
|
5085 return _L("CCTSYIntegrationTestCustomAPI0068"); |
|
5086 } |
|
5087 |
|
5088 |
|
5089 |
|
5090 CCTSYIntegrationTestCustomAPI0069::CCTSYIntegrationTestCustomAPI0069(CEtelSessionMgr& aEtelSessionMgr) |
|
5091 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
5092 /** |
|
5093 * Constructor. |
|
5094 */ |
|
5095 { |
|
5096 SetTestStepName(CCTSYIntegrationTestCustomAPI0069::GetTestStepName()); |
|
5097 } |
|
5098 |
|
5099 CCTSYIntegrationTestCustomAPI0069::~CCTSYIntegrationTestCustomAPI0069() |
|
5100 /** |
|
5101 * Destructor. |
|
5102 */ |
|
5103 { |
|
5104 } |
|
5105 |
|
5106 TVerdict CCTSYIntegrationTestCustomAPI0069::doTestStepL() |
|
5107 /** |
|
5108 * @SYMTestCaseID BA-CTSY-INT-CAPI-0069 |
|
5109 * @SYMFssID BA/CTSY/CAPI-0069 |
|
5110 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetIccCallForwardingIndicatorStatus |
|
5111 * @SYMTestPriority High |
|
5112 * @SYMTestActions |
|
5113 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
5114 * @SYMTestType CIT |
|
5115 * @SYMTestCaseDependencies live/automatic |
|
5116 * |
|
5117 * Reason for test: Test calling RMmCustomAPI::GetIccCallForwardingIndicatorStatus |
|
5118 * |
|
5119 * @return - TVerdict code |
|
5120 */ |
|
5121 { |
|
5122 |
|
5123 // |
|
5124 // SET UP |
|
5125 // |
|
5126 |
|
5127 |
|
5128 |
|
5129 // |
|
5130 // SET UP END |
|
5131 // |
|
5132 |
|
5133 StartTest(); |
|
5134 |
|
5135 // |
|
5136 // TEST START |
|
5137 // |
|
5138 |
|
5139 |
|
5140 // Test calling RMmCustomAPI::GetIccCallForwardingIndicatorStatus |
|
5141 |
|
5142 |
|
5143 // |
|
5144 // TEST END |
|
5145 // |
|
5146 |
|
5147 StartCleanup(); |
|
5148 |
|
5149 // Put any required test clean up here, then remove this comment |
|
5150 |
|
5151 return TestStepResult(); |
|
5152 } |
|
5153 |
|
5154 TPtrC CCTSYIntegrationTestCustomAPI0069::GetTestStepName() |
|
5155 /** |
|
5156 * @return The test step name. |
|
5157 */ |
|
5158 { |
|
5159 return _L("CCTSYIntegrationTestCustomAPI0069"); |
|
5160 } |
|
5161 |
|
5162 |
|
5163 |
|
5164 CCTSYIntegrationTestCustomAPI0070::CCTSYIntegrationTestCustomAPI0070(CEtelSessionMgr& aEtelSessionMgr) |
|
5165 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
5166 /** |
|
5167 * Constructor. |
|
5168 */ |
|
5169 { |
|
5170 SetTestStepName(CCTSYIntegrationTestCustomAPI0070::GetTestStepName()); |
|
5171 } |
|
5172 |
|
5173 CCTSYIntegrationTestCustomAPI0070::~CCTSYIntegrationTestCustomAPI0070() |
|
5174 /** |
|
5175 * Destructor. |
|
5176 */ |
|
5177 { |
|
5178 } |
|
5179 |
|
5180 TVerdict CCTSYIntegrationTestCustomAPI0070::doTestStepL() |
|
5181 /** |
|
5182 * @SYMTestCaseID BA-CTSY-INT-CAPI-0070 |
|
5183 * @SYMFssID BA/CTSY/CAPI-0070 |
|
5184 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifyIccCallForwardingStatusChange |
|
5185 * @SYMTestPriority High |
|
5186 * @SYMTestActions |
|
5187 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
5188 * @SYMTestType CIT |
|
5189 * @SYMTestCaseDependencies live/automatic |
|
5190 * |
|
5191 * Reason for test: Test calling RMmCustomAPI::NotifyIccCallForwardingStatusChange |
|
5192 * |
|
5193 * @return - TVerdict code |
|
5194 */ |
|
5195 { |
|
5196 |
|
5197 // |
|
5198 // SET UP |
|
5199 // |
|
5200 |
|
5201 |
|
5202 |
|
5203 // |
|
5204 // SET UP END |
|
5205 // |
|
5206 |
|
5207 StartTest(); |
|
5208 |
|
5209 // |
|
5210 // TEST START |
|
5211 // |
|
5212 |
|
5213 |
|
5214 // Test calling RMmCustomAPI::NotifyIccCallForwardingStatusChange |
|
5215 |
|
5216 |
|
5217 // |
|
5218 // TEST END |
|
5219 // |
|
5220 |
|
5221 StartCleanup(); |
|
5222 |
|
5223 // Put any required test clean up here, then remove this comment |
|
5224 |
|
5225 return TestStepResult(); |
|
5226 } |
|
5227 |
|
5228 TPtrC CCTSYIntegrationTestCustomAPI0070::GetTestStepName() |
|
5229 /** |
|
5230 * @return The test step name. |
|
5231 */ |
|
5232 { |
|
5233 return _L("CCTSYIntegrationTestCustomAPI0070"); |
|
5234 } |
|
5235 |
|
5236 |
|
5237 |
|
5238 CCTSYIntegrationTestCustomAPI0071::CCTSYIntegrationTestCustomAPI0071(CEtelSessionMgr& aEtelSessionMgr) |
|
5239 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
5240 /** |
|
5241 * Constructor. |
|
5242 */ |
|
5243 { |
|
5244 SetTestStepName(CCTSYIntegrationTestCustomAPI0071::GetTestStepName()); |
|
5245 } |
|
5246 |
|
5247 CCTSYIntegrationTestCustomAPI0071::~CCTSYIntegrationTestCustomAPI0071() |
|
5248 /** |
|
5249 * Destructor. |
|
5250 */ |
|
5251 { |
|
5252 } |
|
5253 |
|
5254 TVerdict CCTSYIntegrationTestCustomAPI0071::doTestStepL() |
|
5255 /** |
|
5256 * @SYMTestCaseID BA-CTSY-INT-CAPI-0071 |
|
5257 * @SYMFssID BA/CTSY/CAPI-0071 |
|
5258 * @SYMTestCaseDesc Test calling RMmCustomAPI::GetCellInfo |
|
5259 * @SYMTestPriority High |
|
5260 * @SYMTestActions |
|
5261 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
5262 * @SYMTestType CIT |
|
5263 * @SYMTestCaseDependencies live/automatic |
|
5264 * |
|
5265 * Reason for test: Test calling RMmCustomAPI::GetCellInfo |
|
5266 * |
|
5267 * @return - TVerdict code |
|
5268 */ |
|
5269 { |
|
5270 |
|
5271 // |
|
5272 // SET UP |
|
5273 // |
|
5274 |
|
5275 |
|
5276 |
|
5277 // |
|
5278 // SET UP END |
|
5279 // |
|
5280 |
|
5281 StartTest(); |
|
5282 |
|
5283 // |
|
5284 // TEST START |
|
5285 // |
|
5286 |
|
5287 |
|
5288 // Test calling RMmCustomAPI::GetCellInfo |
|
5289 |
|
5290 |
|
5291 // |
|
5292 // TEST END |
|
5293 // |
|
5294 |
|
5295 StartCleanup(); |
|
5296 |
|
5297 // Put any required test clean up here, then remove this comment |
|
5298 |
|
5299 return TestStepResult(); |
|
5300 } |
|
5301 |
|
5302 TPtrC CCTSYIntegrationTestCustomAPI0071::GetTestStepName() |
|
5303 /** |
|
5304 * @return The test step name. |
|
5305 */ |
|
5306 { |
|
5307 return _L("CCTSYIntegrationTestCustomAPI0071"); |
|
5308 } |
|
5309 |
|
5310 |
|
5311 |
|
5312 CCTSYIntegrationTestCustomAPI0072::CCTSYIntegrationTestCustomAPI0072(CEtelSessionMgr& aEtelSessionMgr) |
|
5313 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
5314 /** |
|
5315 * Constructor. |
|
5316 */ |
|
5317 { |
|
5318 SetTestStepName(CCTSYIntegrationTestCustomAPI0072::GetTestStepName()); |
|
5319 } |
|
5320 |
|
5321 CCTSYIntegrationTestCustomAPI0072::~CCTSYIntegrationTestCustomAPI0072() |
|
5322 /** |
|
5323 * Destructor. |
|
5324 */ |
|
5325 { |
|
5326 } |
|
5327 |
|
5328 TVerdict CCTSYIntegrationTestCustomAPI0072::doTestStepL() |
|
5329 /** |
|
5330 * @SYMTestCaseID BA-CTSY-INT-CAPI-0072 |
|
5331 * @SYMFssID BA/CTSY/CAPI-0072 |
|
5332 * @SYMTestCaseDesc Test calling RMmCustomAPI::NotifyCellInfoChange |
|
5333 * @SYMTestPriority High |
|
5334 * @SYMTestActions |
|
5335 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
5336 * @SYMTestType CIT |
|
5337 * @SYMTestCaseDependencies simulated/manual |
|
5338 * |
|
5339 * Reason for test: Test calling RMmCustomAPI::NotifyCellInfoChange |
|
5340 * |
|
5341 * @return - TVerdict code |
|
5342 */ |
|
5343 { |
|
5344 |
|
5345 // |
|
5346 // SET UP |
|
5347 // |
|
5348 |
|
5349 |
|
5350 |
|
5351 // |
|
5352 // SET UP END |
|
5353 // |
|
5354 |
|
5355 StartTest(); |
|
5356 |
|
5357 // |
|
5358 // TEST START |
|
5359 // |
|
5360 |
|
5361 |
|
5362 // Test calling RMmCustomAPI::NotifyCellInfoChange |
|
5363 |
|
5364 |
|
5365 // |
|
5366 // TEST END |
|
5367 // |
|
5368 |
|
5369 StartCleanup(); |
|
5370 |
|
5371 // Put any required test clean up here, then remove this comment |
|
5372 |
|
5373 return TestStepResult(); |
|
5374 } |
|
5375 |
|
5376 TPtrC CCTSYIntegrationTestCustomAPI0072::GetTestStepName() |
|
5377 /** |
|
5378 * @return The test step name. |
|
5379 */ |
|
5380 { |
|
5381 return _L("CCTSYIntegrationTestCustomAPI0072"); |
|
5382 } |
|
5383 |
|
5384 |
|
5385 |
|
5386 CCTSYIntegrationTestCustomAPI0073::CCTSYIntegrationTestCustomAPI0073(CEtelSessionMgr& aEtelSessionMgr) |
|
5387 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
5388 /** |
|
5389 * Constructor. |
|
5390 */ |
|
5391 { |
|
5392 SetTestStepName(CCTSYIntegrationTestCustomAPI0073::GetTestStepName()); |
|
5393 } |
|
5394 |
|
5395 CCTSYIntegrationTestCustomAPI0073::~CCTSYIntegrationTestCustomAPI0073() |
|
5396 /** |
|
5397 * Destructor. |
|
5398 */ |
|
5399 { |
|
5400 } |
|
5401 |
|
5402 TVerdict CCTSYIntegrationTestCustomAPI0073::doTestStepL() |
|
5403 /** |
|
5404 * @SYMTestCaseID BA-CTSY-INT-CAPI-0073 |
|
5405 * @SYMFssID BA/CTSY/CAPI-0073 |
|
5406 * @SYMTestCaseDesc Test calling RMmCustomAPI::WriteAlphaString |
|
5407 * @SYMTestPriority High |
|
5408 * @SYMTestActions |
|
5409 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
5410 * @SYMTestType CIT |
|
5411 * @SYMTestCaseDependencies live/automatic |
|
5412 * |
|
5413 * Reason for test: Test calling RMmCustomAPI::WriteAlphaString |
|
5414 * |
|
5415 * @return - TVerdict code |
|
5416 */ |
|
5417 { |
|
5418 |
|
5419 // |
|
5420 // SET UP |
|
5421 // |
|
5422 |
|
5423 |
|
5424 |
|
5425 // |
|
5426 // SET UP END |
|
5427 // |
|
5428 |
|
5429 StartTest(); |
|
5430 |
|
5431 // |
|
5432 // TEST START |
|
5433 // |
|
5434 |
|
5435 |
|
5436 // Test calling RMmCustomAPI::WriteAlphaString |
|
5437 |
|
5438 |
|
5439 // |
|
5440 // TEST END |
|
5441 // |
|
5442 |
|
5443 StartCleanup(); |
|
5444 |
|
5445 // Put any required test clean up here, then remove this comment |
|
5446 |
|
5447 return TestStepResult(); |
|
5448 } |
|
5449 |
|
5450 TPtrC CCTSYIntegrationTestCustomAPI0073::GetTestStepName() |
|
5451 /** |
|
5452 * @return The test step name. |
|
5453 */ |
|
5454 { |
|
5455 return _L("CCTSYIntegrationTestCustomAPI0073"); |
|
5456 } |
|
5457 |
|
5458 |
|
5459 |
|
5460 CCTSYIntegrationTestCustomAPI0074::CCTSYIntegrationTestCustomAPI0074(CEtelSessionMgr& aEtelSessionMgr) |
|
5461 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
5462 /** |
|
5463 * Constructor. |
|
5464 */ |
|
5465 { |
|
5466 SetTestStepName(CCTSYIntegrationTestCustomAPI0074::GetTestStepName()); |
|
5467 } |
|
5468 |
|
5469 CCTSYIntegrationTestCustomAPI0074::~CCTSYIntegrationTestCustomAPI0074() |
|
5470 /** |
|
5471 * Destructor. |
|
5472 */ |
|
5473 { |
|
5474 } |
|
5475 |
|
5476 TVerdict CCTSYIntegrationTestCustomAPI0074::doTestStepL() |
|
5477 /** |
|
5478 * @SYMTestCaseID BA-CTSY-INT-CAPI-0074 |
|
5479 * @SYMFssID BA/CTSY/CAPI-0074 |
|
5480 * @SYMTestCaseDesc Test calling RMmCustomAPI::ReadAlphaString |
|
5481 * @SYMTestPriority High |
|
5482 * @SYMTestActions |
|
5483 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
5484 * @SYMTestType CIT |
|
5485 * @SYMTestCaseDependencies live/automatic |
|
5486 * |
|
5487 * Reason for test: Test calling RMmCustomAPI::ReadAlphaString |
|
5488 * |
|
5489 * @return - TVerdict code |
|
5490 */ |
|
5491 { |
|
5492 |
|
5493 // |
|
5494 // SET UP |
|
5495 // |
|
5496 |
|
5497 |
|
5498 |
|
5499 // |
|
5500 // SET UP END |
|
5501 // |
|
5502 |
|
5503 StartTest(); |
|
5504 |
|
5505 // |
|
5506 // TEST START |
|
5507 // |
|
5508 |
|
5509 |
|
5510 // Test calling RMmCustomAPI::ReadAlphaString |
|
5511 |
|
5512 |
|
5513 // |
|
5514 // TEST END |
|
5515 // |
|
5516 |
|
5517 StartCleanup(); |
|
5518 |
|
5519 // Put any required test clean up here, then remove this comment |
|
5520 |
|
5521 return TestStepResult(); |
|
5522 } |
|
5523 |
|
5524 TPtrC CCTSYIntegrationTestCustomAPI0074::GetTestStepName() |
|
5525 /** |
|
5526 * @return The test step name. |
|
5527 */ |
|
5528 { |
|
5529 return _L("CCTSYIntegrationTestCustomAPI0074"); |
|
5530 } |
|
5531 |
|
5532 |
|
5533 |
|
5534 CCTSYIntegrationTestCustomAPI0075::CCTSYIntegrationTestCustomAPI0075(CEtelSessionMgr& aEtelSessionMgr) |
|
5535 : CCTSYIntegrationTestCustomAPIBase(aEtelSessionMgr) |
|
5536 /** |
|
5537 * Constructor. |
|
5538 */ |
|
5539 { |
|
5540 SetTestStepName(CCTSYIntegrationTestCustomAPI0075::GetTestStepName()); |
|
5541 } |
|
5542 |
|
5543 CCTSYIntegrationTestCustomAPI0075::~CCTSYIntegrationTestCustomAPI0075() |
|
5544 /** |
|
5545 * Destructor. |
|
5546 */ |
|
5547 { |
|
5548 } |
|
5549 |
|
5550 TVerdict CCTSYIntegrationTestCustomAPI0075::doTestStepL() |
|
5551 /** |
|
5552 * @SYMTestCaseID BA-CTSY-INT-CAPI-0075 |
|
5553 * @SYMFssID BA/CTSY/CAPI-0075 |
|
5554 * @SYMTestCaseDesc Test calling RMmCustomAPI::DeleteAlphaString |
|
5555 * @SYMTestPriority High |
|
5556 * @SYMTestActions |
|
5557 * @SYMTestExpectedResults Pass - Place holder - fill this in when writing test |
|
5558 * @SYMTestType CIT |
|
5559 * @SYMTestCaseDependencies live/automatic |
|
5560 * |
|
5561 * Reason for test: Test calling RMmCustomAPI::DeleteAlphaString |
|
5562 * |
|
5563 * @return - TVerdict code |
|
5564 */ |
|
5565 { |
|
5566 |
|
5567 // |
|
5568 // SET UP |
|
5569 // |
|
5570 |
|
5571 |
|
5572 |
|
5573 // |
|
5574 // SET UP END |
|
5575 // |
|
5576 |
|
5577 StartTest(); |
|
5578 |
|
5579 // |
|
5580 // TEST START |
|
5581 // |
|
5582 |
|
5583 |
|
5584 // Test calling RMmCustomAPI::DeleteAlphaString |
|
5585 |
|
5586 |
|
5587 // |
|
5588 // TEST END |
|
5589 // |
|
5590 |
|
5591 StartCleanup(); |
|
5592 |
|
5593 // Put any required test clean up here, then remove this comment |
|
5594 |
|
5595 return TestStepResult(); |
|
5596 } |
|
5597 |
|
5598 TPtrC CCTSYIntegrationTestCustomAPI0075::GetTestStepName() |
|
5599 /** |
|
5600 * @return The test step name. |
|
5601 */ |
|
5602 { |
|
5603 return _L("CCTSYIntegrationTestCustomAPI0075"); |
|
5604 } |
|
5605 |
|
5606 |
|
5607 |