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 #define private public
16 #define protected public
17 #include <gtest/gtest.h>
18 #include <string_ex.h>
19 
20 #include "core_manager_inner.h"
21 #include "core_service.h"
22 #include "icc_dialling_numbers_handler.h"
23 #include "icc_dialling_numbers_manager.h"
24 #include "icc_file_controller.h"
25 #include "icc_operator_privilege_controller.h"
26 #include "mcc_pool.h"
27 #include "operator_config_cache.h"
28 #include "operator_config_loader.h"
29 #include "parcel.h"
30 #include "plmn_file.h"
31 #include "sim_account_manager.h"
32 #include "sim_data_type.h"
33 #include "sim_file_controller.h"
34 #include "sim_manager.h"
35 #include "sim_rdb_helper.h"
36 #include "sim_sms_manager.h"
37 #include "telephony_ext_wrapper.h"
38 #include "telephony_log_wrapper.h"
39 #include "usim_dialling_numbers_service.h"
40 #include "want.h"
41 #include "sim_constant.h"
42 
43 namespace OHOS {
44 namespace Telephony {
45 using namespace testing::ext;
46 
47 namespace {
48 constexpr int32_t SLOT_ID = 0;
49 constexpr int INVALID_MCC = 100;
50 const int32_t INVALID_SLOTID = -1;
51 } // namespace
52 
53 class DemoHandler : public AppExecFwk::EventHandler {
54 public:
DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> & runner)55     explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &runner) : AppExecFwk::EventHandler(runner) {}
~DemoHandler()56     virtual ~DemoHandler() {}
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)57     void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
58 };
59 
60 class SimRilBranchTest : public testing::Test {
61 public:
62     static void SetUpTestCase();
63     static void TearDownTestCase();
64     void SetUp();
65     void TearDown();
66 };
SetUpTestCase()67 void SimRilBranchTest::SetUpTestCase() {}
68 
TearDownTestCase()69 void SimRilBranchTest::TearDownTestCase() {}
70 
SetUp()71 void SimRilBranchTest::SetUp() {}
72 
TearDown()73 void SimRilBranchTest::TearDown() {}
74 
75 /**
76  * @tc.number   Telephony_IccOperatorPrivilegeController_001
77  * @tc.name     test error branch
78  * @tc.desc     Function test
79  */
80 HWTEST_F(SimRilBranchTest, Telephony_IccOperatorPrivilegeController_001, Function | MediumTest | Level1)
81 {
82     auto telRilManager = std::make_shared<TelRilManager>();
83     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
84     auto iccOperatorPrivilegeController =
85         std::make_shared<IccOperatorPrivilegeController>(telRilManager, simStateManager);
86     auto iccOperatorPrivilegeController2 = std::make_shared<IccOperatorPrivilegeController>(nullptr, simStateManager);
87     auto iccOperatorPrivilegeController3 = std::make_shared<IccOperatorPrivilegeController>(telRilManager, nullptr);
88     iccOperatorPrivilegeController->Init(0);
89     iccOperatorPrivilegeController2->Init(0);
90     iccOperatorPrivilegeController3->Init(0);
91     int slotId = 2;
92     iccOperatorPrivilegeController->Init(slotId);
93     std::shared_ptr<AppExecFwk::EventHandler> handler;
94     bool hasOperatorPrivileges = false;
95     AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(1, 1);
96     event = nullptr;
97     iccOperatorPrivilegeController->ProcessEvent(event);
98     iccOperatorPrivilegeController->ProcessEvent(AppExecFwk::InnerEvent::Get(-1));
99     constexpr std::string_view certHash = " test ";
100     constexpr std::string_view packageName = "  ";
101     iccOperatorPrivilegeController->HasOperatorPrivileges(certHash, packageName, hasOperatorPrivileges);
102     iccOperatorPrivilegeController->ProcessEvent(AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_CHANGE));
103     iccOperatorPrivilegeController->ProcessEvent(
104         AppExecFwk::InnerEvent::Get(IccOperatorPrivilegeController::MSG_OPEN_LOGICAL_CHANNEL_DONE, 1));
105     auto resultPtr = std::make_shared<OpenLogicalChannelResponse>();
106     resultPtr->channelId = 0;
107     iccOperatorPrivilegeController->ProcessEvent(
108         AppExecFwk::InnerEvent::Get(IccOperatorPrivilegeController::MSG_OPEN_LOGICAL_CHANNEL_DONE, resultPtr));
109     resultPtr->channelId = 1;
110     iccOperatorPrivilegeController->ProcessEvent(
111         AppExecFwk::InnerEvent::Get(IccOperatorPrivilegeController::MSG_OPEN_LOGICAL_CHANNEL_DONE, resultPtr));
112     iccOperatorPrivilegeController->ProcessEvent(
113         AppExecFwk::InnerEvent::Get(IccOperatorPrivilegeController::MSG_TRANSMIT_LOGICAL_CHANNEL_DONE, 1));
114     auto resultPtr1 = std::make_shared<IccIoResultInfo>();
115     iccOperatorPrivilegeController->ProcessEvent(
116         AppExecFwk::InnerEvent::Get(IccOperatorPrivilegeController::MSG_TRANSMIT_LOGICAL_CHANNEL_DONE, resultPtr1));
117     iccOperatorPrivilegeController->ProcessEvent(
118         AppExecFwk::InnerEvent::Get(IccOperatorPrivilegeController::MSG_CLOSE_LOGICAL_CHANNEL_DONE));
119     iccOperatorPrivilegeController->OpenChannel();
120     EXPECT_GT(iccOperatorPrivilegeController->HasOperatorPrivileges(hasOperatorPrivileges), TELEPHONY_ERR_SUCCESS);
121 }
122 
123 /**
124  * @tc.number   Telephony_SimAccountManager_001
125  * @tc.name     test error branch
126  * @tc.desc     Function test
127  */
128 HWTEST_F(SimRilBranchTest, Telephony_SimAccountManager_001, Function | MediumTest | Level1)
129 {
130     auto telRilManager = std::make_shared<TelRilManager>();
131     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
132     EventFwk::MatchingSkills matchingSkills;
133     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
134     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
135     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
136     auto simAccountManager = std::make_shared<SimAccountManager>(telRilManager, simStateManager, simFileManager);
137     simAccountManager->Init(0);
138     simAccountManager->Init(-1);
139     auto simAccountManager1 = std::make_shared<SimAccountManager>(nullptr, simStateManager, simFileManager);
140     simAccountManager1->Init(0);
141     OperatorConfig operatorConfig;
142     simAccountManager->GetOperatorConfigs(0, operatorConfig);
143     simAccountManager->operatorConfigCache_ = nullptr;
144     EXPECT_GE(simAccountManager->GetOperatorConfigs(0, operatorConfig), TELEPHONY_ERR_SUCCESS);
145     int32_t errorId = -2;
146     EXPECT_FALSE(simAccountManager->IsValidSlotIdForDefault(errorId));
147     EXPECT_TRUE(simAccountManager->IsValidSlotIdForDefault(0));
148     bool hasOperatorPrivileges = false;
149     simAccountManager->HasOperatorPrivileges(0, hasOperatorPrivileges);
150     simAccountManager->privilegeController_ = nullptr;
151     simAccountManager->HasOperatorPrivileges(0, hasOperatorPrivileges);
152     simAccountManager->telRilManager_ = nullptr;
153     EXPECT_GE(simAccountManager->HasOperatorPrivileges(0, hasOperatorPrivileges), TELEPHONY_ERR_SUCCESS);
154     simAccountManager->privilegesRunner_ = nullptr;
155     EXPECT_GE(simAccountManager->HasOperatorPrivileges(0, hasOperatorPrivileges), TELEPHONY_ERR_SUCCESS);
156 }
157 
158 /**
159  * @tc.number   Telephony_OperatorConfigLoader_001
160  * @tc.name     test error branch
161  * @tc.desc     Function test
162  */
163 HWTEST_F(SimRilBranchTest, Telephony_OperatorConfigLoader_001, Function | MediumTest | Level1)
164 {
165     auto telRilManager = std::make_shared<TelRilManager>();
166     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
167     EventFwk::MatchingSkills matchingSkills;
168     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
169     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
170     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
171     auto operatorConfigCache = std::make_shared<OperatorConfigCache>(simFileManager, 0);
172     auto operatorConfigLoader = std::make_shared<OperatorConfigLoader>(simFileManager, operatorConfigCache);
173     operatorConfigLoader->LoadOperatorConfig(0);
174     operatorConfigLoader->operatorConfigCache_ = nullptr;
175     operatorConfigLoader->LoadOperatorConfig(0);
176     operatorConfigLoader->LoadOpKeyOnMccMnc(0);
177     simFileManager = nullptr;
178     operatorConfigLoader->simFileManager_ = simFileManager;
179     EXPECT_EQ(operatorConfigLoader->LoadOpKeyOnMccMnc(0), DEFAULT_OPERATOR_KEY);
180     EXPECT_EQ(operatorConfigLoader->GetOpKey(nullptr, 0), DEFAULT_OPERATOR_KEY);
181     std::shared_ptr<DataShare::DataShareResultSet> resultSet = nullptr;
182     EXPECT_FALSE(operatorConfigLoader->MatchOperatorRule(resultSet, 0));
183 }
184 
185 /**
186  * @tc.number   Telephony_StkManager_001
187  * @tc.name     test error branch
188  * @tc.desc     Function test
189  */
190 HWTEST_F(SimRilBranchTest, Telephony_StkManager_001, Function | MediumTest | Level1)
191 {
192     auto telRilManager = std::make_shared<TelRilManager>();
193     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
194     std::string cmd = "";
195     auto stkManager = std::make_shared<StkManager>(nullptr, simStateManager);
196     stkManager->Init(0);
197     stkManager->stkController_ = nullptr;
198     EXPECT_EQ(stkManager->SendEnvelopeCmd(0, cmd), TELEPHONY_ERR_LOCAL_PTR_NULL);
199     EXPECT_EQ(stkManager->SendTerminalResponseCmd(0, cmd), TELEPHONY_ERR_LOCAL_PTR_NULL);
200     EXPECT_EQ(stkManager->SendCallSetupRequestResult(0, false), TELEPHONY_ERR_LOCAL_PTR_NULL);
201 }
202 
203 /**
204  * @tc.number   Telephony_StkController_002
205  * @tc.name     test error branch
206  * @tc.desc     Function test
207  */
208 HWTEST_F(SimRilBranchTest, Telephony_StkController_002, Function | MediumTest | Level1)
209 {
210     std::string name = "StkController_";
211     AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_CALL_SETUP, 1);
212     std::shared_ptr<TelRilManager> telRilManager = nullptr;
213     std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
214     auto stkController = std::make_shared<StkController>(telRilManager, simStateManager, INVALID_SLOTID);
215     std::string bundleNameEmpty = "";
216     std::string bundleName = "123";
217     EXPECT_FALSE(stkController->CheckIsSystemApp(bundleNameEmpty));
218     EXPECT_FALSE(stkController->CheckIsSystemApp(bundleName));
219     AAFwk::Want want;
220     EXPECT_FALSE(stkController->PublishStkEvent(want));
221 }
222 
223 /**
224  * @tc.number   Telephony_SimStateTracker_001
225  * @tc.name     test error branch
226  * @tc.desc     Function test
227  */
228 HWTEST_F(SimRilBranchTest, Telephony_SimStateTracker_001, Function | MediumTest | Level1)
229 {
230     auto telRilManager = std::make_shared<TelRilManager>();
231     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
232     EventFwk::MatchingSkills matchingSkills;
233     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
234     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
235     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
236     auto operatorConfigCache = std::make_shared<OperatorConfigCache>(simFileManager, 0);
237     auto simStateTracker =
238         std::make_shared<SimStateTracker>(simFileManager, operatorConfigCache, 0);
239     AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(1, 1);
240     event = nullptr;
241     simStateTracker->ProcessEvent(event);
242     simFileManager = nullptr;
243     simStateTracker->simFileManager_ = simFileManager;
244     std::shared_ptr<OperatorConfigLoader> operatorConfigLoader_ = nullptr;
245     auto statusChangeListener_ =
246         new (std::nothrow) SimStateTracker::SystemAbilityStatusChangeListener(0, operatorConfigLoader_);
247     statusChangeListener_->OnAddSystemAbility(0, "test");
248     EXPECT_FALSE(simStateTracker->RegisterForIccLoaded());
249     EXPECT_FALSE(simStateTracker->UnRegisterForIccLoaded());
250 }
251 
252 /**
253  * @tc.number   Telephony_PlmnFile_001
254  * @tc.name     test error branch
255  * @tc.desc     Function test
256  */
257 HWTEST_F(SimRilBranchTest, Telephony_PlmnFile_001, Function | MediumTest | Level1)
258 {
259     std::string plmn = "plmntest";
260     int32_t accessTechs = 8;
261     Parcel parcel;
262     auto plmnFile = std::make_shared<PlmnFile>(plmn, accessTechs);
263     plmnFile->Marshalling(parcel);
264     EXPECT_TRUE(plmnFile->ReadFromParcel(parcel));
265 }
266 
267 /**
268  * @tc.number   Telephony_IccDiallingNumbersCache_001
269  * @tc.name     test error branch
270  * @tc.desc     Function test
271  */
272 HWTEST_F(SimRilBranchTest, Telephony_IccDiallingNumbersCache_001, Function | MediumTest | Level1)
273 {
274     auto telRilManager = std::make_shared<TelRilManager>();
275     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
276     EventFwk::MatchingSkills matchingSkills;
277     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
278 
279     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
280     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
281     auto diallingNumbersCache = std::make_shared<IccDiallingNumbersCache>(simFileManager);
282     diallingNumbersCache->simFileManager_ = nullptr;
283     diallingNumbersCache->Init();
284     AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(1, 1);
285     event = nullptr;
286     diallingNumbersCache->SendExceptionResult(event, 0);
287     diallingNumbersCache->ProcessEvent(event);
288     diallingNumbersCache->ProcessEvent(AppExecFwk::InnerEvent::Get(MSG_SIM_OBTAIN_ADN_DETAILS_DONE, 1));
289     diallingNumbersCache->ProcessEvent(AppExecFwk::InnerEvent::Get(MSG_SIM_CHANGE_DIALLING_NUMBERS_DONE, 1));
290     diallingNumbersCache->ProcessEvent(AppExecFwk::InnerEvent::Get(MSG_SIM_OBTAIN_PBR_DETAILS_DONE, 1));
291     diallingNumbersCache->Init();
292     diallingNumbersCache->ClearDiallingNumberCache();
293     std::shared_ptr<DiallingNumbersInfo> telNumber = std::make_shared<DiallingNumbersInfo>();
294     telNumber = nullptr;
295     EXPECT_FALSE(diallingNumbersCache->IsDiallingNumberEqual(telNumber, telNumber));
296 }
297 
298 /**
299  * @tc.number   Telephony_IccDiallingNumbersCache_002
300  * @tc.name     test error branch
301  * @tc.desc     Function test
302  */
303 HWTEST_F(SimRilBranchTest, Telephony_IccDiallingNumbersCache_002, Function | MediumTest | Level1)
304 {
305     auto telRilManager = std::make_shared<TelRilManager>();
306     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
307     EventFwk::MatchingSkills matchingSkills;
308     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
309     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
310     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
311     auto diallingNumbersCache = std::make_shared<IccDiallingNumbersCache>(simFileManager);
312     auto iccDiallingNumbersManager = IccDiallingNumbersManager::CreateInstance(simFileManager, simStateManager);
313     diallingNumbersCache->simFileManager_ = nullptr;
314     diallingNumbersCache->Init();
315     diallingNumbersCache->ProcessEvent(AppExecFwk::InnerEvent::Get(6, 1));
316     auto caller = iccDiallingNumbersManager->BuildCallerInfo(-1);
317     AppExecFwk::InnerEvent::Pointer event = diallingNumbersCache->CreateUsimPointer(-1, ELEMENTARY_FILE_PBR, caller);
318     std::unique_ptr<UsimFetcher> fd = event->GetUniqueObject<UsimFetcher>();
319     std::unique_ptr<UsimResult> data = std::make_unique<UsimResult>(fd.get());
320     std::shared_ptr<std::vector<std::shared_ptr<DiallingNumbersInfo>>> list =
321         std::make_shared<std::vector<std::shared_ptr<DiallingNumbersInfo>>>();
322     std::shared_ptr<void> object = nullptr;
323     diallingNumbersCache->SendBackResult(event, list, object);
324     diallingNumbersCache->SendUpdateResult(event, object);
325     data->result = static_cast<std::shared_ptr<void>>(list);
326     auto owner = event->GetOwner();
327     int eventParam = 0;
328     AppExecFwk::InnerEvent::Pointer response = AppExecFwk::InnerEvent::Get(-1, data, eventParam);
329     diallingNumbersCache->ProcessObtainPbrDetailsDone(response);
330     diallingNumbersCache->ProcessObtainAdnDetailsDone(response);
331     diallingNumbersCache->ProcessChangeDiallingNumbersDone(response);
332     diallingNumbersCache->LoadReadyDiallingNumbers(ELEMENTARY_FILE_ADN);
333     diallingNumbersCache->ExtendedElementFile(ELEMENTARY_FILE_ADN);
334     std::u16string str1(u"Hello");
335     std::u16string str2(u"world");
336     EXPECT_FALSE(diallingNumbersCache->StringEqual(str1, str2));
337 }
338 
339 /**
340  * @tc.number   Telephony_IccDiallingNumbersCache_003
341  * @tc.name     test error branch
342  * @tc.desc     Function test
343  */
344 HWTEST_F(SimRilBranchTest, Telephony_IccDiallingNumbersCache_003, Function | MediumTest | Level1)
345 {
346     auto telRilManager = std::make_shared<TelRilManager>();
347     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
348     EventFwk::MatchingSkills matchingSkills;
349     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
350     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
351     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
352     auto diallingNumbersCache = std::make_shared<IccDiallingNumbersCache>(simFileManager);
353     auto iccDiallingNumbersManager = IccDiallingNumbersManager::CreateInstance(simFileManager, simStateManager);
354     diallingNumbersCache->simFileManager_ = nullptr;
355     diallingNumbersCache->Init();
356     std::shared_ptr<DiallingNumbersInfo> diallingNumbers = std::make_shared<DiallingNumbersInfo>();
357     AppExecFwk::InnerEvent::Pointer event = iccDiallingNumbersManager->BuildCallerInfo(-1);
358     diallingNumbersCache->UpdateDiallingNumberToIcc(ELEMENTARY_FILE_ADN, diallingNumbers, 0, true, event);
359     std::u16string str1(u"Hello");
360     EXPECT_TRUE(diallingNumbersCache->StringEqual(str1, str1));
361 }
362 
363 /**
364  * @tc.number   Telephony_IccDiallingNumbersCache_004
365  * @tc.name     test error branch
366  * @tc.desc     Function test
367  */
368 HWTEST_F(SimRilBranchTest, Telephony_IccDiallingNumbersCache_004, Function | MediumTest | Level1)
369 {
370     auto telRilManager = std::make_shared<TelRilManager>();
371     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
372     EventFwk::MatchingSkills matchingSkills;
373     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
374     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
375     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
376     auto diallingNumbersCache = std::make_shared<IccDiallingNumbersCache>(simFileManager);
377     auto iccDiallingNumbersManager = IccDiallingNumbersManager::CreateInstance(simFileManager, simStateManager);
378     diallingNumbersCache->simFileManager_ = nullptr;
379     diallingNumbersCache->Init();
380     auto caller = iccDiallingNumbersManager->BuildCallerInfo(-1);
381     AppExecFwk::InnerEvent::Pointer event = diallingNumbersCache->CreateUsimPointer(-1, ELEMENTARY_FILE_PBR, caller);
382     std::unique_ptr<UsimFetcher> fd = event->GetUniqueObject<UsimFetcher>();
383     std::unique_ptr<UsimResult> data = std::make_unique<UsimResult>(fd.get());
384     std::shared_ptr<std::vector<std::shared_ptr<DiallingNumbersInfo>>> list =
385         std::make_shared<std::vector<std::shared_ptr<DiallingNumbersInfo>>>();
386     std::shared_ptr<DiallingNumbersInfo> diallingNumber =
387         std::make_shared<DiallingNumbersInfo>(DiallingNumbersInfo::SIM_ADN, 0);
388     diallingNumber->name_ = Str8ToStr16("SimAdnZhang");
389     diallingNumber->number_ = Str8ToStr16("12345678901");
390     std::shared_ptr<DiallingNumbersInfo> diallingNumberEx = std::make_shared<DiallingNumbersInfo>();
391     list->push_back(diallingNumber);
392     list->push_back(diallingNumberEx);
393     data->result = static_cast<std::shared_ptr<void>>(list);
394     auto owner = event->GetOwner();
395     int eventParam = 0;
396     AppExecFwk::InnerEvent::Pointer response = AppExecFwk::InnerEvent::Get(-1, data, eventParam);
397     diallingNumbersCache->ProcessObtainPbrDetailsDone(response);
398     event = iccDiallingNumbersManager->BuildCallerInfo(-1);
399     diallingNumbersCache->UpdateDiallingNumberToIcc(ELEMENTARY_FILE_PBR, diallingNumber, 0, true, event);
400     diallingNumbersCache->UpdateDiallingNumberToIcc(ELEMENTARY_FILE_PBR, diallingNumber, -1, true, event);
401     int extensionEf = diallingNumbersCache->ExtendedElementFile(ELEMENTARY_FILE_PBR);
402     event = iccDiallingNumbersManager->BuildCallerInfo(-2);
403     diallingNumbersCache->ObtainAllDiallingNumberFiles(ELEMENTARY_FILE_PBR, extensionEf, event);
404     diallingNumbersCache->IsDiallingNumberEqual(diallingNumber, diallingNumber);
405 }
406 
407 /**
408  * @tc.number   Telephony_IccDiallingNumbersCache_005
409  * @tc.name     test error branch
410  * @tc.desc     Function test
411  */
412 HWTEST_F(SimRilBranchTest, Telephony_IccDiallingNumbersCache_005, Function | MediumTest | Level1)
413 {
414     auto telRilManager = std::make_shared<TelRilManager>();
415     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
416     EventFwk::MatchingSkills matchingSkills;
417     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
418     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
419     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
420     auto diallingNumbersCache = std::make_shared<IccDiallingNumbersCache>(simFileManager);
421     auto iccDiallingNumbersManager = IccDiallingNumbersManager::CreateInstance(simFileManager, simStateManager);
422     diallingNumbersCache->simFileManager_ = nullptr;
423     diallingNumbersCache->Init();
424     int extensionEf = diallingNumbersCache->ExtendedElementFile(ELEMENTARY_FILE_ADN);
425     AppExecFwk::InnerEvent::Pointer event = iccDiallingNumbersManager->BuildCallerInfo(-1);
426     diallingNumbersCache->ObtainAllDiallingNumberFiles(ELEMENTARY_FILE_ADN, extensionEf, event);
427     AppExecFwk::InnerEvent::Pointer caller = iccDiallingNumbersManager->BuildCallerInfo(-2);
428     extensionEf = diallingNumbersCache->ExtendedElementFile(ELEMENTARY_FILE_PBR);
429     diallingNumbersCache->ObtainAllDiallingNumberFiles(ELEMENTARY_FILE_PBR, extensionEf, caller);
430     std::vector<std::u16string> args1 = { u"test", u"test1" };
431     std::vector<std::u16string> args2 = { u"test"};
432     diallingNumbersCache->ArrayEqual(args1, args2);
433 }
434 
435 /**
436  * @tc.number   Telephony_IccDiallingNumbersHandler_001
437  * @tc.name     test error branch
438  * @tc.desc     Function test
439  */
440 HWTEST_F(SimRilBranchTest, Telephony_IccDiallingNumbersHandler_001, Function | MediumTest | Level1)
441 {
442     std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create("test");
443     std::shared_ptr<IccFileController> iccFileController = std::make_shared<SimFileController>(1);
444     auto diallingNumberHandler = std::make_shared<IccDiallingNumbersHandler>(iccFileController);
445     diallingNumberHandler->fileController_ = nullptr;
446     AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(1, 1);
447     DiallingNumberUpdateInfor infor;
448     diallingNumberHandler->GetDiallingNumbers(0, 0, 0, event);
449     diallingNumberHandler->GetAllDiallingNumbers(0, 0, event);
450     diallingNumberHandler->UpdateDiallingNumbers(infor, event);
451     event = nullptr;
452     diallingNumberHandler->ProcessEvent(event);
453     int id;
454     diallingNumberHandler->ProcessLinearSizeDone(event, id);
455     diallingNumberHandler->ProcessUpdateRecordDone(event, id);
456     diallingNumberHandler->ProcessDiallingNumberAllLoadDone(event, id);
457     std::shared_ptr<DiallingNumberLoadRequest> loadRequest = nullptr;
458     std::shared_ptr<MultiRecordResult> object = nullptr;
459     diallingNumberHandler->ProcessDiallingNumber(loadRequest, object);
460     diallingNumberHandler->ProcessDiallingNumberLoadDone(event, id);
461     std::shared_ptr<DiallingNumbersInfo> telNumber = std::make_shared<DiallingNumbersInfo>();
462     EXPECT_TRUE(diallingNumberHandler->FormatNameAndNumber(telNumber, false));
463     EXPECT_TRUE(diallingNumberHandler->FormatNameAndNumber(telNumber, true));
464     diallingNumberHandler->MakeExceptionResult(0);
465     diallingNumberHandler->UpdateFileController(iccFileController);
466     diallingNumberHandler->CreateSavingSequence(telNumber, -1);
467     telNumber = nullptr;
468     diallingNumberHandler->FormatNameAndNumber(telNumber, true);
469     std::shared_ptr<unsigned char> diallingNumberStringPac = nullptr;
470     std::string numbe = "test";
471     diallingNumberHandler->FillNumberFiledForDiallingNumber(diallingNumberStringPac, numbe, 0);
472     diallingNumberHandler->FindLoadRequest(-1);
473     std::string recordData = "test";
474     diallingNumberHandler->FetchDiallingNumberContent(telNumber, recordData);
475     std::u16string name = u"电话联系人";
476     int seqLength;
477     diallingNumberHandler->CreateNameSequence(name, seqLength);
478 }
479 
480 /**
481  * @tc.number   Telephony_IccDiallingNumbersManager_001
482  * @tc.name     test error branch
483  * @tc.desc     Function test
484  */
485 HWTEST_F(SimRilBranchTest, Telephony_IccDiallingNumbersManager_001, Function | MediumTest | Level1)
486 {
487     auto telRilManager = std::make_shared<TelRilManager>();
488     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
489     EventFwk::MatchingSkills matchingSkills;
490     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
491     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
492     auto simFileManager1 = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
493     simFileManager1 = nullptr;
494     IccDiallingNumbersManager::CreateInstance(simFileManager1, simStateManager);
495     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
496     auto iccDiallingNumbersManager = IccDiallingNumbersManager::CreateInstance(simFileManager, simStateManager);
497     iccDiallingNumbersManager->stateDiallingNumbers_ = IccDiallingNumbersManager::HandleRunningState::STATE_RUNNING;
498     iccDiallingNumbersManager->Init();
499     iccDiallingNumbersManager->stateDiallingNumbers_ = IccDiallingNumbersManager::HandleRunningState::STATE_NOT_START;
500     iccDiallingNumbersManager->Init();
501     simFileManager = nullptr;
502     iccDiallingNumbersManager->simFileManager_ = simFileManager;
503     iccDiallingNumbersManager->stateDiallingNumbers_ = IccDiallingNumbersManager::HandleRunningState::STATE_NOT_START;
504     iccDiallingNumbersManager->Init();
505     AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(1, 1);
506     event = nullptr;
507     iccDiallingNumbersManager->ProcessEvent(event);
508     iccDiallingNumbersManager->ProcessEvent(AppExecFwk::InnerEvent::Get(0, 1));
509     iccDiallingNumbersManager->ProcessEvent(AppExecFwk::InnerEvent::Get(MSG_SIM_DIALLING_NUMBERS_GET_DONE, 1));
510     iccDiallingNumbersManager->ProcessEvent(AppExecFwk::InnerEvent::Get(MSG_SIM_DIALLING_NUMBERS_UPDATE_DONE, 1));
511     iccDiallingNumbersManager->ProcessEvent(AppExecFwk::InnerEvent::Get(MSG_SIM_DIALLING_NUMBERS_WRITE_DONE, 1));
512     iccDiallingNumbersManager->ProcessEvent(AppExecFwk::InnerEvent::Get(MSG_SIM_DIALLING_NUMBERS_DELETE_DONE, 1));
513     iccDiallingNumbersManager->BuildCallerInfo(-1);
514     std::shared_ptr<DiallingNumbersInfo> diallingNumber = nullptr;
515     std::vector<std::shared_ptr<DiallingNumbersInfo>> result = {};
516     EXPECT_GE(iccDiallingNumbersManager->UpdateIccDiallingNumbers(0, diallingNumber), TELEPHONY_ERR_SUCCESS);
517     EXPECT_GE(iccDiallingNumbersManager->DelIccDiallingNumbers(0, diallingNumber), TELEPHONY_ERR_SUCCESS);
518     EXPECT_GE(iccDiallingNumbersManager->AddIccDiallingNumbers(0, diallingNumber), TELEPHONY_ERR_SUCCESS);
519     iccDiallingNumbersManager->diallingNumbersCache_ = nullptr;
520     EXPECT_GE(iccDiallingNumbersManager->QueryIccDiallingNumbers(0, result), TELEPHONY_ERR_SUCCESS);
521     std::shared_ptr<DiallingNumbersInfo> diallingNumbers1 = std::make_shared<DiallingNumbersInfo>();
522     EXPECT_GE(iccDiallingNumbersManager->UpdateIccDiallingNumbers(-1, diallingNumber), TELEPHONY_ERR_SUCCESS);
523     EXPECT_GE(iccDiallingNumbersManager->DelIccDiallingNumbers(-1, diallingNumber), TELEPHONY_ERR_SUCCESS);
524     EXPECT_GE(iccDiallingNumbersManager->AddIccDiallingNumbers(-1, diallingNumber), TELEPHONY_ERR_SUCCESS);
525     EXPECT_GE(iccDiallingNumbersManager->QueryIccDiallingNumbers(-1, result), TELEPHONY_ERR_SUCCESS);
526 }
527 
528 /**
529  * @tc.number   Telephony_UsimDiallingNumbersService_001
530  * @tc.name     test error branch
531  * @tc.desc     Function test
532  */
533 HWTEST_F(SimRilBranchTest, Telephony_UsimDiallingNumbersService_001, Function | MediumTest | Level1)
534 {
535     auto usimDiallingNumbersService = std::make_shared<UsimDiallingNumbersService>();
536     usimDiallingNumbersService->InitFuncMap();
537     AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(1, 1);
538     event = nullptr;
539     usimDiallingNumbersService->ProcessEvent(event);
540     usimDiallingNumbersService->FillDiallingNumbersRecords(nullptr);
541     std::string record = "record";
542     std::vector<std::string> records;
543     records.push_back(record);
544     usimDiallingNumbersService->GeneratePbrFile(records);
545     usimDiallingNumbersService->BuildCallerInfo(-1);
546     usimDiallingNumbersService->CreateHandlerPointer(-1, 1, 0, nullptr);
547     usimDiallingNumbersService->BuildNumberFileByRecord(record);
548     std::shared_ptr<UsimDiallingNumberFile> file = std::make_shared<UsimDiallingNumberFile>();
549     std::vector<uint8_t> datav;
550     uint8_t data = 0;
551     datav.push_back(data);
552     auto tlvEfSfi = std::make_shared<TagService>(datav);
553     usimDiallingNumbersService->StorePbrDetailInfo(file, tlvEfSfi, 0);
554     std::shared_ptr<IccFileController> iccFileController = nullptr;
555     std::shared_ptr<IccDiallingNumbersHandler> iccDiallingNumbersHandler = nullptr;
556     usimDiallingNumbersService->SetFileControllerAndDiallingNumberHandler(iccFileController, iccDiallingNumbersHandler);
557     usimDiallingNumbersService->LoadPbrFiles();
558     EXPECT_TRUE(usimDiallingNumbersService->fileController_ == nullptr);
559 }
560 
561 /**
562  * @tc.number   Telephony_UsimDiallingNumbersService_002
563  * @tc.name     test error branch
564  * @tc.desc     Function test
565  */
566 HWTEST_F(SimRilBranchTest, Telephony_UsimDiallingNumbersService_002, Function | MediumTest | Level1)
567 {
568     auto usimDiallingNumbersService = std::make_shared<UsimDiallingNumbersService>();
569     usimDiallingNumbersService->InitFuncMap();
570     AppExecFwk::InnerEvent::Pointer event = usimDiallingNumbersService->BuildCallerInfo(MSG_USIM_PBR_LOAD_DONE);
571     event = nullptr;
572     usimDiallingNumbersService->ProcessPbrLoadDone(event);
573     usimDiallingNumbersService->ProcessDiallingNumberLoadDone(event);
574     usimDiallingNumbersService->NextStep(0);
575 }
576 
577 /**
578  * @tc.number   Telephony_UsimDiallingNumbersService_003
579  * @tc.name     test error branch
580  * @tc.desc     Function test
581  */
582 HWTEST_F(SimRilBranchTest, Telephony_UsimDiallingNumbersService_003, Function | MediumTest | Level1)
583 {
584     auto telRilManager = std::make_shared<TelRilManager>();
585     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
586     EventFwk::MatchingSkills matchingSkills;
587     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
588     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
589     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
590     auto diallingNumbersCache = std::make_shared<IccDiallingNumbersCache>(simFileManager);
591     auto iccDiallingNumbersManager = IccDiallingNumbersManager::CreateInstance(simFileManager, simStateManager);
592     diallingNumbersCache->simFileManager_ = nullptr;
593     diallingNumbersCache->Init();
594     auto usimDiallingNumbersService = std::make_shared<UsimDiallingNumbersService>();
595     usimDiallingNumbersService->InitFuncMap();
596     auto caller = iccDiallingNumbersManager->BuildCallerInfo(-1);
597     AppExecFwk::InnerEvent::Pointer pointer = diallingNumbersCache->CreateUsimPointer(-1, ELEMENTARY_FILE_PBR, caller);
598     usimDiallingNumbersService->ObtainUsimElementaryFiles(pointer);
599     AppExecFwk::InnerEvent::Pointer event = usimDiallingNumbersService->BuildCallerInfo(-1);
600     std::unique_ptr<FileToControllerMsg> cmdData = event->GetUniqueObject<FileToControllerMsg>();
601     std::shared_ptr<MultiRecordResult> object = std::make_shared<MultiRecordResult>(cmdData.get());
602     std::vector<std::string> strValue = {"FFFFFFFFFFFFFFFF"};
603     object->fileResults.assign(strValue.begin(), strValue.end());
604     object->resultLength = static_cast<int>(strValue.size());
605     int eventParam = 0;
606     AppExecFwk::InnerEvent::Pointer response = AppExecFwk::InnerEvent::Get(-1, object, eventParam);
607     usimDiallingNumbersService->ProcessPbrLoadDone(response);
608 }
609 
610 /**
611  * @tc.number   Telephony_UsimDiallingNumbersService_004
612  * @tc.name     test error branch
613  * @tc.desc     Function test
614  */
615 HWTEST_F(SimRilBranchTest, Telephony_UsimDiallingNumbersService_004, Function | MediumTest | Level1)
616 {
617     auto telRilManager = std::make_shared<TelRilManager>();
618     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
619     EventFwk::MatchingSkills matchingSkills;
620     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
621     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
622     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
623     auto diallingNumbersCache = std::make_shared<IccDiallingNumbersCache>(simFileManager);
624     auto iccDiallingNumbersManager = IccDiallingNumbersManager::CreateInstance(simFileManager, simStateManager);
625     diallingNumbersCache->simFileManager_ = nullptr;
626     diallingNumbersCache->Init();
627     auto usimDiallingNumbersService = std::make_shared<UsimDiallingNumbersService>();
628     usimDiallingNumbersService->InitFuncMap();
629     AppExecFwk::InnerEvent::Pointer event = usimDiallingNumbersService->CreateHandlerPointer(
630         MSG_USIM_USIM_ADN_LOAD_DONE, ELEMENTARY_FILE_PBR, 0, nullptr);
631     std::unique_ptr<DiallingNumbersHandleHolder> fd = event->GetUniqueObject<DiallingNumbersHandleHolder>();
632     std::unique_ptr<DiallingNumbersHandlerResult> data = std::make_unique<DiallingNumbersHandlerResult>(fd.get());
633     std::shared_ptr<std::vector<std::shared_ptr<DiallingNumbersInfo>>> diallingNumberList =
634         std::make_shared<std::vector<std::shared_ptr<DiallingNumbersInfo>>>();
635     data->result = diallingNumberList;
636     data->exception = nullptr;
637     int eventParam = 0;
638     AppExecFwk::InnerEvent::Pointer response = AppExecFwk::InnerEvent::Get(-1, data, eventParam);
639 }
640 
641 /**
642  * @tc.number   Telephony_UsimDiallingNumbersService_005
643  * @tc.name     test error branch
644  * @tc.desc     Function test
645  */
646 HWTEST_F(SimRilBranchTest, Telephony_UsimDiallingNumbersService_005, Function | MediumTest | Level1)
647 {
648     auto telRilManager = std::make_shared<TelRilManager>();
649     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
650     EventFwk::MatchingSkills matchingSkills;
651     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
652     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
653     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
654     auto diallingNumbersCache = std::make_shared<IccDiallingNumbersCache>(simFileManager);
655     auto iccDiallingNumbersManager = IccDiallingNumbersManager::CreateInstance(simFileManager, simStateManager);
656     diallingNumbersCache->simFileManager_ = nullptr;
657     diallingNumbersCache->Init();
658     auto usimDiallingNumbersService = std::make_shared<UsimDiallingNumbersService>();
659     usimDiallingNumbersService->InitFuncMap();
660     std::shared_ptr<std::vector<std::shared_ptr<DiallingNumbersInfo>>> diallingNumberList =
661         std::make_shared<std::vector<std::shared_ptr<DiallingNumbersInfo>>>();
662     std::shared_ptr<DiallingNumbersInfo> diallingNumber =
663         std::make_shared<DiallingNumbersInfo>(DiallingNumbersInfo::SIM_ADN, 0);
664     diallingNumber->name_ = Str8ToStr16("SimAdnZhang");
665     diallingNumber->number_ = Str8ToStr16("12345678901");
666     diallingNumberList->push_back(diallingNumber);
667     usimDiallingNumbersService->FillDiallingNumbersRecords(diallingNumberList);
668     std::string record = "record";
669     std::vector<std::string> records;
670     records.push_back(record);
671     usimDiallingNumbersService->GeneratePbrFile(records);
672     usimDiallingNumbersService->LoadDiallingNumberFiles(0);
673 }
674 
675 /**
676  * @tc.number   Telephony_SimStateManager_001
677  * @tc.name     test error branch
678  * @tc.desc     Function test
679  */
680 HWTEST_F(SimRilBranchTest, Telephony_SimStateManager_001, Function | MediumTest | Level1)
681 {
682     std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
683     std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
684     simStateManager->SyncCmdResponse();
685     EXPECT_FALSE(simStateManager->HasSimCard());
686 }
687 
688 /**
689  * @tc.number   Telephony_SimStateManager_002
690  * @tc.name     test error branch
691  * @tc.desc     Function test
692  */
693 HWTEST_F(SimRilBranchTest, Telephony_SimStateManager_002, Function | MediumTest | Level1)
694 {
695     std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
696     std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
697     simStateManager->simStateRun_ = STATE_RUNNING;
698     simStateManager->Init(0);
699     simStateManager->simStateRun_ = STATE_NOT_START;
700     simStateManager->telRilManager_ = nullptr;
701     simStateManager->Init(0);
702     simStateManager->simStateHandle_ = nullptr;
703     simStateManager->RegisterCoreNotify(nullptr, 1);
704     simStateManager->UnRegisterCoreNotify(nullptr, 1);
705     simStateManager->RefreshSimState(0);
706     std::string password = "1234";
707     LockStatusResponse mLockStatusResponse;
708     EXPECT_GT(simStateManager->UnlockPin(0, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
709     EXPECT_GT(simStateManager->UnlockPuk(0, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
710     EXPECT_GT(simStateManager->AlterPin(0, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
711     LockInfo mLockInfo;
712     mLockInfo.lockType = LockType::PIN_LOCK;
713     mLockInfo.lockState = LockState::LOCK_OFF;
714     EXPECT_GT(simStateManager->SetLockState(0, mLockInfo, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
715     LockState lockState;
716     PersoLockInfo mPersoLockInfo;
717     SimAuthenticationResponse mResponse;
718     EXPECT_GT(simStateManager->GetLockState(0, LockType::PIN_LOCK, lockState), TELEPHONY_ERR_SUCCESS);
719     EXPECT_GT(simStateManager->UnlockPin2(0, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
720     EXPECT_GT(simStateManager->UnlockPuk2(0, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
721     EXPECT_GT(simStateManager->AlterPin2(0, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
722     EXPECT_GT(simStateManager->UnlockSimLock(0, mPersoLockInfo, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
723     EXPECT_NE(
724         simStateManager->SimAuthentication(0, AuthType::SIM_AUTH_EAP_SIM_TYPE, "", mResponse), TELEPHONY_ERR_SUCCESS);
725     EXPECT_NE(simStateManager->SendSimMatchedOperatorInfo(0, 0, "", ""), TELEPHONY_ERR_SUCCESS);
726 }
727 
728 /**
729  * @tc.number   Telephony_SimStateHandle_002
730  * @tc.name     test error branch
731  * @tc.desc     Function test
732  */
733 HWTEST_F(SimRilBranchTest, Telephony_SimStateHandle_002, Function | MediumTest | Level1)
734 {
735     std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
736     std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
737     auto simStateHandle = std::make_shared<SimStateHandle>(simStateManager);
738     simStateHandle->Init(0);
739     std::shared_ptr<TelRilManager> telRilManager1 = std::make_shared<TelRilManager>();
740     telRilManager1 = nullptr;
741     simStateHandle->SetRilManager(telRilManager1);
742     simStateHandle->Init(0);
743     simStateHandle->iccState_.simStatus_ = ICC_CARD_ABSENT;
744     EXPECT_FALSE(simStateHandle->HasSimCard());
745     simStateHandle->iccState_.simStatus_ = ICC_CONTENT_READY;
746     EXPECT_TRUE(simStateHandle->HasSimCard());
747     simStateHandle->GetSimState();
748     simStateHandle->GetCardType();
749     PersoLockInfo lockInfo;
750     std::string authData = "test";
751     simStateHandle->UnlockSimLock(0, lockInfo);
752     EXPECT_EQ(simStateHandle->SimAuthentication(0, AuthType::SIM_AUTH_EAP_SIM_TYPE, authData), SIM_AUTH_FAIL);
753 }
754 
755 /**
756  * @tc.number   Telephony_IccOperatorRule_002
757  * @tc.name     test error branch
758  * @tc.desc     Function test
759  */
760 HWTEST_F(SimRilBranchTest, Telephony_IccOperatorRule_002, Function | MediumTest | Level1)
761 {
762     auto iccOperatorRule = std::make_shared<IccOperatorRule>();
763     std::string numIt = "E2E2";
764     std::string numIt1 = "E1E1";
765     std::string numIt2 = "E3E3";
766     std::string numIt3 = "FF40FF40";
767     IccOperatorRule result;
768     std::string::const_iterator hexStrBeg = numIt.begin();
769     std::string::const_iterator hexStrEnd = numIt.begin();
770     std::string::const_iterator hexStrBeg1 = numIt1.begin();
771     std::string::const_iterator hexStrEnd1 = numIt1.begin();
772     std::string::const_iterator hexStrBeg2 = numIt2.begin();
773     std::string::const_iterator hexStrEnd2 = numIt2.begin();
774     std::string::const_iterator hexStrBeg3 = numIt3.begin();
775     std::string::const_iterator hexStrEnd3 = numIt3.begin();
776     std::vector<IccOperatorRule> list;
777     std::string_view certHash = iccOperatorRule->certificate_;
778     std::string_view packageName;
779     std::string hexStr = "12";
780     std::string testStr = "testStr";
781     int32_t len = 1;
782     iccOperatorRule->GetCertificate(testStr);
783     iccOperatorRule->SetCertificate(testStr);
784     iccOperatorRule->SetCertificate(std::move(testStr));
785     iccOperatorRule->SetAccessLimit(testStr);
786     iccOperatorRule->SetAccessLimit(std::move(testStr));
787     EXPECT_FALSE(iccOperatorRule->DecodeTLVTagRule(hexStrBeg, hexStrEnd, result, len));
788     EXPECT_FALSE(iccOperatorRule->DecodeTLVTagCertPkg(hexStrBeg1, hexStrEnd1, result));
789     EXPECT_FALSE(iccOperatorRule->DecodeTLVTagLimits(hexStrBeg2, hexStrEnd2, result));
790     EXPECT_FALSE(iccOperatorRule->CreateFromTLV(hexStrBeg3, hexStrEnd3, list));
791     EXPECT_TRUE(iccOperatorRule->CreateFromTLV(numIt3, list));
792     EXPECT_TRUE(iccOperatorRule->Matche(certHash, packageName));
793     EXPECT_TRUE(iccOperatorRule->SetPackageNameByHexStr(hexStr));
794 }
795 
796 /**
797  * @tc.number   Telephony_tel_ril_manager_001
798  * @tc.name     test error branch
799  * @tc.desc     Function test
800  */
801 HWTEST_F(SimRilBranchTest, Telephony_tel_ril_manager_001, Function | MediumTest | Level1)
802 {
803     auto telRilManager = std::make_shared<TelRilManager>();
804     telRilManager->DeInit();
805     telRilManager->ReduceRunningLock();
806     telRilManager->SendAckAndLock();
807     int32_t slotFaild = -1;
808     telRilManager->GetTelRilSms(slotFaild);
809     telRilManager->GetTelRilSim(slotFaild);
810     telRilManager->GetTelRilModem(slotFaild);
811     telRilManager->GetTelRilData(slotFaild);
812     telRilManager->GetTelRilNetwork(slotFaild);
813     telRilManager->GetTelRilCall(slotFaild);
814     int32_t slot_0 = SLOT_ID;
815     telRilManager->GetTelRilSms(slot_0);
816     telRilManager->GetTelRilSim(slot_0);
817     telRilManager->GetTelRilModem(slot_0);
818     telRilManager->GetTelRilData(slot_0);
819     telRilManager->GetTelRilNetwork(slot_0);
820     telRilManager->GetTelRilCall(slot_0);
821     std::shared_ptr<TelRilCall> emptyCall = nullptr;
822     telRilManager->telRilCall_.push_back(emptyCall);
823     telRilManager->ResetRilInterface();
824     std::shared_ptr<ObserverHandler> observerHandler = nullptr;
825     telRilManager->observerHandler_.push_back(observerHandler);
826     std::shared_ptr<AppExecFwk::EventHandler> observerCallBack = nullptr;
827     int32_t what = 0;
828     int32_t *obj = 0;
829     telRilManager->RegisterCoreNotify(slot_0, observerCallBack, what, obj);
830     telRilManager->UnRegisterCoreNotify(slot_0, observerCallBack, what);
831     telRilManager->rilInterface_ = nullptr;
832     ASSERT_TRUE(telRilManager->DisConnectRilInterface());
833 }
834 
835 /**
836  * @tc.number   Telephony_IccFileController_001
837  * @tc.name     test error branch
838  * @tc.desc     Function test
839  */
840 HWTEST_F(SimRilBranchTest, Telephony_IccFileController_001, Function | MediumTest | Level1)
841 {
842     std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create("test");
843     std::shared_ptr<IccFileController> iccFileController = std::make_shared<SimFileController>(1);
844     auto event = AppExecFwk::InnerEvent::Get(0);
845     iccFileController->ProcessReadBinary(event);
846     std::shared_ptr<IccControllerHolder> holder = nullptr;
847     std::unique_ptr<Telephony::IccFromRilMsg> object = std::make_unique<Telephony::IccFromRilMsg>(holder);
848     auto event1 = AppExecFwk::InnerEvent::Get(0, object);
849     auto event01 = AppExecFwk::InnerEvent::Get(0, object);
850     auto event2 = AppExecFwk::InnerEvent::Get(0, object);
851     iccFileController->ProcessReadBinary(event1);
852     int fileId = 0;
853     int size = 0;
854     std::string path = "";
855     int fileNum = 0;
856     std::string data = "";
857     int dataLength = 0;
858     std::string pin2 = "";
859     int *val = nullptr;
860     iccFileController->ObtainBinaryFile(fileId, event01);
861     iccFileController->ObtainBinaryFile(fileId, size, event2);
862     iccFileController->ObtainLinearFixedFile(fileId, path, fileNum, event);
863     iccFileController->ObtainAllLinearFixedFile(fileId, path, event);
864     iccFileController->ObtainLinearFileSize(fileId, path, event);
865     iccFileController->UpdateLinearFixedFile(fileId, path, fileNum, data, dataLength, pin2, event);
866     iccFileController->UpdateLinearFixedFile(fileId, fileNum, data, dataLength, pin2, event);
867     iccFileController->UpdateBinaryFile(fileId, data, dataLength, event);
868     auto telRilManager = std::make_shared<TelRilManager>();
869     iccFileController->telRilManager_ = telRilManager;
870     auto event3 = AppExecFwk::InnerEvent::Get(0, object);
871     auto event4 = AppExecFwk::InnerEvent::Get(0, object);
872     iccFileController->ObtainBinaryFile(fileId, event3);
873     iccFileController->ObtainBinaryFile(fileId, size, event4);
874     iccFileController->ObtainLinearFixedFile(fileId, path, fileNum, event);
875     iccFileController->UpdateLinearFixedFile(fileId, path, fileNum, data, dataLength, pin2, event);
876     iccFileController->UpdateLinearFixedFile(fileId, fileNum, data, dataLength, pin2, event);
877     iccFileController->UpdateBinaryFile(fileId, data, dataLength, event);
878     std::vector<std::string> strValue;
879     IccFileData *fd = nullptr;
880     iccFileController->SendResponse(holder, fd);
881     auto event5 = AppExecFwk::InnerEvent::Get(0);
882     iccFileController->SendEfLinearResult(event5, val, size);
883     auto event6 = AppExecFwk::InnerEvent::Get(0);
884     iccFileController->SendMultiRecordResult(event6, strValue);
885     unsigned char *data1;
886     iccFileController->ParseFileSize(val, size, data1);
887     iccFileController->IsValidRecordSizeData(data1);
888     iccFileController->GetFileAndDataSize(data1, size, size);
889     ASSERT_TRUE(iccFileController->BuildCallerInfo(0, 0, 0, holder) != nullptr);
890 }
891 
GetControllerToFileMsgEvent(int32_t code,bool withException)892 AppExecFwk::InnerEvent::Pointer GetControllerToFileMsgEvent(int32_t code, bool withException)
893 {
894     auto objectUnique = std::make_unique<ControllerToFileMsg>(nullptr, nullptr);
895     objectUnique->resultData = "123456";
896     if (withException) {
897         objectUnique->exception = std::make_shared<int32_t>(0);
898     }
899     return AppExecFwk::InnerEvent::Get(code, objectUnique);
900 }
901 
GetDiallingNumbersHandlerResultEvent(int32_t code,bool withException)902 AppExecFwk::InnerEvent::Pointer GetDiallingNumbersHandlerResultEvent(int32_t code, bool withException)
903 {
904     auto objectUnique = std::make_unique<DiallingNumbersHandlerResult>(nullptr);
905     objectUnique->result = std::make_shared<DiallingNumbersInfo>();
906     if (withException) {
907         objectUnique->exception = std::make_shared<int32_t>(0);
908     }
909     return AppExecFwk::InnerEvent::Get(code, objectUnique);
910 }
911 
912 /**
913  * @tc.number   Telephony_SimFile_001
914  * @tc.name     test error branch
915  * @tc.desc     Function test
916  */
917 HWTEST_F(SimRilBranchTest, Telephony_SimFile_001, Function | MediumTest | Level1)
918 {
919     std::shared_ptr<AppExecFwk::EventRunner> runner = nullptr;
920     std::shared_ptr<SimStateManager> simStateManager = nullptr;
921     auto simFile = std::make_shared<SimFile>(simStateManager);
922     std::vector<int> testCase1 = { MSG_SIM_OBTAIN_GID1_DONE, MSG_SIM_OBTAIN_GID2_DONE, MSG_SIM_SET_MSISDN_DONE,
923         MSG_SIM_OBTAIN_SPDI_DONE, MSG_SIM_OBTAIN_CFIS_DONE, MSG_SIM_OBTAIN_MWIS_DONE,
924         MSG_SIM_OBTAIN_VOICE_MAIL_INDICATOR_CPHS_DONE, MSG_SIM_OBTAIN_ICCID_DONE, MSG_SIM_OBTAIN_CFF_DONE,
925         MSG_SIM_OBTAIN_CFF_DONE, MSG_SIM_OBTAIN_AD_DONE, MSG_SIM_SMS_ON_SIM, MSG_SIM_OBTAIN_ALL_SMS_DONE,
926         MSG_SIM_OBTAIN_SMS_DONE, MSG_SIM_OBTAIN_PLMN_W_ACT_DONE, MSG_SIM_OBTAIN_OPLMN_W_ACT_DONE,
927         MSG_SIM_OBTAIN_CSP_CPHS_DONE, MSG_SIM_OBTAIN_INFO_CPHS_DONE, MSG_SIM_OBTAIN_SST_DONE, MSG_SIM_OBTAIN_PNN_DONE,
928         MSG_SIM_OBTAIN_OPL_DONE, MSG_SIM_OBTAIN_OPL5G_DONE, MSG_SIM_UPDATE_DONE, MSG_SIM_OBTAIN_HPLMN_W_ACT_DONE,
929         MSG_SIM_OBTAIN_EHPLMN_DONE, MSG_SIM_OBTAIN_FPLMN_DONE };
930     for (int32_t code : testCase1) {
931         auto event1 = GetControllerToFileMsgEvent(code, true);
932         simFile->ProcessEvent(event1);
933         if (code == MSG_SIM_SMS_ON_SIM) {
934             continue;
935         }
936         auto event2 = GetControllerToFileMsgEvent(code, false);
937         simFile->ProcessEvent(event2);
938     }
939     std::vector<int> testCase2 = { MSG_SIM_OBTAIN_MSISDN_DONE, MSG_SIM_OBTAIN_CPHS_MAILBOX_DONE,
940         MSG_SIM_SET_CPHS_MAILBOX_DONE, MSG_SIM_SET_MBDN_DONE };
941     simFile->cphsInfo_ = "";
942     for (int32_t code : testCase2) {
943         auto event1 = GetDiallingNumbersHandlerResultEvent(code, false);
944         simFile->ProcessEvent(event1);
945         auto event2 = GetDiallingNumbersHandlerResultEvent(code, true);
946         simFile->ProcessEvent(event2);
947     }
948     int32_t efCfisSize = 0;
949     std::string efCfisStr = "1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF";
950     std::string number = "123456789111111";
951     std::shared_ptr<unsigned char> efCfisData = SIMUtils::HexStringConvertToBytes(efCfisStr, efCfisSize);
952     ASSERT_TRUE(simFile->FillNumber(efCfisData, efCfisSize, number));
953     efCfisStr = "1234";
954     efCfisData = SIMUtils::HexStringConvertToBytes(efCfisStr, efCfisSize);
955     ASSERT_FALSE(simFile->FillNumber(efCfisData, efCfisSize, number));
956 }
957 
958 /**
959  * @tc.number   Telephony_SimFile_002
960  * @tc.name     test error branch
961  * @tc.desc     Function test
962  */
963 HWTEST_F(SimRilBranchTest, Telephony_SimFile_002, Function | MediumTest | Level1)
964 {
965     std::shared_ptr<AppExecFwk::EventRunner> runner = nullptr;
966     std::shared_ptr<SimStateManager> simStateManager = nullptr;
967     auto simFile = std::make_shared<SimFile>(simStateManager);
968     int32_t voiceMailCount = 2;
969     simFile->SetVoiceMailCount(voiceMailCount);
970     bool enable = true;
971     std::string number = "00000000000";
972     simFile->SetVoiceCallForwarding(enable, number);
973     std::vector<std::string> records = { "460000", "01AABBCCDD" };
974     simFile->ParsePnn(records);
975     ASSERT_FALSE(simFile->EfCfisAvailable(0));
976 }
977 
978 /**
979  * @tc.number   Telephony_MccPool_001
980  * @tc.name     test error branch
981  * @tc.desc     Function test
982  */
983 HWTEST_F(SimRilBranchTest, Telephony_MccPool_001, Function | MediumTest | Level1)
984 {
985     EXPECT_EQ(MccPool::MccCountryCode(MCC_CN_A), "cn");
986     EXPECT_EQ(MccPool::MccCountryCode(INVALID_MCC), "");
987     EXPECT_EQ(MccPool::ShortestMncLengthFromMcc(MCC_CN_A), MCC_SHORT);
988     EXPECT_EQ(MccPool::ShortestMncLengthFromMcc(MCC_US_A), MCC_LONG);
989     ASSERT_TRUE(MccPool::LengthIsThreeMnc("302370"));
990     ASSERT_FALSE(MccPool::LengthIsThreeMnc("46000"));
991 
992     auto mccAccess = MccPool::AccessToMcc(MCC_BJ);
993     EXPECT_EQ(mccAccess->iso_, "bj");
994     std::shared_ptr<MccAccess> mccAccessA = std::make_shared<MccAccess>(MCC_MK, "", 0);
995     std::shared_ptr<MccAccess> mccAccessB = std::make_shared<MccAccess>(MCC_CN_A, "", 0);
996     std::shared_ptr<MccAccess> mccAccessC = std::make_shared<MccAccess>(MCC_CD, "", 0);
997     std::shared_ptr<MccAccess> mccAccessD = nullptr;
998     ASSERT_TRUE(MccPool::MccCompare(mccAccessA, mccAccessB));
999     ASSERT_FALSE(MccPool::MccCompare(mccAccessC, mccAccessB));
1000     ASSERT_FALSE(MccPool::MccCompare(mccAccessA, mccAccessD));
1001 }
1002 
1003 HWTEST_F(SimRilBranchTest, Telephony_IsChineseString001, Function | MediumTest | Level1)
1004 {
1005     auto simCharDecode = std::make_shared<SimCharDecode>();
1006 
1007     EXPECT_TRUE(simCharDecode->IsChineseString("测试文本"));
1008     EXPECT_FALSE(simCharDecode->IsChineseString("testString"));
1009 }
1010 
1011 HWTEST_F(SimRilBranchTest, Telephony_IsValidNumberString001, Function | MediumTest | Level1)
1012 {
1013     auto simNumberDecode = std::make_shared<SimNumberDecode>();
1014 
1015     EXPECT_TRUE(simNumberDecode->IsValidNumberString("123###"));
1016     EXPECT_FALSE(simNumberDecode->IsValidNumberString("abc@abc"));
1017 
1018     EXPECT_EQ(simNumberDecode->chooseExtendedByType(0), nullptr);
1019 }
1020 
1021 HWTEST_F(SimRilBranchTest, Telephony_CharToBCD001, Function | MediumTest | Level1)
1022 {
1023     auto simNumberDecode = std::make_shared<SimNumberDecode>();
1024     uint8_t result = 1;
1025 
1026     EXPECT_TRUE(simNumberDecode->CharToBCD('0', result, 0));
1027     EXPECT_EQ(result, 0);
1028 
1029     result = 1;
1030     EXPECT_FALSE(simNumberDecode->CharToBCD('a', result, 0));
1031     EXPECT_EQ(result, 1);
1032 
1033     EXPECT_FALSE(simNumberDecode->CharToBCD('a', result, SimNumberDecode::BCD_TYPE_ADN));
1034     EXPECT_EQ(result, 1);
1035 
1036     EXPECT_TRUE(simNumberDecode->CharToBCD('a', result, SimNumberDecode::BCD_TYPE_CALLER));
1037     EXPECT_EQ(result, 0xc);
1038 }
1039 
1040 HWTEST_F(SimRilBranchTest, Telephony_BcdToChar, Function | MediumTest | Level1)
1041 {
1042     auto simNumberDecode = std::make_shared<SimNumberDecode>();
1043     uint8_t bcdCode = 9;
1044     char result = 'a';
1045 
1046     EXPECT_TRUE(simNumberDecode->BcdToChar(bcdCode, result, 0));
1047     EXPECT_EQ(result, '9');
1048 
1049     bcdCode = 0xa;
1050     result = 'a';
1051     EXPECT_FALSE(simNumberDecode->BcdToChar(bcdCode, result, 0));
1052     EXPECT_EQ(result, 'a');
1053 
1054     EXPECT_TRUE(simNumberDecode->BcdToChar(bcdCode, result, SimNumberDecode::BCD_TYPE_ADN));
1055     EXPECT_EQ(result, '*');
1056 
1057     bcdCode = 0xff;
1058     EXPECT_FALSE(simNumberDecode->BcdToChar(bcdCode, result, SimNumberDecode::BCD_TYPE_CALLER));
1059     EXPECT_EQ(result, '*');
1060 
1061     bcdCode = 0xb;
1062     EXPECT_TRUE(simNumberDecode->BcdToChar(bcdCode, result, SimNumberDecode::BCD_TYPE_CALLER));
1063     EXPECT_EQ(result, '#');
1064 }
1065 
1066 HWTEST_F(SimRilBranchTest, Telephony_TagService, Function | MediumTest | Level1)
1067 {
1068     TagService tagService("");
1069     EXPECT_EQ(tagService.data_.size(), 0);
1070 
1071     TagService tagService1("1234");
1072     EXPECT_EQ(tagService1.data_.size(), 2);
1073 
1074     TagService tagService2("1234");
1075     EXPECT_EQ(tagService2.data_.size(), 2);
1076 }
1077 
1078 HWTEST_F(SimRilBranchTest, Telephony_OperatorConfigLoader_002, Function | MediumTest | Level1)
1079 {
1080     auto telRilManager = std::make_shared<TelRilManager>();
1081     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
1082     EventFwk::MatchingSkills matchingSkills;
1083     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
1084     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
1085     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
1086     auto operatorConfigCache = std::make_shared<OperatorConfigCache>(simFileManager, 0);
1087     auto operatorConfigLoader = std::make_shared<OperatorConfigLoader>(simFileManager, operatorConfigCache);
1088     operatorConfigLoader->iccidFromSim_ = "";
1089     EXPECT_EQ(operatorConfigLoader->InsertOpkeyToSimDb(""), TELEPHONY_ERR_ARGUMENT_NULL);
1090 
1091     EXPECT_EQ(operatorConfigLoader->InsertOpkeyToSimDb("testOpKey"), TELEPHONY_ERR_ARGUMENT_NULL);
1092 
1093     operatorConfigLoader->iccidFromSim_ = "12345678901234567890";
1094     EXPECT_EQ(operatorConfigLoader->InsertOpkeyToSimDb(""), TELEPHONY_ERR_ARGUMENT_NULL);
1095 
1096     std::shared_ptr<DataShare::DataShareResultSet> resultSet = std::make_shared<DataShare::DataShareResultSet>();
1097     operatorConfigLoader->simFileManager_.reset();
1098     EXPECT_STREQ((operatorConfigLoader->GetOpKey(resultSet, 0)).c_str(), DEFAULT_OPERATOR_KEY);
1099 }
1100 
1101 HWTEST_F(SimRilBranchTest, Telephony_VoiceMailConstants001, Function | MediumTest | Level1)
1102 {
1103     ASSERT_EQ(TELEPHONY_EXT_WRAPPER.telephonyExtWrapperHandle_, nullptr);
1104     VoiceMailConstants voiceMailConstants(0);
1105 
1106     CoreManagerInner mInner;
1107     mInner.simManager_ = nullptr;
1108     OperatorConfig operatorConfig;
1109     ASSERT_EQ(mInner.GetOperatorConfigs(0, operatorConfig), TELEPHONY_ERR_LOCAL_PTR_NULL);
1110     EXPECT_STREQ((voiceMailConstants.GetStringValueFromCust(0, "key")).c_str(), "");
1111 
1112     voiceMailConstants.isVoiceMailFixed_ = true;
1113     voiceMailConstants.ResetVoiceMailLoadedFlag();
1114     ASSERT_EQ(voiceMailConstants.isVoiceMailFixed_, false);
1115 
1116     EXPECT_EQ(voiceMailConstants.GetVoiceMailFixed("test"), true);
1117     EXPECT_STREQ((voiceMailConstants.GetVoiceMailNumber("test")).c_str(), "");
1118     EXPECT_STREQ((voiceMailConstants.GetVoiceMailTag("test")).c_str(), "");
1119     EXPECT_STREQ((voiceMailConstants.LoadVoiceMailConfigFromCard("testName", "testCarrier")).c_str(), "");
1120 }
1121 
1122 HWTEST_F(SimRilBranchTest, Telephony_IccOperatorRule_003, Function | MediumTest | Level1)
1123 {
1124     auto iccOperatorRule = std::make_shared<IccOperatorRule>();
1125 
1126     EXPECT_FALSE(iccOperatorRule->SetPackageNameByHexStr("G"));
1127     EXPECT_FALSE(iccOperatorRule->SetPackageNameByHexStr("G1"));
1128 
1129     std::string pkgHexStr = "E1E";
1130     std::string::const_iterator pkgHexStrBeg = pkgHexStr.begin();
1131     std::string::const_iterator pkgHexStrEnd = pkgHexStr.end();
1132     IccOperatorRule result;
1133     EXPECT_FALSE(iccOperatorRule->DecodeTLVTagCertPkg(pkgHexStrBeg, pkgHexStrEnd, result));
1134 
1135     std::string limitHexStr = "E3E";
1136     std::string::const_iterator limitHexStrBeg = limitHexStr.begin();
1137     std::string::const_iterator limitHexStrEnd = limitHexStr.end();
1138     EXPECT_FALSE(iccOperatorRule->DecodeTLVTagLimits(limitHexStrBeg, limitHexStrEnd, result));
1139 
1140     std::string ruleHexStr = "E2E";
1141     std::string::const_iterator ruleHexStrBeg = ruleHexStr.begin();
1142     std::string::const_iterator ruleHexStrEnd = ruleHexStr.end();
1143     int32_t len = 0;
1144     EXPECT_FALSE(iccOperatorRule->DecodeTLVTagRule(ruleHexStrBeg, ruleHexStrEnd, result, len));
1145 
1146     ruleHexStr = "E202E1E";
1147     ruleHexStrBeg = ruleHexStr.begin();
1148     ruleHexStrEnd = ruleHexStr.end();
1149     EXPECT_FALSE(iccOperatorRule->DecodeTLVTagRule(ruleHexStrBeg, ruleHexStrEnd, result, len));
1150 
1151     iccOperatorRule->SetCertificate("testCertificate");
1152     iccOperatorRule->SetPackageName("testPackageName");
1153 
1154     std::string_view certHash = "testCertificate";
1155     std::string_view packageName = "testPackageName";
1156     EXPECT_TRUE(iccOperatorRule->Matche(certHash, packageName));
1157 }
1158 
1159 HWTEST_F(SimRilBranchTest, Telephony_IccDiallingNumbersManager_002, Function | MediumTest | Level1)
1160 {
1161     auto telRilManager = std::make_shared<TelRilManager>();
1162     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
1163     EventFwk::MatchingSkills matchingSkills;
1164     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
1165     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
1166     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
1167     IccDiallingNumbersManager iccDiallingNumbersManager(simFileManager, nullptr);
1168     std::shared_ptr<DiallingNumbersInfo> diallingNumbers = std::make_shared<DiallingNumbersInfo>();
1169 
1170     EXPECT_EQ(iccDiallingNumbersManager.UpdateIccDiallingNumbers(0, diallingNumbers), TELEPHONY_ERR_NO_SIM_CARD);
1171     EXPECT_EQ(iccDiallingNumbersManager.DelIccDiallingNumbers(0, diallingNumbers), TELEPHONY_ERR_NO_SIM_CARD);
1172     EXPECT_EQ(iccDiallingNumbersManager.AddIccDiallingNumbers(0, diallingNumbers), TELEPHONY_ERR_NO_SIM_CARD);
1173 
1174     EXPECT_EQ(iccDiallingNumbersManager.GetFileIdForType(DiallingNumbersInfo::SIM_ADN), ELEMENTARY_FILE_ADN);
1175     EXPECT_EQ(iccDiallingNumbersManager.GetFileIdForType(DiallingNumbersInfo::SIM_FDN), ELEMENTARY_FILE_FDN);
1176     EXPECT_EQ(iccDiallingNumbersManager.GetFileIdForType(-1), 0);
1177 
1178     EXPECT_TRUE(iccDiallingNumbersManager.IsValidType(DiallingNumbersInfo::SIM_ADN));
1179     EXPECT_TRUE(iccDiallingNumbersManager.IsValidType(DiallingNumbersInfo::SIM_FDN));
1180     EXPECT_FALSE(iccDiallingNumbersManager.IsValidType(-1));
1181 
1182     EXPECT_TRUE(iccDiallingNumbersManager.IsValidParam(DiallingNumbersInfo::SIM_ADN, diallingNumbers));
1183     EXPECT_FALSE(iccDiallingNumbersManager.IsValidParam(DiallingNumbersInfo::SIM_FDN, diallingNumbers));
1184 }
1185 
1186 HWTEST_F(SimRilBranchTest, Telephony_SimSmsManager, Function | MediumTest | Level1)
1187 {
1188     auto telRilManager = std::make_shared<TelRilManager>();
1189     auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
1190     EventFwk::MatchingSkills matchingSkills;
1191     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
1192     EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
1193     auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
1194 
1195     SimSmsManager simSmsManager1(telRilManager, simFileManager, simStateManager);
1196     simSmsManager1.stateSms_ = SimSmsManager::HandleRunningState::STATE_RUNNING;
1197     simSmsManager1.Init(0);
1198 
1199     SimSmsManager simSmsManager2(nullptr, simFileManager, simStateManager);
1200     simSmsManager2.stateSms_ = SimSmsManager::HandleRunningState::STATE_NOT_START;
1201     simSmsManager2.Init(1);
1202 
1203     SimSmsManager simSmsManager3(telRilManager, nullptr, simStateManager);
1204     simSmsManager3.stateSms_ = SimSmsManager::HandleRunningState::STATE_NOT_START;
1205     simSmsManager3.Init(1);
1206 
1207     EXPECT_EQ(simSmsManager3.smsController_, nullptr);
1208 
1209     std::string testPdu = "testPdu";
1210     std::string testSmsc = "testSmsc";
1211     EXPECT_EQ(simSmsManager3.AddSmsToIcc(0, testPdu, testSmsc), TELEPHONY_ERR_LOCAL_PTR_NULL);
1212     EXPECT_EQ(simSmsManager3.UpdateSmsIcc(0, 0, testPdu, testSmsc), TELEPHONY_ERR_LOCAL_PTR_NULL);
1213     EXPECT_EQ(simSmsManager3.DelSmsIcc(0), TELEPHONY_ERR_LOCAL_PTR_NULL);
1214     EXPECT_EQ((simSmsManager3.ObtainAllSmsOfIcc()).size(), 0);
1215 }
1216 
1217 HWTEST_F(SimRilBranchTest, Telephony_SimSmsController_002, Function | MediumTest | Level1)
1218 {
1219     std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1220     std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1221     std::shared_ptr<Telephony::SimSmsController> simSmsController = std::make_shared<SimSmsController>(simStateManager);
1222 
1223     EXPECT_FALSE(simSmsController->loadDone_);
1224     AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr);
1225     ASSERT_EQ(event, nullptr);
1226     simSmsController->ProcessEvent(event);
1227     simSmsController->ProcessLoadDone(event);
1228     simSmsController->ProcessUpdateDone(event);
1229     simSmsController->ProcessWriteDone(event);
1230     simSmsController->ProcessDeleteDone(event);
1231     EXPECT_FALSE(simSmsController->loadDone_);
1232 
1233     simSmsController->stateManager_ = std::make_shared<SimStateManager>(telRilManager);
1234     simSmsController->stateManager_->simStateHandle_  = std::make_shared<SimStateHandle>(simStateManager);
1235     simSmsController->stateManager_->simStateHandle_->externalType_ = CardType::SINGLE_MODE_RUIM_CARD;
1236     EXPECT_TRUE(simSmsController->IsCdmaCardType());
1237 }
1238 
1239 HWTEST_F(SimRilBranchTest, Telephony_IccFileController_002, Function | MediumTest | Level1)
1240 {
1241     std::shared_ptr<IccFileController> iccFileController = std::make_shared<SimFileController>(1);
1242 
1243     int32_t fileSize[] = { 0, 0, 0 };
1244     int32_t testLenNum = 3;
1245     AppExecFwk::InnerEvent::Pointer respone(nullptr, nullptr);
1246     iccFileController->SendEfLinearResult(respone, fileSize, testLenNum);
1247     std::vector<std::string> strValue;
1248 
1249     iccFileController->SendMultiRecordResult(respone, strValue);
1250     unsigned char data[] = {0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 1, 1};
1251     iccFileController->ParseFileSize(fileSize, testLenNum, data);
1252     EXPECT_EQ(fileSize[0], 1);
1253     EXPECT_EQ(fileSize[1], 2);
1254     EXPECT_EQ(fileSize[2], 2);
1255 
1256     fileSize[2] = 0;
1257     data[SIZE_TWO_OF_FILE] = 1;
1258     data[LENGTH_OF_RECORD] = 0;
1259     iccFileController->ParseFileSize(fileSize, testLenNum, data);
1260     EXPECT_EQ(fileSize[0], 0);
1261     EXPECT_EQ(fileSize[1], 1);
1262     EXPECT_EQ(fileSize[2], 0);
1263 
1264     EXPECT_FALSE(iccFileController->IsValidRecordSizeData(data));
1265     EXPECT_FALSE(iccFileController->IsValidBinarySizeData(data));
1266 
1267     data[TYPE_OF_FILE] = ICC_ELEMENTARY_FILE;
1268     EXPECT_FALSE(iccFileController->IsValidRecordSizeData(data));
1269     EXPECT_FALSE(iccFileController->IsValidBinarySizeData(data));
1270 
1271     data[STRUCTURE_OF_DATA] = 1;
1272     EXPECT_TRUE(iccFileController->IsValidRecordSizeData(data));
1273     data[STRUCTURE_OF_DATA] = ELEMENTARY_FILE_TYPE_TRANSPARENT;
1274     EXPECT_TRUE(iccFileController->IsValidBinarySizeData(data));
1275 
1276     EXPECT_STREQ((iccFileController->CheckRightPath("testPath", 0)).c_str(), "testPath");
1277 
1278     auto objectUnique = std::make_unique<ControllerToFileMsg>(nullptr, nullptr);
1279     iccFileController->SendEvent(nullptr, 1, true, nullptr, objectUnique);
1280     iccFileController->SendEvent(nullptr, 1, false, nullptr, objectUnique);
1281 }
1282 
1283 HWTEST_F(SimRilBranchTest, Telephony_SimStateManager_003, Function | MediumTest | Level1)
1284 {
1285     std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1286     std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1287 
1288     auto simStateManagerTwo = std::make_shared<SimStateManager>(telRilManager);
1289     auto simStateHandle = std::make_shared<SimStateHandle>(simStateManagerTwo);
1290     simStateManager->simStateHandle_ = simStateHandle;
1291 
1292     EXPECT_EQ(simStateManager->SetModemInit(false), TELEPHONY_ERR_SUCCESS);
1293     EXPECT_FALSE(simStateManager->IfModemInitDone());
1294 
1295     simStateManager->simStateHandle_ = nullptr;
1296     EXPECT_EQ(simStateManager->SetModemInit(false), TELEPHONY_ERR_LOCAL_PTR_NULL);
1297     EXPECT_FALSE(simStateManager->IfModemInitDone());
1298 
1299     LockInfo lockInfo;
1300     lockInfo.lockType = static_cast<LockType>(0);
1301     LockStatusResponse lockStatusResponse;
1302     lockStatusResponse.result = UNLOCK_OK;
1303     EXPECT_EQ(simStateManager->SetLockState(0, lockInfo, lockStatusResponse), TELEPHONY_ERR_ARGUMENT_INVALID);
1304     EXPECT_EQ(lockStatusResponse.result, UNLOCK_FAIL);
1305 
1306     lockInfo.lockType = LockType::FDN_LOCK;
1307     EXPECT_EQ(simStateManager->SetLockState(0, lockInfo, lockStatusResponse), TELEPHONY_ERR_ARGUMENT_INVALID);
1308 
1309     LockState lockState;
1310     LockType lockType = static_cast<LockType>(0);
1311     EXPECT_EQ(simStateManager->GetLockState(0, lockType, lockState), TELEPHONY_ERR_ARGUMENT_INVALID);
1312     EXPECT_EQ(lockState, LockState::LOCK_ERROR);
1313 
1314     lockType = LockType::FDN_LOCK;
1315     EXPECT_EQ(simStateManager->GetLockState(0, lockType, lockState), TELEPHONY_ERR_LOCAL_PTR_NULL);
1316 
1317     SimIoRequestInfo simIoRequestInfo;
1318     SimAuthenticationResponse response;
1319     EXPECT_EQ(simStateManager->GetSimIO(0, simIoRequestInfo, response), SIM_AUTH_FAIL);
1320 }
1321 
1322 HWTEST_F(SimRilBranchTest, Telephony_StkController_003, Function | MediumTest | Level1)
1323 {
1324     std::shared_ptr<TelRilManager> telRilManager = nullptr;
1325     std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1326     auto stkController = std::make_shared<StkController>(telRilManager, simStateManager, INVALID_SLOTID);
1327 
1328     EXPECT_FALSE(stkController->CheckIsBipCmd("01234567890000"));
1329     ASSERT_EQ(TELEPHONY_EXT_WRAPPER.sendEvent_, nullptr);
1330 
1331     EXPECT_TRUE(stkController->CheckIsBipCmd("01234567894000"));
1332     EXPECT_TRUE(stkController->CheckIsBipCmd("01234567894300"));
1333     EXPECT_TRUE(stkController->CheckIsBipCmd("01234567894200"));
1334     EXPECT_TRUE(stkController->CheckIsBipCmd("01234567894400"));
1335     EXPECT_TRUE(stkController->CheckIsBipCmd("01234567894100"));
1336 
1337     AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr);
1338     stkController->OnSendTerminalResponseResult(event);
1339     stkController->OnSendEnvelopeCmdResult(event);
1340     stkController->OnSendCallSetupRequestResult(event);
1341 }
1342 
1343 HWTEST_F(SimRilBranchTest, Telephony_SimStateHandle_003, Function | MediumTest | Level1)
1344 {
1345     std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1346     std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1347     auto simStateHandle = std::make_shared<SimStateHandle>(simStateManager);
1348     simStateHandle->observerHandler_ = std::make_unique<ObserverHandler>();
1349     LockReason reason = LockReason::SIM_NONE;
1350 
1351     simStateHandle->SimStateEscape(ICC_CARD_ABSENT, 0, reason);
1352     EXPECT_EQ(simStateHandle->externalState_, SimState::SIM_STATE_NOT_PRESENT);
1353 
1354     simStateHandle->SimStateEscape(ICC_CONTENT_READY, 0, reason);
1355     EXPECT_EQ(simStateHandle->externalState_, SimState::SIM_STATE_READY);
1356 
1357     simStateHandle->SimStateEscape(ICC_CONTENT_PIN, 0, reason);
1358     EXPECT_EQ(simStateHandle->externalState_, SimState::SIM_STATE_LOCKED);
1359     EXPECT_EQ(reason, LockReason::SIM_PIN);
1360 
1361     simStateHandle->SimStateEscape(ICC_CONTENT_PUK, 0, reason);
1362     EXPECT_EQ(simStateHandle->externalState_, SimState::SIM_STATE_LOCKED);
1363     EXPECT_EQ(reason, LockReason::SIM_PUK);
1364 
1365     simStateHandle->SimStateEscape(-1, 0, reason);
1366 }
1367 
1368 
1369 HWTEST_F(SimRilBranchTest, Telephony_SimStateHandle_004, Function | MediumTest | Level1)
1370 {
1371     std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1372     std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1373     auto simStateHandle = std::make_shared<SimStateHandle>(simStateManager);
1374     simStateHandle->observerHandler_ = std::make_unique<ObserverHandler>();
1375     LockReason reason = LockReason::SIM_NONE;
1376 
1377     simStateHandle->SimLockStateEscape(ICC_CONTENT_PH_NET_PIN, 0, reason);
1378     EXPECT_EQ(reason, LockReason::SIM_PN_PIN);
1379 
1380     simStateHandle->SimLockStateEscape(ICC_CONTENT_PH_NET_PUK, 0, reason);
1381     EXPECT_EQ(reason, LockReason::SIM_PN_PUK);
1382 
1383     simStateHandle->SimLockStateEscape(ICC_CONTENT_PH_NET_SUB_PIN, 0, reason);
1384     EXPECT_EQ(reason, LockReason::SIM_PU_PIN);
1385 
1386     simStateHandle->SimLockStateEscape(ICC_CONTENT_PH_NET_SUB_PUK, 0, reason);
1387     EXPECT_EQ(reason, LockReason::SIM_PU_PUK);
1388 
1389     simStateHandle->SimLockStateEscape(ICC_CONTENT_PH_SP_PIN, 0, reason);
1390     EXPECT_EQ(reason, LockReason::SIM_PP_PIN);
1391 
1392     simStateHandle->SimLockStateEscape(ICC_CONTENT_PH_SP_PUK, 0, reason);
1393     EXPECT_EQ(reason, LockReason::SIM_PP_PUK);
1394 
1395     simStateHandle->SimLockStateEscape(ICC_CONTENT_UNKNOWN, 0, reason);
1396     EXPECT_EQ(simStateHandle->externalState_, SimState::SIM_STATE_UNKNOWN);
1397 }
1398 
1399 HWTEST_F(SimRilBranchTest, Telephony_SimStateHandle_005, Function | MediumTest | Level1)
1400 {
1401     std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1402     std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1403     auto simStateHandle = std::make_shared<SimStateHandle>(simStateManager);
1404 
1405     simStateHandle->observerHandler_ = std::make_unique<ObserverHandler>();
1406     simStateHandle->externalType_ = CardType::UNKNOWN_CARD;
1407     simStateHandle->CardTypeEscape(-1, 0);
1408     EXPECT_EQ(simStateHandle->externalType_, CardType::UNKNOWN_CARD);
1409 
1410     simStateHandle->CardTypeEscape(ICC_SIM_TYPE, 0);
1411     EXPECT_EQ(simStateHandle->externalType_, CardType::SINGLE_MODE_SIM_CARD);
1412 
1413     simStateHandle->CardTypeEscape(ICC_USIM_TYPE, 0);
1414     EXPECT_EQ(simStateHandle->externalType_, CardType::SINGLE_MODE_USIM_CARD);
1415 
1416     simStateHandle->CardTypeEscape(ICC_RUIM_TYPE, 0);
1417     EXPECT_EQ(simStateHandle->externalType_, CardType::SINGLE_MODE_RUIM_CARD);
1418 
1419     simStateHandle->CardTypeEscape(ICC_CG_TYPE, 0);
1420     EXPECT_EQ(simStateHandle->externalType_, CardType::DUAL_MODE_CG_CARD);
1421 
1422     simStateHandle->CardTypeEscape(ICC_DUAL_MODE_ROAMING_TYPE, 0);
1423     EXPECT_EQ(simStateHandle->externalType_, CardType::CT_NATIONAL_ROAMING_CARD);
1424 
1425     simStateHandle->CardTypeEscape(ICC_UNICOM_DUAL_MODE_TYPE, 0);
1426     EXPECT_EQ(simStateHandle->externalType_, CardType::CU_DUAL_MODE_CARD);
1427 
1428     simStateHandle->CardTypeEscape(ICC_4G_LTE_TYPE, 0);
1429     EXPECT_EQ(simStateHandle->externalType_, CardType::DUAL_MODE_TELECOM_LTE_CARD);
1430 
1431     simStateHandle->CardTypeEscape(ICC_UG_TYPE, 0);
1432     EXPECT_EQ(simStateHandle->externalType_, CardType::DUAL_MODE_UG_CARD);
1433 
1434     simStateHandle->CardTypeEscape(ICC_IMS_TYPE, 0);
1435     EXPECT_EQ(simStateHandle->externalType_, CardType::SINGLE_MODE_ISIM_CARD);
1436 
1437     simStateHandle->UnRegisterCoreNotify(nullptr, RadioEvent::RADIO_SIM_STATE_CHANGE);
1438     simStateHandle->UnRegisterCoreNotify(nullptr, RadioEvent::RADIO_SIM_STATE_READY);
1439     simStateHandle->UnRegisterCoreNotify(nullptr, RadioEvent::RADIO_SIM_STATE_LOCKED);
1440     simStateHandle->UnRegisterCoreNotify(nullptr, RadioEvent::RADIO_SIM_STATE_SIMLOCK);
1441     simStateHandle->UnRegisterCoreNotify(nullptr, RadioEvent::RADIO_CARD_TYPE_CHANGE);
1442     simStateHandle->UnRegisterCoreNotify(nullptr, -1);
1443 }
1444 
1445 HWTEST_F(SimRilBranchTest, Telephony_OperatorFileParser, Function | MediumTest | Level1)
1446 {
1447     OperatorFileParser parser;
1448 
1449     EXPECT_FALSE(parser.WriteOperatorConfigJson("testName", nullptr));
1450     EXPECT_STREQ((parser.GetOperatorConfigFilePath("")).c_str(), "");
1451 
1452     parser.tempConfig_ = {{"valid_key", "{\"name\":\"valid_value\"}"}, {"invalid_key", ""}};
1453 
1454     cJSON *root = cJSON_CreateObject();
1455     parser.CreateJsonFromOperatorConfig(root);
1456 
1457     EXPECT_NE(cJSON_GetObjectItem(root, "valid_key"), nullptr);
1458     EXPECT_EQ(cJSON_GetObjectItem(root, "invalid_key"), nullptr);
1459 
1460     cJSON_Delete(root);
1461     root = nullptr;
1462 
1463     OperatorConfig operatorConfig;
1464     parser.ParseArray("testKey", nullptr, operatorConfig);
1465 
1466     cJSON *value = cJSON_CreateArray();
1467     ASSERT_NE(value, nullptr);
1468     parser.ParseArray("testKey", value, operatorConfig);
1469 
1470     cJSON_Delete(value);
1471     value = nullptr;
1472 }
1473 } // namespace Telephony
1474 } // namespace OHOS
1475