1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "cmath"
17 #include "condition_variable"
18 #include "cstdio"
19 #include "hdf_base.h"
20 #include "hdf_log.h"
21 #include "map"
22 #include "mutex"
23 #include "securec.h"
24 #include "cstdlib"
25 #include "unistd.h"
26 #include "v1_3/iril.h"
27 #include "gtest/gtest.h"
28 #include "hdf_ril_callback_common.h"
29
30 using namespace OHOS::HDI::Ril::V1_3;
31 using namespace testing::ext;
32
33 class HdfRilHdiTestAdditional1st : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp();
38 void TearDown();
39 };
40 /**
41 ** HdfRilHdiTestAdditional1st implement
42 **/
SetUpTestCase()43 void HdfRilHdiTestAdditional1st::SetUpTestCase()
44 {
45 g_rilInterface = OHOS::HDI::Ril::V1_3::IRil::Get();
46 if (g_rilInterface != nullptr) {
47 g_rilInterface->SetCallback1_3(&g_callback);
48 g_rilInterface->SendRilAck();
49 g_rilInterface->GetSimStatus(SLOTID_1, GetSerialId());
50 g_rilInterface->GetSimStatus(SLOTID_2, GetSerialId());
51 }
52 }
53
TearDownTestCase()54 void HdfRilHdiTestAdditional1st::TearDownTestCase() {}
SetUp()55 void HdfRilHdiTestAdditional1st::SetUp() {}
TearDown()56 void HdfRilHdiTestAdditional1st::TearDown() {}
57 /**
58 ** Xts Test
59 **/
60 /**
61 * @tc.number: SUB_Telephony_DriverSystem_V1GetSimStatus_0300
62 * @tc.name : testV1GetSimStatus001
63 * @tc.desc : GetSimStatus, stability test
64 */
65 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetSimStatus001, Function | MediumTest | Level1)
66 {
67 if (!IsReady(SLOTID_1)) {
68 return;
69 }
70 int32_t ret;
71 for (int i = 0; i < 10; i++) {
72 ret = g_rilInterface->GetSimStatus(SLOTID_1, GetSerialId());
73 if (ret != 2) {
74 WaitFor(WAIT_TIME_SECOND);
75 EXPECT_EQ(SUCCESS, ret);
76 } else {
77 return;
78 }
79 }
80 }
81
82 /**
83 * @tc.number: SUB_Telephony_DriverSystem_V1GetSimStatusResponse_0100
84 * @tc.name : testV1GetSimStatusResponse001
85 * @tc.desc : GetSimStatusResponse, slotId is SLOTID_1
86 */
87 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetSimStatusResponse001, Function | MediumTest | Level1)
88 {
89 if (!IsReady(SLOTID_1)) {
90 return;
91 }
92 g_getSimStatusResponseFlag = false;
93 int32_t ret = g_rilInterface->GetSimStatus(SLOTID_1, GetSerialId());
94 if (ret != 2) {
95 WaitFor(WAIT_TIME_SECOND);
96 EXPECT_EQ(SUCCESS, ret);
97 EXPECT_EQ(true, g_getSimStatusResponseFlag);
98 } else {
99 return;
100 }
101 }
102
103 /**
104 * @tc.number: SUB_Telephony_DriverSystem_V1GetSimStatusResponse_0200
105 * @tc.name : testV1GetSimStatusResponse002
106 * @tc.desc : GetSimStatusResponse, slotId is SLOTID_2
107 */
108 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetSimStatusResponse002, Function | MediumTest | Level1)
109 {
110 if (!IsReady(SLOTID_2)) {
111 return;
112 }
113 g_getSimStatusResponseFlag = false;
114 int32_t ret = g_rilInterface->GetSimStatus(SLOTID_2, GetSerialId());
115 if (ret != 2) {
116 WaitFor(WAIT_TIME_SECOND);
117 EXPECT_EQ(SUCCESS, ret);
118 EXPECT_EQ(true, g_getSimStatusResponseFlag);
119 } else {
120 return;
121 }
122 }
123
124 /**
125 * @tc.number: SUB_Telephony_DriverSystem_V1GetSimCardStatusResponse_0100
126 * @tc.name : testV1GetSimCardStatusResponse001
127 * @tc.desc : GetSimCardStatusResponse, slotId is SLOTID_1
128 */
129 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetSimCardStatusResponse001, Function | MediumTest | Level1)
130 {
131 if (!IsReady(SLOTID_1)) {
132 return;
133 }
134 g_getSimCardStatusResponseFlag = false;
135 int32_t ret = g_rilInterface->GetSimStatus(SLOTID_1, GetSerialId());
136 if (ret != 2) {
137 WaitFor(WAIT_TIME_SECOND);
138 EXPECT_EQ(SUCCESS, ret);
139 EXPECT_EQ(true, g_getSimCardStatusResponseFlag);
140 } else {
141 return;
142 }
143 }
144
145 /**
146 * @tc.number: SUB_Telephony_DriverSystem_V1GetSimCardStatusResponse_0200
147 * @tc.name : testV1GetSimCardStatusResponse002
148 * @tc.desc : GetSimCardStatusResponse, slotId is SLOTID_2
149 */
150 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetSimCardStatusResponse002, Function | MediumTest | Level1)
151 {
152 if (!IsReady(SLOTID_2)) {
153 return;
154 }
155 g_getSimCardStatusResponseFlag = false;
156 int32_t ret = g_rilInterface->GetSimStatus(SLOTID_2, GetSerialId());
157 if (ret != 2) {
158 WaitFor(WAIT_TIME_SECOND);
159 EXPECT_EQ(SUCCESS, ret);
160 EXPECT_EQ(true, g_getSimCardStatusResponseFlag);
161 } else {
162 return;
163 }
164 }
165
166 /**
167 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_0600
168 * @tc.name : testV1SetEmergencyCallList004
169 * @tc.desc : Call the function V1 SetEmergencyCallList with serialId and a value of -11111
170 */
171 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList004, Function | MediumTest | Level2)
172 {
173 if (!IsReady(SLOTID_1)) {
174 return;
175 }
176 EmergencyInfoList emergencyInfoList;
177 EmergencyCall emergencyInfo = {};
178 emergencyInfo.index = 1;
179 emergencyInfo.total = 1;
180 emergencyInfo.eccNum = "120";
181 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
182 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
183 emergencyInfo.mcc = "460";
184 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
185 emergencyInfoList.calls.push_back(emergencyInfo);
186 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, -11111, emergencyInfoList);
187 WaitFor(WAIT_TIME_SECOND);
188 EXPECT_NE(SUCCESS, ret);
189 }
190
191 /**
192 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_0700
193 * @tc.name : testV1SetEmergencyCallList005
194 * @tc.desc : Call the function V1 SetEmergencyCallList with serialId and a value of 0
195 */
196 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList005, Function | MediumTest | Level1)
197 {
198 if (!IsReady(SLOTID_1)) {
199 return;
200 }
201 EmergencyInfoList emergencyInfoList;
202 EmergencyCall emergencyInfo = {};
203 emergencyInfo.index = 1;
204 emergencyInfo.total = 1;
205 emergencyInfo.eccNum = "120";
206 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
207 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
208 emergencyInfo.mcc = "460";
209 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
210 emergencyInfoList.calls.push_back(emergencyInfo);
211 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, 0, emergencyInfoList);
212 WaitFor(WAIT_TIME_SECOND);
213 EXPECT_EQ(SUCCESS, ret);
214 }
215
216 /**
217 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_0800
218 * @tc.name : testV1SetEmergencyCallList006
219 * @tc.desc : Call the function V1 SetEmergencyCallList with serialId and a value of 11111
220 */
221 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList006, Function | MediumTest | Level1)
222 {
223 if (!IsReady(SLOTID_1)) {
224 return;
225 }
226 EmergencyInfoList emergencyInfoList;
227 EmergencyCall emergencyInfo = {};
228 emergencyInfo.index = 1;
229 emergencyInfo.total = 1;
230 emergencyInfo.eccNum = "120";
231 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
232 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
233 emergencyInfo.mcc = "460";
234 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
235 emergencyInfoList.calls.push_back(emergencyInfo);
236 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, 11111, emergencyInfoList);
237 WaitFor(WAIT_TIME_SECOND);
238 EXPECT_EQ(SUCCESS, ret);
239 }
240
241 /**
242 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_0900
243 * @tc.name : testV1SetEmergencyCallList007
244 * @tc.desc : Call the function V1 SetEmergencyCallList with serialId and a value of 32768
245 */
246 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList007, Function | MediumTest | Level1)
247 {
248 if (!IsReady(SLOTID_1)) {
249 return;
250 }
251 EmergencyInfoList emergencyInfoList;
252 EmergencyCall emergencyInfo = {};
253 emergencyInfo.index = 1;
254 emergencyInfo.total = 1;
255 emergencyInfo.eccNum = "120";
256 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
257 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
258 emergencyInfo.mcc = "460";
259 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
260 emergencyInfoList.calls.push_back(emergencyInfo);
261 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, 32768, emergencyInfoList);
262 WaitFor(WAIT_TIME_SECOND);
263 EXPECT_EQ(SUCCESS, ret);
264 }
265
266 /**
267 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_1000
268 * @tc.name : testV1SetEmergencyCallList008
269 * @tc.desc : Call the function V1 SetEmergencyCallList with serialId and a value of -32768
270 */
271 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList008, Function | MediumTest | Level2)
272 {
273 if (!IsReady(SLOTID_1)) {
274 return;
275 }
276 EmergencyInfoList emergencyInfoList;
277 EmergencyCall emergencyInfo = {};
278 emergencyInfo.index = 1;
279 emergencyInfo.total = 1;
280 emergencyInfo.eccNum = "120";
281 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
282 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
283 emergencyInfo.mcc = "460";
284 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
285 emergencyInfoList.calls.push_back(emergencyInfo);
286 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, -32768, emergencyInfoList);
287 WaitFor(WAIT_TIME_SECOND);
288 EXPECT_NE(SUCCESS, ret);
289 }
290
291 /**
292 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_1100
293 * @tc.name : testV1SetEmergencyCallList009
294 * @tc.desc : Call the function V1 SetEmergencyCallList with index and a value of 0
295 */
296 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList009, Function | MediumTest | Level1)
297 {
298 if (!IsReady(SLOTID_1)) {
299 return;
300 }
301 EmergencyInfoList emergencyInfoList;
302 EmergencyCall emergencyInfo = {};
303 emergencyInfo.index = 0;
304 emergencyInfo.total = 1;
305 emergencyInfo.eccNum = "120";
306 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
307 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
308 emergencyInfo.mcc = "460";
309 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
310 emergencyInfoList.calls.push_back(emergencyInfo);
311 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
312 WaitFor(WAIT_TIME_SECOND);
313 EXPECT_EQ(SUCCESS, ret);
314 }
315
316 /**
317 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_1200
318 * @tc.name : testV1SetEmergencyCallList010
319 * @tc.desc : Call the function V1 SetEmergencyCallList with index and a value of -1
320 */
321 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList010, Function | MediumTest | Level2)
322 {
323 if (!IsReady(SLOTID_1)) {
324 return;
325 }
326 EmergencyInfoList emergencyInfoList;
327 EmergencyCall emergencyInfo = {};
328 emergencyInfo.index = -1;
329 emergencyInfo.total = 1;
330 emergencyInfo.eccNum = "120";
331 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
332 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
333 emergencyInfo.mcc = "460";
334 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
335 emergencyInfoList.calls.push_back(emergencyInfo);
336 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
337 WaitFor(WAIT_TIME_SECOND);
338 EXPECT_NE(SUCCESS, ret);
339 }
340
341 /**
342 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_1300
343 * @tc.name : testV1SetEmergencyCallList011
344 * @tc.desc : Call the function V1 SetEmergencyCallList with total and a value of 0
345 */
346 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList011, Function | MediumTest | Level1)
347 {
348 if (!IsReady(SLOTID_1)) {
349 return;
350 }
351 EmergencyInfoList emergencyInfoList;
352 EmergencyCall emergencyInfo = {};
353 emergencyInfo.index = 1;
354 emergencyInfo.total = 0;
355 emergencyInfo.eccNum = "120";
356 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
357 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
358 emergencyInfo.mcc = "460";
359 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
360 emergencyInfoList.calls.push_back(emergencyInfo);
361 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
362 WaitFor(WAIT_TIME_SECOND);
363 EXPECT_EQ(SUCCESS, ret);
364 }
365
366 /**
367 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_1400
368 * @tc.name : testV1SetEmergencyCallList012
369 * @tc.desc : Call the function V1 SetEmergencyCallList with total and a value of -1
370 */
371 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList012, Function | MediumTest | Level2)
372 {
373 if (!IsReady(SLOTID_1)) {
374 return;
375 }
376 EmergencyInfoList emergencyInfoList;
377 EmergencyCall emergencyInfo = {};
378 emergencyInfo.index = 1;
379 emergencyInfo.total = -1;
380 emergencyInfo.eccNum = "120";
381 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
382 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
383 emergencyInfo.mcc = "460";
384 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
385 emergencyInfoList.calls.push_back(emergencyInfo);
386 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
387 WaitFor(WAIT_TIME_SECOND);
388 EXPECT_NE(SUCCESS, ret);
389 }
390
391 /**
392 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_1500
393 * @tc.name : testV1SetEmergencyCallList013
394 * @tc.desc : Call the function V1 SetEmergencyCallList with eccNum and a value of 0
395 */
396 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList013, Function | MediumTest | Level1)
397 {
398 if (!IsReady(SLOTID_1)) {
399 return;
400 }
401 EmergencyInfoList emergencyInfoList;
402 EmergencyCall emergencyInfo = {};
403 emergencyInfo.index = 1;
404 emergencyInfo.total = 1;
405 emergencyInfo.eccNum = "0";
406 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
407 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
408 emergencyInfo.mcc = "460";
409 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
410 emergencyInfoList.calls.push_back(emergencyInfo);
411 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
412 WaitFor(WAIT_TIME_SECOND);
413 EXPECT_EQ(SUCCESS, ret);
414 }
415
416 /**
417 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_1600
418 * @tc.name : testV1SetEmergencyCallList014
419 * @tc.desc : Call the function V1 SetEmergencyCallList with eccNum and a value of 110
420 */
421 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList014, Function | MediumTest | Level1)
422 {
423 if (!IsReady(SLOTID_1)) {
424 return;
425 }
426 EmergencyInfoList emergencyInfoList;
427 EmergencyCall emergencyInfo = {};
428 emergencyInfo.index = 1;
429 emergencyInfo.total = 1;
430 emergencyInfo.eccNum = "110";
431 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
432 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
433 emergencyInfo.mcc = "460";
434 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
435 emergencyInfoList.calls.push_back(emergencyInfo);
436 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
437 WaitFor(WAIT_TIME_SECOND);
438 EXPECT_EQ(SUCCESS, ret);
439 }
440
441 /**
442 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_1700
443 * @tc.name : testV1SetEmergencyCallList015
444 * @tc.desc : Call the function V1 SetEmergencyCallList with eccNum and a value of -110
445 */
446 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList015, Function | MediumTest | Level2)
447 {
448 if (!IsReady(SLOTID_1)) {
449 return;
450 }
451 EmergencyInfoList emergencyInfoList;
452 EmergencyCall emergencyInfo = {};
453 emergencyInfo.index = 1;
454 emergencyInfo.total = 1;
455 emergencyInfo.eccNum = "-110";
456 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
457 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
458 emergencyInfo.mcc = "460";
459 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
460 emergencyInfoList.calls.push_back(emergencyInfo);
461 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
462 WaitFor(WAIT_TIME_SECOND);
463 EXPECT_NE(SUCCESS, ret);
464 }
465
466 /**
467 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_1800
468 * @tc.name : testV1SetEmergencyCallList016
469 * @tc.desc : Call the function V1 SetEmergencyCallList with mcc and a value of 0
470 */
471 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList016, Function | MediumTest | Level1)
472 {
473 if (!IsReady(SLOTID_1)) {
474 return;
475 }
476 EmergencyInfoList emergencyInfoList;
477 EmergencyCall emergencyInfo = {};
478 emergencyInfo.index = 1;
479 emergencyInfo.total = 1;
480 emergencyInfo.eccNum = "120";
481 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
482 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
483 emergencyInfo.mcc = "0";
484 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
485 emergencyInfoList.calls.push_back(emergencyInfo);
486 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
487 WaitFor(WAIT_TIME_SECOND);
488 EXPECT_EQ(SUCCESS, ret);
489 }
490
491 /**
492 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_1900
493 * @tc.name : testV1SetEmergencyCallList017
494 * @tc.desc : Call the function V1 SetEmergencyCallList with mcc and a value of 86
495 */
496 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList017, Function | MediumTest | Level1)
497 {
498 if (!IsReady(SLOTID_1)) {
499 return;
500 }
501 EmergencyInfoList emergencyInfoList;
502 EmergencyCall emergencyInfo = {};
503 emergencyInfo.index = 1;
504 emergencyInfo.total = 1;
505 emergencyInfo.eccNum = "120";
506 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
507 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
508 emergencyInfo.mcc = "86";
509 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
510 emergencyInfoList.calls.push_back(emergencyInfo);
511 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
512 WaitFor(WAIT_TIME_SECOND);
513 EXPECT_EQ(SUCCESS, ret);
514 }
515
516 /**
517 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_2000
518 * @tc.name : testV1SetEmergencyCallList018
519 * @tc.desc : Call the function V1 SetEmergencyCallList with mcc and a value of -1
520 */
521 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList018, Function | MediumTest | Level2)
522 {
523 if (!IsReady(SLOTID_1)) {
524 return;
525 }
526 EmergencyInfoList emergencyInfoList;
527 EmergencyCall emergencyInfo = {};
528 emergencyInfo.index = 1;
529 emergencyInfo.total = 1;
530 emergencyInfo.eccNum = "120";
531 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
532 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
533 emergencyInfo.mcc = "-1";
534 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
535 emergencyInfoList.calls.push_back(emergencyInfo);
536 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
537 WaitFor(WAIT_TIME_SECOND);
538 EXPECT_NE(SUCCESS, ret);
539 }
540
541 /**
542 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_2100
543 * @tc.name : testV1SetEmergencyCallList019
544 * @tc.desc : Call the function V1 SetEmergencyCallList with eccType and a value of TYPE_POLICE
545 */
546 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList019, Function | MediumTest | Level1)
547 {
548 if (!IsReady(SLOTID_1)) {
549 return;
550 }
551 EmergencyInfoList emergencyInfoList;
552 EmergencyCall emergencyInfo = {};
553 emergencyInfo.index = 1;
554 emergencyInfo.total = 1;
555 emergencyInfo.eccNum = "120";
556 emergencyInfo.eccType = EccType::TYPE_POLICE;
557 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
558 emergencyInfo.mcc = "460";
559 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
560 emergencyInfoList.calls.push_back(emergencyInfo);
561 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
562 WaitFor(WAIT_TIME_SECOND);
563 EXPECT_EQ(SUCCESS, ret);
564 }
565
566 /**
567 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_2200
568 * @tc.name : testV1SetEmergencyCallList020
569 * @tc.desc : Call the function V1 SetEmergencyCallList with eccType and a value of TYPE_AMBULANCE
570 */
571 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList020, Function | MediumTest | Level1)
572 {
573 if (!IsReady(SLOTID_1)) {
574 return;
575 }
576 EmergencyInfoList emergencyInfoList;
577 EmergencyCall emergencyInfo = {};
578 emergencyInfo.index = 1;
579 emergencyInfo.total = 1;
580 emergencyInfo.eccNum = "120";
581 emergencyInfo.eccType = EccType::TYPE_AMBULANCE;
582 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
583 emergencyInfo.mcc = "460";
584 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
585 emergencyInfoList.calls.push_back(emergencyInfo);
586 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
587 WaitFor(WAIT_TIME_SECOND);
588 EXPECT_EQ(SUCCESS, ret);
589 }
590
591 /**
592 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_2300
593 * @tc.name : testV1SetEmergencyCallList021
594 * @tc.desc : Call the function V1 SetEmergencyCallList with eccType and a value of TYPE_FIRE
595 */
596 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList021, Function | MediumTest | Level1)
597 {
598 if (!IsReady(SLOTID_1)) {
599 return;
600 }
601 EmergencyInfoList emergencyInfoList;
602 EmergencyCall emergencyInfo = {};
603 emergencyInfo.index = 1;
604 emergencyInfo.total = 1;
605 emergencyInfo.eccNum = "120";
606 emergencyInfo.eccType = EccType::TYPE_FIRE;
607 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
608 emergencyInfo.mcc = "460";
609 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
610 emergencyInfoList.calls.push_back(emergencyInfo);
611 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
612 WaitFor(WAIT_TIME_SECOND);
613 EXPECT_EQ(SUCCESS, ret);
614 }
615
616 /**
617 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_2400
618 * @tc.name : testV1SetEmergencyCallList022
619 * @tc.desc : Call the function V1 SetEmergencyCallList with eccType and a value of TYPE_SEA
620 */
621 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList022, Function | MediumTest | Level1)
622 {
623 if (!IsReady(SLOTID_1)) {
624 return;
625 }
626 EmergencyInfoList emergencyInfoList;
627 EmergencyCall emergencyInfo = {};
628 emergencyInfo.index = 1;
629 emergencyInfo.total = 1;
630 emergencyInfo.eccNum = "120";
631 emergencyInfo.eccType = EccType::TYPE_SEA;
632 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
633 emergencyInfo.mcc = "460";
634 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
635 emergencyInfoList.calls.push_back(emergencyInfo);
636 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
637 WaitFor(WAIT_TIME_SECOND);
638 EXPECT_EQ(SUCCESS, ret);
639 }
640
641 /**
642 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_2500
643 * @tc.name : testV1SetEmergencyCallList023
644 * @tc.desc : Call the function V1 SetEmergencyCallList with eccType and a value of TYPE_MOUNTAIN
645 */
646 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList023, Function | MediumTest | Level1)
647 {
648 if (!IsReady(SLOTID_1)) {
649 return;
650 }
651 EmergencyInfoList emergencyInfoList;
652 EmergencyCall emergencyInfo = {};
653 emergencyInfo.index = 1;
654 emergencyInfo.total = 1;
655 emergencyInfo.eccNum = "120";
656 emergencyInfo.eccType = EccType::TYPE_MOUNTAIN;
657 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
658 emergencyInfo.mcc = "460";
659 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
660 emergencyInfoList.calls.push_back(emergencyInfo);
661 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
662 WaitFor(WAIT_TIME_SECOND);
663 EXPECT_EQ(SUCCESS, ret);
664 }
665
666 /**
667 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_2600
668 * @tc.name : testV1SetEmergencyCallList024
669 * @tc.desc : Call the function V1 SetEmergencyCallList with simpresent and a value of TYPE_NO_CARD
670 */
671 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList024, Function | MediumTest | Level1)
672 {
673 if (!IsReady(SLOTID_1)) {
674 return;
675 }
676 EmergencyInfoList emergencyInfoList;
677 EmergencyCall emergencyInfo = {};
678 emergencyInfo.index = 1;
679 emergencyInfo.total = 1;
680 emergencyInfo.eccNum = "120";
681 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
682 emergencyInfo.simpresent = SimpresentType::TYPE_NO_CARD;
683 emergencyInfo.mcc = "460";
684 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
685 emergencyInfoList.calls.push_back(emergencyInfo);
686 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
687 WaitFor(WAIT_TIME_SECOND);
688 EXPECT_EQ(SUCCESS, ret);
689 }
690
691 /**
692 * @tc.number : SUB_Telephony_DriverSystem_V1SetEmergencyCallList_2700
693 * @tc.name : testV1SetEmergencyCallList025
694 * @tc.desc : Call the function V1 SetEmergencyCallList with abnormalService and a value of TYPE_ONLY_CS
695 */
696 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetEmergencyCallList025, Function | MediumTest | Level1)
697 {
698 if (!IsReady(SLOTID_1)) {
699 return;
700 }
701 EmergencyInfoList emergencyInfoList;
702 EmergencyCall emergencyInfo = {};
703 emergencyInfo.index = 1;
704 emergencyInfo.total = 1;
705 emergencyInfo.eccNum = "120";
706 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
707 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
708 emergencyInfo.mcc = "460";
709 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ONLY_CS;
710 emergencyInfoList.calls.push_back(emergencyInfo);
711 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
712 WaitFor(WAIT_TIME_SECOND);
713 EXPECT_EQ(SUCCESS, ret);
714 }
715
716 /**
717 * @tc.number : SUB_Telephony_DriverSystem_V1CloseUnFinishedUssd_0600
718 * @tc.name : testV1CloseUnFinishedUssd004
719 * @tc.desc : Call the function V1 CloseUnFinishedUssd with serialId and a value of -11111
720 */
721 HWTEST_F(HdfRilHdiTestAdditional1st, testV1CloseUnFinishedUssd004, Function | MediumTest | Level2)
722 {
723 if (!IsReady(SLOTID_1)) {
724 return;
725 }
726 int32_t ret = g_rilInterface->CloseUnFinishedUssd(SLOTID_1, -11111);
727 WaitFor(WAIT_TIME_SECOND);
728 EXPECT_NE(SUCCESS, ret);
729 }
730
731 /**
732 * @tc.number : SUB_Telephony_DriverSystem_V1CloseUnFinishedUssd_0700
733 * @tc.name : testV1CloseUnFinishedUssd005
734 * @tc.desc : Call the function V1 CloseUnFinishedUssd with serialId and a value of 0
735 */
736 HWTEST_F(HdfRilHdiTestAdditional1st, testV1CloseUnFinishedUssd005, Function | MediumTest | Level1)
737 {
738 if (!IsReady(SLOTID_1)) {
739 return;
740 }
741 int32_t ret = g_rilInterface->CloseUnFinishedUssd(SLOTID_1, 0);
742 WaitFor(WAIT_TIME_SECOND);
743 EXPECT_EQ(SUCCESS, ret);
744 }
745
746 /**
747 * @tc.number : SUB_Telephony_DriverSystem_V1CloseUnFinishedUssd_0800
748 * @tc.name : testV1CloseUnFinishedUssd006
749 * @tc.desc : Call the function V1 CloseUnFinishedUssd with serialId and a value of 11111
750 */
751 HWTEST_F(HdfRilHdiTestAdditional1st, testV1CloseUnFinishedUssd006, Function | MediumTest | Level1)
752 {
753 if (!IsReady(SLOTID_1)) {
754 return;
755 }
756 int32_t ret = g_rilInterface->CloseUnFinishedUssd(SLOTID_1, 11111);
757 WaitFor(WAIT_TIME_SECOND);
758 EXPECT_EQ(SUCCESS, ret);
759 }
760
761 /**
762 * @tc.number : SUB_Telephony_DriverSystem_V1CloseUnFinishedUssd_0900
763 * @tc.name : testV1CloseUnFinishedUssd007
764 * @tc.desc : Call the function V1 CloseUnFinishedUssd with serialId and a value of 32768
765 */
766 HWTEST_F(HdfRilHdiTestAdditional1st, testV1CloseUnFinishedUssd007, Function | MediumTest | Level1)
767 {
768 if (!IsReady(SLOTID_1)) {
769 return;
770 }
771 int32_t ret = g_rilInterface->CloseUnFinishedUssd(SLOTID_1, 32768);
772 WaitFor(WAIT_TIME_SECOND);
773 EXPECT_EQ(SUCCESS, ret);
774 }
775
776 /**
777 * @tc.number : SUB_Telephony_DriverSystem_V1CloseUnFinishedUssd_1000
778 * @tc.name : testV1CloseUnFinishedUssd008
779 * @tc.desc : Call the function V1 CloseUnFinishedUssd with serialId and a value of -32768
780 */
781 HWTEST_F(HdfRilHdiTestAdditional1st, testV1CloseUnFinishedUssd008, Function | MediumTest | Level2)
782 {
783 if (!IsReady(SLOTID_1)) {
784 return;
785 }
786 int32_t ret = g_rilInterface->CloseUnFinishedUssd(SLOTID_1, -32768);
787 WaitFor(WAIT_TIME_SECOND);
788 EXPECT_NE(SUCCESS, ret);
789 }
790
791 /**
792 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_0600
793 * @tc.name : testV1SetBarringPassword004
794 * @tc.desc : Call the function V1 SetBarringPassword with serialId and a value of -11111
795 */
796 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword004, Function | MediumTest | Level1)
797 {
798 if (!IsReady(SLOTID_1)) {
799 return;
800 }
801 SetBarringInfo setBarringInfo = {};
802 setBarringInfo.fac = "AB";
803 setBarringInfo.oldPassword = "1234";
804 setBarringInfo.newPassword = "2345";
805 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, -11111, setBarringInfo);
806 WaitFor(WAIT_TIME_SECOND);
807 EXPECT_EQ(SUCCESS, ret);
808 }
809
810 /**
811 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_0700
812 * @tc.name : testV1SetBarringPassword005
813 * @tc.desc : Call the function V1 SetBarringPassword with serialId and a value of 0
814 */
815 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword005, Function | MediumTest | Level1)
816 {
817 if (!IsReady(SLOTID_1)) {
818 return;
819 }
820 SetBarringInfo setBarringInfo = {};
821 setBarringInfo.fac = "AB";
822 setBarringInfo.oldPassword = "1234";
823 setBarringInfo.newPassword = "2345";
824 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, 0, setBarringInfo);
825 WaitFor(WAIT_TIME_SECOND);
826 EXPECT_EQ(SUCCESS, ret);
827 }
828
829 /**
830 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_0800
831 * @tc.name : testV1SetBarringPassword006
832 * @tc.desc : Call the function V1 SetBarringPassword with serialId and a value of 11111
833 */
834 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword006, Function | MediumTest | Level1)
835 {
836 if (!IsReady(SLOTID_1)) {
837 return;
838 }
839 SetBarringInfo setBarringInfo = {};
840 setBarringInfo.fac = "AB";
841 setBarringInfo.oldPassword = "1234";
842 setBarringInfo.newPassword = "2345";
843 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, 11111, setBarringInfo);
844 WaitFor(WAIT_TIME_SECOND);
845 EXPECT_EQ(SUCCESS, ret);
846 }
847
848 /**
849 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_0900
850 * @tc.name : testV1SetBarringPassword007
851 * @tc.desc : Call the function V1 SetBarringPassword with serialId and a value of 32768
852 */
853 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword007, Function | MediumTest | Level1)
854 {
855 if (!IsReady(SLOTID_1)) {
856 return;
857 }
858 SetBarringInfo setBarringInfo = {};
859 setBarringInfo.fac = "AB";
860 setBarringInfo.oldPassword = "1234";
861 setBarringInfo.newPassword = "2345";
862 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, 32768, setBarringInfo);
863 WaitFor(WAIT_TIME_SECOND);
864 EXPECT_EQ(SUCCESS, ret);
865 }
866
867 /**
868 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_1000
869 * @tc.name : testV1SetBarringPassword008
870 * @tc.desc : Call the function V1 SetBarringPassword with serialId and a value of -32768
871 */
872 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword008, Function | MediumTest | Level1)
873 {
874 if (!IsReady(SLOTID_1)) {
875 return;
876 }
877 SetBarringInfo setBarringInfo = {};
878 setBarringInfo.fac = "AB";
879 setBarringInfo.oldPassword = "1234";
880 setBarringInfo.newPassword = "2345";
881 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, -32768, setBarringInfo);
882 WaitFor(WAIT_TIME_SECOND);
883 EXPECT_EQ(SUCCESS, ret);
884 }
885
886 /**
887 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_1100
888 * @tc.name : testV1SetBarringPassword009
889 * @tc.desc : Call the function V1 SetBarringPassword with fac and a value of 0
890 */
891 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword009, Function | MediumTest | Level1)
892 {
893 if (!IsReady(SLOTID_1)) {
894 return;
895 }
896 SetBarringInfo setBarringInfo = {};
897 setBarringInfo.fac = "0";
898 setBarringInfo.oldPassword = "1234";
899 setBarringInfo.newPassword = "2345";
900 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, GetSerialId(), setBarringInfo);
901 WaitFor(WAIT_TIME_SECOND);
902 EXPECT_EQ(SUCCESS, ret);
903 }
904
905 /**
906 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_1200
907 * @tc.name : testV1SetBarringPassword010
908 * @tc.desc : Call the function V1 SetBarringPassword with fac and a value of -AB
909 */
910 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword010, Function | MediumTest | Level1)
911 {
912 if (!IsReady(SLOTID_1)) {
913 return;
914 }
915 SetBarringInfo setBarringInfo = {};
916 setBarringInfo.fac = "-AB";
917 setBarringInfo.oldPassword = "1234";
918 setBarringInfo.newPassword = "2345";
919 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, GetSerialId(), setBarringInfo);
920 WaitFor(WAIT_TIME_SECOND);
921 EXPECT_EQ(SUCCESS, ret);
922 }
923
924 /**
925 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_1300
926 * @tc.name : testV1SetBarringPassword011
927 * @tc.desc : Call the function V1 SetBarringPassword with oldPassword and a value of 0
928 */
929 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword011, Function | MediumTest | Level1)
930 {
931 if (!IsReady(SLOTID_1)) {
932 return;
933 }
934 SetBarringInfo setBarringInfo = {};
935 setBarringInfo.fac = "AB";
936 setBarringInfo.oldPassword = "0";
937 setBarringInfo.newPassword = "2345";
938 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, GetSerialId(), setBarringInfo);
939 WaitFor(WAIT_TIME_SECOND);
940 EXPECT_EQ(SUCCESS, ret);
941 }
942
943 /**
944 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_1400
945 * @tc.name : testV1SetBarringPassword012
946 * @tc.desc : Call the function V1 SetBarringPassword with oldPassword and a value of 1qaz!QAZ
947 */
948 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword012, Function | MediumTest | Level1)
949 {
950 if (!IsReady(SLOTID_1)) {
951 return;
952 }
953 SetBarringInfo setBarringInfo = {};
954 setBarringInfo.fac = "AB";
955 setBarringInfo.oldPassword = "1qaz!QAZ";
956 setBarringInfo.newPassword = "2345";
957 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, GetSerialId(), setBarringInfo);
958 WaitFor(WAIT_TIME_SECOND);
959 EXPECT_EQ(SUCCESS, ret);
960 }
961
962 /**
963 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_1500
964 * @tc.name : testV1SetBarringPassword013
965 * @tc.desc : Call the function V1 SetBarringPassword with oldPassword and a value of -1234
966 */
967 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword013, Function | MediumTest | Level1)
968 {
969 if (!IsReady(SLOTID_1)) {
970 return;
971 }
972 SetBarringInfo setBarringInfo = {};
973 setBarringInfo.fac = "AB";
974 setBarringInfo.oldPassword = "-1234";
975 setBarringInfo.newPassword = "2345";
976 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, GetSerialId(), setBarringInfo);
977 WaitFor(WAIT_TIME_SECOND);
978 EXPECT_EQ(SUCCESS, ret);
979 }
980
981 /**
982 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_1600
983 * @tc.name : testV1SetBarringPassword014
984 * @tc.desc : Call the function V1 SetBarringPassword with newPassword and a value of 0
985 */
986 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword014, Function | MediumTest | Level1)
987 {
988 if (!IsReady(SLOTID_1)) {
989 return;
990 }
991 SetBarringInfo setBarringInfo = {};
992 setBarringInfo.fac = "AB";
993 setBarringInfo.oldPassword = "1234";
994 setBarringInfo.newPassword = "0";
995 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, GetSerialId(), setBarringInfo);
996 WaitFor(WAIT_TIME_SECOND);
997 EXPECT_EQ(SUCCESS, ret);
998 }
999
1000 /**
1001 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_1700
1002 * @tc.name : testV1SetBarringPassword015
1003 * @tc.desc : Call the function V1 SetBarringPassword with newPassword and a value of 1qaz!QAZ
1004 */
1005 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword015, Function | MediumTest | Level1)
1006 {
1007 if (!IsReady(SLOTID_1)) {
1008 return;
1009 }
1010 SetBarringInfo setBarringInfo = {};
1011 setBarringInfo.fac = "AB";
1012 setBarringInfo.oldPassword = "1234";
1013 setBarringInfo.newPassword = "1qaz!QAZ";
1014 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, GetSerialId(), setBarringInfo);
1015 WaitFor(WAIT_TIME_SECOND);
1016 EXPECT_EQ(SUCCESS, ret);
1017 }
1018
1019 /**
1020 * @tc.number : SUB_Telephony_DriverSystem_V1SetBarringPassword_1800
1021 * @tc.name : testV1SetBarringPassword016
1022 * @tc.desc : Call the function V1 SetBarringPassword with newPassword and a value of -2345
1023 */
1024 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetBarringPassword016, Function | MediumTest | Level1)
1025 {
1026 if (!IsReady(SLOTID_1)) {
1027 return;
1028 }
1029 SetBarringInfo setBarringInfo = {};
1030 setBarringInfo.fac = "AB";
1031 setBarringInfo.oldPassword = "1234";
1032 setBarringInfo.newPassword = "-2345";
1033 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, GetSerialId(), setBarringInfo);
1034 WaitFor(WAIT_TIME_SECOND);
1035 EXPECT_EQ(SUCCESS, ret);
1036 }
1037
1038 /**
1039 * @tc.number : SUB_Telephony_DriverSystem_V1GetEmergencyCallList_0600
1040 * @tc.name : testV1GetEmergencyCallList004
1041 * @tc.desc : Call the function V1 GetEmergencyCallList with serialId and a value of -11111
1042 */
1043 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetEmergencyCallList004, Function | MediumTest | Level1)
1044 {
1045 if (!IsReady(SLOTID_1)) {
1046 return;
1047 }
1048 int32_t ret = g_rilInterface->GetEmergencyCallList(SLOTID_1, -11111);
1049 WaitFor(WAIT_TIME_SECOND);
1050 EXPECT_EQ(SUCCESS, ret);
1051 }
1052
1053 /**
1054 * @tc.number : SUB_Telephony_DriverSystem_V1GetEmergencyCallList_0700
1055 * @tc.name : testV1GetEmergencyCallList005
1056 * @tc.desc : Call the function V1 GetEmergencyCallList with serialId and a value of 0
1057 */
1058 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetEmergencyCallList005, Function | MediumTest | Level1)
1059 {
1060 if (!IsReady(SLOTID_1)) {
1061 return;
1062 }
1063 int32_t ret = g_rilInterface->GetEmergencyCallList(SLOTID_1, 0);
1064 WaitFor(WAIT_TIME_SECOND);
1065 EXPECT_EQ(SUCCESS, ret);
1066 }
1067
1068 /**
1069 * @tc.number : SUB_Telephony_DriverSystem_V1GetEmergencyCallList_0800
1070 * @tc.name : testV1GetEmergencyCallList006
1071 * @tc.desc : Call the function V1 GetEmergencyCallList with serialId and a value of 11111
1072 */
1073 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetEmergencyCallList006, Function | MediumTest | Level1)
1074 {
1075 if (!IsReady(SLOTID_1)) {
1076 return;
1077 }
1078 int32_t ret = g_rilInterface->GetEmergencyCallList(SLOTID_1, 11111);
1079 WaitFor(WAIT_TIME_SECOND);
1080 EXPECT_EQ(SUCCESS, ret);
1081 }
1082
1083 /**
1084 * @tc.number : SUB_Telephony_DriverSystem_V1GetEmergencyCallList_0900
1085 * @tc.name : testV1GetEmergencyCallList007
1086 * @tc.desc : Call the function V1 GetEmergencyCallList with serialId and a value of 32768
1087 */
1088 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetEmergencyCallList007, Function | MediumTest | Level1)
1089 {
1090 if (!IsReady(SLOTID_1)) {
1091 return;
1092 }
1093 int32_t ret = g_rilInterface->GetEmergencyCallList(SLOTID_1, 32768);
1094 WaitFor(WAIT_TIME_SECOND);
1095 EXPECT_EQ(SUCCESS, ret);
1096 }
1097
1098 /**
1099 * @tc.number : SUB_Telephony_DriverSystem_V1GetEmergencyCallList_1000
1100 * @tc.name : testV1GetEmergencyCallList008
1101 * @tc.desc : Call the function V1 GetEmergencyCallList with serialId and a value of -32768
1102 */
1103 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetEmergencyCallList008, Function | MediumTest | Level1)
1104 {
1105 if (!IsReady(SLOTID_1)) {
1106 return;
1107 }
1108 int32_t ret = g_rilInterface->GetEmergencyCallList(SLOTID_1, -32768);
1109 WaitFor(WAIT_TIME_SECOND);
1110 EXPECT_EQ(SUCCESS, ret);
1111 }
1112
1113 /**
1114 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallList_0600
1115 * @tc.name : testV1GetCallList004
1116 * @tc.desc : Call the function V1 GetCallList with serialId and a value of -11111
1117 */
1118 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallList004, Function | MediumTest | Level1)
1119 {
1120 if (!IsReady(SLOTID_1)) {
1121 return;
1122 }
1123 int32_t ret = g_rilInterface->GetCallList(SLOTID_1, -11111);
1124 WaitFor(WAIT_TIME_SECOND);
1125 EXPECT_EQ(SUCCESS, ret);
1126 }
1127
1128 /**
1129 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallList_0700
1130 * @tc.name : testV1GetCallList005
1131 * @tc.desc : Call the function V1 GetCallList with serialId and a value of 0
1132 */
1133 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallList005, Function | MediumTest | Level1)
1134 {
1135 if (!IsReady(SLOTID_1)) {
1136 return;
1137 }
1138 int32_t ret = g_rilInterface->GetCallList(SLOTID_1, 0);
1139 WaitFor(WAIT_TIME_SECOND);
1140 EXPECT_EQ(SUCCESS, ret);
1141 }
1142
1143 /**
1144 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallList_0800
1145 * @tc.name : testV1GetCallList006
1146 * @tc.desc : Call the function V1 GetCallList with serialId and a value of 11111
1147 */
1148 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallList006, Function | MediumTest | Level1)
1149 {
1150 if (!IsReady(SLOTID_1)) {
1151 return;
1152 }
1153 int32_t ret = g_rilInterface->GetCallList(SLOTID_1, 11111);
1154 WaitFor(WAIT_TIME_SECOND);
1155 EXPECT_EQ(SUCCESS, ret);
1156 }
1157
1158 /**
1159 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallList_0900
1160 * @tc.name : testV1GetCallList007
1161 * @tc.desc : Call the function V1 GetCallList with serialId and a value of 32768
1162 */
1163 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallList007, Function | MediumTest | Level1)
1164 {
1165 if (!IsReady(SLOTID_1)) {
1166 return;
1167 }
1168 int32_t ret = g_rilInterface->GetCallList(SLOTID_1, 32768);
1169 WaitFor(WAIT_TIME_SECOND);
1170 EXPECT_EQ(SUCCESS, ret);
1171 }
1172
1173 /**
1174 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallList_1000
1175 * @tc.name : testV1GetCallList008
1176 * @tc.desc : Call the function V1 GetCallList with serialId and a value of -32768
1177 */
1178 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallList008, Function | MediumTest | Level1)
1179 {
1180 if (!IsReady(SLOTID_1)) {
1181 return;
1182 }
1183 int32_t ret = g_rilInterface->GetCallList(SLOTID_1, -32768);
1184 WaitFor(WAIT_TIME_SECOND);
1185 EXPECT_EQ(SUCCESS, ret);
1186 }
1187
1188 /**
1189 * @tc.number : SUB_Telephony_DriverSystem_V1Dial_0600
1190 * @tc.name : testV1Dial004
1191 * @tc.desc : Call the function V1 Dial with serialId and a value of -11111
1192 */
1193 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Dial004, Function | MediumTest | Level1)
1194 {
1195 if (!IsReady(SLOTID_1)) {
1196 return;
1197 }
1198 DialInfo dialInfo = {};
1199 dialInfo.address = "10086";
1200 dialInfo.clir = 0;
1201 int32_t ret = g_rilInterface->Dial(SLOTID_1, -11111, dialInfo);
1202 WaitFor(WAIT_TIME_SECOND);
1203 EXPECT_EQ(SUCCESS, ret);
1204 }
1205
1206 /**
1207 * @tc.number : SUB_Telephony_DriverSystem_V1Dial_0700
1208 * @tc.name : testV1Dial005
1209 * @tc.desc : Call the function V1 Dial with serialId and a value of 0
1210 */
1211 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Dial005, Function | MediumTest | Level1)
1212 {
1213 if (!IsReady(SLOTID_1)) {
1214 return;
1215 }
1216 DialInfo dialInfo = {};
1217 dialInfo.address = "10086";
1218 dialInfo.clir = 0;
1219 int32_t ret = g_rilInterface->Dial(SLOTID_1, 0, dialInfo);
1220 WaitFor(WAIT_TIME_SECOND);
1221 EXPECT_EQ(SUCCESS, ret);
1222 }
1223
1224 /**
1225 * @tc.number : SUB_Telephony_DriverSystem_V1Dial_0800
1226 * @tc.name : testV1Dial006
1227 * @tc.desc : Call the function V1 Dial with serialId and a value of 11111
1228 */
1229 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Dial006, Function | MediumTest | Level1)
1230 {
1231 if (!IsReady(SLOTID_1)) {
1232 return;
1233 }
1234 DialInfo dialInfo = {};
1235 dialInfo.address = "10086";
1236 dialInfo.clir = 0;
1237 int32_t ret = g_rilInterface->Dial(SLOTID_1, 11111, dialInfo);
1238 WaitFor(WAIT_TIME_SECOND);
1239 EXPECT_EQ(SUCCESS, ret);
1240 }
1241
1242 /**
1243 * @tc.number : SUB_Telephony_DriverSystem_V1Dial_0900
1244 * @tc.name : testV1Dial007
1245 * @tc.desc : Call the function V1 Dial with serialId and a value of 32768
1246 */
1247 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Dial007, Function | MediumTest | Level1)
1248 {
1249 if (!IsReady(SLOTID_1)) {
1250 return;
1251 }
1252 DialInfo dialInfo = {};
1253 dialInfo.address = "10086";
1254 dialInfo.clir = 0;
1255 int32_t ret = g_rilInterface->Dial(SLOTID_1, 32768, dialInfo);
1256 WaitFor(WAIT_TIME_SECOND);
1257 EXPECT_EQ(SUCCESS, ret);
1258 }
1259
1260 /**
1261 * @tc.number : SUB_Telephony_DriverSystem_V1Dial_1000
1262 * @tc.name : testV1Dial008
1263 * @tc.desc : Call the function V1 Dial with serialId and a value of -32768
1264 */
1265 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Dial008, Function | MediumTest | Level1)
1266 {
1267 if (!IsReady(SLOTID_1)) {
1268 return;
1269 }
1270 DialInfo dialInfo = {};
1271 dialInfo.address = "10086";
1272 dialInfo.clir = 0;
1273 int32_t ret = g_rilInterface->Dial(SLOTID_1, -32768, dialInfo);
1274 WaitFor(WAIT_TIME_SECOND);
1275 EXPECT_EQ(SUCCESS, ret);
1276 }
1277
1278 /**
1279 * @tc.number : SUB_Telephony_DriverSystem_V1Dial_1100
1280 * @tc.name : testV1Dial009
1281 * @tc.desc : Call the function V1 Dial with dialInfo.clir and a value of 1
1282 */
1283 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Dial009, Function | MediumTest | Level1)
1284 {
1285 if (!IsReady(SLOTID_1)) {
1286 return;
1287 }
1288 DialInfo dialInfo = {};
1289 dialInfo.address = "10086";
1290 dialInfo.clir = 1;
1291 int32_t ret = g_rilInterface->Dial(SLOTID_1, GetSerialId(), dialInfo);
1292 WaitFor(WAIT_TIME_SECOND);
1293 EXPECT_EQ(SUCCESS, ret);
1294 }
1295
1296 /**
1297 * @tc.number : SUB_Telephony_DriverSystem_V1Dial_1200
1298 * @tc.name : testV1Dial010
1299 * @tc.desc : Call the function V1 Dial with dialInfo.clir and a value of 2
1300 */
1301 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Dial010, Function | MediumTest | Level1)
1302 {
1303 if (!IsReady(SLOTID_1)) {
1304 return;
1305 }
1306 DialInfo dialInfo = {};
1307 dialInfo.address = "10086";
1308 dialInfo.clir = 2;
1309 int32_t ret = g_rilInterface->Dial(SLOTID_1, GetSerialId(), dialInfo);
1310 WaitFor(WAIT_TIME_SECOND);
1311 EXPECT_EQ(SUCCESS, ret);
1312 }
1313
1314 /**
1315 * @tc.number : SUB_Telephony_DriverSystem_V1Dial_1300
1316 * @tc.name : testV1Dial011
1317 * @tc.desc : Call the function V1 Dial with dialInfo.address and a value of -10086
1318 */
1319 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Dial011, Function | MediumTest | Level1)
1320 {
1321 if (!IsReady(SLOTID_1)) {
1322 return;
1323 }
1324 DialInfo dialInfo = {};
1325 dialInfo.address = "-10086";
1326 dialInfo.clir = 0;
1327 int32_t ret = g_rilInterface->Dial(SLOTID_1, GetSerialId(), dialInfo);
1328 WaitFor(WAIT_TIME_SECOND);
1329 EXPECT_EQ(SUCCESS, ret);
1330 }
1331
1332 /**
1333 * @tc.number : SUB_Telephony_DriverSystem_V1Dial_1400
1334 * @tc.name : testV1Dial012
1335 * @tc.desc : Call the function V1 Dial with dialInfo.address and a value of 0
1336 */
1337 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Dial012, Function | MediumTest | Level1)
1338 {
1339 if (!IsReady(SLOTID_1)) {
1340 return;
1341 }
1342 DialInfo dialInfo = {};
1343 dialInfo.address = "0";
1344 dialInfo.clir = 0;
1345 int32_t ret = g_rilInterface->Dial(SLOTID_1, GetSerialId(), dialInfo);
1346 WaitFor(WAIT_TIME_SECOND);
1347 EXPECT_EQ(SUCCESS, ret);
1348 }
1349
1350 /**
1351 * @tc.number : SUB_Telephony_DriverSystem_V1Reject_0600
1352 * @tc.name : testV1Reject004
1353 * @tc.desc : Call the function V1 Reject with serialId and a value of -11111
1354 */
1355 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Reject004, Function | MediumTest | Level1)
1356 {
1357 if (!IsReady(SLOTID_1)) {
1358 return;
1359 }
1360 int32_t ret = g_rilInterface->Reject(SLOTID_1, -11111);
1361 WaitFor(WAIT_TIME_SECOND);
1362 EXPECT_EQ(SUCCESS, ret);
1363 }
1364
1365 /**
1366 * @tc.number : SUB_Telephony_DriverSystem_V1Reject_0700
1367 * @tc.name : testV1Reject005
1368 * @tc.desc : Call the function V1 Reject with serialId and a value of 0
1369 */
1370 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Reject005, Function | MediumTest | Level1)
1371 {
1372 if (!IsReady(SLOTID_1)) {
1373 return;
1374 }
1375 int32_t ret = g_rilInterface->Reject(SLOTID_1, 0);
1376 WaitFor(WAIT_TIME_SECOND);
1377 EXPECT_EQ(SUCCESS, ret);
1378 }
1379
1380 /**
1381 * @tc.number : SUB_Telephony_DriverSystem_V1Reject_0800
1382 * @tc.name : testV1Reject006
1383 * @tc.desc : Call the function V1 Reject with serialId and a value of 11111
1384 */
1385 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Reject006, Function | MediumTest | Level1)
1386 {
1387 if (!IsReady(SLOTID_1)) {
1388 return;
1389 }
1390 int32_t ret = g_rilInterface->Reject(SLOTID_1, 11111);
1391 WaitFor(WAIT_TIME_SECOND);
1392 EXPECT_EQ(SUCCESS, ret);
1393 }
1394
1395 /**
1396 * @tc.number : SUB_Telephony_DriverSystem_V1Reject_0900
1397 * @tc.name : testV1Reject007
1398 * @tc.desc : Call the function V1 Reject with serialId and a value of 32768
1399 */
1400 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Reject007, Function | MediumTest | Level1)
1401 {
1402 if (!IsReady(SLOTID_1)) {
1403 return;
1404 }
1405 int32_t ret = g_rilInterface->Reject(SLOTID_1, 32768);
1406 WaitFor(WAIT_TIME_SECOND);
1407 EXPECT_EQ(SUCCESS, ret);
1408 }
1409
1410 /**
1411 * @tc.number : SUB_Telephony_DriverSystem_V1Reject_1000
1412 * @tc.name : testV1Reject008
1413 * @tc.desc : Call the function V1 Reject with serialId and a value of -32768
1414 */
1415 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Reject008, Function | MediumTest | Level1)
1416 {
1417 if (!IsReady(SLOTID_1)) {
1418 return;
1419 }
1420 int32_t ret = g_rilInterface->Reject(SLOTID_1, -32768);
1421 WaitFor(WAIT_TIME_SECOND);
1422 EXPECT_EQ(SUCCESS, ret);
1423 }
1424
1425 /**
1426 * @tc.number : SUB_Telephony_DriverSystem_V1Hangup_0600
1427 * @tc.name : testV1Hangup004
1428 * @tc.desc : Call the function V1 Hangup with serialId and a value of -11111
1429 */
1430 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Hangup004, Function | MediumTest | Level1)
1431 {
1432 if (!IsReady(SLOTID_1)) {
1433 return;
1434 }
1435 int32_t ret = g_rilInterface->Hangup(SLOTID_1, -11111, 0);
1436 WaitFor(WAIT_TIME_SECOND);
1437 EXPECT_EQ(SUCCESS, ret);
1438 }
1439
1440 /**
1441 * @tc.number : SUB_Telephony_DriverSystem_V1Hangup_0700
1442 * @tc.name : testV1Hangup005
1443 * @tc.desc : Call the function V1 Hangup with serialId and a value of 0
1444 */
1445 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Hangup005, Function | MediumTest | Level1)
1446 {
1447 if (!IsReady(SLOTID_1)) {
1448 return;
1449 }
1450 int32_t ret = g_rilInterface->Hangup(SLOTID_1, 0, 0);
1451 WaitFor(WAIT_TIME_SECOND);
1452 EXPECT_EQ(SUCCESS, ret);
1453 }
1454
1455 /**
1456 * @tc.number : SUB_Telephony_DriverSystem_V1Hangup_0800
1457 * @tc.name : testV1Hangup006
1458 * @tc.desc : Call the function V1 Hangup with serialId and a value of 11111
1459 */
1460 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Hangup006, Function | MediumTest | Level1)
1461 {
1462 if (!IsReady(SLOTID_1)) {
1463 return;
1464 }
1465 int32_t ret = g_rilInterface->Hangup(SLOTID_1, 11111, 0);
1466 WaitFor(WAIT_TIME_SECOND);
1467 EXPECT_EQ(SUCCESS, ret);
1468 }
1469
1470 /**
1471 * @tc.number : SUB_Telephony_DriverSystem_V1Hangup_0900
1472 * @tc.name : testV1Hangup007
1473 * @tc.desc : Call the function V1 Hangup with serialId and a value of 32768
1474 */
1475 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Hangup007, Function | MediumTest | Level1)
1476 {
1477 if (!IsReady(SLOTID_1)) {
1478 return;
1479 }
1480 int32_t ret = g_rilInterface->Hangup(SLOTID_1, 32768, 0);
1481 WaitFor(WAIT_TIME_SECOND);
1482 EXPECT_EQ(SUCCESS, ret);
1483 }
1484
1485 /**
1486 * @tc.number : SUB_Telephony_DriverSystem_V1Hangup_1000
1487 * @tc.name : testV1Hangup008
1488 * @tc.desc : Call the function V1 Hangup with serialId and a value of -32768
1489 */
1490 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Hangup008, Function | MediumTest | Level1)
1491 {
1492 if (!IsReady(SLOTID_1)) {
1493 return;
1494 }
1495 int32_t ret = g_rilInterface->Hangup(SLOTID_1, -32768, 0);
1496 WaitFor(WAIT_TIME_SECOND);
1497 EXPECT_EQ(SUCCESS, ret);
1498 }
1499
1500 /**
1501 * @tc.number : SUB_Telephony_DriverSystem_V1Hangup_1100
1502 * @tc.name : testV1Hangup009
1503 * @tc.desc : Call the function V1 Hangup with callId and a value of 1
1504 */
1505 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Hangup009, Function | MediumTest | Level1)
1506 {
1507 if (!IsReady(SLOTID_1)) {
1508 return;
1509 }
1510 int32_t ret = g_rilInterface->Hangup(SLOTID_1, GetSerialId(), 1);
1511 WaitFor(WAIT_TIME_SECOND);
1512 EXPECT_EQ(SUCCESS, ret);
1513 }
1514
1515 /**
1516 * @tc.number : SUB_Telephony_DriverSystem_V1Hangup_1100
1517 * @tc.name : testV1Hangup010
1518 * @tc.desc : Call the function V1 Hangup with callId and a value of -1
1519 */
1520 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Hangup010, Function | MediumTest | Level1)
1521 {
1522 if (!IsReady(SLOTID_1)) {
1523 return;
1524 }
1525 int32_t ret = g_rilInterface->Hangup(SLOTID_1, GetSerialId(), -1);
1526 WaitFor(WAIT_TIME_SECOND);
1527 EXPECT_EQ(SUCCESS, ret);
1528 }
1529
1530 /**
1531 * @tc.number : SUB_Telephony_DriverSystem_V1Hangup_1200
1532 * @tc.name : testV1Hangup011
1533 * @tc.desc : Call the function V1 Hangup with callId and a value of 255
1534 */
1535 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Hangup011, Function | MediumTest | Level1)
1536 {
1537 if (!IsReady(SLOTID_1)) {
1538 return;
1539 }
1540 int32_t ret = g_rilInterface->Hangup(SLOTID_1, GetSerialId(), 255);
1541 WaitFor(WAIT_TIME_SECOND);
1542 EXPECT_EQ(SUCCESS, ret);
1543 }
1544
1545 /**
1546 * @tc.number : SUB_Telephony_DriverSystem_V1Hangup_1400
1547 * @tc.name : testV1Hangup012
1548 * @tc.desc : Call the function V1 Hangup with callId and a value of -255
1549 */
1550 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Hangup012, Function | MediumTest | Level1)
1551 {
1552 if (!IsReady(SLOTID_1)) {
1553 return;
1554 }
1555 int32_t ret = g_rilInterface->Hangup(SLOTID_1, GetSerialId(), -255);
1556 WaitFor(WAIT_TIME_SECOND);
1557 EXPECT_EQ(SUCCESS, ret);
1558 }
1559
1560 /**
1561 * @tc.number : SUB_Telephony_DriverSystem_V1Answer_0600
1562 * @tc.name : testV1Answer004
1563 * @tc.desc : Call the function V1 Answer with serialId and a value of -11111
1564 */
1565 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Answer004, Function | MediumTest | Level1)
1566 {
1567 if (!IsReady(SLOTID_1)) {
1568 return;
1569 }
1570 int32_t ret = g_rilInterface->Answer(SLOTID_1, -11111);
1571 WaitFor(WAIT_TIME_SECOND);
1572 EXPECT_EQ(SUCCESS, ret);
1573 }
1574
1575 /**
1576 * @tc.number : SUB_Telephony_DriverSystem_V1Answer_0700
1577 * @tc.name : testV1Answer005
1578 * @tc.desc : Call the function V1 Answer with serialId and a value of 0
1579 */
1580 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Answer005, Function | MediumTest | Level1)
1581 {
1582 if (!IsReady(SLOTID_1)) {
1583 return;
1584 }
1585 int32_t ret = g_rilInterface->Answer(SLOTID_1, 0);
1586 WaitFor(WAIT_TIME_SECOND);
1587 EXPECT_EQ(SUCCESS, ret);
1588 }
1589
1590 /**
1591 * @tc.number : SUB_Telephony_DriverSystem_V1Answer_0800
1592 * @tc.name : testV1Answer006
1593 * @tc.desc : Call the function V1 Answer with serialId and a value of 11111
1594 */
1595 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Answer006, Function | MediumTest | Level1)
1596 {
1597 if (!IsReady(SLOTID_1)) {
1598 return;
1599 }
1600 int32_t ret = g_rilInterface->Answer(SLOTID_1, 11111);
1601 WaitFor(WAIT_TIME_SECOND);
1602 EXPECT_EQ(SUCCESS, ret);
1603 }
1604
1605 /**
1606 * @tc.number : SUB_Telephony_DriverSystem_V1Answer_0900
1607 * @tc.name : testV1Answer007
1608 * @tc.desc : Call the function V1 Answer with serialId and a value of 32768
1609 */
1610 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Answer007, Function | MediumTest | Level1)
1611 {
1612 if (!IsReady(SLOTID_1)) {
1613 return;
1614 }
1615 int32_t ret = g_rilInterface->Answer(SLOTID_1, 32768);
1616 WaitFor(WAIT_TIME_SECOND);
1617 EXPECT_EQ(SUCCESS, ret);
1618 }
1619
1620 /**
1621 * @tc.number : SUB_Telephony_DriverSystem_V1Answer_1000
1622 * @tc.name : testV1Answer008
1623 * @tc.desc : Call the function V1 Answer with serialId and a value of -32768
1624 */
1625 HWTEST_F(HdfRilHdiTestAdditional1st, testV1Answer008, Function | MediumTest | Level1)
1626 {
1627 if (!IsReady(SLOTID_1)) {
1628 return;
1629 }
1630 int32_t ret = g_rilInterface->Answer(SLOTID_1, -32768);
1631 WaitFor(WAIT_TIME_SECOND);
1632 EXPECT_EQ(SUCCESS, ret);
1633 }
1634
1635 /**
1636 * @tc.number : SUB_Telephony_DriverSystem_V1HoldCall_0600
1637 * @tc.name : testV1HoldCall004
1638 * @tc.desc : Call the function V1 HoldCall with serialId and a value of -11111
1639 */
1640 HWTEST_F(HdfRilHdiTestAdditional1st, testV1HoldCall004, Function | MediumTest | Level1)
1641 {
1642 if (!IsReady(SLOTID_1)) {
1643 return;
1644 }
1645 int32_t ret = g_rilInterface->HoldCall(SLOTID_1, -11111);
1646 WaitFor(WAIT_TIME_SECOND);
1647 EXPECT_EQ(SUCCESS, ret);
1648 }
1649
1650 /**
1651 * @tc.number : SUB_Telephony_DriverSystem_V1HoldCall_0700
1652 * @tc.name : testV1HoldCall005
1653 * @tc.desc : Call the function V1 HoldCall with serialId and a value of 0
1654 */
1655 HWTEST_F(HdfRilHdiTestAdditional1st, testV1HoldCall005, Function | MediumTest | Level1)
1656 {
1657 if (!IsReady(SLOTID_1)) {
1658 return;
1659 }
1660 int32_t ret = g_rilInterface->HoldCall(SLOTID_1, 0);
1661 WaitFor(WAIT_TIME_SECOND);
1662 EXPECT_EQ(SUCCESS, ret);
1663 }
1664
1665 /**
1666 * @tc.number : SUB_Telephony_DriverSystem_V1HoldCall_0800
1667 * @tc.name : testV1HoldCall006
1668 * @tc.desc : Call the function V1 HoldCall with serialId and a value of 11111
1669 */
1670 HWTEST_F(HdfRilHdiTestAdditional1st, testV1HoldCall006, Function | MediumTest | Level1)
1671 {
1672 if (!IsReady(SLOTID_1)) {
1673 return;
1674 }
1675 int32_t ret = g_rilInterface->HoldCall(SLOTID_1, 11111);
1676 WaitFor(WAIT_TIME_SECOND);
1677 EXPECT_EQ(SUCCESS, ret);
1678 }
1679
1680 /**
1681 * @tc.number : SUB_Telephony_DriverSystem_V1HoldCall_0900
1682 * @tc.name : testV1HoldCall007
1683 * @tc.desc : Call the function V1 HoldCall with serialId and a value of 32768
1684 */
1685 HWTEST_F(HdfRilHdiTestAdditional1st, testV1HoldCall007, Function | MediumTest | Level1)
1686 {
1687 if (!IsReady(SLOTID_1)) {
1688 return;
1689 }
1690 int32_t ret = g_rilInterface->HoldCall(SLOTID_1, 32768);
1691 WaitFor(WAIT_TIME_SECOND);
1692 EXPECT_EQ(SUCCESS, ret);
1693 }
1694
1695 /**
1696 * @tc.number : SUB_Telephony_DriverSystem_V1HoldCall_1000
1697 * @tc.name : testV1HoldCall008
1698 * @tc.desc : Call the function V1 HoldCall with serialId and a value of -32768
1699 */
1700 HWTEST_F(HdfRilHdiTestAdditional1st, testV1HoldCall008, Function | MediumTest | Level1)
1701 {
1702 if (!IsReady(SLOTID_1)) {
1703 return;
1704 }
1705 int32_t ret = g_rilInterface->HoldCall(SLOTID_1, -32768);
1706 WaitFor(WAIT_TIME_SECOND);
1707 EXPECT_EQ(SUCCESS, ret);
1708 }
1709
1710 /**
1711 * @tc.number : SUB_Telephony_DriverSystem_V1UnHoldCall_0600
1712 * @tc.name : testV1UnHoldCall004
1713 * @tc.desc : Call the function V1 UnHoldCall with serialId and a value of -11111
1714 */
1715 HWTEST_F(HdfRilHdiTestAdditional1st, testV1UnHoldCall004, Function | MediumTest | Level1)
1716 {
1717 if (!IsReady(SLOTID_1)) {
1718 return;
1719 }
1720 int32_t ret = g_rilInterface->UnHoldCall(SLOTID_1, -11111);
1721 WaitFor(WAIT_TIME_SECOND);
1722 EXPECT_EQ(SUCCESS, ret);
1723 }
1724
1725 /**
1726 * @tc.number : SUB_Telephony_DriverSystem_V1UnHoldCall_0700
1727 * @tc.name : testV1UnHoldCall005
1728 * @tc.desc : Call the function V1 UnHoldCall with serialId and a value of 0
1729 */
1730 HWTEST_F(HdfRilHdiTestAdditional1st, testV1UnHoldCall005, Function | MediumTest | Level1)
1731 {
1732 if (!IsReady(SLOTID_1)) {
1733 return;
1734 }
1735 int32_t ret = g_rilInterface->UnHoldCall(SLOTID_1, 0);
1736 WaitFor(WAIT_TIME_SECOND);
1737 EXPECT_EQ(SUCCESS, ret);
1738 }
1739
1740 /**
1741 * @tc.number : SUB_Telephony_DriverSystem_V1UnHoldCall_0800
1742 * @tc.name : testV1UnHoldCall006
1743 * @tc.desc : Call the function V1 UnHoldCall with serialId and a value of 11111
1744 */
1745 HWTEST_F(HdfRilHdiTestAdditional1st, testV1UnHoldCall006, Function | MediumTest | Level1)
1746 {
1747 if (!IsReady(SLOTID_1)) {
1748 return;
1749 }
1750 int32_t ret = g_rilInterface->UnHoldCall(SLOTID_1, 11111);
1751 WaitFor(WAIT_TIME_SECOND);
1752 EXPECT_EQ(SUCCESS, ret);
1753 }
1754
1755 /**
1756 * @tc.number : SUB_Telephony_DriverSystem_V1UnHoldCall_0900
1757 * @tc.name : testV1UnHoldCall007
1758 * @tc.desc : Call the function V1 UnHoldCall with serialId and a value of 32768
1759 */
1760 HWTEST_F(HdfRilHdiTestAdditional1st, testV1UnHoldCall007, Function | MediumTest | Level1)
1761 {
1762 if (!IsReady(SLOTID_1)) {
1763 return;
1764 }
1765 int32_t ret = g_rilInterface->UnHoldCall(SLOTID_1, 32768);
1766 WaitFor(WAIT_TIME_SECOND);
1767 EXPECT_EQ(SUCCESS, ret);
1768 }
1769
1770 /**
1771 * @tc.number : SUB_Telephony_DriverSystem_V1UnHoldCall_1000
1772 * @tc.name : testV1UnHoldCall008
1773 * @tc.desc : Call the function V1 UnHoldCall with serialId and a value of -32768
1774 */
1775 HWTEST_F(HdfRilHdiTestAdditional1st, testV1UnHoldCall008, Function | MediumTest | Level1)
1776 {
1777 if (!IsReady(SLOTID_1)) {
1778 return;
1779 }
1780 int32_t ret = g_rilInterface->UnHoldCall(SLOTID_1, -32768);
1781 WaitFor(WAIT_TIME_SECOND);
1782 EXPECT_EQ(SUCCESS, ret);
1783 }
1784
1785 /**
1786 * @tc.number : SUB_Telephony_DriverSystem_V1SwitchCall_0600
1787 * @tc.name : testV1SwitchCall004
1788 * @tc.desc : Call the function V1 SwitchCall with serialId and a value of -11111
1789 */
1790 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SwitchCall004, Function | MediumTest | Level1)
1791 {
1792 if (!IsReady(SLOTID_1)) {
1793 return;
1794 }
1795 int32_t ret = g_rilInterface->SwitchCall(SLOTID_1, -11111);
1796 WaitFor(WAIT_TIME_SECOND);
1797 EXPECT_EQ(SUCCESS, ret);
1798 }
1799
1800 /**
1801 * @tc.number : SUB_Telephony_DriverSystem_V1SwitchCall_0700
1802 * @tc.name : testV1SwitchCall005
1803 * @tc.desc : Call the function V1 SwitchCall with serialId and a value of 0
1804 */
1805 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SwitchCall005, Function | MediumTest | Level1)
1806 {
1807 if (!IsReady(SLOTID_1)) {
1808 return;
1809 }
1810 int32_t ret = g_rilInterface->SwitchCall(SLOTID_1, 0);
1811 WaitFor(WAIT_TIME_SECOND);
1812 EXPECT_EQ(SUCCESS, ret);
1813 }
1814
1815 /**
1816 * @tc.number : SUB_Telephony_DriverSystem_V1SwitchCall_0800
1817 * @tc.name : testV1SwitchCall006
1818 * @tc.desc : Call the function V1 SwitchCall with serialId and a value of 11111
1819 */
1820 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SwitchCall006, Function | MediumTest | Level1)
1821 {
1822 if (!IsReady(SLOTID_1)) {
1823 return;
1824 }
1825 int32_t ret = g_rilInterface->SwitchCall(SLOTID_1, 11111);
1826 WaitFor(WAIT_TIME_SECOND);
1827 EXPECT_EQ(SUCCESS, ret);
1828 }
1829
1830 /**
1831 * @tc.number : SUB_Telephony_DriverSystem_V1SwitchCall_0900
1832 * @tc.name : testV1SwitchCall007
1833 * @tc.desc : Call the function V1 SwitchCall with serialId and a value of 32768
1834 */
1835 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SwitchCall007, Function | MediumTest | Level1)
1836 {
1837 if (!IsReady(SLOTID_1)) {
1838 return;
1839 }
1840 int32_t ret = g_rilInterface->SwitchCall(SLOTID_1, 32768);
1841 WaitFor(WAIT_TIME_SECOND);
1842 EXPECT_EQ(SUCCESS, ret);
1843 }
1844
1845 /**
1846 * @tc.number : SUB_Telephony_DriverSystem_V1SwitchCall_1000
1847 * @tc.name : testV1SwitchCall008
1848 * @tc.desc : Call the function V1 SwitchCall with serialId and a value of -32768
1849 */
1850 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SwitchCall008, Function | MediumTest | Level1)
1851 {
1852 if (!IsReady(SLOTID_1)) {
1853 return;
1854 }
1855 int32_t ret = g_rilInterface->SwitchCall(SLOTID_1, -32768);
1856 WaitFor(WAIT_TIME_SECOND);
1857 EXPECT_EQ(SUCCESS, ret);
1858 }
1859
1860 /**
1861 * @tc.number : SUB_Telephony_DriverSystem_V1CombineConference_0600
1862 * @tc.name : testV1CombineConference004
1863 * @tc.desc : Call the function V1 CombineConference with serialId and a value of -11111
1864 */
1865 HWTEST_F(HdfRilHdiTestAdditional1st, testV1CombineConference004, Function | MediumTest | Level1)
1866 {
1867 if (!IsReady(SLOTID_1)) {
1868 return;
1869 }
1870 int32_t ret = g_rilInterface->CombineConference(SLOTID_1, -11111, 0);
1871 WaitFor(WAIT_TIME_SECOND);
1872 EXPECT_EQ(SUCCESS, ret);
1873 }
1874
1875 /**
1876 * @tc.number : SUB_Telephony_DriverSystem_V1CombineConference_0700
1877 * @tc.name : testV1CombineConference005
1878 * @tc.desc : Call the function V1 CombineConference with serialId and a value of 0
1879 */
1880 HWTEST_F(HdfRilHdiTestAdditional1st, testV1CombineConference005, Function | MediumTest | Level1)
1881 {
1882 if (!IsReady(SLOTID_1)) {
1883 return;
1884 }
1885 int32_t ret = g_rilInterface->CombineConference(SLOTID_1, 0, 0);
1886 WaitFor(WAIT_TIME_SECOND);
1887 EXPECT_EQ(SUCCESS, ret);
1888 }
1889
1890 /**
1891 * @tc.number : SUB_Telephony_DriverSystem_V1CombineConference_0800
1892 * @tc.name : testV1CombineConference006
1893 * @tc.desc : Call the function V1 CombineConference with serialId and a value of 11111
1894 */
1895 HWTEST_F(HdfRilHdiTestAdditional1st, testV1CombineConference006, Function | MediumTest | Level1)
1896 {
1897 if (!IsReady(SLOTID_1)) {
1898 return;
1899 }
1900 int32_t ret = g_rilInterface->CombineConference(SLOTID_1, 11111, 0);
1901 WaitFor(WAIT_TIME_SECOND);
1902 EXPECT_EQ(SUCCESS, ret);
1903 }
1904
1905 /**
1906 * @tc.number : SUB_Telephony_DriverSystem_V1CombineConference_0900
1907 * @tc.name : testV1CombineConference007
1908 * @tc.desc : Call the function V1 CombineConference with serialId and a value of 32768
1909 */
1910 HWTEST_F(HdfRilHdiTestAdditional1st, testV1CombineConference007, Function | MediumTest | Level1)
1911 {
1912 if (!IsReady(SLOTID_1)) {
1913 return;
1914 }
1915 int32_t ret = g_rilInterface->CombineConference(SLOTID_1, 32768, 0);
1916 WaitFor(WAIT_TIME_SECOND);
1917 EXPECT_EQ(SUCCESS, ret);
1918 }
1919
1920 /**
1921 * @tc.number : SUB_Telephony_DriverSystem_V1CombineConference_1000
1922 * @tc.name : testV1CombineConference008
1923 * @tc.desc : Call the function V1 CombineConference with serialId and a value of -32768
1924 */
1925 HWTEST_F(HdfRilHdiTestAdditional1st, testV1CombineConference008, Function | MediumTest | Level1)
1926 {
1927 if (!IsReady(SLOTID_1)) {
1928 return;
1929 }
1930 int32_t ret = g_rilInterface->CombineConference(SLOTID_1, -32768, 0);
1931 WaitFor(WAIT_TIME_SECOND);
1932 EXPECT_EQ(SUCCESS, ret);
1933 }
1934
1935 /**
1936 * @tc.number : SUB_Telephony_DriverSystem_V1CombineConference_1100
1937 * @tc.name : testV1CombineConference009
1938 * @tc.desc : Call the function V1 CombineConference with serialId and a value of -32768
1939 */
1940 HWTEST_F(HdfRilHdiTestAdditional1st, testV1CombineConference009, Function | MediumTest | Level1)
1941 {
1942 if (!IsReady(SLOTID_1)) {
1943 return;
1944 }
1945 int32_t ret = g_rilInterface->CombineConference(SLOTID_1, GetSerialId(), -1);
1946 WaitFor(WAIT_TIME_SECOND);
1947 EXPECT_EQ(SUCCESS, ret);
1948 }
1949
1950 /**
1951 * @tc.number : SUB_Telephony_DriverSystem_V1SeparateConference_0600
1952 * @tc.name : testV1SeparateConference004
1953 * @tc.desc : Call the function V1 SeparateConference with serialId and a value of -11111
1954 */
1955 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SeparateConference004, Function | MediumTest | Level1)
1956 {
1957 if (!IsReady(SLOTID_1)) {
1958 return;
1959 }
1960 int32_t ret = g_rilInterface->SeparateConference(SLOTID_1, -11111, 1, 0);
1961 WaitFor(WAIT_TIME_SECOND);
1962 EXPECT_EQ(SUCCESS, ret);
1963 }
1964
1965 /**
1966 * @tc.number : SUB_Telephony_DriverSystem_V1SeparateConference_0600
1967 * @tc.name : testV1SeparateConference005
1968 * @tc.desc : Call the function V1 SeparateConference with serialId and a value of 0
1969 */
1970 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SeparateConference005, Function | MediumTest | Level1)
1971 {
1972 if (!IsReady(SLOTID_1)) {
1973 return;
1974 }
1975 int32_t ret = g_rilInterface->SeparateConference(SLOTID_1, 0, 1, 0);
1976 WaitFor(WAIT_TIME_SECOND);
1977 EXPECT_EQ(SUCCESS, ret);
1978 }
1979
1980 /**
1981 * @tc.number : SUB_Telephony_DriverSystem_V1SeparateConference_0800
1982 * @tc.name : testV1SeparateConference006
1983 * @tc.desc : Call the function V1 SeparateConference with serialId and a value of 11111
1984 */
1985 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SeparateConference006, Function | MediumTest | Level1)
1986 {
1987 if (!IsReady(SLOTID_1)) {
1988 return;
1989 }
1990 int32_t ret = g_rilInterface->SeparateConference(SLOTID_1, 11111, 1, 0);
1991 WaitFor(WAIT_TIME_SECOND);
1992 EXPECT_EQ(SUCCESS, ret);
1993 }
1994
1995 /**
1996 * @tc.number : SUB_Telephony_DriverSystem_V1SeparateConference_0900
1997 * @tc.name : testV1SeparateConference007
1998 * @tc.desc : Call the function V1 SeparateConference with serialId and a value of 32768
1999 */
2000 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SeparateConference007, Function | MediumTest | Level1)
2001 {
2002 if (!IsReady(SLOTID_1)) {
2003 return;
2004 }
2005 int32_t ret = g_rilInterface->SeparateConference(SLOTID_1, 32768, 1, 0);
2006 WaitFor(WAIT_TIME_SECOND);
2007 EXPECT_EQ(SUCCESS, ret);
2008 }
2009
2010 /**
2011 * @tc.number : SUB_Telephony_DriverSystem_V1SeparateConference_1000
2012 * @tc.name : testV1SeparateConference008
2013 * @tc.desc : Call the function V1 SeparateConference with serialId and a value of -32768
2014 */
2015 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SeparateConference008, Function | MediumTest | Level1)
2016 {
2017 if (!IsReady(SLOTID_1)) {
2018 return;
2019 }
2020 int32_t ret = g_rilInterface->SeparateConference(SLOTID_1, -32768, 1, 0);
2021 WaitFor(WAIT_TIME_SECOND);
2022 EXPECT_EQ(SUCCESS, ret);
2023 }
2024
2025 /**
2026 * @tc.number : SUB_Telephony_DriverSystem_V1SeparateConference_1100
2027 * @tc.name : testV1SeparateConference009
2028 * @tc.desc : Call the function V1 SeparateConference with callId and a value of 0
2029 */
2030 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SeparateConference009, Function | MediumTest | Level1)
2031 {
2032 if (!IsReady(SLOTID_1)) {
2033 return;
2034 }
2035 int32_t ret = g_rilInterface->SeparateConference(SLOTID_1, GetSerialId(), 0, 0);
2036 WaitFor(WAIT_TIME_SECOND);
2037 EXPECT_EQ(SUCCESS, ret);
2038 }
2039
2040 /**
2041 * @tc.number : SUB_Telephony_DriverSystem_V1SeparateConference_1200
2042 * @tc.name : testV1SeparateConference010
2043 * @tc.desc : Call the function V1 SeparateConference with callId and a value of -1
2044 */
2045 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SeparateConference010, Function | MediumTest | Level1)
2046 {
2047 if (!IsReady(SLOTID_1)) {
2048 return;
2049 }
2050 int32_t ret = g_rilInterface->SeparateConference(SLOTID_1, GetSerialId(), -1, 0);
2051 WaitFor(WAIT_TIME_SECOND);
2052 EXPECT_EQ(SUCCESS, ret);
2053 }
2054
2055 /**
2056 * @tc.number : SUB_Telephony_DriverSystem_V1SeparateConference_1300
2057 * @tc.name : testV1SeparateConference011
2058 * @tc.desc : Call the function V1 SeparateConference with callId and a value of 255
2059 */
2060 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SeparateConference011, Function | MediumTest | Level1)
2061 {
2062 if (!IsReady(SLOTID_1)) {
2063 return;
2064 }
2065 int32_t ret = g_rilInterface->SeparateConference(SLOTID_1, GetSerialId(), 255, 0);
2066 WaitFor(WAIT_TIME_SECOND);
2067 EXPECT_EQ(SUCCESS, ret);
2068 }
2069
2070 /**
2071 * @tc.number : SUB_Telephony_DriverSystem_V1SeparateConference_1400
2072 * @tc.name : testV1SeparateConference012
2073 * @tc.desc : Call the function V1 SeparateConference with callId and a value of -255
2074 */
2075 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SeparateConference012, Function | MediumTest | Level1)
2076 {
2077 if (!IsReady(SLOTID_1)) {
2078 return;
2079 }
2080 int32_t ret = g_rilInterface->SeparateConference(SLOTID_1, GetSerialId(), -255, 0);
2081 WaitFor(WAIT_TIME_SECOND);
2082 EXPECT_EQ(SUCCESS, ret);
2083 }
2084
2085 /**
2086 * @tc.number : SUB_Telephony_DriverSystem_V1SeparateConference_1500
2087 * @tc.name : testV1SeparateConference013
2088 * @tc.desc : Call the function V1 SeparateConference with callType and a value of -1
2089 */
2090 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SeparateConference013, Function | MediumTest | Level1)
2091 {
2092 if (!IsReady(SLOTID_1)) {
2093 return;
2094 }
2095 int32_t ret = g_rilInterface->SeparateConference(SLOTID_1, GetSerialId(), 1, -1);
2096 WaitFor(WAIT_TIME_SECOND);
2097 EXPECT_EQ(SUCCESS, ret);
2098 }
2099
2100 /**
2101 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallWaiting_0600
2102 * @tc.name : testV1GetCallWaiting004
2103 * @tc.desc : Call the function V1 GetCallWaiting with serialId and a value of -11111
2104 */
2105 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallWaiting004, Function | MediumTest | Level1)
2106 {
2107 if (!IsReady(SLOTID_1)) {
2108 return;
2109 }
2110 int32_t ret = g_rilInterface->GetCallWaiting(SLOTID_1, -11111);
2111 WaitFor(WAIT_TIME_SECOND);
2112 EXPECT_EQ(SUCCESS, ret);
2113 }
2114
2115 /**
2116 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallWaiting_0700
2117 * @tc.name : testV1GetCallWaiting005
2118 * @tc.desc : Call the function V1 GetCallWaiting with serialId and a value of 0
2119 */
2120 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallWaiting005, Function | MediumTest | Level1)
2121 {
2122 if (!IsReady(SLOTID_1)) {
2123 return;
2124 }
2125 int32_t ret = g_rilInterface->GetCallWaiting(SLOTID_1, 0);
2126 WaitFor(WAIT_TIME_SECOND);
2127 EXPECT_EQ(SUCCESS, ret);
2128 }
2129
2130 /**
2131 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallWaiting_0800
2132 * @tc.name : testV1GetCallWaiting006
2133 * @tc.desc : Call the function V1 GetCallWaiting with serialId and a value of 11111
2134 */
2135 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallWaiting006, Function | MediumTest | Level1)
2136 {
2137 if (!IsReady(SLOTID_1)) {
2138 return;
2139 }
2140 int32_t ret = g_rilInterface->GetCallWaiting(SLOTID_1, 11111);
2141 WaitFor(WAIT_TIME_SECOND);
2142 EXPECT_EQ(SUCCESS, ret);
2143 }
2144
2145 /**
2146 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallWaiting_0900
2147 * @tc.name : testV1GetCallWaiting007
2148 * @tc.desc : Call the function V1 GetCallWaiting with serialId and a value of 32768
2149 */
2150 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallWaiting007, Function | MediumTest | Level1)
2151 {
2152 if (!IsReady(SLOTID_1)) {
2153 return;
2154 }
2155 int32_t ret = g_rilInterface->GetCallWaiting(SLOTID_1, 32768);
2156 WaitFor(WAIT_TIME_SECOND);
2157 EXPECT_EQ(SUCCESS, ret);
2158 }
2159
2160 /**
2161 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallWaiting_1000
2162 * @tc.name : testV1GetCallWaiting008
2163 * @tc.desc : Call the function V1 GetCallWaiting with serialId and a value of -32768
2164 */
2165 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallWaiting008, Function | MediumTest | Level1)
2166 {
2167 if (!IsReady(SLOTID_1)) {
2168 return;
2169 }
2170 int32_t ret = g_rilInterface->GetCallWaiting(SLOTID_1, -32768);
2171 WaitFor(WAIT_TIME_SECOND);
2172 EXPECT_EQ(SUCCESS, ret);
2173 }
2174
2175 /**
2176 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallWaiting_0600
2177 * @tc.name : testV1SetCallWaiting004
2178 * @tc.desc : Call the function V1 SetCallWaiting with serialId and a value of -11111
2179 */
2180 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallWaiting004, Function | MediumTest | Level1)
2181 {
2182 if (!IsReady(SLOTID_1)) {
2183 return;
2184 }
2185 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_1, -11111, 0);
2186 WaitFor(WAIT_TIME_SECOND);
2187 EXPECT_EQ(SUCCESS, ret);
2188 }
2189
2190 /**
2191 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallWaiting_0700
2192 * @tc.name : testV1SetCallWaiting005
2193 * @tc.desc : Call the function V1 SetCallWaiting with serialId and a value of 0
2194 */
2195 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallWaiting005, Function | MediumTest | Level1)
2196 {
2197 if (!IsReady(SLOTID_1)) {
2198 return;
2199 }
2200 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_1, 0, 0);
2201 WaitFor(WAIT_TIME_SECOND);
2202 EXPECT_EQ(SUCCESS, ret);
2203 }
2204
2205 /**
2206 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallWaiting_0800
2207 * @tc.name : testV1SetCallWaiting006
2208 * @tc.desc : Call the function V1 SetCallWaiting with serialId and a value of 11111
2209 */
2210 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallWaiting006, Function | MediumTest | Level1)
2211 {
2212 if (!IsReady(SLOTID_1)) {
2213 return;
2214 }
2215 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_1, 11111, 0);
2216 WaitFor(WAIT_TIME_SECOND);
2217 EXPECT_EQ(SUCCESS, ret);
2218 }
2219
2220 /**
2221 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallWaiting_0900
2222 * @tc.name : testV1SetCallWaiting007
2223 * @tc.desc : Call the function V1 SetCallWaiting with serialId and a value of 32768
2224 */
2225 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallWaiting007, Function | MediumTest | Level1)
2226 {
2227 if (!IsReady(SLOTID_1)) {
2228 return;
2229 }
2230 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_1, 32768, 0);
2231 WaitFor(WAIT_TIME_SECOND);
2232 EXPECT_EQ(SUCCESS, ret);
2233 }
2234
2235 /**
2236 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallWaiting_1000
2237 * @tc.name : testV1SetCallWaiting008
2238 * @tc.desc : Call the function V1 SetCallWaiting with serialId and a value of -32768
2239 */
2240 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallWaiting008, Function | MediumTest | Level1)
2241 {
2242 if (!IsReady(SLOTID_1)) {
2243 return;
2244 }
2245 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_1, -32768, 0);
2246 WaitFor(WAIT_TIME_SECOND);
2247 EXPECT_EQ(SUCCESS, ret);
2248 }
2249
2250 /**
2251 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallWaiting_1100
2252 * @tc.name : testV1SetCallWaiting009
2253 * @tc.desc : Call the function V1 SetCallWaiting with activate and a value of 1
2254 */
2255 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallWaiting009, Function | MediumTest | Level1)
2256 {
2257 if (!IsReady(SLOTID_1)) {
2258 return;
2259 }
2260 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_1, GetSerialId(), 1);
2261 WaitFor(WAIT_TIME_SECOND);
2262 EXPECT_EQ(SUCCESS, ret);
2263 }
2264
2265 /**
2266 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallWaiting_1200
2267 * @tc.name : testV1SetCallWaiting010
2268 * @tc.desc : Call the function V1 SetCallWaiting with activate and a value of -1
2269 */
2270 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallWaiting010, Function | MediumTest | Level1)
2271 {
2272 if (!IsReady(SLOTID_1)) {
2273 return;
2274 }
2275 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_1, GetSerialId(), -1);
2276 WaitFor(WAIT_TIME_SECOND);
2277 EXPECT_EQ(SUCCESS, ret);
2278 }
2279
2280 /**
2281 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallWaiting_1300
2282 * @tc.name : testV1SetCallWaiting011
2283 * @tc.desc : Call the function V1 SetCallWaiting with activate and a value of 255
2284 */
2285 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallWaiting011, Function | MediumTest | Level1)
2286 {
2287 if (!IsReady(SLOTID_1)) {
2288 return;
2289 }
2290 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_1, GetSerialId(), 255);
2291 WaitFor(WAIT_TIME_SECOND);
2292 EXPECT_EQ(SUCCESS, ret);
2293 }
2294
2295 /**
2296 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallWaiting_1400
2297 * @tc.name : testV1SetCallWaiting012
2298 * @tc.desc : Call the function V1 SetCallWaiting with activate and a value of -255
2299 */
2300 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallWaiting012, Function | MediumTest | Level1)
2301 {
2302 if (!IsReady(SLOTID_1)) {
2303 return;
2304 }
2305 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_1, GetSerialId(), -255);
2306 WaitFor(WAIT_TIME_SECOND);
2307 EXPECT_EQ(SUCCESS, ret);
2308 }
2309
2310 /**
2311 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallTransferInfo_0600
2312 * @tc.name : testV1GetCallTransferInfo004
2313 * @tc.desc : Call the function V1 GetCallTransferInfo with serialId and a value of -11111
2314 */
2315 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallTransferInfo004, Function | MediumTest | Level1)
2316 {
2317 if (!IsReady(SLOTID_1)) {
2318 return;
2319 }
2320 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_1, -11111, 1);
2321 WaitFor(WAIT_TIME_SECOND);
2322 EXPECT_EQ(SUCCESS, ret);
2323 }
2324
2325 /**
2326 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallTransferInfo_0700
2327 * @tc.name : testV1GetCallTransferInfo005
2328 * @tc.desc : Call the function V1 GetCallTransferInfo with serialId and a value of 0
2329 */
2330 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallTransferInfo005, Function | MediumTest | Level1)
2331 {
2332 if (!IsReady(SLOTID_1)) {
2333 return;
2334 }
2335 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_1, 0, 1);
2336 WaitFor(WAIT_TIME_SECOND);
2337 EXPECT_EQ(SUCCESS, ret);
2338 }
2339
2340 /**
2341 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallTransferInfo_0800
2342 * @tc.name : testV1GetCallTransferInfo006
2343 * @tc.desc : Call the function V1 GetCallTransferInfo with serialId and a value of 11111
2344 */
2345 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallTransferInfo006, Function | MediumTest | Level1)
2346 {
2347 if (!IsReady(SLOTID_1)) {
2348 return;
2349 }
2350 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_1, 11111, 1);
2351 WaitFor(WAIT_TIME_SECOND);
2352 EXPECT_EQ(SUCCESS, ret);
2353 }
2354
2355 /**
2356 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallTransferInfo_0900
2357 * @tc.name : testV1GetCallTransferInfo007
2358 * @tc.desc : Call the function V1 GetCallTransferInfo with serialId and a value of 32768
2359 */
2360 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallTransferInfo007, Function | MediumTest | Level1)
2361 {
2362 if (!IsReady(SLOTID_1)) {
2363 return;
2364 }
2365 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_1, 32768, 1);
2366 WaitFor(WAIT_TIME_SECOND);
2367 EXPECT_EQ(SUCCESS, ret);
2368 }
2369
2370 /**
2371 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallTransferInfo_1000
2372 * @tc.name : testV1GetCallTransferInfo008
2373 * @tc.desc : Call the function V1 GetCallTransferInfo with serialId and a value of -32768
2374 */
2375 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallTransferInfo008, Function | MediumTest | Level1)
2376 {
2377 if (!IsReady(SLOTID_1)) {
2378 return;
2379 }
2380 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_1, -32768, 1);
2381 WaitFor(WAIT_TIME_SECOND);
2382 EXPECT_EQ(SUCCESS, ret);
2383 }
2384
2385 /**
2386 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallTransferInfo_1100
2387 * @tc.name : testV1GetCallTransferInfo009
2388 * @tc.desc : Call the function V1 GetCallTransferInfo with reason and a value of 0
2389 */
2390 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallTransferInfo009, Function | MediumTest | Level1)
2391 {
2392 if (!IsReady(SLOTID_1)) {
2393 return;
2394 }
2395 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_1, GetSerialId(), 0);
2396 WaitFor(WAIT_TIME_SECOND);
2397 EXPECT_EQ(SUCCESS, ret);
2398 }
2399
2400 /**
2401 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallTransferInfo_1200
2402 * @tc.name : testV1GetCallTransferInfo010
2403 * @tc.desc : Call the function V1 GetCallTransferInfo with reason and a value of 2
2404 */
2405 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallTransferInfo010, Function | MediumTest | Level1)
2406 {
2407 if (!IsReady(SLOTID_1)) {
2408 return;
2409 }
2410 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_1, GetSerialId(), 2);
2411 WaitFor(WAIT_TIME_SECOND);
2412 EXPECT_EQ(SUCCESS, ret);
2413 }
2414
2415 /**
2416 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallTransferInfo_1300
2417 * @tc.name : testV1GetCallTransferInfo011
2418 * @tc.desc : Call the function V1 GetCallTransferInfo with reason and a value of 3
2419 */
2420 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallTransferInfo011, Function | MediumTest | Level1)
2421 {
2422 if (!IsReady(SLOTID_1)) {
2423 return;
2424 }
2425 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_1, GetSerialId(), 3);
2426 WaitFor(WAIT_TIME_SECOND);
2427 EXPECT_EQ(SUCCESS, ret);
2428 }
2429
2430 /**
2431 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallTransferInfo_1400
2432 * @tc.name : testV1GetCallTransferInfo012
2433 * @tc.desc : Call the function V1 GetCallTransferInfo with reason and a value of 4
2434 */
2435 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallTransferInfo012, Function | MediumTest | Level1)
2436 {
2437 if (!IsReady(SLOTID_1)) {
2438 return;
2439 }
2440 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_1, GetSerialId(), 4);
2441 WaitFor(WAIT_TIME_SECOND);
2442 EXPECT_EQ(SUCCESS, ret);
2443 }
2444
2445 /**
2446 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallTransferInfo_1500
2447 * @tc.name : testV1GetCallTransferInfo013
2448 * @tc.desc : Call the function V1 GetCallTransferInfo with reason and a value of -1
2449 */
2450 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallTransferInfo013, Function | MediumTest | Level1)
2451 {
2452 if (!IsReady(SLOTID_1)) {
2453 return;
2454 }
2455 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_1, GetSerialId(), -1);
2456 WaitFor(WAIT_TIME_SECOND);
2457 EXPECT_EQ(SUCCESS, ret);
2458 }
2459
2460 /**
2461 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_0600
2462 * @tc.name : testV1SetCallTransferInfo004
2463 * @tc.desc : Call the function V1 SetCallTransferInfo with serialId and a value of -11111
2464 */
2465 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo004, Function | MediumTest | Level1)
2466 {
2467 if (!IsReady(SLOTID_1)) {
2468 return;
2469 }
2470 CallForwardSetInfo callForwardSetInfo = {};
2471 callForwardSetInfo.reason = 1;
2472 callForwardSetInfo.mode = 1;
2473 callForwardSetInfo.classx = 1;
2474 callForwardSetInfo.number = "10086";
2475 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, -11111, callForwardSetInfo);
2476 WaitFor(WAIT_TIME_SECOND);
2477 EXPECT_EQ(SUCCESS, ret);
2478 }
2479
2480 /**
2481 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_0700
2482 * @tc.name : testV1SetCallTransferInfo005
2483 * @tc.desc : Call the function V1 SetCallTransferInfo with serialId and a value of 0
2484 */
2485 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo005, Function | MediumTest | Level1)
2486 {
2487 if (!IsReady(SLOTID_1)) {
2488 return;
2489 }
2490 CallForwardSetInfo callForwardSetInfo = {};
2491 callForwardSetInfo.reason = 1;
2492 callForwardSetInfo.mode = 1;
2493 callForwardSetInfo.classx = 1;
2494 callForwardSetInfo.number = "10086";
2495 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, 0, callForwardSetInfo);
2496 WaitFor(WAIT_TIME_SECOND);
2497 EXPECT_EQ(SUCCESS, ret);
2498 }
2499
2500 /**
2501 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_0800
2502 * @tc.name : testV1SetCallTransferInfo006
2503 * @tc.desc : Call the function V1 SetCallTransferInfo with serialId and a value of 11111
2504 */
2505 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo006, Function | MediumTest | Level1)
2506 {
2507 if (!IsReady(SLOTID_1)) {
2508 return;
2509 }
2510 CallForwardSetInfo callForwardSetInfo = {};
2511 callForwardSetInfo.reason = 1;
2512 callForwardSetInfo.mode = 1;
2513 callForwardSetInfo.classx = 1;
2514 callForwardSetInfo.number = "10086";
2515 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, 11111, callForwardSetInfo);
2516 WaitFor(WAIT_TIME_SECOND);
2517 EXPECT_EQ(SUCCESS, ret);
2518 }
2519
2520 /**
2521 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_0900
2522 * @tc.name : testV1SetCallTransferInfo007
2523 * @tc.desc : Call the function V1 SetCallTransferInfo with serialId and a value of 32768
2524 */
2525 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo007, Function | MediumTest | Level1)
2526 {
2527 if (!IsReady(SLOTID_1)) {
2528 return;
2529 }
2530 CallForwardSetInfo callForwardSetInfo = {};
2531 callForwardSetInfo.reason = 1;
2532 callForwardSetInfo.mode = 1;
2533 callForwardSetInfo.classx = 1;
2534 callForwardSetInfo.number = "10086";
2535 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, 32768, callForwardSetInfo);
2536 WaitFor(WAIT_TIME_SECOND);
2537 EXPECT_EQ(SUCCESS, ret);
2538 }
2539
2540 /**
2541 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_1000
2542 * @tc.name : testV1SetCallTransferInfo008
2543 * @tc.desc : Call the function V1 SetCallTransferInfo with serialId and a value of -32768
2544 */
2545 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo008, Function | MediumTest | Level1)
2546 {
2547 if (!IsReady(SLOTID_1)) {
2548 return;
2549 }
2550 CallForwardSetInfo callForwardSetInfo = {};
2551 callForwardSetInfo.reason = 1;
2552 callForwardSetInfo.mode = 1;
2553 callForwardSetInfo.classx = 1;
2554 callForwardSetInfo.number = "10086";
2555 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, -32768, callForwardSetInfo);
2556 WaitFor(WAIT_TIME_SECOND);
2557 EXPECT_EQ(SUCCESS, ret);
2558 }
2559
2560 /**
2561 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_1100
2562 * @tc.name : testV1SetCallTransferInfo009
2563 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.reason and a value of 0
2564 */
2565 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo009, Function | MediumTest | Level1)
2566 {
2567 if (!IsReady(SLOTID_1)) {
2568 return;
2569 }
2570 CallForwardSetInfo callForwardSetInfo = {};
2571 callForwardSetInfo.reason = 0;
2572 callForwardSetInfo.mode = 1;
2573 callForwardSetInfo.classx = 1;
2574 callForwardSetInfo.number = "10086";
2575 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2576 WaitFor(WAIT_TIME_SECOND);
2577 EXPECT_EQ(SUCCESS, ret);
2578 }
2579
2580 /**
2581 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_1200
2582 * @tc.name : testV1SetCallTransferInfo010
2583 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.reason and a value of 2
2584 */
2585 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo010, Function | MediumTest | Level1)
2586 {
2587 if (!IsReady(SLOTID_1)) {
2588 return;
2589 }
2590 CallForwardSetInfo callForwardSetInfo = {};
2591 callForwardSetInfo.reason = 2;
2592 callForwardSetInfo.mode = 1;
2593 callForwardSetInfo.classx = 1;
2594 callForwardSetInfo.number = "10086";
2595 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2596 WaitFor(WAIT_TIME_SECOND);
2597 EXPECT_EQ(SUCCESS, ret);
2598 }
2599
2600 /**
2601 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_1300
2602 * @tc.name : testV1SetCallTransferInfo011
2603 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.reason and a value of 3
2604 */
2605 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo011, Function | MediumTest | Level1)
2606 {
2607 if (!IsReady(SLOTID_1)) {
2608 return;
2609 }
2610 CallForwardSetInfo callForwardSetInfo = {};
2611 callForwardSetInfo.reason = 3;
2612 callForwardSetInfo.mode = 1;
2613 callForwardSetInfo.classx = 1;
2614 callForwardSetInfo.number = "10086";
2615 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2616 WaitFor(WAIT_TIME_SECOND);
2617 EXPECT_EQ(SUCCESS, ret);
2618 }
2619
2620 /**
2621 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_1400
2622 * @tc.name : testV1SetCallTransferInfo012
2623 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.reason and a value of 4
2624 */
2625 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo012, Function | MediumTest | Level1)
2626 {
2627 if (!IsReady(SLOTID_1)) {
2628 return;
2629 }
2630 CallForwardSetInfo callForwardSetInfo = {};
2631 callForwardSetInfo.reason = 4;
2632 callForwardSetInfo.mode = 1;
2633 callForwardSetInfo.classx = 1;
2634 callForwardSetInfo.number = "10086";
2635 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2636 WaitFor(WAIT_TIME_SECOND);
2637 EXPECT_EQ(SUCCESS, ret);
2638 }
2639
2640 /**
2641 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_1500
2642 * @tc.name : testV1SetCallTransferInfo013
2643 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.reason and a value of 5
2644 */
2645 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo013, Function | MediumTest | Level1)
2646 {
2647 if (!IsReady(SLOTID_1)) {
2648 return;
2649 }
2650 CallForwardSetInfo callForwardSetInfo = {};
2651 callForwardSetInfo.reason = 5;
2652 callForwardSetInfo.mode = 1;
2653 callForwardSetInfo.classx = 1;
2654 callForwardSetInfo.number = "10086";
2655 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2656 WaitFor(WAIT_TIME_SECOND);
2657 EXPECT_EQ(SUCCESS, ret);
2658 }
2659
2660 /**
2661 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_1600
2662 * @tc.name : testV1SetCallTransferInfo014
2663 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.reason and a value of 6
2664 */
2665 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo014, Function | MediumTest | Level1)
2666 {
2667 if (!IsReady(SLOTID_1)) {
2668 return;
2669 }
2670 CallForwardSetInfo callForwardSetInfo = {};
2671 callForwardSetInfo.reason = 6;
2672 callForwardSetInfo.mode = 1;
2673 callForwardSetInfo.classx = 1;
2674 callForwardSetInfo.number = "10086";
2675 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2676 WaitFor(WAIT_TIME_SECOND);
2677 EXPECT_EQ(SUCCESS, ret);
2678 }
2679
2680 /**
2681 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_1700
2682 * @tc.name : testV1SetCallTransferInfo015
2683 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.reason and a value of -1
2684 */
2685 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo015, Function | MediumTest | Level1)
2686 {
2687 if (!IsReady(SLOTID_1)) {
2688 return;
2689 }
2690 CallForwardSetInfo callForwardSetInfo = {};
2691 callForwardSetInfo.reason = -1;
2692 callForwardSetInfo.mode = 1;
2693 callForwardSetInfo.classx = 1;
2694 callForwardSetInfo.number = "10086";
2695 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2696 WaitFor(WAIT_TIME_SECOND);
2697 EXPECT_EQ(SUCCESS, ret);
2698 }
2699
2700 /**
2701 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_1800
2702 * @tc.name : testV1SetCallTransferInfo016
2703 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.mode and a value of 0
2704 */
2705 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo016, Function | MediumTest | Level1)
2706 {
2707 if (!IsReady(SLOTID_1)) {
2708 return;
2709 }
2710 CallForwardSetInfo callForwardSetInfo = {};
2711 callForwardSetInfo.reason = 1;
2712 callForwardSetInfo.mode = 0;
2713 callForwardSetInfo.classx = 1;
2714 callForwardSetInfo.number = "10086";
2715 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2716 WaitFor(WAIT_TIME_SECOND);
2717 EXPECT_EQ(SUCCESS, ret);
2718 }
2719
2720 /**
2721 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_1900
2722 * @tc.name : testV1SetCallTransferInfo017
2723 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.mode and a value of 2
2724 */
2725 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo017, Function | MediumTest | Level1)
2726 {
2727 if (!IsReady(SLOTID_1)) {
2728 return;
2729 }
2730 CallForwardSetInfo callForwardSetInfo = {};
2731 callForwardSetInfo.reason = 1;
2732 callForwardSetInfo.mode = 2;
2733 callForwardSetInfo.classx = 1;
2734 callForwardSetInfo.number = "10086";
2735 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2736 WaitFor(WAIT_TIME_SECOND);
2737 EXPECT_EQ(SUCCESS, ret);
2738 }
2739
2740 /**
2741 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_2000
2742 * @tc.name : testV1SetCallTransferInfo018
2743 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.mode and a value of 3
2744 */
2745 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo018, Function | MediumTest | Level1)
2746 {
2747 if (!IsReady(SLOTID_1)) {
2748 return;
2749 }
2750 CallForwardSetInfo callForwardSetInfo = {};
2751 callForwardSetInfo.reason = 1;
2752 callForwardSetInfo.mode = 3;
2753 callForwardSetInfo.classx = 1;
2754 callForwardSetInfo.number = "10086";
2755 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2756 WaitFor(WAIT_TIME_SECOND);
2757 EXPECT_EQ(SUCCESS, ret);
2758 }
2759
2760 /**
2761 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_2100
2762 * @tc.name : testV1SetCallTransferInfo019
2763 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.mode and a value of 4
2764 */
2765 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo019, Function | MediumTest | Level1)
2766 {
2767 if (!IsReady(SLOTID_1)) {
2768 return;
2769 }
2770 CallForwardSetInfo callForwardSetInfo = {};
2771 callForwardSetInfo.reason = 1;
2772 callForwardSetInfo.mode = 4;
2773 callForwardSetInfo.classx = 1;
2774 callForwardSetInfo.number = "10086";
2775 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2776 WaitFor(WAIT_TIME_SECOND);
2777 EXPECT_EQ(SUCCESS, ret);
2778 }
2779
2780 /**
2781 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_2200
2782 * @tc.name : testV1SetCallTransferInfo020
2783 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.mode and a value of 5
2784 */
2785 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo020, Function | MediumTest | Level1)
2786 {
2787 if (!IsReady(SLOTID_1)) {
2788 return;
2789 }
2790 CallForwardSetInfo callForwardSetInfo = {};
2791 callForwardSetInfo.reason = 1;
2792 callForwardSetInfo.mode = 5;
2793 callForwardSetInfo.classx = 1;
2794 callForwardSetInfo.number = "10086";
2795 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2796 WaitFor(WAIT_TIME_SECOND);
2797 EXPECT_EQ(SUCCESS, ret);
2798 }
2799
2800 /**
2801 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_2300
2802 * @tc.name : testV1SetCallTransferInfo021
2803 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.mode and a value of -1
2804 */
2805 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo021, Function | MediumTest | Level1)
2806 {
2807 if (!IsReady(SLOTID_1)) {
2808 return;
2809 }
2810 CallForwardSetInfo callForwardSetInfo = {};
2811 callForwardSetInfo.reason = 1;
2812 callForwardSetInfo.mode = -1;
2813 callForwardSetInfo.classx = 1;
2814 callForwardSetInfo.number = "10086";
2815 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2816 WaitFor(WAIT_TIME_SECOND);
2817 EXPECT_EQ(SUCCESS, ret);
2818 }
2819
2820 /**
2821 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_2400
2822 * @tc.name : testV1SetCallTransferInfo022
2823 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.number and a value of 0
2824 */
2825 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo022, Function | MediumTest | Level1)
2826 {
2827 if (!IsReady(SLOTID_1)) {
2828 return;
2829 }
2830 CallForwardSetInfo callForwardSetInfo = {};
2831 callForwardSetInfo.reason = 1;
2832 callForwardSetInfo.mode = 1;
2833 callForwardSetInfo.classx = 1;
2834 callForwardSetInfo.number = "0";
2835 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2836 WaitFor(WAIT_TIME_SECOND);
2837 EXPECT_EQ(SUCCESS, ret);
2838 }
2839
2840 /**
2841 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_2500
2842 * @tc.name : testV1SetCallTransferInfo023
2843 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.number and a value of -1
2844 */
2845 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo023, Function | MediumTest | Level1)
2846 {
2847 if (!IsReady(SLOTID_1)) {
2848 return;
2849 }
2850 CallForwardSetInfo callForwardSetInfo = {};
2851 callForwardSetInfo.reason = 1;
2852 callForwardSetInfo.mode = 1;
2853 callForwardSetInfo.classx = 1;
2854 callForwardSetInfo.number = "-1";
2855 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2856 WaitFor(WAIT_TIME_SECOND);
2857 EXPECT_EQ(SUCCESS, ret);
2858 }
2859
2860 /**
2861 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallTransferInfo_2600
2862 * @tc.name : testV1SetCallTransferInfo024
2863 * @tc.desc : Call the function V1 SetCallTransferInfo with callForwardSetInfo.number and a value of 12306
2864 */
2865 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallTransferInfo024, Function | MediumTest | Level1)
2866 {
2867 if (!IsReady(SLOTID_1)) {
2868 return;
2869 }
2870 CallForwardSetInfo callForwardSetInfo = {};
2871 callForwardSetInfo.reason = 1;
2872 callForwardSetInfo.mode = 1;
2873 callForwardSetInfo.classx = 1;
2874 callForwardSetInfo.number = "12306";
2875 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2876 WaitFor(WAIT_TIME_SECOND);
2877 EXPECT_EQ(SUCCESS, ret);
2878 }
2879
2880 /**
2881 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallRestriction_0600
2882 * @tc.name : testV1GetCallRestriction004
2883 * @tc.desc : Call the function V1 GetCallRestriction with serialId and a value of -11111
2884 */
2885 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallRestriction004, Function | MediumTest | Level1)
2886 {
2887 if (!IsReady(SLOTID_1)) {
2888 return;
2889 }
2890 std::string fac = "AO";
2891 int32_t ret = g_rilInterface->GetCallRestriction(SLOTID_1, -11111, fac);
2892 WaitFor(WAIT_TIME_SECOND);
2893 EXPECT_EQ(SUCCESS, ret);
2894 }
2895
2896 /**
2897 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallRestriction_0700
2898 * @tc.name : testV1GetCallRestriction005
2899 * @tc.desc : Call the function V1 GetCallRestriction with serialId and a value of 0
2900 */
2901 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallRestriction005, Function | MediumTest | Level1)
2902 {
2903 if (!IsReady(SLOTID_1)) {
2904 return;
2905 }
2906 std::string fac = "AO";
2907 int32_t ret = g_rilInterface->GetCallRestriction(SLOTID_1, 0, fac);
2908 WaitFor(WAIT_TIME_SECOND);
2909 EXPECT_EQ(SUCCESS, ret);
2910 }
2911
2912 /**
2913 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallRestriction_0800
2914 * @tc.name : testV1GetCallRestriction006
2915 * @tc.desc : Call the function V1 GetCallRestriction with serialId and a value of 11111
2916 */
2917 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallRestriction006, Function | MediumTest | Level1)
2918 {
2919 if (!IsReady(SLOTID_1)) {
2920 return;
2921 }
2922 std::string fac = "AO";
2923 int32_t ret = g_rilInterface->GetCallRestriction(SLOTID_1, 11111, fac);
2924 WaitFor(WAIT_TIME_SECOND);
2925 EXPECT_EQ(SUCCESS, ret);
2926 }
2927
2928 /**
2929 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallRestriction_0900
2930 * @tc.name : testV1GetCallRestriction007
2931 * @tc.desc : Call the function V1 GetCallRestriction with serialId and a value of 32768
2932 */
2933 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallRestriction007, Function | MediumTest | Level1)
2934 {
2935 if (!IsReady(SLOTID_1)) {
2936 return;
2937 }
2938 std::string fac = "AO";
2939 int32_t ret = g_rilInterface->GetCallRestriction(SLOTID_1, 32768, fac);
2940 WaitFor(WAIT_TIME_SECOND);
2941 EXPECT_EQ(SUCCESS, ret);
2942 }
2943
2944 /**
2945 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallRestriction_1000
2946 * @tc.name : testV1GetCallRestriction008
2947 * @tc.desc : Call the function V1 GetCallRestriction with serialId and a value of -32768
2948 */
2949 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallRestriction008, Function | MediumTest | Level1)
2950 {
2951 if (!IsReady(SLOTID_1)) {
2952 return;
2953 }
2954 std::string fac = "AO";
2955 int32_t ret = g_rilInterface->GetCallRestriction(SLOTID_1, -32768, fac);
2956 WaitFor(WAIT_TIME_SECOND);
2957 EXPECT_EQ(SUCCESS, ret);
2958 }
2959
2960 /**
2961 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallRestriction_0600
2962 * @tc.name : testV1SetCallRestriction004
2963 * @tc.desc : Call the function V1 SetCallRestriction with serialId and a value of -11111
2964 */
2965 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallRestriction004, Function | MediumTest | Level1)
2966 {
2967 if (!IsReady(SLOTID_1)) {
2968 return;
2969 }
2970 CallRestrictionInfo callRestrictionInfo = {};
2971 callRestrictionInfo.fac = "AO";
2972 callRestrictionInfo.mode = 1;
2973 callRestrictionInfo.password = "123456";
2974 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, -11111, callRestrictionInfo);
2975 WaitFor(WAIT_TIME_SECOND);
2976 EXPECT_EQ(SUCCESS, ret);
2977 }
2978
2979 /**
2980 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallRestriction_0700
2981 * @tc.name : testV1SetCallRestriction005
2982 * @tc.desc : Call the function V1 SetCallRestriction with serialId and a value of 0
2983 */
2984 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallRestriction005, Function | MediumTest | Level1)
2985 {
2986 if (!IsReady(SLOTID_1)) {
2987 return;
2988 }
2989 CallRestrictionInfo callRestrictionInfo = {};
2990 callRestrictionInfo.fac = "AO";
2991 callRestrictionInfo.mode = 1;
2992 callRestrictionInfo.password = "123456";
2993 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, 0, callRestrictionInfo);
2994 WaitFor(WAIT_TIME_SECOND);
2995 EXPECT_EQ(SUCCESS, ret);
2996 }
2997
2998 /**
2999 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallRestriction_0800
3000 * @tc.name : testV1SetCallRestriction006
3001 * @tc.desc : Call the function V1 SetCallRestriction with serialId and a value of 11111
3002 */
3003 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallRestriction006, Function | MediumTest | Level1)
3004 {
3005 if (!IsReady(SLOTID_1)) {
3006 return;
3007 }
3008 CallRestrictionInfo callRestrictionInfo = {};
3009 callRestrictionInfo.fac = "AO";
3010 callRestrictionInfo.mode = 1;
3011 callRestrictionInfo.password = "123456";
3012 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, 11111, callRestrictionInfo);
3013 WaitFor(WAIT_TIME_SECOND);
3014 EXPECT_EQ(SUCCESS, ret);
3015 }
3016
3017 /**
3018 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallRestriction_0900
3019 * @tc.name : testV1SetCallRestriction007
3020 * @tc.desc : Call the function V1 SetCallRestriction with serialId and a value of 32768
3021 */
3022 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallRestriction007, Function | MediumTest | Level1)
3023 {
3024 if (!IsReady(SLOTID_1)) {
3025 return;
3026 }
3027 CallRestrictionInfo callRestrictionInfo = {};
3028 callRestrictionInfo.fac = "AO";
3029 callRestrictionInfo.mode = 1;
3030 callRestrictionInfo.password = "123456";
3031 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, 32768, callRestrictionInfo);
3032 WaitFor(WAIT_TIME_SECOND);
3033 EXPECT_EQ(SUCCESS, ret);
3034 }
3035
3036 /**
3037 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallRestriction_1000
3038 * @tc.name : testV1SetCallRestriction008
3039 * @tc.desc : Call the function V1 SetCallRestriction with serialId and a value of -32768
3040 */
3041 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallRestriction008, Function | MediumTest | Level1)
3042 {
3043 if (!IsReady(SLOTID_1)) {
3044 return;
3045 }
3046 CallRestrictionInfo callRestrictionInfo = {};
3047 callRestrictionInfo.fac = "AO";
3048 callRestrictionInfo.mode = 1;
3049 callRestrictionInfo.password = "123456";
3050 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, -32768, callRestrictionInfo);
3051 WaitFor(WAIT_TIME_SECOND);
3052 EXPECT_EQ(SUCCESS, ret);
3053 }
3054
3055 /**
3056 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallRestriction_1100
3057 * @tc.name : testV1SetCallRestriction009
3058 * @tc.desc : Call the function V1 SetCallRestriction with callRestrictionInfo.mode and a value of 0
3059 */
3060 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallRestriction009, Function | MediumTest | Level1)
3061 {
3062 if (!IsReady(SLOTID_1)) {
3063 return;
3064 }
3065 CallRestrictionInfo callRestrictionInfo = {};
3066 callRestrictionInfo.fac = "AO";
3067 callRestrictionInfo.mode = 0;
3068 callRestrictionInfo.password = "123456";
3069 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, GetSerialId(), callRestrictionInfo);
3070 WaitFor(WAIT_TIME_SECOND);
3071 EXPECT_EQ(SUCCESS, ret);
3072 }
3073
3074 /**
3075 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallRestriction_1200
3076 * @tc.name : testV1SetCallRestriction010
3077 * @tc.desc : Call the function V1 SetCallRestriction with callRestrictionInfo.mode and a value of -1
3078 */
3079 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallRestriction010, Function | MediumTest | Level1)
3080 {
3081 if (!IsReady(SLOTID_1)) {
3082 return;
3083 }
3084 CallRestrictionInfo callRestrictionInfo = {};
3085 callRestrictionInfo.fac = "AO";
3086 callRestrictionInfo.mode = -1;
3087 callRestrictionInfo.password = "123456";
3088 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, GetSerialId(), callRestrictionInfo);
3089 WaitFor(WAIT_TIME_SECOND);
3090 EXPECT_EQ(SUCCESS, ret);
3091 }
3092
3093 /**
3094 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallRestriction_1300
3095 * @tc.name : testV1SetCallRestriction011
3096 * @tc.desc : Call the function V1 SetCallRestriction with callRestrictionInfo.mode and a value of 255
3097 */
3098 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallRestriction011, Function | MediumTest | Level1)
3099 {
3100 if (!IsReady(SLOTID_1)) {
3101 return;
3102 }
3103 CallRestrictionInfo callRestrictionInfo = {};
3104 callRestrictionInfo.fac = "AO";
3105 callRestrictionInfo.mode = 255;
3106 callRestrictionInfo.password = "123456";
3107 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, GetSerialId(), callRestrictionInfo);
3108 WaitFor(WAIT_TIME_SECOND);
3109 EXPECT_EQ(SUCCESS, ret);
3110 }
3111
3112 /**
3113 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallRestriction_1400
3114 * @tc.name : testV1SetCallRestriction012
3115 * @tc.desc : Call the function V1 SetCallRestriction with callRestrictionInfo.password and a value of 0
3116 */
3117 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallRestriction012, Function | MediumTest | Level1)
3118 {
3119 if (!IsReady(SLOTID_1)) {
3120 return;
3121 }
3122 CallRestrictionInfo callRestrictionInfo = {};
3123 callRestrictionInfo.fac = "AO";
3124 callRestrictionInfo.mode = 1;
3125 callRestrictionInfo.password = "0";
3126 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, GetSerialId(), callRestrictionInfo);
3127 WaitFor(WAIT_TIME_SECOND);
3128 EXPECT_EQ(SUCCESS, ret);
3129 }
3130
3131 /**
3132 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallRestriction_1500
3133 * @tc.name : testV1SetCallRestriction013
3134 * @tc.desc : Call the function V1 SetCallRestriction with callRestrictionInfo.password and a value of -1
3135 */
3136 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallRestriction013, Function | MediumTest | Level1)
3137 {
3138 if (!IsReady(SLOTID_1)) {
3139 return;
3140 }
3141 CallRestrictionInfo callRestrictionInfo = {};
3142 callRestrictionInfo.fac = "AO";
3143 callRestrictionInfo.mode = 255;
3144 callRestrictionInfo.password = "-1";
3145 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, GetSerialId(), callRestrictionInfo);
3146 WaitFor(WAIT_TIME_SECOND);
3147 EXPECT_EQ(SUCCESS, ret);
3148 }
3149
3150 /**
3151 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallRestriction_1600
3152 * @tc.name : testV1SetCallRestriction014
3153 * @tc.desc : Call the function V1 SetCallRestriction with callRestrictionInfo.password and a value of abcd1234
3154 */
3155 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallRestriction014, Function | MediumTest | Level1)
3156 {
3157 if (!IsReady(SLOTID_1)) {
3158 return;
3159 }
3160 CallRestrictionInfo callRestrictionInfo = {};
3161 callRestrictionInfo.fac = "AO";
3162 callRestrictionInfo.mode = 255;
3163 callRestrictionInfo.password = "abcd1234";
3164 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, GetSerialId(), callRestrictionInfo);
3165 WaitFor(WAIT_TIME_SECOND);
3166 EXPECT_EQ(SUCCESS, ret);
3167 }
3168
3169 /**
3170 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallRestriction_1700
3171 * @tc.name : testV1SetCallRestriction015
3172 * @tc.desc : Verifying whether a value of 1qaz!QAZ for the password is feasible
3173 */
3174 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallRestriction015, Function | MediumTest | Level1)
3175 {
3176 if (!IsReady(SLOTID_1)) {
3177 return;
3178 }
3179 CallRestrictionInfo callRestrictionInfo = {};
3180 callRestrictionInfo.fac = "AO";
3181 callRestrictionInfo.mode = 255;
3182 callRestrictionInfo.password = "1qaz!QAZ";
3183 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, GetSerialId(), callRestrictionInfo);
3184 WaitFor(WAIT_TIME_SECOND);
3185 EXPECT_EQ(SUCCESS, ret);
3186 }
3187
3188 /**
3189 * @tc.number : SUB_Telephony_DriverSystem_V1GetClip_0600
3190 * @tc.name : testV1GetClip004
3191 * @tc.desc : Call the function V1 GetClip with serialId and a value of -11111
3192 */
3193 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetClip004, Function | MediumTest | Level1)
3194 {
3195 if (!IsReady(SLOTID_1)) {
3196 return;
3197 }
3198 int32_t ret = g_rilInterface->GetClip(SLOTID_1, -11111);
3199 WaitFor(WAIT_TIME_SECOND);
3200 EXPECT_EQ(SUCCESS, ret);
3201 }
3202
3203 /**
3204 * @tc.number : SUB_Telephony_DriverSystem_V1GetClip_0700
3205 * @tc.name : testV1GetClip005
3206 * @tc.desc : Call the function V1 GetClip with serialId and a value of 0
3207 */
3208 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetClip005, Function | MediumTest | Level1)
3209 {
3210 if (!IsReady(SLOTID_1)) {
3211 return;
3212 }
3213 int32_t ret = g_rilInterface->GetClip(SLOTID_1, 0);
3214 WaitFor(WAIT_TIME_SECOND);
3215 EXPECT_EQ(SUCCESS, ret);
3216 }
3217
3218 /**
3219 * @tc.number : SUB_Telephony_DriverSystem_V1GetClip_0800
3220 * @tc.name : testV1GetClip006
3221 * @tc.desc : Call the function V1 GetClip with serialId and a value of 11111
3222 */
3223 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetClip006, Function | MediumTest | Level1)
3224 {
3225 if (!IsReady(SLOTID_1)) {
3226 return;
3227 }
3228 int32_t ret = g_rilInterface->GetClip(SLOTID_1, 11111);
3229 WaitFor(WAIT_TIME_SECOND);
3230 EXPECT_EQ(SUCCESS, ret);
3231 }
3232
3233 /**
3234 * @tc.number : SUB_Telephony_DriverSystem_V1GetClip_0900
3235 * @tc.name : testV1GetClip007
3236 * @tc.desc : Call the function V1 GetClip with serialId and a value of 32768
3237 */
3238 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetClip007, Function | MediumTest | Level1)
3239 {
3240 if (!IsReady(SLOTID_1)) {
3241 return;
3242 }
3243 int32_t ret = g_rilInterface->GetClip(SLOTID_1, 32768);
3244 WaitFor(WAIT_TIME_SECOND);
3245 EXPECT_EQ(SUCCESS, ret);
3246 }
3247
3248 /**
3249 * @tc.number : SUB_Telephony_DriverSystem_V1GetClip_1000
3250 * @tc.name : testV1GetClip008
3251 * @tc.desc : Call the function V1 GetClip with serialId and a value of -32768
3252 */
3253 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetClip008, Function | MediumTest | Level1)
3254 {
3255 if (!IsReady(SLOTID_1)) {
3256 return;
3257 }
3258 int32_t ret = g_rilInterface->GetClip(SLOTID_1, -32768);
3259 WaitFor(WAIT_TIME_SECOND);
3260 EXPECT_EQ(SUCCESS, ret);
3261 }
3262
3263 /**
3264 * @tc.number : SUB_Telephony_DriverSystem_V1SetClip_0600
3265 * @tc.name : testV1SetClip004
3266 * @tc.desc : Call the function V1 SetClip with serialId and a value of -11111
3267 */
3268 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClip004, Function | MediumTest | Level1)
3269 {
3270 if (!IsReady(SLOTID_1)) {
3271 return;
3272 }
3273 int32_t ret = g_rilInterface->SetClip(SLOTID_1, -11111, 1);
3274 WaitFor(WAIT_TIME_SECOND);
3275 EXPECT_EQ(SUCCESS, ret);
3276 }
3277
3278 /**
3279 * @tc.number : SUB_Telephony_DriverSystem_V1SetClip_0700
3280 * @tc.name : testV1SetClip005
3281 * @tc.desc : Call the function V1 SetClip with serialId and a value of 0
3282 */
3283 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClip005, Function | MediumTest | Level1)
3284 {
3285 if (!IsReady(SLOTID_1)) {
3286 return;
3287 }
3288 int32_t ret = g_rilInterface->SetClip(SLOTID_1, 0, 1);
3289 WaitFor(WAIT_TIME_SECOND);
3290 EXPECT_EQ(SUCCESS, ret);
3291 }
3292
3293 /**
3294 * @tc.number : SUB_Telephony_DriverSystem_V1SetClip_0800
3295 * @tc.name : testV1SetClip006
3296 * @tc.desc : Call the function V1 SetClip with serialId and a value of 11111
3297 */
3298 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClip006, Function | MediumTest | Level1)
3299 {
3300 if (!IsReady(SLOTID_1)) {
3301 return;
3302 }
3303 int32_t ret = g_rilInterface->SetClip(SLOTID_1, 11111, 1);
3304 WaitFor(WAIT_TIME_SECOND);
3305 EXPECT_EQ(SUCCESS, ret);
3306 }
3307
3308 /**
3309 * @tc.number : SUB_Telephony_DriverSystem_V1SetClip_0900
3310 * @tc.name : testV1SetClip007
3311 * @tc.desc : Call the function V1 SetClip with serialId and a value of 32768
3312 */
3313 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClip007, Function | MediumTest | Level1)
3314 {
3315 if (!IsReady(SLOTID_1)) {
3316 return;
3317 }
3318 int32_t ret = g_rilInterface->SetClip(SLOTID_1, 32768, 1);
3319 WaitFor(WAIT_TIME_SECOND);
3320 EXPECT_EQ(SUCCESS, ret);
3321 }
3322
3323 /**
3324 * @tc.number : SUB_Telephony_DriverSystem_V1SetClip_1000
3325 * @tc.name : testV1SetClip008
3326 * @tc.desc : Call the function V1 SetClip with serialId and a value of -32768
3327 */
3328 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClip008, Function | MediumTest | Level1)
3329 {
3330 if (!IsReady(SLOTID_1)) {
3331 return;
3332 }
3333 int32_t ret = g_rilInterface->SetClip(SLOTID_1, -32768, 1);
3334 WaitFor(WAIT_TIME_SECOND);
3335 EXPECT_EQ(SUCCESS, ret);
3336 }
3337
3338 /**
3339 * @tc.number : SUB_Telephony_DriverSystem_V1SetClip_1100
3340 * @tc.name : testV1SetClip009
3341 * @tc.desc : Call the function V1 SetClip with action and a value of 0
3342 */
3343 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClip009, Function | MediumTest | Level1)
3344 {
3345 if (!IsReady(SLOTID_1)) {
3346 return;
3347 }
3348 int32_t ret = g_rilInterface->SetClip(SLOTID_1, GetSerialId(), 0);
3349 WaitFor(WAIT_TIME_SECOND);
3350 EXPECT_EQ(SUCCESS, ret);
3351 }
3352
3353 /**
3354 * @tc.number : SUB_Telephony_DriverSystem_V1SetClip_1200
3355 * @tc.name : testV1SetClip010
3356 * @tc.desc : Call the function V1 SetClip with action and a value of -1
3357 */
3358 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClip010, Function | MediumTest | Level1)
3359 {
3360 if (!IsReady(SLOTID_1)) {
3361 return;
3362 }
3363 int32_t ret = g_rilInterface->SetClip(SLOTID_1, GetSerialId(), -1);
3364 WaitFor(WAIT_TIME_SECOND);
3365 EXPECT_EQ(SUCCESS, ret);
3366 }
3367
3368 /**
3369 * @tc.number : SUB_Telephony_DriverSystem_V1GetClir_0600
3370 * @tc.name : testV1GetClir004
3371 * @tc.desc : Call the function V1 GetClir with serialId and a value of -11111
3372 */
3373 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetClir004, Function | MediumTest | Level1)
3374 {
3375 if (!IsReady(SLOTID_1)) {
3376 return;
3377 }
3378 int32_t ret = g_rilInterface->GetClir(SLOTID_1, -11111);
3379 WaitFor(WAIT_TIME_SECOND);
3380 EXPECT_EQ(SUCCESS, ret);
3381 }
3382
3383 /**
3384 * @tc.number : SUB_Telephony_DriverSystem_V1GetClir_0700
3385 * @tc.name : testV1GetClir005
3386 * @tc.desc : Call the function V1 GetClir with serialId and a value of 0
3387 */
3388 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetClir005, Function | MediumTest | Level1)
3389 {
3390 if (!IsReady(SLOTID_1)) {
3391 return;
3392 }
3393 int32_t ret = g_rilInterface->GetClir(SLOTID_1, 0);
3394 WaitFor(WAIT_TIME_SECOND);
3395 EXPECT_EQ(SUCCESS, ret);
3396 }
3397
3398 /**
3399 * @tc.number : SUB_Telephony_DriverSystem_V1GetClir_0800
3400 * @tc.name : testV1GetClir006
3401 * @tc.desc : Call the function V1 GetClir with serialId and a value of 11111
3402 */
3403 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetClir006, Function | MediumTest | Level1)
3404 {
3405 if (!IsReady(SLOTID_1)) {
3406 return;
3407 }
3408 int32_t ret = g_rilInterface->GetClir(SLOTID_1, 11111);
3409 WaitFor(WAIT_TIME_SECOND);
3410 EXPECT_EQ(SUCCESS, ret);
3411 }
3412
3413 /**
3414 * @tc.number : SUB_Telephony_DriverSystem_V1GetClir_0900
3415 * @tc.name : testV1GetClir007
3416 * @tc.desc : Call the function V1 GetClir with serialId and a value of 32768
3417 */
3418 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetClir007, Function | MediumTest | Level1)
3419 {
3420 if (!IsReady(SLOTID_1)) {
3421 return;
3422 }
3423 int32_t ret = g_rilInterface->GetClir(SLOTID_1, 32768);
3424 WaitFor(WAIT_TIME_SECOND);
3425 EXPECT_EQ(SUCCESS, ret);
3426 }
3427
3428 /**
3429 * @tc.number : SUB_Telephony_DriverSystem_V1GetClir_1000
3430 * @tc.name : testV1GetClir008
3431 * @tc.desc : Call the function V1 GetClir with serialId and a value of -32768
3432 */
3433 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetClir008, Function | MediumTest | Level1)
3434 {
3435 if (!IsReady(SLOTID_1)) {
3436 return;
3437 }
3438 int32_t ret = g_rilInterface->GetClir(SLOTID_1, -32768);
3439 WaitFor(WAIT_TIME_SECOND);
3440 EXPECT_EQ(SUCCESS, ret);
3441 }
3442
3443 /**
3444 * @tc.number : SUB_Telephony_DriverSystem_V1SetClir_0600
3445 * @tc.name : testV1SetClir004
3446 * @tc.desc : Call the function V1 SetClir with serialId and a value of -11111
3447 */
3448 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClir004, Function | MediumTest | Level1)
3449 {
3450 if (!IsReady(SLOTID_1)) {
3451 return;
3452 }
3453 int32_t ret = g_rilInterface->SetClir(SLOTID_1, -11111, 1);
3454 WaitFor(WAIT_TIME_SECOND);
3455 EXPECT_EQ(SUCCESS, ret);
3456 }
3457
3458 /**
3459 * @tc.number : SUB_Telephony_DriverSystem_V1SetClir_0700
3460 * @tc.name : testV1SetClir005
3461 * @tc.desc : Call the function V1 SetClir with serialId and a value of 0
3462 */
3463 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClir005, Function | MediumTest | Level1)
3464 {
3465 if (!IsReady(SLOTID_1)) {
3466 return;
3467 }
3468 int32_t ret = g_rilInterface->SetClir(SLOTID_1, 0, 1);
3469 WaitFor(WAIT_TIME_SECOND);
3470 EXPECT_EQ(SUCCESS, ret);
3471 }
3472
3473 /**
3474 * @tc.number : SUB_Telephony_DriverSystem_V1SetClir_0800
3475 * @tc.name : testV1SetClir006
3476 * @tc.desc : Call the function V1 SetClir with serialId and a value of 11111
3477 */
3478 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClir006, Function | MediumTest | Level1)
3479 {
3480 if (!IsReady(SLOTID_1)) {
3481 return;
3482 }
3483 int32_t ret = g_rilInterface->SetClir(SLOTID_1, 11111, 1);
3484 WaitFor(WAIT_TIME_SECOND);
3485 EXPECT_EQ(SUCCESS, ret);
3486 }
3487
3488 /**
3489 * @tc.number : SUB_Telephony_DriverSystem_V1SetClir_0900
3490 * @tc.name : testV1SetClir007
3491 * @tc.desc : Call the function V1 SetClir with serialId and a value of 32768
3492 */
3493 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClir007, Function | MediumTest | Level1)
3494 {
3495 if (!IsReady(SLOTID_1)) {
3496 return;
3497 }
3498 int32_t ret = g_rilInterface->SetClir(SLOTID_1, 32768, 1);
3499 WaitFor(WAIT_TIME_SECOND);
3500 EXPECT_EQ(SUCCESS, ret);
3501 }
3502
3503 /**
3504 * @tc.number : SUB_Telephony_DriverSystem_V1SetClir_1000
3505 * @tc.name : testV1SetClir008
3506 * @tc.desc : Call the function V1 SetClir with serialId and a value of -32768
3507 */
3508 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClir008, Function | MediumTest | Level1)
3509 {
3510 if (!IsReady(SLOTID_1)) {
3511 return;
3512 }
3513 int32_t ret = g_rilInterface->SetClir(SLOTID_1, -32768, 1);
3514 WaitFor(WAIT_TIME_SECOND);
3515 EXPECT_EQ(SUCCESS, ret);
3516 }
3517
3518 /**
3519 * @tc.number : SUB_Telephony_DriverSystem_V1SetClir_1100
3520 * @tc.name : testV1SetClir009
3521 * @tc.desc : Call the function V1 SetClir with action and a value of 0
3522 */
3523 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClir009, Function | MediumTest | Level1)
3524 {
3525 if (!IsReady(SLOTID_1)) {
3526 return;
3527 }
3528 int32_t ret = g_rilInterface->SetClir(SLOTID_1, GetSerialId(), 0);
3529 WaitFor(WAIT_TIME_SECOND);
3530 EXPECT_EQ(SUCCESS, ret);
3531 }
3532
3533 /**
3534 * @tc.number : SUB_Telephony_DriverSystem_V1SetClir_1200
3535 * @tc.name : testV1SetClir010
3536 * @tc.desc : Call the function V1 SetClir with action and a value of -1
3537 */
3538 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetClir010, Function | MediumTest | Level1)
3539 {
3540 if (!IsReady(SLOTID_1)) {
3541 return;
3542 }
3543 int32_t ret = g_rilInterface->SetClir(SLOTID_1, GetSerialId(), -1);
3544 WaitFor(WAIT_TIME_SECOND);
3545 EXPECT_EQ(SUCCESS, ret);
3546 }
3547
3548 /**
3549 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallPreferenceMode_0600
3550 * @tc.name : testV1SetCallPreferenceMode004
3551 * @tc.desc : Call the function V1 SetCallPreferenceMode with serialId and a value of -11111
3552 */
3553 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallPreferenceMode004, Function | MediumTest | Level1)
3554 {
3555 if (!IsReady(SLOTID_1)) {
3556 return;
3557 }
3558 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_1, -11111, 1);
3559 WaitFor(WAIT_TIME_SECOND);
3560 EXPECT_EQ(SUCCESS, ret);
3561 }
3562
3563 /**
3564 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallPreferenceMode_0700
3565 * @tc.name : testV1SetCallPreferenceMode005
3566 * @tc.desc : Call the function V1 SetCallPreferenceMode with serialId and a value of 0
3567 */
3568 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallPreferenceMode005, Function | MediumTest | Level1)
3569 {
3570 if (!IsReady(SLOTID_1)) {
3571 return;
3572 }
3573 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_1, 0, 1);
3574 WaitFor(WAIT_TIME_SECOND);
3575 EXPECT_EQ(SUCCESS, ret);
3576 }
3577
3578 /**
3579 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallPreferenceMode_0800
3580 * @tc.name : testV1SetCallPreferenceMode006
3581 * @tc.desc : Call the function V1 SetCallPreferenceMode with serialId and a value of 11111
3582 */
3583 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallPreferenceMode006, Function | MediumTest | Level1)
3584 {
3585 if (!IsReady(SLOTID_1)) {
3586 return;
3587 }
3588 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_1, 11111, 1);
3589 WaitFor(WAIT_TIME_SECOND);
3590 EXPECT_EQ(SUCCESS, ret);
3591 }
3592
3593 /**
3594 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallPreferenceMode_0900
3595 * @tc.name : testV1SetCallPreferenceMode007
3596 * @tc.desc : Call the function V1 SetCallPreferenceMode with serialId and a value of 32768
3597 */
3598 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallPreferenceMode007, Function | MediumTest | Level1)
3599 {
3600 if (!IsReady(SLOTID_1)) {
3601 return;
3602 }
3603 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_1, 32768, 1);
3604 WaitFor(WAIT_TIME_SECOND);
3605 EXPECT_EQ(SUCCESS, ret);
3606 }
3607
3608 /**
3609 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallPreferenceMode_1000
3610 * @tc.name : testV1SetCallPreferenceMode008
3611 * @tc.desc : Call the function V1 SetCallPreferenceMode with serialId and a value of -32768
3612 */
3613 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallPreferenceMode008, Function | MediumTest | Level1)
3614 {
3615 if (!IsReady(SLOTID_1)) {
3616 return;
3617 }
3618 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_1, -32768, 1);
3619 WaitFor(WAIT_TIME_SECOND);
3620 EXPECT_EQ(SUCCESS, ret);
3621 }
3622
3623 /**
3624 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallPreferenceMode_1100
3625 * @tc.name : testV1SetCallPreferenceMode009
3626 * @tc.desc : Call the function V1 SetCallPreferenceMode with mode and a value of 2
3627 */
3628 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallPreferenceMode009, Function | MediumTest | Level1)
3629 {
3630 if (!IsReady(SLOTID_1)) {
3631 return;
3632 }
3633 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_1, GetSerialId(), 2);
3634 WaitFor(WAIT_TIME_SECOND);
3635 EXPECT_EQ(SUCCESS, ret);
3636 }
3637
3638 /**
3639 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallPreferenceMode_1200
3640 * @tc.name : testV1SetCallPreferenceMode010
3641 * @tc.desc : Call the function V1 SetCallPreferenceMode with mode and a value of 3
3642 */
3643 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallPreferenceMode010, Function | MediumTest | Level1)
3644 {
3645 if (!IsReady(SLOTID_1)) {
3646 return;
3647 }
3648 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_1, GetSerialId(), 3);
3649 WaitFor(WAIT_TIME_SECOND);
3650 EXPECT_EQ(SUCCESS, ret);
3651 }
3652
3653 /**
3654 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallPreferenceMode_1300
3655 * @tc.name : testV1SetCallPreferenceMode011
3656 * @tc.desc : Call the function V1 SetCallPreferenceMode with mode and a value of 4
3657 */
3658 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallPreferenceMode011, Function | MediumTest | Level1)
3659 {
3660 if (!IsReady(SLOTID_1)) {
3661 return;
3662 }
3663 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_1, GetSerialId(), 4);
3664 WaitFor(WAIT_TIME_SECOND);
3665 EXPECT_EQ(SUCCESS, ret);
3666 }
3667
3668 /**
3669 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallPreferenceMode_1400
3670 * @tc.name : testV1SetCallPreferenceMode012
3671 * @tc.desc : Call the function V1 SetCallPreferenceMode with mode and a value of 5
3672 */
3673 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallPreferenceMode012, Function | MediumTest | Level1)
3674 {
3675 if (!IsReady(SLOTID_1)) {
3676 return;
3677 }
3678 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_1, GetSerialId(), 5);
3679 WaitFor(WAIT_TIME_SECOND);
3680 EXPECT_EQ(SUCCESS, ret);
3681 }
3682
3683 /**
3684 * @tc.number : SUB_Telephony_DriverSystem_V1SetCallPreferenceMode_1500
3685 * @tc.name : testV1SetCallPreferenceMode013
3686 * @tc.desc : Call the function V1 SetCallPreferenceMode with mode and a value of -1
3687 */
3688 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCallPreferenceMode013, Function | MediumTest | Level1)
3689 {
3690 if (!IsReady(SLOTID_1)) {
3691 return;
3692 }
3693 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_1, GetSerialId(), -1);
3694 WaitFor(WAIT_TIME_SECOND);
3695 EXPECT_EQ(SUCCESS, ret);
3696 }
3697
3698 /**
3699 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallPreferenceMode_0600
3700 * @tc.name : testV1GetCallPreferenceMode004
3701 * @tc.desc : Call the function V1 GetCallPreferenceMode with serialId and a value of -11111
3702 */
3703 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallPreferenceMode004, Function | MediumTest | Level1)
3704 {
3705 if (!IsReady(SLOTID_1)) {
3706 return;
3707 }
3708 int32_t ret = g_rilInterface->GetCallPreferenceMode(SLOTID_1, -11111);
3709 WaitFor(WAIT_TIME_SECOND);
3710 EXPECT_EQ(SUCCESS, ret);
3711 }
3712
3713 /**
3714 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallPreferenceMode_0700
3715 * @tc.name : testV1GetCallPreferenceMode005
3716 * @tc.desc : Call the function V1 GetCallPreferenceMode with serialId and a value of 0
3717 */
3718 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallPreferenceMode005, Function | MediumTest | Level1)
3719 {
3720 if (!IsReady(SLOTID_1)) {
3721 return;
3722 }
3723 int32_t ret = g_rilInterface->GetCallPreferenceMode(SLOTID_1, 0);
3724 WaitFor(WAIT_TIME_SECOND);
3725 EXPECT_EQ(SUCCESS, ret);
3726 }
3727
3728 /**
3729 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallPreferenceMode_0800
3730 * @tc.name : testV1GetCallPreferenceMode006
3731 * @tc.desc : Call the function V1 GetCallPreferenceMode with serialId and a value of 11111
3732 */
3733 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallPreferenceMode006, Function | MediumTest | Level1)
3734 {
3735 if (!IsReady(SLOTID_1)) {
3736 return;
3737 }
3738 int32_t ret = g_rilInterface->GetCallPreferenceMode(SLOTID_1, 11111);
3739 WaitFor(WAIT_TIME_SECOND);
3740 EXPECT_EQ(SUCCESS, ret);
3741 }
3742
3743 /**
3744 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallPreferenceMode_0900
3745 * @tc.name : testV1GetCallPreferenceMode007
3746 * @tc.desc : Call the function V1 GetCallPreferenceMode with serialId and a value of 32768
3747 */
3748 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallPreferenceMode007, Function | MediumTest | Level1)
3749 {
3750 if (!IsReady(SLOTID_1)) {
3751 return;
3752 }
3753 int32_t ret = g_rilInterface->GetCallPreferenceMode(SLOTID_1, 32768);
3754 WaitFor(WAIT_TIME_SECOND);
3755 EXPECT_EQ(SUCCESS, ret);
3756 }
3757
3758 /**
3759 * @tc.number : SUB_Telephony_DriverSystem_V1GetCallPreferenceMode_1000
3760 * @tc.name : testV1GetCallPreferenceMode008
3761 * @tc.desc : Call the function V1 GetCallPreferenceMode with serialId and a value of -32768
3762 */
3763 HWTEST_F(HdfRilHdiTestAdditional1st, testV1GetCallPreferenceMode008, Function | MediumTest | Level1)
3764 {
3765 if (!IsReady(SLOTID_1)) {
3766 return;
3767 }
3768 int32_t ret = g_rilInterface->GetCallPreferenceMode(SLOTID_1, -32768);
3769 WaitFor(WAIT_TIME_SECOND);
3770 EXPECT_EQ(SUCCESS, ret);
3771 }
3772
3773 /**
3774 * @tc.number: SUB_Telephony_DriverSystem_V1SetCBConfig_0300
3775 * @tc.name : testV1SetCBConfig001
3776 * @tc.desc : Call function SetCBConfig with an gsmType of 0.
3777 */
3778 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCBConfig001, Function | MediumTest | Level1)
3779 {
3780 if (!IsReady(SLOTID_1)) {
3781 return;
3782 }
3783 int32_t gsmType = 0;
3784 CBConfigInfo info;
3785 info.mode = gsmType;
3786 info.mids = TEST_ID_LIST;
3787 info.dcss = TEST_DCS_LIST;
3788 int32_t ret = g_rilInterface->SetCBConfig(SLOTID_1, GetSerialId(), info);
3789 WaitFor(WAIT_TIME_SECOND_LONG);
3790 EXPECT_EQ(SUCCESS, ret);
3791 }
3792
3793 /**
3794 * @tc.number: SUB_Telephony_DriverSystem_V1SetCBConfig_0500
3795 * @tc.name : testV1SetCBConfig002
3796 * @tc.desc : Call function SetCBConfig with an gsmType of 0 100times.
3797 */
3798 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCBConfig002, Function | MediumTest | Level1)
3799 {
3800 if (!IsReady(SLOTID_1)) {
3801 return;
3802 }
3803 int32_t gsmType = 0;
3804 CBConfigInfo info;
3805 info.mode = gsmType;
3806 info.mids = TEST_ID_LIST;
3807 info.dcss = TEST_DCS_LIST;
3808 int32_t ret = 0;
3809 for (int i = 0; i < 10; i++) {
3810 ret = g_rilInterface->SetCBConfig(SLOTID_1, GetSerialId(), info);
3811 WaitFor(WAIT_TIME_SECOND_LONG);
3812 EXPECT_EQ(SUCCESS, ret);
3813 }
3814 }
3815
3816 /**
3817 * @tc.number: SUB_Telephony_DriverSystem_V1SetCBConfig_0600
3818 * @tc.name : testV1SetCBConfig003
3819 * @tc.desc : Call function SetCBConfig with an entry of -1.
3820 */
3821 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCBConfig003, Function | MediumTest | Level1)
3822 {
3823 if (!IsReady(SLOTID_1)) {
3824 return;
3825 }
3826 int32_t gsmType = -1;
3827 CBConfigInfo info;
3828 info.mode = gsmType;
3829 info.mids = TEST_ID_LIST;
3830 info.dcss = TEST_DCS_LIST;
3831 int32_t ret = g_rilInterface->SetCBConfig(SLOTID_1, GetSerialId(), info);
3832 WaitFor(WAIT_TIME_SECOND_LONG);
3833 EXPECT_EQ(SUCCESS, ret);
3834 }
3835
3836 /**
3837 * @tc.number: SUB_Telephony_DriverSystem_V1SetCBConfig_0700
3838 * @tc.name : testV1SetCBConfig004
3839 * @tc.desc : Call function SetCBConfig with the second argument as 255.
3840 */
3841 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCBConfig004, Function | MediumTest | Level1)
3842 {
3843 if (!IsReady(SLOTID_1)) {
3844 return;
3845 }
3846 int32_t gsmType = 1;
3847 CBConfigInfo info;
3848 info.mode = gsmType;
3849 info.mids = TEST_ID_LIST;
3850 info.dcss = TEST_DCS_LIST;
3851 int32_t ret = g_rilInterface->SetCBConfig(SLOTID_1, 255, info);
3852 WaitFor(WAIT_TIME_SECOND_LONG);
3853 EXPECT_EQ(SUCCESS, ret);
3854 }
3855
3856 /**
3857 * @tc.number: SUB_Telephony_DriverSystem_V1SetCBConfig_0800
3858 * @tc.name : testV1SetCBConfig005
3859 * @tc.desc : Call function SetCBConfig with the second argument as 1.
3860 */
3861 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCBConfig005, Function | MediumTest | Level1)
3862 {
3863 if (!IsReady(SLOTID_1)) {
3864 return;
3865 }
3866 int32_t gsmType = 1;
3867 CBConfigInfo info;
3868 info.mode = gsmType;
3869 info.mids = TEST_ID_LIST;
3870 info.dcss = TEST_DCS_LIST;
3871 int32_t ret = g_rilInterface->SetCBConfig(SLOTID_1, 1, info);
3872 WaitFor(WAIT_TIME_SECOND_LONG);
3873 EXPECT_EQ(SUCCESS, ret);
3874 }
3875
3876 /**
3877 * @tc.number: SUB_Telephony_DriverSystem_V1SetCBConfig_0900
3878 * @tc.name : testV1SetCBConfig006
3879 * @tc.desc : Call function SetCBConfig with the second argument as 1000000001.
3880 */
3881 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCBConfig006, Function | MediumTest | Level1)
3882 {
3883 if (!IsReady(SLOTID_1)) {
3884 return;
3885 }
3886 int32_t gsmType = 1;
3887 CBConfigInfo info;
3888 info.mode = gsmType;
3889 info.mids = TEST_ID_LIST;
3890 info.dcss = TEST_DCS_LIST;
3891 int32_t ret = g_rilInterface->SetCBConfig(SLOTID_1, 1000000001, info);
3892 WaitFor(WAIT_TIME_SECOND_LONG);
3893 EXPECT_EQ(SUCCESS, ret);
3894 }
3895
3896 /**
3897 * @tc.number: SUB_Telephony_DriverSystem_V1SetCBConfig_1000
3898 * @tc.name : testV1SetCBConfig007
3899 * @tc.desc : Call function SetCBConfig with the second argument as -1.
3900 */
3901 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCBConfig007, Function | MediumTest | Level1)
3902 {
3903 if (!IsReady(SLOTID_1)) {
3904 return;
3905 }
3906 int32_t gsmType = 1;
3907 CBConfigInfo info;
3908 info.mode = gsmType;
3909 info.mids = TEST_ID_LIST;
3910 info.dcss = TEST_DCS_LIST;
3911 int32_t ret = g_rilInterface->SetCBConfig(SLOTID_1, -1, info);
3912 WaitFor(WAIT_TIME_SECOND_LONG);
3913 EXPECT_EQ(SUCCESS, ret);
3914 }
3915
3916 /**
3917 * @tc.number: SUB_Telephony_DriverSystem_V1SetCBConfig_1100
3918 * @tc.name : testV1SetCBConfig008
3919 * @tc.desc : Call function SetCBConfig with the third argument as info.mode = 255.
3920 */
3921 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCBConfig008, Function | MediumTest | Level1)
3922 {
3923 if (!IsReady(SLOTID_1)) {
3924 return;
3925 }
3926 CBConfigInfo info;
3927 info.mode = 255;
3928 info.mids = TEST_ID_LIST;
3929 info.dcss = TEST_DCS_LIST;
3930 int32_t ret = g_rilInterface->SetCBConfig(SLOTID_1, GetSerialId(), info);
3931 WaitFor(WAIT_TIME_SECOND_LONG);
3932 EXPECT_EQ(SUCCESS, ret);
3933 }
3934
3935 /**
3936 * @tc.number: SUB_Telephony_DriverSystem_V1SetCBConfig_1200
3937 * @tc.name : testV1SetCBConfig009
3938 * @tc.desc : Call function SetCBConfig with the third argument as info.mode = 1.
3939 */
3940 HWTEST_F(HdfRilHdiTestAdditional1st, testV1SetCBConfig009, Function | MediumTest | Level1)
3941 {
3942 if (!IsReady(SLOTID_1)) {
3943 return;
3944 }
3945 CBConfigInfo info;
3946 info.mode = 1;
3947 info.mids = TEST_ID_LIST;
3948 info.dcss = TEST_DCS_LIST;
3949 int32_t ret = g_rilInterface->SetCBConfig(SLOTID_1, GetSerialId(), info);
3950 WaitFor(WAIT_TIME_SECOND_LONG);
3951 EXPECT_EQ(SUCCESS, ret);
3952 }