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