1 /*
2 * Copyright (c) 2025 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 #define private public
16 #define protected public
17 #include <gtest/gtest.h>
18 #include <thread>
19
20 #include "asn1_node.h"
21 #include "common_event_manager.h"
22 #include "common_event_support.h"
23 #include "esim_file.h"
24 #include "icc_file.h"
25 #include "sim_file_manager.h"
26 #include "sim_constant.h"
27 #include "sim_file_manager.h"
28 #include "tel_ril_manager.h"
29 #include "telephony_tag_def.h"
30 #include "gtest/gtest.h"
31 using namespace OHOS::AppExecFwk;
32 using namespace OHOS::EventFwk;
33
34 namespace OHOS {
35 namespace NFC {
36 namespace TEST {
37 using namespace testing::ext;
38 using namespace OHOS::Telephony;
39 class EsimFileTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp();
44 void TearDown();
45 public:
46 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
47 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
48 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
49 };
50
51 static const std::string BPP_COMBINE_HEX_STR = "BF3781ADBF27678008D14FE1DE62C340D7BF2F3480024C66810207800C1E31302E313"
52 "02E31322E3136342F64702D706C75732D696E746572666163655A0A98680010203040506080060388370AA21FA01D4F10A000000559101"
53 "0FFFFFFFF890000120004093007A00530038001005F3740B354AE39D08ACD7EDD7D2D01C73378621F623B832DFA3243489C5B42C90F220"
54 "14E6C928130D78EE561982EF412AC3D94C04B56F37657DA84FD7BB24DD5634E89";
55
SetUpTestCase()56 void EsimFileTest::SetUpTestCase() {}
57
TearDownTestCase()58 void EsimFileTest::TearDownTestCase() {}
59
SetUp()60 void EsimFileTest::SetUp() {}
61
TearDown()62 void EsimFileTest::TearDown() {}
63
64 /**
65 * @tc.name: SyncCloseChannel001
66 * @tc.desc: Test EsimFileTest SyncCloseChannel.
67 * @tc.type: FUNC
68 */
69 HWTEST_F(EsimFileTest, SyncCloseChannel001, TestSize.Level1)
70 {
71 esimFile->currentChannelId_ = 1;
72 esimFile->SyncCloseChannel();
73 ASSERT_TRUE(esimFile != nullptr);
74 }
75
76 /**
77 * @tc.name: ObtainEid001
78 * @tc.desc: Test EsimFileTest ObtainEid.
79 * @tc.type: FUNC
80 */
81 HWTEST_F(EsimFileTest, ObtainEid001, TestSize.Level1)
82 {
83 esimFile->eid_ = "test";
84 ASSERT_TRUE(esimFile->ObtainEid() == "test");
85 ASSERT_TRUE(esimFile != nullptr);
86 }
87
88 /**
89 * @tc.name: CopyApdCmdToReqInfo001
90 * @tc.desc: Test EsimFileTest CopyApdCmdToReqInfo.
91 * @tc.type: FUNC
92 */
93 HWTEST_F(EsimFileTest, CopyApdCmdToReqInfo001, TestSize.Level1)
94 {
95 ApduSimIORequestInfo requestInfo;
96 ApduCommand *apduCommand = nullptr;
97 esimFile->CopyApdCmdToReqInfo(requestInfo, apduCommand);
98 ASSERT_TRUE(esimFile != nullptr);
99 }
100
101 /**
102 * @tc.name: CopyApdCmdToReqInfo002
103 * @tc.desc: Test EsimFileTest CopyApdCmdToReqInfo.
104 * @tc.type: FUNC
105 */
106 HWTEST_F(EsimFileTest, CopyApdCmdToReqInfo002, TestSize.Level1)
107 {
108 int32_t channelId = 0;
109 ApduData apduData;
110 ApduSimIORequestInfo requestInfo;
111 ApduCommand *apduCommand = new (std::nothrow)ApduCommand(channelId, apduData);
112 esimFile->nextSerialId_ = 2147483647;
113 esimFile->CopyApdCmdToReqInfo(requestInfo, apduCommand);
114 ASSERT_TRUE(esimFile != nullptr);
115 }
116
117 /**
118 * @tc.name: ObtainChannelSuccessAlllowSameAidReuse001
119 * @tc.desc: Test EsimFileTest ObtainChannelSuccessAlllowSameAidReuse.
120 * @tc.type: FUNC
121 */
122 HWTEST_F(EsimFileTest, ObtainChannelSuccessAlllowSameAidReuse001, TestSize.Level1)
123 {
124 std::u16string aid = u"";
125 esimFile->aidStr_ = u"test";
126 ResultInnerCode ret = esimFile->ObtainChannelSuccessAlllowSameAidReuse(aid);
127 ASSERT_TRUE(ret == ResultInnerCode::RESULT_EUICC_CARD_CHANNEL_OTHER_AID);
128 }
129
130 /**
131 * @tc.name: ObtainChannelSuccessAlllowSameAidReuse002
132 * @tc.desc: Test EsimFileTest ObtainChannelSuccessAlllowSameAidReuse.
133 * @tc.type: FUNC
134 */
135 HWTEST_F(EsimFileTest, ObtainChannelSuccessAlllowSameAidReuse002, TestSize.Level1)
136 {
137 esimFile->currentChannelId_ = 0;
138 std::u16string aid = u"test";
139 esimFile->aidStr_ = u"test";
140 esimFile->ObtainChannelSuccessAlllowSameAidReuse(aid);
141 ASSERT_TRUE(esimFile != nullptr);
142 }
143
144 /**
145 * @tc.name: GetEuiccProfileInfoList001
146 * @tc.desc: Test EsimFileTest GetEuiccProfileInfoList.
147 * @tc.type: FUNC
148 */
149 HWTEST_F(EsimFileTest, GetEuiccProfileInfoList001, TestSize.Level1)
150 {
151 esimFile->currentChannelId_ = 0;
152 esimFile->GetEuiccProfileInfoList();
153 ASSERT_TRUE(esimFile != nullptr);
154 }
155
156 /**
157 * @tc.name: GetEuiccInfo001
158 * @tc.desc: Test EsimFileTest GetEuiccInfo.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(EsimFileTest, GetEuiccInfo001, TestSize.Level1)
162 {
163 esimFile->currentChannelId_ = 0;
164 esimFile->GetEuiccInfo();
165 ASSERT_TRUE(esimFile != nullptr);
166 }
167
168 /**
169 * @tc.name: ProcessEsimOpenChannelDone001
170 * @tc.desc: Test EsimFileTest ProcessEsimOpenChannelDone.
171 * @tc.type: FUNC
172 */
173 HWTEST_F(EsimFileTest, ProcessEsimOpenChannelDone001, TestSize.Level1)
174 {
175 OpenLogicalChannelResponse response;
176 response.channelId = 0;
177 auto responseInfo = std::make_shared<OpenLogicalChannelResponse>();
178 auto event = AppExecFwk::InnerEvent::Get(0, responseInfo);
179 esimFile->ProcessEsimOpenChannelDone(event);
180 ASSERT_TRUE(esimFile != nullptr);
181 }
182
183 /**
184 * @tc.name: ProcessEsimCloseSpareChannel001
185 * @tc.desc: Test EsimFileTest ProcessEsimCloseSpareChannel.
186 * @tc.type: FUNC
187 */
188 HWTEST_F(EsimFileTest, ProcessEsimCloseSpareChannel001, TestSize.Level1)
189 {
190 esimFile->ProcessEsimCloseSpareChannel();
191 ASSERT_TRUE(esimFile != nullptr);
192 }
193
194 /**
195 * @tc.name: MakeVersionString001
196 * @tc.desc: Test EsimFileTest MakeVersionString.
197 * @tc.type: FUNC
198 */
199 HWTEST_F(EsimFileTest, MakeVersionString001, TestSize.Level1)
200 {
201 std::vector<uint8_t> versionRaw(1, 1);
202 esimFile->MakeVersionString(versionRaw);
203 ASSERT_TRUE(esimFile != nullptr);
204 }
205
206 /**
207 * @tc.name: ProcessObtainEidDone001
208 * @tc.desc: Test EsimFileTest ProcessObtainEidDone.
209 * @tc.type: FUNC
210 */
211 HWTEST_F(EsimFileTest, ProcessObtainEidDone001, TestSize.Level1)
212 {
213 std::vector<uint8_t> src;
214 auto rootInfo = std::make_shared<Asn1Node>(0, src, 0, 0);
215 auto event = AppExecFwk::InnerEvent::Get(0, rootInfo);
216 esimFile->ProcessObtainEidDone(event);
217 ASSERT_TRUE(esimFile != nullptr);
218 }
219
220 /**
221 * @tc.name: ProcessObtainEuiccInfo1Done001
222 * @tc.desc: Test EsimFileTest ProcessObtainEuiccInfo1Done.
223 * @tc.type: FUNC
224 */
225 HWTEST_F(EsimFileTest, ProcessObtainEuiccInfo1Done001, TestSize.Level1)
226 {
227 std::shared_ptr<IccControllerHolder> holder = nullptr;
228 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
229 rcvMsg->fileData.resultData = "";
230 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
231 esimFile->ProcessObtainEuiccInfo1Done(event);
232 ASSERT_TRUE(esimFile != nullptr);
233 }
234
235 /**
236 * @tc.name: SplitMccAndMnc001
237 * @tc.desc: Test EsimFileTest SplitMccAndMnc.
238 * @tc.type: FUNC
239 */
240 HWTEST_F(EsimFileTest, SplitMccAndMnc001, TestSize.Level1)
241 {
242 std::string mccMnc = "FFFF";
243 std::string mcc = "";
244 std::string mnc = "";
245 esimFile->SplitMccAndMnc(mccMnc, mcc, mnc);
246 ASSERT_TRUE(esimFile != nullptr);
247 }
248
249 /**
250 * @tc.name: SplitMccAndMnc002
251 * @tc.desc: Test EsimFileTest SplitMccAndMnc.
252 * @tc.type: FUNC
253 */
254 HWTEST_F(EsimFileTest, SplitMccAndMnc002, TestSize.Level1)
255 {
256 std::string mccMnc = "EEEE";
257 std::string mcc = "";
258 std::string mnc = "";
259 esimFile->SplitMccAndMnc(mccMnc, mcc, mnc);
260 ASSERT_TRUE(esimFile != nullptr);
261 }
262
263 /**
264 * @tc.name: BuildBasicProfileInfo001
265 * @tc.desc: Test EsimFileTest BuildBasicProfileInfo.
266 * @tc.type: FUNC
267 */
268 HWTEST_F(EsimFileTest, BuildBasicProfileInfo001, TestSize.Level1)
269 {
270 EuiccProfileInfo *eProfileInfo = nullptr;
271 std::shared_ptr<Asn1Node> profileNode = nullptr;
272 esimFile->BuildBasicProfileInfo(eProfileInfo, profileNode);
273 ASSERT_TRUE(esimFile != nullptr);
274 }
275
276 /**
277 * @tc.name: BuildBasicProfileInfo002
278 * @tc.desc: Test EsimFileTest BuildBasicProfileInfo.
279 * @tc.type: FUNC
280 */
281 HWTEST_F(EsimFileTest, BuildBasicProfileInfo002, TestSize.Level1)
282 {
283 EuiccProfileInfo *eProfileInfo = new (std::nothrow)EuiccProfileInfo();
284 std::shared_ptr<Asn1Node> profileNode = nullptr;
285 esimFile->BuildBasicProfileInfo(eProfileInfo, profileNode);
286 ASSERT_TRUE(esimFile != nullptr);
287 }
288
289 /**
290 * @tc.name: BuildBasicProfileInfo003
291 * @tc.desc: Test EsimFileTest BuildBasicProfileInfo.
292 * @tc.type: FUNC
293 */
294 HWTEST_F(EsimFileTest, BuildBasicProfileInfo003, TestSize.Level1)
295 {
296 EuiccProfileInfo *eProfileInfo = nullptr;
297 std::vector<uint8_t> src;
298 std::shared_ptr<Asn1Node> profileNode = std::make_shared<Asn1Node>(0, src, 0, 0);
299 esimFile->BuildBasicProfileInfo(eProfileInfo, profileNode);
300 ASSERT_TRUE(esimFile != nullptr);
301 }
302
303 /**
304 * @tc.name: BuildBasicProfileInfo004
305 * @tc.desc: Test EsimFileTest BuildBasicProfileInfo.
306 * @tc.type: FUNC
307 */
308 HWTEST_F(EsimFileTest, BuildBasicProfileInfo004, TestSize.Level1)
309 {
310 EuiccProfileInfo *eProfileInfo = new (std::nothrow)EuiccProfileInfo();
311 std::vector<uint8_t> src;
312 std::shared_ptr<Asn1Node> profileNode = std::make_shared<Asn1Node>(0, src, 0, 0);
313 esimFile->BuildBasicProfileInfo(eProfileInfo, profileNode);
314 ASSERT_TRUE(esimFile != nullptr);
315 }
316
317 /**
318 * @tc.name: BuildAdvancedProfileInfo001
319 * @tc.desc: Test EsimFileTest BuildAdvancedProfileInfo.
320 * @tc.type: FUNC
321 */
322 HWTEST_F(EsimFileTest, BuildAdvancedProfileInfo001, TestSize.Level1)
323 {
324 EuiccProfileInfo *eProfileInfo = nullptr;
325 std::shared_ptr<Asn1Node> profileNode = nullptr;
326 esimFile->BuildAdvancedProfileInfo(eProfileInfo, profileNode);
327 ASSERT_TRUE(esimFile != nullptr);
328 }
329
330 /**
331 * @tc.name: BuildAdvancedProfileInfo002
332 * @tc.desc: Test EsimFileTest BuildAdvancedProfileInfo.
333 * @tc.type: FUNC
334 */
335 HWTEST_F(EsimFileTest, BuildAdvancedProfileInfo002, TestSize.Level1)
336 {
337 EuiccProfileInfo *eProfileInfo = new (std::nothrow)EuiccProfileInfo();
338 std::shared_ptr<Asn1Node> profileNode = nullptr;
339 esimFile->BuildAdvancedProfileInfo(eProfileInfo, profileNode);
340 ASSERT_TRUE(esimFile != nullptr);
341 }
342
343 /**
344 * @tc.name: BuildAdvancedProfileInfo003
345 * @tc.desc: Test EsimFileTest BuildAdvancedProfileInfo.
346 * @tc.type: FUNC
347 */
348 HWTEST_F(EsimFileTest, BuildAdvancedProfileInfo003, TestSize.Level1)
349 {
350 EuiccProfileInfo *eProfileInfo = nullptr;
351 std::vector<uint8_t> src;
352 std::shared_ptr<Asn1Node> profileNode = std::make_shared<Asn1Node>(0, src, 0, 0);
353 esimFile->BuildAdvancedProfileInfo(eProfileInfo, profileNode);
354 ASSERT_TRUE(esimFile != nullptr);
355 }
356
357 /**
358 * @tc.name: BuildAdvancedProfileInfo004
359 * @tc.desc: Test EsimFileTest BuildAdvancedProfileInfo.
360 * @tc.type: FUNC
361 */
362 HWTEST_F(EsimFileTest, BuildAdvancedProfileInfo004, TestSize.Level1)
363 {
364 EuiccProfileInfo *eProfileInfo = new (std::nothrow)EuiccProfileInfo();
365 std::vector<uint8_t> src;
366 std::shared_ptr<Asn1Node> profileNode = std::make_shared<Asn1Node>(0, src, 0, 0);
367 esimFile->BuildAdvancedProfileInfo(eProfileInfo, profileNode);
368 ASSERT_TRUE(esimFile != nullptr);
369 }
370
371 /**
372 * @tc.name: BuildOperatorId001
373 * @tc.desc: Test EsimFileTest BuildOperatorId.
374 * @tc.type: FUNC
375 */
376 HWTEST_F(EsimFileTest, BuildOperatorId001, TestSize.Level1)
377 {
378 EuiccProfileInfo *eProfileInfo = nullptr;
379 std::shared_ptr<Asn1Node> operatorIdNode = nullptr;
380 esimFile->BuildOperatorId(eProfileInfo, operatorIdNode);
381 ASSERT_TRUE(esimFile != nullptr);
382 }
383
384 /**
385 * @tc.name: BuildOperatorId002
386 * @tc.desc: Test EsimFileTest BuildOperatorId.
387 * @tc.type: FUNC
388 */
389 HWTEST_F(EsimFileTest, BuildOperatorId002, TestSize.Level1)
390 {
391 EuiccProfileInfo *eProfileInfo = new (std::nothrow)EuiccProfileInfo();
392 std::shared_ptr<Asn1Node> operatorIdNode = nullptr;
393 esimFile->BuildOperatorId(eProfileInfo, operatorIdNode);
394 ASSERT_TRUE(esimFile != nullptr);
395 }
396
397 /**
398 * @tc.name: BuildOperatorId003
399 * @tc.desc: Test EsimFileTest BuildOperatorId.
400 * @tc.type: FUNC
401 */
402 HWTEST_F(EsimFileTest, BuildOperatorId003, TestSize.Level1)
403 {
404 EuiccProfileInfo *eProfileInfo = nullptr;
405 std::vector<uint8_t> src;
406 std::shared_ptr<Asn1Node> operatorIdNode = std::make_shared<Asn1Node>(0, src, 0, 0);
407 esimFile->BuildOperatorId(eProfileInfo, operatorIdNode);
408 ASSERT_TRUE(esimFile != nullptr);
409 }
410
411 /**
412 * @tc.name: BuildOperatorId004
413 * @tc.desc: Test EsimFileTest BuildOperatorId.
414 * @tc.type: FUNC
415 */
416 HWTEST_F(EsimFileTest, BuildOperatorId004, TestSize.Level1)
417 {
418 EuiccProfileInfo *eProfileInfo = new (std::nothrow)EuiccProfileInfo();
419 std::vector<uint8_t> src;
420 std::shared_ptr<Asn1Node> operatorIdNode = std::make_shared<Asn1Node>(0, src, 0, 0);
421 esimFile->BuildOperatorId(eProfileInfo, operatorIdNode);
422 ASSERT_TRUE(esimFile != nullptr);
423 }
424
425 /**
426 * @tc.name: DisableProfile001
427 * @tc.desc: Test EsimFileTest DisableProfile.
428 * @tc.type: FUNC
429 */
430 HWTEST_F(EsimFileTest, DisableProfile001, TestSize.Level1)
431 {
432 int32_t portIndex = 0;
433 std::u16string iccId = u"test";
434 esimFile->currentChannelId_ = 0;
435 esimFile->DisableProfile(portIndex, iccId);
436 ASSERT_TRUE(esimFile != nullptr);
437 }
438
439 /**
440 * @tc.name: ObtainSmdsAddress001
441 * @tc.desc: Test EsimFileTest ObtainSmdsAddress.
442 * @tc.type: FUNC
443 */
444 HWTEST_F(EsimFileTest, ObtainSmdsAddress001, TestSize.Level1)
445 {
446 int32_t portIndex = 0;
447 esimFile->currentChannelId_ = 0;
448 esimFile->ObtainSmdsAddress(portIndex);
449 ASSERT_TRUE(esimFile != nullptr);
450 }
451
452 /**
453 * @tc.name: ObtainRulesAuthTable001
454 * @tc.desc: Test EsimFileTest ObtainRulesAuthTable.
455 * @tc.type: FUNC
456 */
457 HWTEST_F(EsimFileTest, ObtainRulesAuthTable001, TestSize.Level1)
458 {
459 int32_t portIndex = 0;
460 esimFile->currentChannelId_ = 0;
461 esimFile->ObtainRulesAuthTable(portIndex);
462 ASSERT_TRUE(esimFile != nullptr);
463 }
464
465 /**
466 * @tc.name: ObtainEuiccChallenge001
467 * @tc.desc: Test EsimFileTest ObtainEuiccChallenge.
468 * @tc.type: FUNC
469 */
470 HWTEST_F(EsimFileTest, ObtainEuiccChallenge001, TestSize.Level1)
471 {
472 int32_t portIndex = 0;
473 esimFile->currentChannelId_ = 0;
474 esimFile->ObtainEuiccChallenge(portIndex);
475 ASSERT_TRUE(esimFile != nullptr);
476 }
477
478 /**
479 * @tc.name: ProcessGetProfile001
480 * @tc.desc: Test EsimFileTest ProcessGetProfile.
481 * @tc.type: FUNC
482 */
483 HWTEST_F(EsimFileTest, ProcessGetProfile001, TestSize.Level1)
484 {
485 int32_t slotId = 0;
486 auto responseEvent = AppExecFwk::InnerEvent::Get(0);
487 esimFile->currentChannelId_ = 1;
488 esimFile->ProcessGetProfile(slotId, responseEvent);
489 ASSERT_TRUE(esimFile != nullptr);
490 }
491
492 /**
493 * @tc.name: GetProfileDoneParseProfileInfo001
494 * @tc.desc: Test EsimFileTest GetProfileDoneParseProfileInfo.
495 * @tc.type: FUNC
496 */
497 HWTEST_F(EsimFileTest, GetProfileDoneParseProfileInfo001, TestSize.Level1)
498 {
499 std::vector<uint8_t> src;
500 std::shared_ptr<Asn1Node> root = std::make_shared<Asn1Node>(0, src, 0, 0);
501 esimFile->GetProfileDoneParseProfileInfo(root);
502 ASSERT_TRUE(esimFile != nullptr);
503 }
504
505 /**
506 * @tc.name: ProcessGetProfileDone001
507 * @tc.desc: Test EsimFileTest ProcessGetProfileDone.
508 * @tc.type: FUNC
509 */
510 HWTEST_F(EsimFileTest, ProcessGetProfileDone001, TestSize.Level1)
511 {
512 std::vector<uint8_t> src;
513 auto rootInfo = std::make_shared<Asn1Node>(0, src, 0, 0);
514 auto event = AppExecFwk::InnerEvent::Get(0, rootInfo);
515 esimFile->ProcessGetProfileDone(event);
516 event = nullptr;
517 esimFile->ProcessGetProfileDone(event);
518 ASSERT_TRUE(esimFile != nullptr);
519 }
520
521 /**
522 * @tc.name: SetDefaultSmdpAddress001
523 * @tc.desc: Test EsimFileTest SetDefaultSmdpAddress.
524 * @tc.type: FUNC
525 */
526 HWTEST_F(EsimFileTest, SetDefaultSmdpAddress001, TestSize.Level1)
527 {
528 esimFile->currentChannelId_ = 0;
529 std::u16string defaultSmdpAddress = u"";
530 esimFile->SetDefaultSmdpAddress(defaultSmdpAddress);
531 ASSERT_TRUE(esimFile != nullptr);
532 }
533
534 /**
535 * @tc.name: ProcessEstablishDefaultSmdpAddress001
536 * @tc.desc: Test EsimFileTest ProcessEstablishDefaultSmdpAddress.
537 * @tc.type: FUNC
538 */
539 HWTEST_F(EsimFileTest, ProcessEstablishDefaultSmdpAddress001, TestSize.Level1)
540 {
541 esimFile->currentChannelId_ = 0;
542 int32_t slotId = 0;
543 auto responseEvent = AppExecFwk::InnerEvent::Get(0);
544 esimFile->ProcessEstablishDefaultSmdpAddress(slotId, responseEvent);
545 ASSERT_TRUE(esimFile != nullptr);
546 }
547
548 /**
549 * @tc.name: ProcessEstablishDefaultSmdpAddress002
550 * @tc.desc: Test EsimFileTest ProcessEstablishDefaultSmdpAddress.
551 * @tc.type: FUNC
552 */
553 HWTEST_F(EsimFileTest, ProcessEstablishDefaultSmdpAddress002, TestSize.Level1)
554 {
555 esimFile->currentChannelId_ = 1;
556 int32_t slotId = 0;
557 std::vector<uint8_t> src;
558 auto rootInfo = std::make_shared<Asn1Node>(0, src, 0, 0);
559 auto responseEvent = AppExecFwk::InnerEvent::Get(0, rootInfo);
560 esimFile->ProcessEstablishDefaultSmdpAddress(slotId, responseEvent);
561 ASSERT_TRUE(esimFile != nullptr);
562 }
563
564 /**
565 * @tc.name: ProcessEstablishDefaultSmdpAddressDone001
566 * @tc.desc: Test EsimFileTest ProcessEstablishDefaultSmdpAddressDone.
567 * @tc.type: FUNC
568 */
569 HWTEST_F(EsimFileTest, ProcessEstablishDefaultSmdpAddressDone001, TestSize.Level1)
570 {
571 auto event = AppExecFwk::InnerEvent::Get(0);
572 esimFile->ProcessEstablishDefaultSmdpAddressDone(event);
573 event = nullptr;
574 esimFile->ProcessEstablishDefaultSmdpAddressDone(event);
575 ASSERT_TRUE(esimFile != nullptr);
576 }
577
578 /**
579 * @tc.name: IsSupported001
580 * @tc.desc: Test EsimFileTest IsSupported.
581 * @tc.type: FUNC
582 */
583 HWTEST_F(EsimFileTest, IsSupported001, TestSize.Level1)
584 {
585 esimFile->isSupported_ = false;
586 esimFile->IsSupported();
587 ASSERT_TRUE(esimFile != nullptr);
588 }
589
590 /**
591 * @tc.name: SendApduData001
592 * @tc.desc: Test EsimFileTest SendApduData.
593 * @tc.type: FUNC
594 */
595 HWTEST_F(EsimFileTest, SendApduData001, TestSize.Level1)
596 {
597 std::u16string aid = u"";
598 EsimApduData apduData;
599 esimFile->SendApduData(aid, apduData);
600 ASSERT_TRUE(esimFile != nullptr);
601 }
602
603 /**
604 * @tc.name: SendApduData002
605 * @tc.desc: Test EsimFileTest SendApduData.
606 * @tc.type: FUNC
607 */
608 HWTEST_F(EsimFileTest, SendApduData002, TestSize.Level1)
609 {
610 std::u16string aid = u"test";
611 EsimApduData apduData;
612 apduData.closeChannelFlag_ = true;
613 esimFile->aidStr_ = u"test";
614 esimFile->SendApduData(aid, apduData);
615 ASSERT_TRUE(esimFile != nullptr);
616 }
617
618 /**
619 * @tc.name: SendApduData003
620 * @tc.desc: Test EsimFileTest SendApduData.
621 * @tc.type: FUNC
622 */
623 HWTEST_F(EsimFileTest, SendApduData003, TestSize.Level1)
624 {
625 std::u16string aid = u"test";
626 EsimApduData apduData;
627 apduData.closeChannelFlag_ = true;
628 esimFile->aidStr_ = u"demo";
629 esimFile->SendApduData(aid, apduData);
630 ASSERT_TRUE(esimFile != nullptr);
631 }
632
633 /**
634 * @tc.name: SendApduData004
635 * @tc.desc: Test EsimFileTest SendApduData.
636 * @tc.type: FUNC
637 */
638 HWTEST_F(EsimFileTest, SendApduData004, TestSize.Level1)
639 {
640 std::u16string aid = u"test";
641 EsimApduData apduData;
642 apduData.closeChannelFlag_ = false;
643 esimFile->currentChannelId_ = 0;
644 esimFile->aidStr_ = u"demo";
645 esimFile->SendApduData(aid, apduData);
646 ASSERT_TRUE(esimFile != nullptr);
647 }
648
649 /**
650 * @tc.name: SendApduData005
651 * @tc.desc: Test EsimFileTest SendApduData.
652 * @tc.type: FUNC
653 */
654 HWTEST_F(EsimFileTest, SendApduData005, TestSize.Level1)
655 {
656 std::u16string aid = u"test";
657 EsimApduData apduData;
658 apduData.closeChannelFlag_ = false;
659 esimFile->currentChannelId_ = 0;
660 esimFile->aidStr_ = u"";
661 esimFile->SendApduData(aid, apduData);
662 ASSERT_TRUE(esimFile != nullptr);
663 }
664
665 /**
666 * @tc.name: SendApduData006
667 * @tc.desc: Test EsimFileTest SendApduData.
668 * @tc.type: FUNC
669 */
670 HWTEST_F(EsimFileTest, SendApduData006, TestSize.Level1)
671 {
672 std::u16string aid = u"test";
673 EsimApduData apduData;
674 apduData.closeChannelFlag_ = false;
675 esimFile->currentChannelId_ = 1;
676 esimFile->aidStr_ = u"";
677 esimFile->SendApduData(aid, apduData);
678 ASSERT_TRUE(esimFile != nullptr);
679 }
680
681 /**
682 * @tc.name: CombineResponseDataFinish001
683 * @tc.desc: Test EsimFileTest CombineResponseDataFinish.
684 * @tc.type: FUNC
685 */
686 HWTEST_F(EsimFileTest, CombineResponseDataFinish001, TestSize.Level1)
687 {
688 IccFileData fileData;
689 fileData.sw1 = 0x61;
690 esimFile->CombineResponseDataFinish(fileData);
691 ASSERT_TRUE(esimFile != nullptr);
692 }
693
694 /**
695 * @tc.name: ProcessIfNeedMoreResponse001
696 * @tc.desc: Test EsimFileTest ProcessIfNeedMoreResponse.
697 * @tc.type: FUNC
698 */
699 HWTEST_F(EsimFileTest, ProcessIfNeedMoreResponse001, TestSize.Level1)
700 {
701 IccFileData fileData;
702 fileData.sw1 = 0x61;
703 int32_t eventId = 0;
704 esimFile->ProcessIfNeedMoreResponse(fileData, eventId);
705 ASSERT_TRUE(esimFile != nullptr);
706 }
707
708 /**
709 * @tc.name: ProcessIfNeedMoreResponse002
710 * @tc.desc: Test EsimFileTest ProcessIfNeedMoreResponse.
711 * @tc.type: FUNC
712 */
713 HWTEST_F(EsimFileTest, ProcessIfNeedMoreResponse002, TestSize.Level1)
714 {
715 IccFileData fileData;
716 fileData.sw1 = 0x62;
717 int32_t eventId = 0;
718 esimFile->ProcessIfNeedMoreResponse(fileData, eventId);
719 ASSERT_TRUE(esimFile != nullptr);
720 }
721
722 /**
723 * @tc.name: MergeRecvLongDataComplete001
724 * @tc.desc: Test EsimFileTest MergeRecvLongDataComplete.
725 * @tc.type: FUNC
726 */
727 HWTEST_F(EsimFileTest, MergeRecvLongDataComplete001, TestSize.Level1)
728 {
729 IccFileData fileData;
730 fileData.sw1 = 0x62;
731 int32_t eventId = 0;
732 esimFile->MergeRecvLongDataComplete(fileData, eventId);
733 ASSERT_TRUE(esimFile != nullptr);
734 }
735
736 /**
737 * @tc.name: ProcessPrepareDownloadDone001
738 * @tc.desc: Test EsimFileTest ProcessPrepareDownloadDone.
739 * @tc.type: FUNC
740 */
741 HWTEST_F(EsimFileTest, ProcessPrepareDownloadDone001, TestSize.Level1)
742 {
743 auto event = AppExecFwk::InnerEvent::Get(0);
744 esimFile->ProcessPrepareDownloadDone(event);
745 event = nullptr;
746 esimFile->ProcessPrepareDownloadDone(event);
747 ASSERT_TRUE(esimFile != nullptr);
748 }
749
750 /**
751 * @tc.name: ProcessPrepareDownloadDone002
752 * @tc.desc: Test EsimFileTest ProcessPrepareDownloadDone.
753 * @tc.type: FUNC
754 */
755 HWTEST_F(EsimFileTest, ProcessPrepareDownloadDone002, TestSize.Level1)
756 {
757 IccFileData newRecvData;
758 newRecvData.sw1 = 0x61;
759 esimFile->newRecvData_ = newRecvData;
760 std::shared_ptr<IccControllerHolder> holder = nullptr;
761 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
762 rcvMsg->fileData.resultData = "";
763 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
764 esimFile->ProcessPrepareDownloadDone(event);
765 ASSERT_TRUE(esimFile != nullptr);
766 }
767
768 /**
769 * @tc.name: ProcessPrepareDownloadDone003
770 * @tc.desc: Test EsimFileTest ProcessPrepareDownloadDone.
771 * @tc.type: FUNC
772 */
773 HWTEST_F(EsimFileTest, ProcessPrepareDownloadDone003, TestSize.Level1)
774 {
775 IccFileData newRecvData;
776 newRecvData.sw1 = 0x90;
777 newRecvData.sw2 = 0x00;
778 newRecvData.resultData = "test";
779 esimFile->newRecvData_ = newRecvData;
780 std::shared_ptr<IccControllerHolder> holder = nullptr;
781 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
782 rcvMsg->fileData.resultData = "";
783 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
784 esimFile->ProcessPrepareDownloadDone(event);
785 ASSERT_TRUE(esimFile != nullptr);
786 }
787
788 /**
789 * @tc.name: RealProcessPrepareDownloadDone001
790 * @tc.desc: Test EsimFileTest RealProcessPrepareDownloadDone.
791 * @tc.type: FUNC
792 */
793 HWTEST_F(EsimFileTest, RealProcessPrepareDownloadDone001, TestSize.Level1)
794 {
795 esimFile->RealProcessPrepareDownloadDone();
796 ASSERT_TRUE(esimFile != nullptr);
797 }
798
799 /**
800 * @tc.name: LoadBoundProfilePackageParseNotificationMetadata001
801 * @tc.desc: Test EsimFileTest LoadBoundProfilePackageParseNotificationMetadata.
802 * @tc.type: FUNC
803 */
804 HWTEST_F(EsimFileTest, LoadBoundProfilePackageParseNotificationMetadata001, TestSize.Level1)
805 {
806 std::shared_ptr<Asn1Node> notificationMetadata = nullptr;
807 esimFile->LoadBoundProfilePackageParseNotificationMetadata(notificationMetadata);
808 ASSERT_TRUE(esimFile != nullptr);
809 }
810
811 /**
812 * @tc.name: LoadBoundProfilePackageParseProfileInstallResult001
813 * @tc.desc: Test EsimFileTest LoadBoundProfilePackageParseProfileInstallResult.
814 * @tc.type: FUNC
815 */
816 HWTEST_F(EsimFileTest, LoadBoundProfilePackageParseProfileInstallResult001, TestSize.Level1)
817 {
818 std::shared_ptr<Asn1Node> root = nullptr;
819 esimFile->LoadBoundProfilePackageParseProfileInstallResult(root);
820 ASSERT_TRUE(esimFile != nullptr);
821 }
822
823 /**
824 * @tc.name: ProcessListNotificationsDone001
825 * @tc.desc: Test EsimFileTest ProcessListNotificationsDone.
826 * @tc.type: FUNC
827 */
828 HWTEST_F(EsimFileTest, ProcessListNotificationsDone001, TestSize.Level1)
829 {
830 auto event = AppExecFwk::InnerEvent::Get(0);
831 esimFile->ProcessListNotificationsDone(event);
832 event = nullptr;
833 esimFile->ProcessListNotificationsDone(event);
834 ASSERT_TRUE(esimFile != nullptr);
835 }
836
837 /**
838 * @tc.name: ProcessListNotificationsDone002
839 * @tc.desc: Test EsimFileTest ProcessListNotificationsDone.
840 * @tc.type: FUNC
841 */
842 HWTEST_F(EsimFileTest, ProcessListNotificationsDone002, TestSize.Level1)
843 {
844 IccFileData newRecvData;
845 newRecvData.sw1 = 0x61;
846 esimFile->newRecvData_ = newRecvData;
847 std::shared_ptr<IccControllerHolder> holder = nullptr;
848 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
849 rcvMsg->fileData.resultData = "";
850 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
851 esimFile->ProcessListNotificationsDone(event);
852 ASSERT_TRUE(esimFile != nullptr);
853 }
854
855 /**
856 * @tc.name: ProcessListNotificationsDone003
857 * @tc.desc: Test EsimFileTest ProcessListNotificationsDone.
858 * @tc.type: FUNC
859 */
860 HWTEST_F(EsimFileTest, ProcessListNotificationsDone003, TestSize.Level1)
861 {
862 IccFileData newRecvData;
863 newRecvData.sw1 = 0x90;
864 newRecvData.sw2 = 0x00;
865 newRecvData.resultData = "test";
866 esimFile->newRecvData_ = newRecvData;
867 esimFile->recvCombineStr_ = BPP_COMBINE_HEX_STR;
868 std::shared_ptr<IccControllerHolder> holder = nullptr;
869 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
870 rcvMsg->fileData.resultData = "";
871 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
872 esimFile->ProcessListNotificationsDone(event);
873 ASSERT_TRUE(esimFile != nullptr);
874 }
875
876 /**
877 * @tc.name: ProcessRetrieveNotificationDone001
878 * @tc.desc: Test EsimFileTest ProcessRetrieveNotificationDone.
879 * @tc.type: FUNC
880 */
881 HWTEST_F(EsimFileTest, ProcessRetrieveNotificationDone001, TestSize.Level1)
882 {
883 auto event = AppExecFwk::InnerEvent::Get(0);
884 esimFile->ProcessRetrieveNotificationDone(event);
885 event = nullptr;
886 esimFile->ProcessRetrieveNotificationDone(event);
887 ASSERT_TRUE(esimFile != nullptr);
888 }
889
890 /**
891 * @tc.name: ProcessRetrieveNotificationDone002
892 * @tc.desc: Test EsimFileTest ProcessRetrieveNotificationDone.
893 * @tc.type: FUNC
894 */
895 HWTEST_F(EsimFileTest, ProcessRetrieveNotificationDone002, TestSize.Level1)
896 {
897 IccFileData newRecvData;
898 newRecvData.sw1 = 0x61;
899 esimFile->newRecvData_ = newRecvData;
900 std::shared_ptr<IccControllerHolder> holder = nullptr;
901 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
902 rcvMsg->fileData.resultData = "";
903 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
904 esimFile->ProcessRetrieveNotificationDone(event);
905 ASSERT_TRUE(esimFile != nullptr);
906 }
907
908 /**
909 * @tc.name: ProcessRetrieveNotificationDone003
910 * @tc.desc: Test EsimFileTest ProcessRetrieveNotificationDone.
911 * @tc.type: FUNC
912 */
913 HWTEST_F(EsimFileTest, ProcessRetrieveNotificationDone003, TestSize.Level1)
914 {
915 IccFileData newRecvData;
916 newRecvData.sw1 = 0x90;
917 newRecvData.sw2 = 0x00;
918 newRecvData.resultData = "test";
919 esimFile->newRecvData_ = newRecvData;
920 esimFile->recvCombineStr_ = BPP_COMBINE_HEX_STR;
921 std::shared_ptr<IccControllerHolder> holder = nullptr;
922 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
923 rcvMsg->fileData.resultData = "";
924 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
925 esimFile->ProcessRetrieveNotificationDone(event);
926 ASSERT_TRUE(esimFile != nullptr);
927 }
928
929 /**
930 * @tc.name: GetImeiBytes0001
931 * @tc.desc: Test EsimFileTest GetImeiBytes.
932 * @tc.type: FUNC
933 */
934 HWTEST_F(EsimFileTest, GetImeiBytes001, TestSize.Level1)
935 {
936 std::vector<uint8_t> imeiBytes;
937 std::string imei = "";
938 esimFile->GetImeiBytes(imeiBytes, imei);
939 ASSERT_TRUE(esimFile != nullptr);
940 }
941
942 /**
943 * @tc.name: GetImeiBytes0002
944 * @tc.desc: Test EsimFileTest GetImeiBytes.
945 * @tc.type: FUNC
946 */
947 HWTEST_F(EsimFileTest, GetImeiBytes002, TestSize.Level1)
948 {
949 std::vector<uint8_t> imeiBytes;
950 std::string imei(16, '1');
951 esimFile->GetImeiBytes(imeiBytes, imei);
952 ASSERT_TRUE(esimFile != nullptr);
953 }
954
955 /**
956 * @tc.name: GetImeiBytes0003
957 * @tc.desc: Test EsimFileTest GetImeiBytes.
958 * @tc.type: FUNC
959 */
960 HWTEST_F(EsimFileTest, GetImeiBytes003, TestSize.Level1)
961 {
962 std::vector<uint8_t> imeiBytes;
963 std::string imei(20, '1');
964 esimFile->GetImeiBytes(imeiBytes, imei);
965 ASSERT_TRUE(esimFile != nullptr);
966 }
967
968 /**
969 * @tc.name: AddCtxParams10001
970 * @tc.desc: Test EsimFileTest AddCtxParams1.
971 * @tc.type: FUNC
972 */
973 HWTEST_F(EsimFileTest, AddCtxParams1001, TestSize.Level1)
974 {
975 std::shared_ptr<Asn1Builder> ctxParams1Builder = nullptr;
976 Es9PlusInitAuthResp authRespData;
977 esimFile->AddCtxParams1(ctxParams1Builder, authRespData);
978 ASSERT_TRUE(esimFile != nullptr);
979 }
980
981 /**
982 * @tc.name: ProcessObtainEuiccInfo2Done0001
983 * @tc.desc: Test EsimFileTest ProcessObtainEuiccInfo2Done.
984 * @tc.type: FUNC
985 */
986 HWTEST_F(EsimFileTest, ProcessObtainEuiccInfo2Done001, TestSize.Level1)
987 {
988 auto event = AppExecFwk::InnerEvent::Get(0);
989 esimFile->ProcessObtainEuiccInfo2Done(event);
990 event = nullptr;
991 esimFile->ProcessObtainEuiccInfo2Done(event);
992 ASSERT_TRUE(esimFile != nullptr);
993 }
994
995 /**
996 * @tc.name: ProcessObtainEuiccInfo2Done0002
997 * @tc.desc: Test EsimFileTest ProcessObtainEuiccInfo2Done.
998 * @tc.type: FUNC
999 */
1000 HWTEST_F(EsimFileTest, ProcessObtainEuiccInfo2Done002, TestSize.Level1)
1001 {
1002 IccFileData newRecvData;
1003 newRecvData.sw1 = 0x61;
1004 esimFile->newRecvData_ = newRecvData;
1005 std::shared_ptr<IccControllerHolder> holder = nullptr;
1006 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
1007 rcvMsg->fileData.resultData = "";
1008 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
1009 esimFile->ProcessObtainEuiccInfo2Done(event);
1010 ASSERT_TRUE(esimFile != nullptr);
1011 }
1012
1013 /**
1014 * @tc.name: ProcessObtainEuiccInfo2Done0003
1015 * @tc.desc: Test EsimFileTest ProcessObtainEuiccInfo2Done.
1016 * @tc.type: FUNC
1017 */
1018 HWTEST_F(EsimFileTest, ProcessObtainEuiccInfo2Done003, TestSize.Level1)
1019 {
1020 IccFileData newRecvData;
1021 newRecvData.sw1 = 0x90;
1022 newRecvData.sw2 = 0x00;
1023 newRecvData.resultData = "test";
1024 esimFile->newRecvData_ = newRecvData;
1025 esimFile->recvCombineStr_ = BPP_COMBINE_HEX_STR;
1026 std::shared_ptr<IccControllerHolder> holder = nullptr;
1027 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
1028 rcvMsg->fileData.resultData = "";
1029 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
1030 esimFile->ProcessObtainEuiccInfo2Done(event);
1031 ASSERT_TRUE(esimFile != nullptr);
1032 }
1033
1034 /**
1035 * @tc.name: ProcessObtainEuiccInfo2Done0004
1036 * @tc.desc: Test EsimFileTest ProcessObtainEuiccInfo2Done.
1037 * @tc.type: FUNC
1038 */
1039 HWTEST_F(EsimFileTest, ProcessObtainEuiccInfo2Done004, TestSize.Level1)
1040 {
1041 IccFileData newRecvData;
1042 newRecvData.sw1 = 0x90;
1043 newRecvData.sw2 = 0x00;
1044 newRecvData.resultData = "";
1045 esimFile->newRecvData_ = newRecvData;
1046 esimFile->recvCombineStr_ = BPP_COMBINE_HEX_STR;
1047 std::shared_ptr<IccControllerHolder> holder = nullptr;
1048 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
1049 rcvMsg->fileData.resultData = "";
1050 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
1051 esimFile->ProcessObtainEuiccInfo2Done(event);
1052 ASSERT_TRUE(esimFile != nullptr);
1053 }
1054
1055 HWTEST_F(EsimFileTest, ObtainChannelSuccessAlllowSameAidReuse0001, TestSize.Level1)
1056 {
1057 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(nullptr);
1058 esimFile->aidStr_ = u"testAid";
1059 std::u16string testAid = u"testAid1";
1060 auto ret = esimFile->ObtainChannelSuccessAlllowSameAidReuse(testAid);
1061 EXPECT_EQ(ret, ResultInnerCode::RESULT_EUICC_CARD_CHANNEL_OTHER_AID);
1062 }
1063
1064 HWTEST_F(EsimFileTest, SyncCloseChannel0001, TestSize.Level1)
1065 {
1066 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(nullptr);
1067 esimFile->currentChannelId_.store(2);
1068 esimFile->telRilManager_ = nullptr;
1069 esimFile->SyncCloseChannel();
1070 EXPECT_EQ(esimFile->currentChannelId_.load(), 0);
1071 }
1072
1073 HWTEST_F(EsimFileTest, RealProcessRequestAllProfilesDone001, TestSize.Level1)
1074 {
1075 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1076 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1077 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1078 EXPECT_FALSE(esimFile->RealProcessRequestAllProfilesDone());
1079 }
1080
1081 HWTEST_F(EsimFileTest, RealProcessRequestAllProfilesDone002, TestSize.Level1)
1082 {
1083 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1084 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1085 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1086 esimFile->recvCombineStr_ = "bf2d820000";
1087 EXPECT_FALSE(esimFile->RealProcessRequestAllProfilesDone());
1088 }
1089
1090 HWTEST_F(EsimFileTest, RealProcessRequestAllProfilesDone003, TestSize.Level1)
1091 {
1092 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1093 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1094 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1095 esimFile->recvCombineStr_ = "BF2D14A012E3105A0A896700000000004523019F700101";
1096 EXPECT_TRUE(esimFile->RealProcessRequestAllProfilesDone());
1097 }
1098
1099 HWTEST_F(EsimFileTest, RealProcessRequestAllProfilesDone004, TestSize.Level1)
1100 {
1101 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1102 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1103 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1104 esimFile->recvCombineStr_ = "BF2D14A012E3105B0A896700000000004523019F700101";
1105 EXPECT_TRUE(esimFile->RealProcessRequestAllProfilesDone());
1106 }
1107
1108 HWTEST_F(EsimFileTest, RealProcessAuthenticateServerDone001, TestSize.Level1)
1109 {
1110 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1111 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1112 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1113 EXPECT_FALSE(esimFile->RealProcessAuthenticateServerDone());
1114 }
1115
1116 HWTEST_F(EsimFileTest, RealProcessAuthenticateServerDone002, TestSize.Level1)
1117 {
1118 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1119 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1120 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1121 esimFile->recvCombineStr_ = "BF3706A10480000200009000";
1122 EXPECT_FALSE(esimFile->RealProcessAuthenticateServerDone());
1123 }
1124
1125 HWTEST_F(EsimFileTest, RealProcessAuthenticateServerDone003, TestSize.Level1)
1126 {
1127 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1128 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1129 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1130 esimFile->recvCombineStr_ = "BF3706A10480000200009000";
1131 EXPECT_FALSE(esimFile->RealProcessAuthenticateServerDone());
1132 }
1133
1134 HWTEST_F(EsimFileTest, RealProcessAuthenticateServerDone004, TestSize.Level1)
1135 {
1136 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1137 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1138 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1139 esimFile->recvCombineStr_ = "bf38820019a18200158010d26989bcf14248379c55bb75c9569186020101";
1140 EXPECT_TRUE(esimFile->RealProcessAuthenticateServerDone());
1141 }
1142
1143 HWTEST_F(EsimFileTest, RealProcessAuthenticateServerDone005, TestSize.Level1)
1144 {
1145 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1146 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1147 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1148 esimFile->recvCombineStr_ = "bf3882000aa1820006800000020000";
1149 EXPECT_FALSE(esimFile->RealProcessAuthenticateServerDone());
1150 }
1151
1152 HWTEST_F(EsimFileTest, RealProcessAuthenticateServerDone006, TestSize.Level1)
1153 {
1154 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1155 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1156 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1157 esimFile->recvCombineStr_ = "bf3882000aa0820006800000020000";
1158 EXPECT_TRUE(esimFile->RealProcessAuthenticateServerDone());
1159 }
1160
1161 HWTEST_F(EsimFileTest, ProcessEsimCloseSpareChannel0001, TestSize.Level1)
1162 {
1163 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1164 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1165 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1166 esimFile->telRilManager_ = telRilManager;
1167 esimFile->ProcessEsimCloseSpareChannel();
1168 EXPECT_EQ(esimFile->currentChannelId_.load(), 0);
1169 }
1170
1171 HWTEST_F(EsimFileTest, CommMergeRecvData001, TestSize.Level1)
1172 {
1173 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1174 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1175 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1176 std::mutex mtx;
1177 bool lag = false;
1178 std::condition_variable cv;
1179 int32_t eventId = 0;
1180 bool isHandleFinish = false;
1181 IccFileData newRecvData;
1182 newRecvData.sw1 = 0x90;
1183 newRecvData.sw2 = 0x00;
1184 esimFile->newRecvData_ = newRecvData;
1185 EXPECT_TRUE(esimFile->CommMergeRecvData(mtx, lag, cv, eventId, isHandleFinish));
1186 }
1187
1188 HWTEST_F(EsimFileTest, CommMergeRecvData002, TestSize.Level1)
1189 {
1190 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1191 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1192 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1193 std::mutex mtx;
1194 bool lag = false;
1195 std::condition_variable cv;
1196 int32_t eventId = 0;
1197 bool isHandleFinish = false;
1198 IccFileData newRecvData;
1199 newRecvData.sw1 = 0x90;
1200 newRecvData.sw2 = 0x00;
1201 newRecvData.resultData = "test";
1202 esimFile->newRecvData_ = newRecvData;
1203 EXPECT_FALSE(esimFile->CommMergeRecvData(mtx, lag, cv, eventId, isHandleFinish));
1204 }
1205
1206 HWTEST_F(EsimFileTest, CommMergeRecvData003, TestSize.Level1)
1207 {
1208 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1209 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1210 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1211 std::mutex mtx;
1212 bool lag = false;
1213 std::condition_variable cv;
1214 int32_t eventId = 0;
1215 bool isHandleFinish = false;
1216 IccFileData newRecvData;
1217 newRecvData.sw1 = 0x61;
1218 esimFile->newRecvData_ = newRecvData;
1219 EXPECT_TRUE(esimFile->CommMergeRecvData(mtx, lag, cv, eventId, isHandleFinish));
1220 }
1221
1222 HWTEST_F(EsimFileTest, RealProcessPrepareDownloadDone0001, TestSize.Level1)
1223 {
1224 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1225 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1226 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1227 esimFile->recvCombineStr_ = "bf21820019a18200158010d26989bcf14248379c55bb75c9569186020101";
1228 EXPECT_FALSE(esimFile->RealProcessPrepareDownloadDone());
1229 }
1230
1231 HWTEST_F(EsimFileTest, RealProcessPrepareDownloadDone002, TestSize.Level1)
1232 {
1233 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1234 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1235 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1236 esimFile->recvCombineStr_ = "bf21820019a18200158010d26989bcf14248379c55bb75c9569186020100";
1237 EXPECT_TRUE(esimFile->RealProcessPrepareDownloadDone());
1238 }
1239
1240 HWTEST_F(EsimFileTest, RealProcessPrepareDownloadDone003, TestSize.Level1)
1241 {
1242 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1243 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1244 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1245 esimFile->recvCombineStr_ = "bf21820019a08200158010d26989bcf14248379c55bb75c9569186020101";
1246 EXPECT_TRUE(esimFile->RealProcessPrepareDownloadDone());
1247 }
1248
1249 HWTEST_F(EsimFileTest, RealProcessPrepareDownloadDone004, TestSize.Level1)
1250 {
1251 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1252 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1253 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1254 esimFile->recvCombineStr_ = "bf21820016a18200128010d26989bcf14248379c55bb75c9569186";
1255 EXPECT_TRUE(esimFile->RealProcessPrepareDownloadDone());
1256 }
1257
1258 HWTEST_F(EsimFileTest, RealProcessLoadBoundProfilePackageDone001, TestSize.Level1)
1259 {
1260 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1261 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1262 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1263 esimFile->recvCombineStr_ = "BF370ABF2807A205A1038101039000";
1264 EXPECT_FALSE(esimFile->RealProcessLoadBoundProfilePackageDone());
1265 }
1266
1267 HWTEST_F(EsimFileTest, RealProcessLoadBoundProfilePackageDone002, TestSize.Level1)
1268 {
1269 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1270 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1271 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1272 esimFile->recvCombineStr_ = "BF370ABF2707A205A1038101039000";
1273 EXPECT_FALSE(esimFile->RealProcessLoadBoundProfilePackageDone());
1274 }
1275
1276 HWTEST_F(EsimFileTest, RealProcessLoadBoundProfilePackageDone003, TestSize.Level1)
1277 {
1278 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1279 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1280 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1281 esimFile->recvCombineStr_ = "BF3709BF2706A304A10281009000";
1282 EXPECT_FALSE(esimFile->RealProcessLoadBoundProfilePackageDone());
1283 }
1284
1285 HWTEST_F(EsimFileTest, RealProcessLoadBoundProfilePackageDone004, TestSize.Level1)
1286 {
1287 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1288 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1289 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1290 esimFile->recvCombineStr_ = "BF2709BF2706BF2F03820101";
1291 EXPECT_FALSE(esimFile->RealProcessLoadBoundProfilePackageDone());
1292 }
1293
1294 HWTEST_F(EsimFileTest, RealProcessLoadBoundProfilePackageDone005, TestSize.Level1)
1295 {
1296 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1297 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1298 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1299 esimFile->recvCombineStr_ = "BF2709BF2706BF2F03800101";
1300 EXPECT_FALSE(esimFile->RealProcessLoadBoundProfilePackageDone());
1301 }
1302
1303 HWTEST_F(EsimFileTest, RealProcessLoadBoundProfilePackageDone006, TestSize.Level1)
1304 {
1305 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1306 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1307 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1308 esimFile->recvCombineStr_ = "BF270CBF2709BF2F06800101810101";
1309 EXPECT_FALSE(esimFile->RealProcessLoadBoundProfilePackageDone());
1310 }
1311
1312 HWTEST_F(EsimFileTest, RealProcessLoadBoundProfilePackageDone007, TestSize.Level1)
1313 {
1314 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1315 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1316 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1317 esimFile->recvCombineStr_ = "BF2712BF270FBF2F0C8001018101010C01005A0100";
1318 EXPECT_TRUE(esimFile->RealProcessLoadBoundProfilePackageDone());
1319 }
1320
1321 HWTEST_F(EsimFileTest, RealProcessLoadBoundProfilePackageDone008, TestSize.Level1)
1322 {
1323 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1324 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1325 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1326 esimFile->recvCombineStr_ = "BF270FBF270CBF2F098001018101010C0100";
1327 EXPECT_FALSE(esimFile->RealProcessLoadBoundProfilePackageDone());
1328 }
1329
1330 HWTEST_F(EsimFileTest, ProcessListNotificationsDone004, TestSize.Level1)
1331 {
1332 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1333 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1334 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1335 IccFileData newRecvData;
1336 newRecvData.sw1 = 0x90;
1337 newRecvData.sw2 = 0x00;
1338 newRecvData.resultData = "BF2717800100A012BF270FBF2F0C8001018101010C01005A0100";
1339 esimFile->newRecvData_ = newRecvData;
1340 std::shared_ptr<IccControllerHolder> holder = nullptr;
1341 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
1342 rcvMsg->fileData = newRecvData;
1343 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
1344 EXPECT_TRUE(esimFile->ProcessListNotificationsDone(event));
1345 }
1346
1347 HWTEST_F(EsimFileTest, ProcessListNotificationsDone005, TestSize.Level1)
1348 {
1349 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1350 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1351 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1352 IccFileData newRecvData;
1353 newRecvData.sw1 = 0x90;
1354 newRecvData.sw2 = 0x00;
1355 newRecvData.resultData = "BF2717800100A112BF270FBF2F0C8001018101010C01005A0100";
1356 esimFile->newRecvData_ = newRecvData;
1357 std::shared_ptr<IccControllerHolder> holder = nullptr;
1358 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
1359 rcvMsg->fileData = newRecvData;
1360 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
1361 EXPECT_FALSE(esimFile->ProcessListNotificationsDone(event));
1362 }
1363
1364 HWTEST_F(EsimFileTest, ProcessListNotificationsDone006, TestSize.Level1)
1365 {
1366 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1367 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1368 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1369 IccFileData newRecvData;
1370 newRecvData.sw1 = 0x90;
1371 newRecvData.sw2 = 0x00;
1372 newRecvData.resultData = "00";
1373 esimFile->newRecvData_ = newRecvData;
1374 std::shared_ptr<IccControllerHolder> holder = nullptr;
1375 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
1376 rcvMsg->fileData = newRecvData;
1377 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
1378 EXPECT_FALSE(esimFile->ProcessListNotificationsDone(event));
1379 }
1380
1381 HWTEST_F(EsimFileTest, ProcessRetrieveNotificationDone004, TestSize.Level1)
1382 {
1383 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1384 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1385 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1386 IccFileData newRecvData;
1387 newRecvData.sw1 = 0x90;
1388 newRecvData.sw2 = 0x00;
1389 newRecvData.resultData = "00";
1390 esimFile->newRecvData_ = newRecvData;
1391 std::shared_ptr<IccControllerHolder> holder = nullptr;
1392 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
1393 rcvMsg->fileData = newRecvData;
1394 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
1395 EXPECT_FALSE(esimFile->ProcessRetrieveNotificationDone(event));
1396 }
1397
1398 HWTEST_F(EsimFileTest, ProcessRetrieveNotificationDone005, TestSize.Level1)
1399 {
1400 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1401 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1402 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1403 IccFileData newRecvData;
1404 newRecvData.sw1 = 0x90;
1405 newRecvData.sw2 = 0x00;
1406 newRecvData.resultData = "BF2717800100A112BF270FBF2F0C8001018101010C01005A0100";
1407 esimFile->newRecvData_ = newRecvData;
1408 std::shared_ptr<IccControllerHolder> holder = nullptr;
1409 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
1410 rcvMsg->fileData = newRecvData;
1411 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
1412 EXPECT_FALSE(esimFile->ProcessRetrieveNotificationDone(event));
1413 }
1414
1415 HWTEST_F(EsimFileTest, ProcessRetrieveNotificationDone006, TestSize.Level1)
1416 {
1417 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1418 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1419 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1420 IccFileData newRecvData;
1421 newRecvData.sw1 = 0x90;
1422 newRecvData.sw2 = 0x00;
1423 newRecvData.resultData = "BF2717800100A012BF370FBF370C8001018101010C01005A0100";
1424 esimFile->newRecvData_ = newRecvData;
1425 std::shared_ptr<IccControllerHolder> holder = nullptr;
1426 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
1427 rcvMsg->fileData = newRecvData;
1428 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
1429 EXPECT_TRUE(esimFile->ProcessRetrieveNotificationDone(event));
1430 }
1431
1432 HWTEST_F(EsimFileTest, ProcessRetrieveNotificationDone007, TestSize.Level1)
1433 {
1434 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1435 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1436 std::shared_ptr<Telephony::EsimFile> esimFile = std::make_shared<EsimFile>(telRilManager);
1437 IccFileData newRecvData;
1438 newRecvData.sw1 = 0x90;
1439 newRecvData.sw2 = 0x00;
1440 newRecvData.resultData = "BF2717800100A012BF270FBF360C8001018101010C01005A0100";
1441 esimFile->newRecvData_ = newRecvData;
1442 std::shared_ptr<IccControllerHolder> holder = nullptr;
1443 std::unique_ptr<Telephony::IccFromRilMsg> rcvMsg = std::make_unique<Telephony::IccFromRilMsg>(holder);
1444 rcvMsg->fileData = newRecvData;
1445 auto event = AppExecFwk::InnerEvent::Get(0, rcvMsg);
1446 EXPECT_FALSE(esimFile->ProcessRetrieveNotificationDone(event));
1447 }
1448 }
1449 }
1450 }
1451