1 /*
2 * Copyright (C) 2023 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 #define private public
17 #include "hril_sim.h"
18 #include "ril_sim_test.h"
19 #include "ril_test_util.h"
20
21 namespace OHOS {
22 namespace Telephony {
23 using namespace OHOS::HDI::Ril::V1_2;
24 using namespace testing::ext;
25 namespace {
26 sptr<OHOS::HDI::Ril::V1_2::IRil> g_rilInterface = nullptr;
27 }
28
SetUpTestCase()29 void RILSimTest::SetUpTestCase()
30 {
31 TELEPHONY_LOGI("----------RilCallTest gtest start ------------");
32 RilTestUtil::GetInstance().Init();
33 g_rilInterface = RilTestUtil::GetRilInterface();
34 }
35
TearDownTestCase()36 void RILSimTest::TearDownTestCase() {}
37
SetUp()38 void RILSimTest::SetUp() {}
39
TearDown()40 void RILSimTest::TearDown() {}
41
42 /**
43 * @tc.number Telephony_DriverSystem_GetSimStatus_V1_0100
44 * @tc.name Get sim status
45 * @tc.desc Function test
46 */
47 HWTEST_F(RILSimTest, Telephony_DriverSystem_GetSimStatus_V1_0100, Function | MediumTest | Level2)
48 {
49 ASSERT_NE(g_rilInterface, nullptr);
50 ASSERT_TRUE(RilTestUtil::HasVoiceCapability());
51 ASSERT_TRUE(RilTestUtil::IsValidSlotId(SLOTID_1));
52 int32_t ret = g_rilInterface->GetSimStatus(SLOTID_1, RilTestUtil::GetSerialId());
53 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
54 EXPECT_EQ(SUCCESS, ret);
55 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_GET_SIM_STATUS));
56 }
57
58 /**
59 * @tc.number Telephony_DriverSystem_GetSimStatus_V1_0200
60 * @tc.name Get sim status
61 * @tc.desc Function test
62 */
63 HWTEST_F(RILSimTest, Telephony_DriverSystem_GetSimStatus_V1_0200, Function | MediumTest | Level2)
64 {
65 ASSERT_NE(g_rilInterface, nullptr);
66 ASSERT_TRUE(RilTestUtil::HasVoiceCapability());
67 ASSERT_TRUE(RilTestUtil::IsValidSlotId(SLOTID_2));
68 int32_t ret = g_rilInterface->GetSimStatus(SLOTID_2, RilTestUtil::GetSerialId());
69 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
70 EXPECT_EQ(SUCCESS, ret);
71 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_GET_SIM_STATUS));
72 }
73
74 /**
75 * @tc.number Telephony_DriverSystem_GetSimIO_V1_0100
76 * @tc.name Get sim IO
77 * @tc.desc Function test
78 */
79 HWTEST_F(RILSimTest, Telephony_DriverSystem_GetSimIO_V1_0100, Function | MediumTest | Level3)
80 {
81 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
82 SimIoRequestInfo msg;
83 msg.command = 0xc0;
84 msg.fileId = 0x2FE2;
85 msg.p1 = 0;
86 msg.p2 = 0;
87 msg.p3 = 15;
88 msg.data = "";
89 msg.path = "3F00";
90 msg.pin2 = "";
91 int32_t ret = g_rilInterface->GetSimIO(SLOTID_1, RilTestUtil::GetSerialId(), msg);
92 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
93 EXPECT_EQ(SUCCESS, ret);
94 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_GET_SIM_IO));
95 }
96
97 /**
98 * @tc.number Telephony_DriverSystem_GetSimIO_V1_0200
99 * @tc.name Get sim IO
100 * @tc.desc Function test
101 */
102 HWTEST_F(RILSimTest, Telephony_DriverSystem_GetSimIO_V1_0200, Function | MediumTest | Level3)
103 {
104 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
105 SimIoRequestInfo msg;
106 msg.command = 0xC0;
107 // ICCID
108 msg.fileId = 0x2FE2;
109 msg.p1 = 0;
110 msg.p2 = 0;
111 msg.p3 = 15;
112 msg.data = "";
113 msg.path = "3F00";
114 msg.pin2 = "";
115 int32_t ret = g_rilInterface->GetSimIO(SLOTID_2, RilTestUtil::GetSerialId(), msg);
116 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
117 EXPECT_EQ(SUCCESS, ret);
118 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_GET_SIM_IO));
119 }
120
121 /**
122 * @tc.number Telephony_DriverSystem_GetImsi_V1_0100
123 * @tc.name Get imsi
124 * @tc.desc Function test
125 */
126 HWTEST_F(RILSimTest, Telephony_DriverSystem_GetImsi_V1_0100, Function | MediumTest | Level3)
127 {
128 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
129 int32_t ret = g_rilInterface->GetImsi(SLOTID_1, RilTestUtil::GetSerialId());
130 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
131 EXPECT_EQ(SUCCESS, ret);
132 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_GET_IMSI));
133 }
134
135 /**
136 * @tc.number Telephony_DriverSystem_GetImsi_V1_0200
137 * @tc.name Get imsi
138 * @tc.desc Function test
139 */
140 HWTEST_F(RILSimTest, Telephony_DriverSystem_GetImsi_V1_0200, Function | MediumTest | Level3)
141 {
142 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
143 int32_t ret = g_rilInterface->GetImsi(SLOTID_2, RilTestUtil::GetSerialId());
144 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
145 EXPECT_EQ(SUCCESS, ret);
146 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_GET_IMSI));
147 }
148
149 /**
150 * @tc.number Telephony_DriverSystem_SetActiveSim_V1_0100
151 * @tc.name Set active sim
152 * @tc.desc Function test
153 */
154 HWTEST_F(RILSimTest, Telephony_DriverSystem_SetActiveSim_V1_0100, Function | MediumTest | Level3)
155 {
156 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
157 int32_t enable = 1;
158 int32_t index = 1; // ENTITY_CARD
159 int32_t ret = g_rilInterface->SetActiveSim(SLOTID_1, RilTestUtil::GetSerialId(), index, enable);
160 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
161 EXPECT_EQ(SUCCESS, ret);
162 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_SET_ACTIVE_SIM));
163 }
164
165 /**
166 * @tc.number Telephony_DriverSystem_SetActiveSim_V1_0200
167 * @tc.name Set active sim
168 * @tc.desc Function test
169 */
170 HWTEST_F(RILSimTest, Telephony_DriverSystem_SetActiveSim_V1_0200, Function | MediumTest | Level3)
171 {
172 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
173 int32_t enable = 1;
174 int32_t index = 1; // ENTITY_CARD
175 int32_t ret = g_rilInterface->SetActiveSim(SLOTID_2, RilTestUtil::GetSerialId(), index, enable);
176 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
177 EXPECT_EQ(SUCCESS, ret);
178 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_SET_ACTIVE_SIM));
179 }
180
181 /**
182 * @tc.number Telephony_DriverSystem_SimStkSendTerminalResponse_V1_0100
183 * @tc.name Sim stk send terminal response
184 * @tc.desc Function test
185 */
186 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimStkSendTerminalResponse_V1_0100, Function | MediumTest | Level3)
187 {
188 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
189 std::string cmd = "send terminal response";
190 int32_t ret = g_rilInterface->SimStkSendTerminalResponse(SLOTID_1, RilTestUtil::GetSerialId(), cmd);
191 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
192 EXPECT_EQ(SUCCESS, ret);
193 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_STK_SEND_TERMINAL_RESPONSE));
194 }
195
196 /**
197 * @tc.number Telephony_DriverSystem_SimStkSendTerminalResponse_V1_0200
198 * @tc.name Sim stk send terminal response
199 * @tc.desc Function test
200 */
201 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimStkSendTerminalResponse_V1_0200, Function | MediumTest | Level3)
202 {
203 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
204 std::string cmd = "send terminal response";
205 int32_t ret = g_rilInterface->SimStkSendTerminalResponse(SLOTID_2, RilTestUtil::GetSerialId(), cmd);
206 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
207 EXPECT_EQ(SUCCESS, ret);
208 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_STK_SEND_TERMINAL_RESPONSE));
209 }
210
211 /**
212 * @tc.number Telephony_DriverSystem_SimStkSendEnvelope_V1_0100
213 * @tc.name Sim stk send envelope
214 * @tc.desc Function test
215 */
216 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimStkSendEnvelope_V1_0100, Function | MediumTest | Level3)
217 {
218 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
219 std::string cmd = "send envelope";
220 int32_t ret = g_rilInterface->SimStkSendEnvelope(SLOTID_1, RilTestUtil::GetSerialId(), cmd);
221 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
222 EXPECT_EQ(SUCCESS, ret);
223 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_STK_SEND_ENVELOPE));
224 }
225
226 /**
227 * @tc.number Telephony_DriverSystem_SimStkSendEnvelope_V1_0200
228 * @tc.name Sim stk send envelope
229 * @tc.desc Function test
230 */
231 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimStkSendEnvelope_V1_0200, Function | MediumTest | Level3)
232 {
233 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
234 std::string cmd = "send envelope";
235 int32_t ret = g_rilInterface->SimStkSendEnvelope(SLOTID_2, RilTestUtil::GetSerialId(), cmd);
236 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
237 EXPECT_EQ(SUCCESS, ret);
238 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_STK_SEND_ENVELOPE));
239 }
240
241 /**
242 * @tc.number Telephony_DriverSystem_SimStkSendCallSetupRequestResult_V1_0100
243 * @tc.name Sim stk send call setup requestResult
244 * @tc.desc Function test
245 */
246 HWTEST_F(
247 RILSimTest, Telephony_DriverSystem_SimStkSendCallSetupRequestResult_V1_0100, Function | MediumTest | Level3)
248 {
249 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
250 int32_t ret = g_rilInterface->SimStkSendCallSetupRequestResult(SLOTID_1, RilTestUtil::GetSerialId(), true);
251 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
252 EXPECT_EQ(SUCCESS, ret);
253 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT));
254 }
255
256 /**
257 * @tc.number Telephony_DriverSystem_SimStkSendCallSetupRequestResult_V1_0200
258 * @tc.name Sim stk send call setup requestResult
259 * @tc.desc Function test
260 */
261 HWTEST_F(
262 RILSimTest, Telephony_DriverSystem_SimStkSendCallSetupRequestResult_V1_0200, Function | MediumTest | Level3)
263 {
264 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
265 int32_t ret = g_rilInterface->SimStkSendCallSetupRequestResult(SLOTID_2, RilTestUtil::GetSerialId(), true);
266 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
267 EXPECT_EQ(SUCCESS, ret);
268 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT));
269 }
270
271 /**
272 * @tc.number Telephony_DriverSystem_SimStkIsReady_V1_0100
273 * @tc.name Sim stk is ready
274 * @tc.desc Function test
275 */
276 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimStkIsReady_V1_0100, Function | MediumTest | Level3)
277 {
278 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
279 int32_t ret = g_rilInterface->SimStkIsReady(SLOTID_1, RilTestUtil::GetSerialId());
280 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
281 EXPECT_EQ(SUCCESS, ret);
282 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_STK_IS_READY));
283 }
284
285 /**
286 * @tc.number Telephony_DriverSystem_SimStkIsReady_V1_0200
287 * @tc.name Sim stk is ready
288 * @tc.desc Function test
289 */
290 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimStkIsReady_V1_0200, Function | MediumTest | Level3)
291 {
292 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
293 int32_t ret = g_rilInterface->SimStkIsReady(SLOTID_2, RilTestUtil::GetSerialId());
294 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
295 EXPECT_EQ(SUCCESS, ret);
296 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_STK_IS_READY));
297 }
298
299 /**
300 * @tc.number Telephony_DriverSystem_SetRadioProtocol_V1_0100
301 * @tc.name Set radio protocol
302 * @tc.desc Function test
303 */
304 HWTEST_F(RILSimTest, Telephony_DriverSystem_SetRadioProtocol_V1_0100, Function | MediumTest | Level3)
305 {
306 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
307 RadioProtocol protocol;
308 protocol.slotId = SLOTID_1;
309 int32_t ret = g_rilInterface->SetRadioProtocol(SLOTID_1, RilTestUtil::GetSerialId(), protocol);
310 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
311 EXPECT_EQ(SUCCESS, ret);
312 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_RADIO_PROTOCOL));
313 }
314
315 /**
316 * @tc.number Telephony_DriverSystem_SetRadioProtocol_V1_0200
317 * @tc.name Set radio protocol
318 * @tc.desc Function test
319 */
320 HWTEST_F(RILSimTest, Telephony_DriverSystem_SetRadioProtocol_V1_0200, Function | MediumTest | Level3)
321 {
322 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
323 RadioProtocol protocol;
324 protocol.slotId = SLOTID_2;
325 int32_t ret = g_rilInterface->SetRadioProtocol(SLOTID_2, RilTestUtil::GetSerialId(), protocol);
326 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
327 EXPECT_EQ(SUCCESS, ret);
328 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_RADIO_PROTOCOL));
329 }
330
331 /**
332 * @tc.number Telephony_DriverSystem_SimOpenLogicalChannel_V1_0100
333 * @tc.name Sim open logical channel
334 * @tc.desc Function test
335 */
336 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimOpenLogicalChannel_V1_0100, Function | MediumTest | Level3)
337 {
338 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
339 std::string appID = "A00000015141434C00"; // ARAM_AID
340 int32_t p2 = 0;
341 int32_t ret = g_rilInterface->SimOpenLogicalChannel(SLOTID_1, RilTestUtil::GetSerialId(), appID, p2);
342 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
343 EXPECT_EQ(SUCCESS, ret);
344 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_OPEN_LOGICAL_CHANNEL));
345 }
346
347 /**
348 * @tc.number Telephony_DriverSystem_SimTransmitApduLogicalChannel_V1_0100
349 * @tc.name Sim transmit apdu logical channel
350 * @tc.desc Function test
351 */
352 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimTransmitApduLogicalChannel_V1_0100, Function | MediumTest | Level3)
353 {
354 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
355 ApduSimIORequestInfo reqInfo;
356 reqInfo.channelId = RilTestUtil::GetCallback()->GetCurrentChannelId();
357 reqInfo.type = 0x80; // CLA
358 reqInfo.instruction = 0xCA; // COMMAND;
359 reqInfo.p1 = 0xFF;
360 reqInfo.p2 = 0x40;
361 reqInfo.p3 = 0x00;
362 reqInfo.data = "";
363 int32_t ret = g_rilInterface->SimTransmitApduLogicalChannel(SLOTID_1, RilTestUtil::GetSerialId(), reqInfo);
364 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
365 EXPECT_EQ(SUCCESS, ret);
366 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL));
367 }
368
369 /**
370 * @tc.number Telephony_DriverSystem_SimCloseLogicalChannel_V1_0100
371 * @tc.name Sim close logical channel
372 * @tc.desc Function test
373 */
374 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimCloseLogicalChannel_V1_0100, Function | MediumTest | Level3)
375 {
376 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
377 int32_t ret = g_rilInterface->SimCloseLogicalChannel(
378 SLOTID_1, RilTestUtil::GetSerialId(), RilTestUtil::GetCallback()->GetCurrentChannelId());
379 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
380 EXPECT_EQ(SUCCESS, ret);
381 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_CLOSE_LOGICAL_CHANNEL));
382 }
383
384 /**
385 * @tc.number Telephony_DriverSystem_SimCloseLogicalChannel_V1_0100
386 * @tc.name Sim open logical channel
387 * @tc.desc Function test
388 */
389 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimOpenLogicalChannel_V1_0200, Function | MediumTest | Level3)
390 {
391 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
392 std::string appID = "A00000015141434C00"; // ARAM_AID
393 int32_t p2 = 0;
394 int32_t ret = g_rilInterface->SimOpenLogicalChannel(SLOTID_2, RilTestUtil::GetSerialId(), appID, p2);
395 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
396 EXPECT_EQ(SUCCESS, ret);
397 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_OPEN_LOGICAL_CHANNEL));
398 }
399
400 /**
401 * @tc.number Telephony_DriverSystem_SimTransmitApduLogicalChannel_V1_0200
402 * @tc.name Sim transmit apdu logical channel
403 * @tc.desc Function test
404 */
405 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimTransmitApduLogicalChannel_V1_0200, Function | MediumTest | Level3)
406 {
407 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
408 ApduSimIORequestInfo reqInfo;
409 reqInfo.channelId = RilTestUtil::GetCallback()->GetCurrentChannelId();
410 reqInfo.type = 0x80; // CLA
411 reqInfo.instruction = 0xCA; // COMMAND;
412 reqInfo.p1 = 0xFF;
413 reqInfo.p2 = 0x40;
414 reqInfo.p3 = 0x00;
415 reqInfo.data = "";
416 int32_t ret = g_rilInterface->SimTransmitApduLogicalChannel(SLOTID_2, RilTestUtil::GetSerialId(), reqInfo);
417 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
418 EXPECT_EQ(SUCCESS, ret);
419 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL));
420 }
421
422 /**
423 * @tc.number Telephony_DriverSystem_SimCloseLogicalChannel_V1_0100
424 * @tc.name Sim close logical channel
425 * @tc.desc Function test
426 */
427 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimCloseLogicalChannel_V1_0200, Function | MediumTest | Level3)
428 {
429 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
430 int32_t ret = g_rilInterface->SimCloseLogicalChannel(
431 SLOTID_2, RilTestUtil::GetSerialId(), RilTestUtil::GetCallback()->GetCurrentChannelId());
432 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
433 EXPECT_EQ(SUCCESS, ret);
434 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_CLOSE_LOGICAL_CHANNEL));
435 }
436
437 /**
438 * @tc.number Telephony_DriverSystem_SimTransmitApduBasicChannel_V1_0100
439 * @tc.name Sim transmit apdu basic channel
440 * @tc.desc Function test
441 */
442 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimTransmitApduBasicChannel_V1_0100, Function | MediumTest | Level3)
443 {
444 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
445 ApduSimIORequestInfo reqInfo;
446 reqInfo.type = 0x80; // CLA
447 reqInfo.instruction = 0xCA; // COMMAND;
448 reqInfo.p1 = 0xFF;
449 reqInfo.p2 = 0x40;
450 reqInfo.p3 = 0x00;
451 reqInfo.data = "";
452 int32_t ret = g_rilInterface->SimTransmitApduBasicChannel(SLOTID_1, RilTestUtil::GetSerialId(), reqInfo);
453 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
454 EXPECT_EQ(SUCCESS, ret);
455 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL));
456 }
457
458 /**
459 * @tc.number Telephony_DriverSystem_SimTransmitApduBasicChannel_V1_0200
460 * @tc.name Sim transmit apdu basic channel
461 * @tc.desc Function test
462 */
463 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimTransmitApduBasicChannel_V1_0200, Function | MediumTest | Level3)
464 {
465 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
466 ApduSimIORequestInfo reqInfo;
467 reqInfo.type = 0x80; // CLA
468 reqInfo.instruction = 0xCA; // COMMAND;
469 reqInfo.p1 = 0xFF;
470 reqInfo.p2 = 0x40;
471 reqInfo.p3 = 0x00;
472 reqInfo.data = "";
473 int32_t ret = g_rilInterface->SimTransmitApduBasicChannel(SLOTID_2, RilTestUtil::GetSerialId(), reqInfo);
474 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
475 EXPECT_EQ(SUCCESS, ret);
476 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL));
477 }
478
479 /**
480 * @tc.number Telephony_DriverSystem_SimAuthentication_V1_0100
481 * @tc.name Sim authentication
482 * @tc.desc Function test
483 */
484 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimAuthentication_V1_0100, Function | MediumTest | Level3)
485 {
486 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
487 SimAuthenticationRequestInfo simAuthInfo;
488 simAuthInfo.serial = SIM_AUTH_EAP_AKA_TYPE;
489 simAuthInfo.aid = "USIM_AID";
490 simAuthInfo.authData = "authData";
491 int32_t ret = g_rilInterface->SimAuthentication(SLOTID_1, RilTestUtil::GetSerialId(), simAuthInfo);
492 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
493 EXPECT_EQ(SUCCESS, ret);
494 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_AUTHENTICATION));
495 }
496
497 /**
498 * @tc.number Telephony_DriverSystem_SimAuthentication_V1_0200
499 * @tc.name Sim authentication
500 * @tc.desc Function test
501 */
502 HWTEST_F(RILSimTest, Telephony_DriverSystem_SimAuthentication_V1_0200, Function | MediumTest | Level3)
503 {
504 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
505 SimAuthenticationRequestInfo simAuthInfo;
506 simAuthInfo.serial = SIM_AUTH_EAP_AKA_TYPE;
507 simAuthInfo.aid = "USIM_AID";
508 simAuthInfo.authData = "authData";
509 int32_t ret = g_rilInterface->SimAuthentication(SLOTID_2, RilTestUtil::GetSerialId(), simAuthInfo);
510 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
511 EXPECT_EQ(SUCCESS, ret);
512 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_AUTHENTICATION));
513 }
514
515 /**
516 * @tc.number Telephony_DriverSystem_GetSimLockStatus_V1_0100
517 * @tc.name Get Sim lock status
518 * @tc.desc Function test
519 */
520 HWTEST_F(RILSimTest, Telephony_DriverSystem_GetSimLockStatus_V1_0100, Function | MediumTest | Level3)
521 {
522 #ifdef TEL_TEST_PIN_PUK
523 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
524 SimLockInfo simLockInfo;
525 simLockInfo.fac = "SC"; // FAC_PIN_LOCK
526 simLockInfo.mode = 2; // MODE
527 simLockInfo.classx = 0;
528 char *FAC_PIN_LOCK = "SC";
529 int32_t ret = g_rilInterface->GetSimLockStatus(SLOTID_1, RilTestUtil::GetSerialId(), simLockInfo);
530 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
531 EXPECT_EQ(SUCCESS, ret);
532 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_GET_SIM_LOCK_STATUS));
533 #endif
534 ASSERT_TRUE(true);
535 }
536
537 /**
538 * @tc.number Telephony_DriverSystem_GetSimLockStatus_V1_0200
539 * @tc.name Get Sim lock status
540 * @tc.desc Function test
541 */
542 HWTEST_F(RILSimTest, Telephony_DriverSystem_GetSimLockStatus_V1_0200, Function | MediumTest | Level3)
543 {
544 #ifdef TEL_TEST_PIN_PUK
545 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
546 SimLockInfo simLockInfo;
547 simLockInfo.fac = "SC"; // FAC_PIN_LOCK
548 simLockInfo.mode = 2; // MODE
549 simLockInfo.classx = 0;
550 char *FAC_PIN_LOCK = "SC";
551 int32_t ret = g_rilInterface->GetSimLockStatus(SLOTID_2, RilTestUtil::GetSerialId(), simLockInfo);
552 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
553 EXPECT_EQ(SUCCESS, ret);
554 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_GET_SIM_LOCK_STATUS));
555 #endif
556 ASSERT_TRUE(true);
557 }
558
559 /**
560 * @tc.number Telephony_DriverSystem_SendSimMatchedOperatorInfo_V1_0100
561 * @tc.name Send sim matched operator info
562 * @tc.desc Function test
563 */
564 HWTEST_F(RILSimTest, Telephony_DriverSystem_SendSimMatchedOperatorInfo_V1_0100, Function | MediumTest | Level3)
565 {
566 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
567 NcfgOperatorInfo ncfgOperatorInfo;
568 ncfgOperatorInfo.operName = "operName";
569 ncfgOperatorInfo.operKey = "operKey";
570 ncfgOperatorInfo.state = 0;
571 ncfgOperatorInfo.reserve = "reserve";
572 int32_t ret = g_rilInterface->SendSimMatchedOperatorInfo(SLOTID_1, RilTestUtil::GetSerialId(), ncfgOperatorInfo);
573 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
574 EXPECT_EQ(SUCCESS, ret);
575 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_SEND_NCFG_OPER_INFO));
576 }
577
578 /**
579 * @tc.number Telephony_DriverSystem_SendSimMatchedOperatorInfo_V1_0200
580 * @tc.name Send sim matched operator info
581 * @tc.desc Function test
582 */
583 HWTEST_F(RILSimTest, Telephony_DriverSystem_SendSimMatchedOperatorInfo_V1_0200, Function | MediumTest | Level3)
584 {
585 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
586 NcfgOperatorInfo ncfgOperatorInfo;
587 ncfgOperatorInfo.operName = "operName";
588 ncfgOperatorInfo.operKey = "operKey";
589 ncfgOperatorInfo.state = 0;
590 ncfgOperatorInfo.reserve = "reserve";
591 int32_t ret = g_rilInterface->SendSimMatchedOperatorInfo(SLOTID_2, RilTestUtil::GetSerialId(), ncfgOperatorInfo);
592 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
593 EXPECT_EQ(SUCCESS, ret);
594 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_SEND_NCFG_OPER_INFO));
595 }
596
597 /**
598 * @tc.number Telephony_DriverSystem_SetSimLock_V1_0100
599 * @tc.name Set Sim lock
600 * @tc.desc Function test
601 */
602 HWTEST_F(RILSimTest, Telephony_DriverSystem_SetSimLock_V1_0100, Function | MediumTest | Level3)
603 {
604 #ifdef TEL_TEST_PIN_PUK
605 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
606 SimLockInfo simLockInfo;
607 simLockInfo.fac = "SC"; // FAC_PIN_LOCK
608 simLockInfo.mode = 2; // MODE
609 simLockInfo.classx = 0;
610 simLockInfo.passwd = "1234";
611 char *FAC_PIN_LOCK = "SC";
612 int32_t ret = g_rilInterface->SetSimLock(SLOTID_1, RilTestUtil::GetSerialId(), simLockInfo);
613 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
614 EXPECT_EQ(SUCCESS, ret);
615 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_SET_SIM_LOCK));
616 #endif
617 ASSERT_TRUE(true);
618 }
619
620 /**
621 * @tc.number Telephony_DriverSystem_SetSimLock_V1_0200
622 * @tc.name Set Sim lock
623 * @tc.desc Function test
624 */
625 HWTEST_F(RILSimTest, Telephony_DriverSystem_SetSimLock_V1_0200, Function | MediumTest | Level3)
626 {
627 #ifdef TEL_TEST_PIN_PUK
628 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
629 SimLockInfo simLockInfo;
630 simLockInfo.fac = "SC"; // FAC_PIN_LOCK
631 simLockInfo.mode = 2; // MODE
632 simLockInfo.classx = 0;
633 simLockInfo.passwd = "1234";
634 char *FAC_PIN_LOCK = "SC";
635 int32_t ret = g_rilInterface->SetSimLock(SLOTID_2, RilTestUtil::GetSerialId(), simLockInfo);
636 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
637 EXPECT_EQ(SUCCESS, ret);
638 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_SET_SIM_LOCK));
639 #endif
640 ASSERT_TRUE(true);
641 }
642
643 /**
644 * @tc.number Telephony_DriverSystem_ChangeSimPassword_V1_0100
645 * @tc.name Change sim password
646 * @tc.desc Function test
647 */
648 HWTEST_F(RILSimTest, Telephony_DriverSystem_ChangeSimPassword_V1_0100, Function | MediumTest | Level3)
649 {
650 #ifdef TEL_TEST_PIN_PUK
651 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
652 ISimPasswordInfo simPassword;
653 simPassword.fac = "SC"; // FAC_PIN_LOCK
654 simPassword.oldPassword = "1234";
655 simPassword.newPassword = "1234";
656 simPassword.passwordLength = 4;
657 int32_t ret = g_rilInterface->ChangeSimPassword(SLOTID_1, RilTestUtil::GetSerialId(), simPassword);
658 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
659 EXPECT_EQ(SUCCESS, ret);
660 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_CHANGE_SIM_PASSWORD));
661 #endif
662 ASSERT_TRUE(true);
663 }
664
665 /**
666 * @tc.number Telephony_DriverSystem_ChangeSimPassword_V1_0200
667 * @tc.name Change sim password
668 * @tc.desc Function test
669 */
670 HWTEST_F(RILSimTest, Telephony_DriverSystem_ChangeSimPassword_V1_0200, Function | MediumTest | Level3)
671 {
672 #ifdef TEL_TEST_PIN_PUK
673 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
674 ISimPasswordInfo simPassword;
675 simPassword.fac = "SC"; // FAC_PIN_LOCK
676 simPassword.oldPassword = "1234";
677 simPassword.newPassword = "1234";
678 simPassword.passwordLength = 4;
679 int32_t ret = g_rilInterface->ChangeSimPassword(SLOTID_2, RilTestUtil::GetSerialId(), simPassword);
680 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
681 EXPECT_EQ(SUCCESS, ret);
682 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_CHANGE_SIM_PASSWORD));
683 #endif
684 ASSERT_TRUE(true);
685 }
686
687 /**
688 * @tc.number Telephony_DriverSystem_UnlockPin_V1_0100
689 * @tc.name Unlock pin
690 * @tc.desc Function test
691 */
692 HWTEST_F(RILSimTest, Telephony_DriverSystem_UnlockPin_V1_0100, Function | MediumTest | Level3)
693 {
694 #ifdef TEL_TEST_PIN_PUK
695 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
696 std::string pin = "1234";
697 int32_t ret = g_rilInterface->UnlockPin(SLOTID_1, RilTestUtil::GetSerialId(), pin);
698 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
699 EXPECT_EQ(SUCCESS, ret);
700 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PIN));
701 #endif
702 ASSERT_TRUE(true);
703 }
704
705 /**
706 * @tc.number Telephony_DriverSystem_UnlockPin_V1_0200
707 * @tc.name Unlock pin
708 * @tc.desc Function test
709 */
710 HWTEST_F(RILSimTest, Telephony_DriverSystem_UnlockPin_V1_0200, Function | MediumTest | Level3)
711 {
712 #ifdef TEL_TEST_PIN_PUK
713 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
714 std::string pin = "1234";
715 int32_t ret = g_rilInterface->UnlockPin(SLOTID_2, RilTestUtil::GetSerialId(), pin);
716 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
717 EXPECT_EQ(SUCCESS, ret);
718 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PIN));
719 #endif
720 ASSERT_TRUE(true);
721 }
722
723 /**
724 * @tc.number Telephony_DriverSystem_UnlockPuk_V1_0100
725 * @tc.name Unlock puk
726 * @tc.desc Function test
727 */
728 HWTEST_F(RILSimTest, Telephony_DriverSystem_UnlockPuk_V1_0100, Function | MediumTest | Level3)
729 {
730 #ifdef TEL_TEST_PIN_PUK
731 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
732 std::string puk = "42014264";
733 std::string pin = "1234";
734 int32_t ret = g_rilInterface->UnlockPuk(SLOTID_1, RilTestUtil::GetSerialId(), puk, pin);
735 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
736 EXPECT_EQ(SUCCESS, ret);
737 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PUK));
738 #endif
739 ASSERT_TRUE(true);
740 }
741
742 /**
743 * @tc.number Telephony_DriverSystem_UnlockPuk_V1_0200
744 * @tc.name Unlock puk
745 * @tc.desc Function test
746 */
747 HWTEST_F(RILSimTest, Telephony_DriverSystem_UnlockPuk_V1_0200, Function | MediumTest | Level3)
748 {
749 #ifdef TEL_TEST_PIN_PUK
750 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
751 std::string puk = "42014264";
752 std::string pin = "1234";
753 int32_t ret = g_rilInterface->UnlockPuk(SLOTID_2, RilTestUtil::GetSerialId(), puk, pin);
754 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
755 EXPECT_EQ(SUCCESS, ret);
756 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PUK));
757 #endif
758 ASSERT_TRUE(true);
759 }
760
761 /**
762 * @tc.number Telephony_DriverSystem_UnlockPin2_V1_0100
763 * @tc.name Unlock pin2
764 * @tc.desc Function test
765 */
766 HWTEST_F(RILSimTest, Telephony_DriverSystem_UnlockPin2_V1_0100, Function | MediumTest | Level3)
767 {
768 #ifdef TEL_TEST_PIN_PUK
769 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
770 std::string pin2 = "1234";
771 int32_t ret = g_rilInterface->UnlockPin2(SLOTID_1, RilTestUtil::GetSerialId(), pin2);
772 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
773 EXPECT_EQ(SUCCESS, ret);
774 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PIN2));
775 #endif
776 ASSERT_TRUE(true);
777 }
778
779 /**
780 * @tc.number Telephony_DriverSystem_UnlockPin2_V1_0200
781 * @tc.name Unlock pin2
782 * @tc.desc Function test
783 */
784 HWTEST_F(RILSimTest, Telephony_DriverSystem_UnlockPin2_V1_0200, Function | MediumTest | Level3)
785 {
786 #ifdef TEL_TEST_PIN_PUK
787 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
788 std::string pin2 = "1234";
789 int32_t ret = g_rilInterface->UnlockPin2(SLOTID_2, RilTestUtil::GetSerialId(), pin2);
790 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
791 EXPECT_EQ(SUCCESS, ret);
792 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PIN2));
793 #endif
794 ASSERT_TRUE(true);
795 }
796
797 /**
798 * @tc.number Telephony_DriverSystem_UnlockPuk2_V1_0100
799 * @tc.name Unlock puk2
800 * @tc.desc Function test
801 */
802 HWTEST_F(RILSimTest, Telephony_DriverSystem_UnlockPuk2_V1_0100, Function | MediumTest | Level3)
803 {
804 #ifdef TEL_TEST_PIN_PUK
805 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
806 std::string puk2 = "42014264";
807 std::string pin2 = "1234";
808 int32_t ret = g_rilInterface->UnlockPuk2(SLOTID_1, RilTestUtil::GetSerialId(), puk2, pin2);
809 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
810 EXPECT_EQ(SUCCESS, ret);
811 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PUK2));
812 #endif
813 ASSERT_TRUE(true);
814 }
815
816 /**
817 * @tc.number Telephony_DriverSystem_UnlockPuk2_V1_0200
818 * @tc.name Unlock puk2
819 * @tc.desc Function test
820 */
821 HWTEST_F(RILSimTest, Telephony_DriverSystem_UnlockPuk2_V1_0200, Function | MediumTest | Level3)
822 {
823 #ifdef TEL_TEST_PIN_PUK
824 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
825 std::string puk2 = "42014264";
826 std::string pin2 = "1234";
827 int32_t ret = g_rilInterface->UnlockPuk2(SLOTID_2, RilTestUtil::GetSerialId(), puk2, pin2);
828 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
829 EXPECT_EQ(SUCCESS, ret);
830 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PUK2));
831 #endif
832 ASSERT_TRUE(true);
833 }
834
835 /**
836 * @tc.number Telephony_DriverSystem_UnlockSimLock_V1_0100
837 * @tc.name Unlock sim lock
838 * @tc.desc Function test
839 */
840 HWTEST_F(RILSimTest, Telephony_DriverSystem_UnlockSimLock_V1_0100, Function | MediumTest | Level3)
841 {
842 #ifdef TEL_TEST_PIN_PUK
843 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_1));
844 int32_t lockType = 0;
845 std::string key = "1234"; // PN_PIN_LOCK
846 int32_t ret = g_rilInterface->UnlockSimLock(SLOTID_1, RilTestUtil::GetSerialId(), lockType, key);
847 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
848 EXPECT_EQ(SUCCESS, ret);
849 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_UNLOCK_SIM_LOCK));
850 #endif
851 ASSERT_TRUE(true);
852 }
853
854 /**
855 * @tc.number Telephony_DriverSystem_UnlockSimLock_V1_0200
856 * @tc.name Unlock sim lock
857 * @tc.desc Function test
858 */
859 HWTEST_F(RILSimTest, Telephony_DriverSystem_UnlockSimLock_V1_0200, Function | MediumTest | Level3)
860 {
861 #ifdef TEL_TEST_PIN_PUK
862 ASSERT_TRUE(RilTestUtil::IsReady(SLOTID_2));
863 int32_t lockType = 0;
864 std::string key = "1234"; // PN_PIN_LOCK
865 int32_t ret = g_rilInterface->UnlockSimLock(SLOTID_2, RilTestUtil::GetSerialId(), lockType, key);
866 RilTestUtil::WaitFor(WAIT_TIME_SECOND);
867 EXPECT_EQ(SUCCESS, ret);
868 ASSERT_TRUE(RilTestUtil::GetBoolResult(HdiId::HREQ_SIM_UNLOCK_SIM_LOCK));
869 #endif
870 ASSERT_TRUE(true);
871 }
872
873 /**
874 * @tc.name : GetRadioProtocolResponse_ShouldSetError_WhenResponseIsNull
875 * @tc.number: GetRadioProtocolResponse_Test_001
876 * @tc.desc : Function test
877 */
878 HWTEST_F(RILSimTest, GetRadioProtocolResponse_ShouldSetError_001, Function | MediumTest | Level3)
879 {
880 int32_t requestNum = 1;
881 HDI::Ril::V1_1::RilRadioResponseInfo responseInfo = {};
882 const void* response = nullptr;
883 size_t responseLen = 0;
884
885 int32_t slotId = 0;
886 auto hrilSim = std::make_shared<HRilSim>(slotId);
887 int32_t ret = hrilSim->GetRadioProtocolResponse(requestNum, responseInfo, response, responseLen);
888 EXPECT_NE(SUCCESS, ret);
889 EXPECT_EQ(responseInfo.error, HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE);
890 }
891
892 /**
893 * @tc.name : GetRadioProtocolResponse_ShouldSetError_WhenResponseLenIsInvalid
894 * @tc.number: GetRadioProtocolResponse_Test_002
895 * @tc.desc : Function test
896 */
897 HWTEST_F(RILSimTest, GetRadioProtocolResponse_ShouldSetError_002, Function | MediumTest | Level3)
898 {
899 int32_t requestNum = 1;
900 HDI::Ril::V1_1::RilRadioResponseInfo responseInfo = {};
901 int dummyResponse = 0;
902 const void* response = &dummyResponse;
903 size_t responseLen = sizeof(dummyResponse);
904
905 int32_t slotId = 0;
906 auto hrilSim = std::make_shared<HRilSim>(slotId);
907 int32_t ret = hrilSim->GetRadioProtocolResponse(requestNum, responseInfo, response, responseLen);
908 EXPECT_NE(SUCCESS, ret);
909 EXPECT_EQ(responseInfo.error, HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE);
910 }
911
912 /**
913 * @tc.name : GetRadioProtocolResponse_ShouldProcessResponse_WhenResponseIsValid
914 * @tc.number: GetRadioProtocolResponse_Test_003
915 * @tc.desc : Function test
916 */
917 HWTEST_F(RILSimTest, GetRadioProtocolResponse_ShouldSetError_003, Function | MediumTest | Level3) {
918 int32_t requestNum = 1;
919 HDI::Ril::V1_1::RilRadioResponseInfo responseInfo = {};
920 HRilRadioProtocol radioProtocol = {};
921 const void* response = &radioProtocol;
922 size_t responseLen = sizeof(radioProtocol);
923
924 int32_t slotId = 0;
925 auto hrilSim = std::make_shared<HRilSim>(slotId);
926 int32_t ret = hrilSim->GetRadioProtocolResponse(requestNum, responseInfo, response, responseLen);
927 EXPECT_NE(SUCCESS, ret);
928 EXPECT_EQ(responseInfo.error, HDI::Ril::V1_1::RilErrType::NONE);
929 }
930
931 /**
932 * @tc.name : SimStkProactiveNotify_ShouldReturnSuccess_WhenCheckCharDataSucceeds
933 * @tc.number: SimStkProactiveNotify_Test_001
934 * @tc.desc : Function test
935 */
936 HWTEST_F(RILSimTest, SimStkProactiveNotify_ShouldReturnSuccess_001, Function | MediumTest | Level3)
937 {
938 int32_t notifyType = 1;
939 HRilErrNumber error = HRIL_ERR_SUCCESS;
940 const char* response = "valid response";
941 size_t responseLen = strlen(response);
942
943 int32_t slotId = 0;
944 auto hrilSim = std::make_shared<HRilSim>(slotId);
945 int32_t ret = hrilSim->SimStkProactiveNotify(notifyType, error, response, responseLen);
946 EXPECT_NE(SUCCESS, ret);
947 EXPECT_NE(ret, HRIL_ERR_SUCCESS);
948 }
949
950 /**
951 * @tc.name : SimStkProactiveNotify_ShouldReturnFailure_WhenCheckCharDataFails
952 * @tc.number: SimStkProactiveNotify_Test_002
953 * @tc.desc : Function test
954 */
955 HWTEST_F(RILSimTest, SimStkProactiveNotify_ShouldReturnSuccess_002, Function | MediumTest | Level3)
956 {
957 int32_t notifyType = 1;
958 HRilErrNumber error = HRIL_ERR_SUCCESS;
959 const char* response = nullptr; // Invalid response
960 size_t responseLen = 0;
961
962 int32_t slotId = 0;
963 auto hrilSim = std::make_shared<HRilSim>(slotId);
964 int32_t ret = hrilSim->SimStkProactiveNotify(notifyType, error, response, responseLen);
965 EXPECT_NE(SUCCESS, ret);
966 EXPECT_NE(ret, HRIL_ERR_SUCCESS);
967 }
968
969 /**
970 * @tc.name : SimStkAlphaNotify_ShouldReturnSuccess_WhenCheckCharDataSucceeds
971 * @tc.number: SimStkAlphaNotify_Test_001
972 * @tc.desc : Function test
973 */
974 HWTEST_F(RILSimTest, SimStkProactiveNotify_ShouldReturnSuccess_003, Function | MediumTest | Level3)
975 {
976 int32_t notifyType = 1;
977 HRilErrNumber error = HRIL_ERR_SUCCESS;
978 const char* response = "valid response";
979 size_t responseLen = strlen(response);
980
981 int32_t slotId = 0;
982 auto hrilSim = std::make_shared<HRilSim>(slotId);
983 int32_t ret = hrilSim->SimStkProactiveNotify(notifyType, error, response, responseLen);
984 EXPECT_NE(SUCCESS, ret);
985 EXPECT_NE(ret, HRIL_ERR_SUCCESS);
986 }
987
988 /**
989 * @tc.name : SimStkAlphaNotify_ShouldReturnFailure_WhenCheckCharDataFails
990 * @tc.number: SimStkAlphaNotify_Test_002
991 * @tc.desc : Function test
992 */
993 HWTEST_F(RILSimTest, SimStkProactiveNotify_ShouldReturnSuccess_004, Function | MediumTest | Level3)
994 {
995 int32_t notifyType = 1;
996 HRilErrNumber error = HRIL_ERR_SUCCESS;
997 const char* response = nullptr; // Invalid response
998 size_t responseLen = 0;
999
1000 int32_t slotId = 0;
1001 auto hrilSim = std::make_shared<HRilSim>(slotId);
1002 int32_t ret = hrilSim->SimStkProactiveNotify(notifyType, error, response, responseLen);
1003 EXPECT_NE(SUCCESS, ret);
1004 EXPECT_NE(ret, HRIL_ERR_SUCCESS);
1005 }
1006
1007 /**
1008 * @tc.name : SimStkEventNotify_ShouldReturnSuccess_WhenCheckCharDataSucceeds
1009 * @tc.number: SimStkEventNotify_Test_001
1010 * @tc.desc : Function test
1011 */
1012 HWTEST_F(RILSimTest, SimStkEventNotify_ShouldReturnSuccess_001, Function | MediumTest | Level3)
1013 {
1014 int32_t notifyType = 1;
1015 HRilErrNumber error = HRIL_ERR_SUCCESS;
1016 const char* response = "valid response";
1017 size_t responseLen = strlen(response);
1018
1019 int32_t slotId = 0;
1020 auto hrilSim = std::make_shared<HRilSim>(slotId);
1021 int32_t ret = hrilSim->SimStkEventNotify(notifyType, error, response, responseLen);
1022 EXPECT_NE(SUCCESS, ret);
1023 EXPECT_NE(ret, HRIL_ERR_SUCCESS);
1024 }
1025
1026 /**
1027 * @tc.name : SimStkEventNotify_ShouldReturnFailure_WhenCheckCharDataFails
1028 * @tc.number: SimStkEventNotify_Test_002
1029 * @tc.desc : Function test
1030 */
1031 HWTEST_F(RILSimTest, SimStkEventNotify_ShouldReturnFailure_002, Function | MediumTest | Level3)
1032 {
1033 int32_t notifyType = 1;
1034 HRilErrNumber error = HRIL_ERR_SUCCESS;
1035 const char* response = nullptr; // Invalid response
1036 size_t responseLen = 0;
1037
1038 int32_t slotId = 0;
1039 auto hrilSim = std::make_shared<HRilSim>(slotId);
1040 int32_t ret = hrilSim->SimStkEventNotify(notifyType, error, response, responseLen);
1041 EXPECT_NE(SUCCESS, ret);
1042 EXPECT_NE(ret, HRIL_ERR_SUCCESS);
1043 }
1044
1045 /**
1046 * @tc.name : SimRadioProtocolUpdated_ShouldReturnFailure_WhenResponseIsNull
1047 * @tc.number: SimRadioProtocolUpdated_Test_001
1048 * @tc.desc : Test SimRadioProtocolUpdated function when response is null
1049 */
1050 HWTEST_F(RILSimTest, SimRadioProtocolUpdated_001, Function | MediumTest | Level3)
1051 {
1052 int32_t notifyType = 1;
1053 HRilErrNumber error = HRIL_ERR_SUCCESS;
1054 const void* response = nullptr;
1055 size_t responseLen = 0;
1056
1057 int32_t slotId = 0;
1058 auto hrilSim = std::make_shared<HRilSim>(slotId);
1059 int32_t ret = hrilSim->SimRadioProtocolUpdated(notifyType, error, response, responseLen);
1060 EXPECT_NE(SUCCESS, ret);
1061 EXPECT_EQ(ret, HRIL_ERR_INVALID_PARAMETER);
1062 }
1063
1064 /**
1065 * @tc.name : SimRadioProtocolUpdated_ShouldReturnFailure_WhenResponseLenIsInvalid
1066 * @tc.number: SimRadioProtocolUpdated_Test_002
1067 * @tc.desc : Test SimRadioProtocolUpdated function when response length is invalid
1068 */
1069 HWTEST_F(RILSimTest, SimRadioProtocolUpdated_002, Function | MediumTest | Level3)
1070 {
1071 int32_t notifyType = 1;
1072 HRilErrNumber error = HRIL_ERR_SUCCESS;
1073 HRilRadioProtocol radioProtocol = {};
1074 const void* response = &radioProtocol;
1075 size_t responseLen = sizeof(radioProtocol) - 1; // Invalid length
1076
1077 int32_t slotId = 0;
1078 auto hrilSim = std::make_shared<HRilSim>(slotId);
1079 int32_t ret = hrilSim->SimRadioProtocolUpdated(notifyType, error, response, responseLen);
1080 EXPECT_NE(SUCCESS, ret);
1081 EXPECT_EQ(ret, HRIL_ERR_INVALID_PARAMETER);
1082 }
1083
1084 /**
1085 * @tc.name : SimRadioProtocolUpdated_ShouldProcessResponse_WhenResponseIsValid
1086 * @tc.number: SimRadioProtocolUpdated_Test_003
1087 * @tc.desc : Test SimRadioProtocolUpdated function when response is valid
1088 */
1089 HWTEST_F(RILSimTest, SimRadioProtocolUpdated_003, Function | MediumTest | Level3)
1090 {
1091 int32_t notifyType = 1;
1092 HRilErrNumber error = HRIL_ERR_SUCCESS;
1093 HRilRadioProtocol radioProtocol = {};
1094 const void* response = &radioProtocol;
1095 size_t responseLen = sizeof(radioProtocol);
1096
1097 int32_t slotId = 0;
1098 auto hrilSim = std::make_shared<HRilSim>(slotId);
1099 int32_t ret = hrilSim->SimRadioProtocolUpdated(notifyType, error, response, responseLen);
1100 EXPECT_NE(SUCCESS, ret);
1101 EXPECT_NE(ret, HRIL_ERR_SUCCESS);
1102 }
1103
1104 /**
1105 * @tc.name : GetSimIOResponse_Success
1106 * @tc.number: GetSimIOResponse_Test_001
1107 * @tc.desc : Function test
1108 */
1109 HWTEST_F(RILSimTest, GetSimIOResponse_Success, Function | MediumTest | Level3)
1110 {
1111 HDI::Ril::V1_1::RilRadioResponseInfo responseInfo;
1112 const void* response = nullptr; // 假设有效响应
1113 size_t responseLen = 0; // 假设有效长度
1114 int32_t slotId = 0;
1115 auto hrilSim = std::make_shared<HRilSim>(slotId);
1116 int32_t ret = hrilSim->GetSimIOResponse(1, responseInfo, response, responseLen);
1117 EXPECT_NE(ret, HRIL_ERR_SUCCESS);
1118 }
1119
1120 /**
1121 * @tc.name : GetSimIOResponse_BuildSimIOResp_Fails
1122 * @tc.number: GetSimIOResponse_Test_002
1123 * @tc.desc : Function test
1124 */
1125 HWTEST_F(RILSimTest, GetSimIOResponse_BuildSimIOResp_Fails, Function | MediumTest | Level3)
1126 {
1127 HDI::Ril::V1_1::RilRadioResponseInfo responseInfo;
1128 const void* response = nullptr;
1129 size_t responseLen = 0;
1130 int32_t slotId = 0;
1131 auto hrilSim = std::make_shared<HRilSim>(slotId);
1132 int32_t ret = hrilSim->GetSimIOResponse(1, responseInfo, response, responseLen);
1133 EXPECT_NE(ret, HRIL_ERR_SUCCESS);
1134 }
1135
1136 /**
1137 * @tc.name : GetSimCardStatusResponse_Success
1138 * @tc.number: GetSimCardStatusResponse_Test_001
1139 * @tc.desc : Function test
1140 */
1141 HWTEST_F(RILSimTest, GetSimCardStatusResponse_001, Function | MediumTest | Level3)
1142 {
1143 HDI::Ril::V1_1::RilRadioResponseInfo responseInfo;
1144 HRilCardState cardState = {};
1145 const void* response = &cardState;
1146 size_t responseLen = sizeof(HRilCardState);
1147 int32_t slotId = 0;
1148 auto hrilSim = std::make_shared<HRilSim>(slotId);
1149 int32_t ret = hrilSim->GetSimCardStatusResponse(1, responseInfo, response, responseLen);
1150 EXPECT_NE(ret, HRIL_ERR_SUCCESS);
1151 }
1152
1153 /**
1154 * @tc.name : GetSimCardStatusResponse_ResponseNull_ResponseLenZero
1155 * @tc.number: GetSimCardStatusResponse_Test_002
1156 * @tc.desc : Function test
1157 */
1158 HWTEST_F(RILSimTest, GetSimCardStatusResponse_002, Function | MediumTest | Level3)
1159 {
1160 HDI::Ril::V1_1::RilRadioResponseInfo responseInfo;
1161 const void* response = nullptr;
1162 size_t responseLen = 0;
1163 int32_t slotId = 0;
1164 auto hrilSim = std::make_shared<HRilSim>(slotId);
1165 int32_t ret = hrilSim->GetSimCardStatusResponse(1, responseInfo, response, responseLen);
1166 EXPECT_NE(SUCCESS, ret);
1167 EXPECT_EQ(responseInfo.error, HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE);
1168 }
1169
1170 /**
1171 * @tc.name : GetSimCardStatusResponse_ResponseNull_ResponseLenNonZero
1172 * @tc.number: GetSimCardStatusResponse_Test_003
1173 * @tc.desc : Function test
1174 */
1175 HWTEST_F(RILSimTest, GetSimCardStatusResponse_003, Function | MediumTest | Level3)
1176 {
1177 HDI::Ril::V1_1::RilRadioResponseInfo responseInfo;
1178 const void* response = nullptr;
1179 size_t responseLen = 1;
1180 int32_t slotId = 0;
1181 auto hrilSim = std::make_shared<HRilSim>(slotId);
1182 int32_t ret = hrilSim->GetSimCardStatusResponse(1, responseInfo, response, responseLen);
1183 EXPECT_EQ(ret, HRIL_ERR_INVALID_PARAMETER);
1184 }
1185
1186 /**
1187 * @tc.name : GetSimCardStatusResponse_ResponseNonNull_ResponseLenInvalid
1188 * @tc.number: GetSimCardStatusResponse_Test_004
1189 * @tc.desc : Function test
1190 */
1191 HWTEST_F(RILSimTest, GetSimCardStatusResponse_004, Function | MediumTest | Level3)
1192 {
1193 HDI::Ril::V1_1::RilRadioResponseInfo responseInfo;
1194 HRilCardState cardState = {};
1195 const void* response = &cardState;
1196 size_t responseLen = 1; // 无效长度
1197 int32_t slotId = 0;
1198 auto hrilSim = std::make_shared<HRilSim>(slotId);
1199 int32_t ret = hrilSim->GetSimCardStatusResponse(1, responseInfo, response, responseLen);
1200 EXPECT_EQ(ret, HRIL_ERR_INVALID_PARAMETER);
1201 }
1202
1203 /**
1204 * @tc.name : BuildLockStatusResp
1205 * @tc.number: BuildLockStatusResp_Test
1206 * @tc.desc : Function test
1207 */
1208 HWTEST_F(RILSimTest, BuildLockStatusResp, Function | MediumTest | Level3)
1209 {
1210 LockStatusResp lockStatus;
1211 int32_t slotId = 0;
1212 auto hrilSim = std::make_shared<HRilSim>(slotId);
1213 EXPECT_FALSE(hrilSim->BuildLockStatusResp(nullptr, 0, lockStatus));
1214 }
1215
1216 /**
1217 * @tc.name : InvalidResponseLen
1218 * @tc.number: InvalidResponseLen_Test
1219 * @tc.desc : Function test
1220 */
1221 HWTEST_F(RILSimTest, InvalidResponseLen, Function | MediumTest | Level3)
1222 {
1223 HRilLockStatus resp = {0};
1224 LockStatusResp lockStatus;
1225 int32_t slotId = 0;
1226 auto hrilSim = std::make_shared<HRilSim>(slotId);
1227 EXPECT_FALSE(hrilSim->BuildLockStatusResp(&resp, sizeof(HRilLockStatus) + 1, lockStatus));
1228 }
1229
1230 /**
1231 * @tc.name : ValidResponse
1232 * @tc.number: ValidResponse_test_001
1233 * @tc.desc : Function test
1234 */
1235 HWTEST_F(RILSimTest, ValidResponse_001, Function | MediumTest | Level3)
1236 {
1237 HRilLockStatus resp = {HRIL_ERR_SUCCESS, 5};
1238 LockStatusResp lockStatus;
1239 int32_t slotId = 0;
1240 auto hrilSim = std::make_shared<HRilSim>(slotId);
1241 EXPECT_TRUE(hrilSim->BuildLockStatusResp(&resp, sizeof(HRilLockStatus), lockStatus));
1242 EXPECT_EQ(lockStatus.result, HRIL_ERR_SUCCESS);
1243 EXPECT_EQ(lockStatus.remain, 5);
1244 }
1245
1246 /**
1247 * @tc.name : InvalidResponse
1248 * @tc.number: InvalidResponse_test_002
1249 * @tc.desc : Function test
1250 */
1251 HWTEST_F(RILSimTest, InvalidResponse_002, Function | MediumTest | Level3)
1252 {
1253 LockStatusResp lockStatus;
1254 RilRadioResponseInfo responseInfo = {RilErrType::NONE};
1255 int32_t slotId = 0;
1256 auto hrilSim = std::make_shared<HRilSim>(slotId);
1257 hrilSim->ResponseLockStatus(lockStatus, responseInfo, nullptr, 0);
1258 EXPECT_EQ(responseInfo.error, RilErrType::RIL_ERR_INVALID_RESPONSE);
1259 }
1260
1261 /**
1262 * @tc.name : InvalidResponse
1263 * @tc.number: InvalidResponse_test_003
1264 * @tc.desc : Function test
1265 */
1266 HWTEST_F(RILSimTest, ValidResponse_003, Function | MediumTest | Level3)
1267 {
1268 HRilLockStatus resp = {HRIL_ERR_SUCCESS, 5};
1269 LockStatusResp lockStatus;
1270 RilRadioResponseInfo responseInfo = {RilErrType::NONE};
1271 int32_t slotId = 0;
1272 auto hrilSim = std::make_shared<HRilSim>(slotId);
1273 hrilSim->ResponseLockStatus(lockStatus, responseInfo, &resp, sizeof(HRilLockStatus));
1274 EXPECT_EQ(lockStatus.result, HRIL_ERR_SUCCESS);
1275 EXPECT_EQ(lockStatus.remain, 5);
1276 EXPECT_EQ(responseInfo.error, RilErrType::NONE);
1277 }
1278
1279 /**
1280 * @tc.name : BuildSimIOResp
1281 * @tc.number: BuildSimIOResp_test_001
1282 * @tc.desc : Function test
1283 */
1284 HWTEST_F(RILSimTest, BuildSimIOResp_001, Function | MediumTest | Level3)
1285 {
1286 IccIoResultInfo result;
1287 RilRadioResponseInfo responseInfo = {RilErrType::NONE};
1288 int32_t slotId = 0;
1289 auto hrilSim = std::make_shared<HRilSim>(slotId);
1290 EXPECT_EQ(hrilSim->BuildSimIOResp(result, responseInfo, nullptr, 1), HRIL_ERR_INVALID_PARAMETER);
1291 }
1292
1293 /**
1294 * @tc.name : BuildSimIOResp
1295 * @tc.number: BuildSimIOResp_test_002
1296 * @tc.desc : Function test
1297 */
1298 HWTEST_F(RILSimTest, BuildSimIOResp_002, Function | MediumTest | Level3)
1299 {
1300 HRilSimIOResponse resp = {0};
1301 IccIoResultInfo result;
1302 RilRadioResponseInfo responseInfo = {RilErrType::NONE};
1303 int32_t slotId = 0;
1304 auto hrilSim = std::make_shared<HRilSim>(slotId);
1305 auto buildresult = hrilSim->BuildSimIOResp(result, responseInfo, &resp, sizeof(HRilSimIOResponse) + 1);
1306 EXPECT_EQ(buildresult, HRIL_ERR_INVALID_PARAMETER);
1307 }
1308
1309 /**
1310 * @tc.name : BuildSimIOResp
1311 * @tc.number: BuildSimIOResp_test_003
1312 * @tc.desc : Function test
1313 */
1314 HWTEST_F(RILSimTest, BuildSimIOResp_003, Function | MediumTest | Level3)
1315 {
1316 IccIoResultInfo result;
1317 RilRadioResponseInfo responseInfo = {RilErrType::NONE};
1318 int32_t slotId = 0;
1319 auto hrilSim = std::make_shared<HRilSim>(slotId);
1320 EXPECT_NE(hrilSim->BuildSimIOResp(result, responseInfo, nullptr, 0), HRIL_ERR_NULL_POINT);
1321 }
1322
1323 /**
1324 * @tc.name : BuildSimIOResp
1325 * @tc.number: BuildSimIOResp_test_004
1326 * @tc.desc : Function test
1327 */
1328 HWTEST_F(RILSimTest, BuildSimIOResp_004, Function | MediumTest | Level3)
1329 {
1330 HRilSimIOResponse resp = {0};
1331 IccIoResultInfo result;
1332 RilRadioResponseInfo responseInfo = {RilErrType::NONE};
1333 int32_t slotId = 0;
1334 auto hrilSim = std::make_shared<HRilSim>(slotId);
1335 EXPECT_EQ(hrilSim->BuildSimIOResp(result, responseInfo, &resp, sizeof(HRilSimIOResponse)), HRIL_ERR_SUCCESS);
1336 }
1337
1338 /**
1339 * @tc.name : CheckCharData
1340 * @tc.number: CheckCharData_test_001
1341 * @tc.desc : Function test
1342 */
1343 HWTEST_F(RILSimTest, CheckCharData_001, Function | MediumTest | Level3)
1344 {
1345 int32_t slotId = 0;
1346 auto hrilSim = std::make_shared<HRilSim>(slotId);
1347 EXPECT_EQ(hrilSim->CheckCharData(nullptr, 1), HRIL_ERR_INVALID_PARAMETER);
1348 }
1349
1350 /**
1351 * @tc.name : CheckCharData
1352 * @tc.number: CheckCharData_test_002
1353 * @tc.desc : Function test
1354 */
1355 HWTEST_F(RILSimTest, CheckCharData_002, Function | MediumTest | Level3)
1356 {
1357 char data[] = "test";
1358 int32_t slotId = 0;
1359 auto hrilSim = std::make_shared<HRilSim>(slotId);
1360 EXPECT_NE(hrilSim->CheckCharData(data, 3), HRIL_ERR_INVALID_PARAMETER);
1361 }
1362
1363 /**
1364 * @tc.name : CheckCharData
1365 * @tc.number: CheckCharData_test_003
1366 * @tc.desc : Function test
1367 */
1368 HWTEST_F(RILSimTest, CheckCharData_003, Function | MediumTest | Level3)
1369 {
1370 int32_t slotId = 0;
1371 auto hrilSim = std::make_shared<HRilSim>(slotId);
1372 EXPECT_EQ(hrilSim->CheckCharData(nullptr, 0), HRIL_ERR_NULL_POINT);
1373 }
1374
1375 /**
1376 * @tc.name : CheckCharData
1377 * @tc.number: CheckCharData_test_004
1378 * @tc.desc : Function test
1379 */
1380 HWTEST_F(RILSimTest, CheckCharData_004, Function | MediumTest | Level3)
1381 {
1382 char data[] = "test";
1383 int32_t slotId = 0;
1384 auto hrilSim = std::make_shared<HRilSim>(slotId);
1385 EXPECT_EQ(hrilSim->CheckCharData(data, 4), HRIL_ERR_SUCCESS);
1386 }
1387 } // namespace Telephony
1388 } // namespace OHOS