1 /*
2 * Copyright (C) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define private public
16 #define protected public
17 #include "cell_info.h"
18 #include "cell_location.h"
19 #include "common_event_manager.h"
20 #include "common_event_support.h"
21 #include "core_manager_inner.h"
22 #include "core_service_client.h"
23 #include "csim_file_controller.h"
24 #include "gtest/gtest.h"
25 #include "tel_ril_base_parcel.h"
26 #include "icc_file.h"
27 #include "icc_file_controller.h"
28 #include "icc_operator_rule.h"
29 #include "ims_core_service_callback_proxy.h"
30 #include "ims_core_service_callback_stub.h"
31 #include "ims_core_service_proxy.h"
32 #include "ims_reg_info_callback_proxy.h"
33 #include "isim_file_controller.h"
34 #include "multi_sim_controller.h"
35 #include "multi_sim_monitor.h"
36 #include "network_register.h"
37 #include "network_search_manager.h"
38 #include "network_search_state.h"
39 #include "operator_matching_rule.h"
40 #include "operator_name.h"
41 #include "radio_protocol_controller.h"
42 #include "ruim_file_controller.h"
43 #include "sim_file_controller.h"
44 #include "sim_file_manager.h"
45 #include "sim_manager.h"
46 #include "sim_number_decode.h"
47 #include "sim_rdb_helper.h"
48 #include "sim_sms_controller.h"
49 #include "sim_state_manager.h"
50 #include "sim_utils.h"
51 #include "stk_controller.h"
52 #include "stk_manager.h"
53 #include "tag_service.h"
54 #include "tel_ril_manager.h"
55 #include "telephony_errors.h"
56 #include "telephony_hisysevent.h"
57 #include "telephony_log_wrapper.h"
58 #include "usim_file_controller.h"
59 #include "telephony_data_helper.h"
60 #include "sim_data.h"
61 #include "accesstoken_kit.h"
62 #include "token_setproc.h"
63 #include "nativetoken_kit.h"
64
65 namespace OHOS {
66 namespace Telephony {
67 using namespace testing::ext;
68
69 namespace {
70 const int32_t SLOT_ID_0 = 0;
71 const int32_t INVALID_SLOTID = -1;
72 const int DATA_STORAGE_ERR_PERMISSION_ERR = -3;
73 const int32_t OBTAIN_SPN_NONE = 0;
74 const int32_t OBTAIN_SPN_START = 1;
75 const int32_t OBTAIN_SPN_GENERAL = 2;
76 const int32_t OBTAIN_OPERATOR_NAMESTRING = 3;
77 const int32_t OBTAIN_OPERATOR_NAME_SHORTFORM = 4;
78 const int32_t BYTES_LENGTH = 3;
79 const int32_t LO_FOUR_LENGTH = 15;
80 const int32_t CORE_NETWORK_MODE_NR = 31;
81 const int32_t VALUE_LENGTH = 128;
82 const CellInformation::CellType NONE = CellInformation::CellType::CELL_TYPE_NONE;
83 const CellInformation::CellType GSM = CellInformation::CellType::CELL_TYPE_GSM;
84 const CellInformation::CellType CDMA = CellInformation::CellType::CELL_TYPE_CDMA;
85 const CellInformation::CellType WCDMA = CellInformation::CellType::CELL_TYPE_WCDMA;
86 const CellInformation::CellType TDSCDMA = CellInformation::CellType::CELL_TYPE_TDSCDMA;
87 const CellInformation::CellType LTE = CellInformation::CellType::CELL_TYPE_LTE;
88 const CellInformation::CellType NR = CellInformation::CellType::CELL_TYPE_NR;
89 } // namespace
90
91 class BranchTest : public testing::Test {
92 public:
93 static void SetUpTestCase();
94 static void TearDownTestCase();
95 void SetUp();
96 void TearDown();
97 };
98
TearDownTestCase()99 void BranchTest::TearDownTestCase() {}
100
SetUp()101 void BranchTest::SetUp() {}
102
TearDown()103 void BranchTest::TearDown() {}
104
SetUpTestCase()105 void BranchTest::SetUpTestCase()
106 {
107 constexpr int permissionNum = 2;
108 const char *perms[permissionNum] = {"ohos.permission.GET_TELEPHONY_STATE",
109 "ohos.permission.SET_TELEPHONY_STATE"};
110 NativeTokenInfoParams infoInstance = {.dcapsNum = 0, .permsNum = permissionNum, .aclsNum = 0, .dcaps = nullptr,
111 .perms = perms, .acls = nullptr, .processName = "BranchTest", .aplStr = "system_basic",
112 };
113 uint64_t tokenId = GetAccessTokenId(&infoInstance);
114 SetSelfTokenID(tokenId);
115 auto result = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
116 EXPECT_EQ(result, Security::AccessToken::RET_SUCCESS);
117 }
118
119 /**
120 * @tc.number Telephony_CellInfo_001
121 * @tc.name test error branch
122 * @tc.desc Function test
123 */
124 HWTEST_F(BranchTest, Telephony_CellInfo_001, Function | MediumTest | Level1)
125 {
126 auto telRilManager = std::make_shared<TelRilManager>();
127 auto simManager = std::make_shared<SimManager>(telRilManager);
128 auto networkSearchManager_ = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
129 auto cellInfo = std::make_shared<CellInfo>(networkSearchManager_, INVALID_SLOTID);
130 std::vector<sptr<CellInformation>> cellInfoList;
131 auto event = AppExecFwk::InnerEvent::Get(0);
132 sptr<CellInformation> gsmCellInformation = new GsmCellInformation();
133 sptr<CellInformation> lteCellInformation = new LteCellInformation();
134 sptr<CellInformation> wcdmaCellInformation = new WcdmaCellInformation();
135 sptr<CellInformation> tdscdmaCellInformation = new TdscdmaCellInformation();
136 sptr<CellInformation> nrCellInformation = new NrCellInformation();
137 sptr<CellInformation> cdmaCellInformation = new CdmaCellInformation();
138 sptr<CellInformation> cdmaCellInformationTwo;
139 cdmaCellInformationTwo = cdmaCellInformation;
140 Parcel parcel;
141 gsmCellInformation->CellInformation::Unmarshalling(parcel);
142 std::vector<sptr<CellInformation>> cellInfos;
143 cellInfo->GetCellInfoList(cellInfoList);
144 cellInfo->ProcessNeighboringCellInfo(event);
145 cellInfo->ProcessCurrentCellInfo(event);
146 event = nullptr;
147 cellInfo->ProcessNeighboringCellInfo(event);
148 cellInfo->ProcessCurrentCellInfo(event);
149 cellInfo->UpdateCellLocation(0, 1, 1);
150 cellInfo->UpdateCellLocation(1, 1, 1);
151 cellInfo->GetCellLocation();
152 cellInfo->NotifyCellInfoUpdated();
153 cellInfo->ProcessCellLocation(gsmCellInformation, CellInformation::CellType::CELL_TYPE_NONE, 1, 0);
154 cellInfo->UpdateSignalLevel(gsmCellInformation, CellInformation::CellType::CELL_TYPE_TDSCDMA);
155 cellInfo->UpdateSignalLevel(gsmCellInformation, CellInformation::CellType::CELL_TYPE_NONE);
156 cellInfo->AddCellInformation(gsmCellInformation, cellInfos);
157 cellInfo->AddCellInformation(lteCellInformation, cellInfos);
158 cellInfo->AddCellInformation(wcdmaCellInformation, cellInfos);
159 cellInfo->AddCellInformation(tdscdmaCellInformation, cellInfos);
160 cellInfo->AddCellInformation(nrCellInformation, cellInfos);
161 cellInfo->AddCellInformation(cdmaCellInformation, cellInfos);
162 EXPECT_TRUE(cellInfo->ProcessCellLocation(gsmCellInformation, CellInformation::CellType::CELL_TYPE_GSM, 1, 0));
163 EXPECT_TRUE(cellInfo->ProcessCellLocation(lteCellInformation, CellInformation::CellType::CELL_TYPE_LTE, 1, 0));
164 EXPECT_TRUE(cellInfo->ProcessCellLocation(wcdmaCellInformation, CellInformation::CellType::CELL_TYPE_WCDMA, 1, 0));
165 EXPECT_TRUE(
166 cellInfo->ProcessCellLocation(tdscdmaCellInformation, CellInformation::CellType::CELL_TYPE_TDSCDMA, 1, 0));
167 EXPECT_TRUE(cellInfo->ProcessCellLocation(nrCellInformation, CellInformation::CellType::CELL_TYPE_NR, 1, 0));
168 EXPECT_GE(cdmaCellInformation->GetSignalIntensity(), 0);
169 }
170
171 /**
172 * @tc.number Telephony_CellInfo_002
173 * @tc.name test error branch
174 * @tc.desc Function test
175 */
176 HWTEST_F(BranchTest, Telephony_CellInfo_002, Function | MediumTest | Level1)
177 {
178 auto telRilManager = std::make_shared<TelRilManager>();
179 auto simManager = std::make_shared<SimManager>(telRilManager);
180 auto networkSearchManager_ = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
181 auto cellInfo = std::make_shared<CellInfo>(networkSearchManager_, INVALID_SLOTID);
182 CellNearbyInfo cellNearbyInfo;
183 cellNearbyInfo.ServiceCellParas.gsm.arfcn = 1;
184 cellNearbyInfo.ServiceCellParas.gsm.cellId = 1;
185 cellNearbyInfo.ServiceCellParas.gsm.bsic = 1;
186 cellNearbyInfo.ServiceCellParas.gsm.lac = 0;
187 cellNearbyInfo.ServiceCellParas.lte.pci = 1;
188 cellNearbyInfo.ServiceCellParas.lte.arfcn = 1;
189 cellNearbyInfo.ServiceCellParas.wcdma.arfcn = 1;
190 cellNearbyInfo.ServiceCellParas.wcdma.psc = 1;
191 cellNearbyInfo.ServiceCellParas.cdma.baseId = 1;
192 cellNearbyInfo.ServiceCellParas.tdscdma.arfcn = 1;
193 cellNearbyInfo.ServiceCellParas.nr.nci = 1;
194 CurrentCellInformation current;
195 EXPECT_TRUE(cellInfo->ProcessNeighboringCellGsm(&cellNearbyInfo));
196 EXPECT_TRUE(cellInfo->ProcessNeighboringCellLte(&cellNearbyInfo));
197 EXPECT_TRUE(cellInfo->ProcessNeighboringCellWcdma(&cellNearbyInfo));
198 EXPECT_TRUE(cellInfo->ProcessNeighboringCellCdma(&cellNearbyInfo));
199 EXPECT_TRUE(cellInfo->ProcessNeighboringCellTdscdma(&cellNearbyInfo));
200 EXPECT_TRUE(cellInfo->ProcessNeighboringCellNr(&cellNearbyInfo));
201 current.ratType = TelRilRatType::NETWORK_TYPE_GSM;
202 EXPECT_TRUE(cellInfo->ProcessCurrentCell(¤t));
203 current.ratType = TelRilRatType::NETWORK_TYPE_LTE;
204 EXPECT_TRUE(cellInfo->ProcessCurrentCell(¤t));
205 current.ratType = TelRilRatType::NETWORK_TYPE_WCDMA;
206 EXPECT_TRUE(cellInfo->ProcessCurrentCell(¤t));
207 current.ratType = TelRilRatType::NETWORK_TYPE_TDSCDMA;
208 EXPECT_TRUE(cellInfo->ProcessCurrentCell(¤t));
209 current.ratType = TelRilRatType::NETWORK_TYPE_CDMA;
210 EXPECT_TRUE(cellInfo->ProcessCurrentCell(¤t));
211 current.ratType = TelRilRatType::NETWORK_TYPE_NR;
212 EXPECT_TRUE(cellInfo->ProcessCurrentCell(¤t));
213 current.ratType = TelRilRatType::NETWORK_TYPE_UNKNOWN;
214 EXPECT_FALSE(cellInfo->ProcessCurrentCell(¤t));
215 }
216
217 /**
218 * @tc.number Telephony_CellInfo_003
219 * @tc.name test error branch
220 * @tc.desc Function test
221 */
222 HWTEST_F(BranchTest, Telephony_CellInfo_003, Function | MediumTest | Level1)
223 {
224 auto telRilManager = std::make_shared<TelRilManager>();
225 auto simManager = std::make_shared<SimManager>(telRilManager);
226 auto networkSearchManager_ = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
227 auto cellInfo = std::make_shared<CellInfo>(networkSearchManager_, INVALID_SLOTID);
228 EXPECT_EQ(cellInfo->ConvertToCellType(SignalInformation::NetworkType::UNKNOWN), NONE);
229 EXPECT_EQ(cellInfo->ConvertToCellType(SignalInformation::NetworkType::GSM), GSM);
230 EXPECT_EQ(cellInfo->ConvertToCellType(SignalInformation::NetworkType::WCDMA), WCDMA);
231 EXPECT_EQ(cellInfo->ConvertToCellType(SignalInformation::NetworkType::LTE), LTE);
232 EXPECT_EQ(cellInfo->ConvertToCellType(SignalInformation::NetworkType::CDMA), CDMA);
233 EXPECT_EQ(cellInfo->ConvertToCellType(SignalInformation::NetworkType::TDSCDMA), TDSCDMA);
234 EXPECT_EQ(cellInfo->ConvertToCellType(SignalInformation::NetworkType::NR), NR);
235 EXPECT_EQ(cellInfo->ConvertTechToCellType(RadioTech::RADIO_TECHNOLOGY_GSM), GSM);
236 EXPECT_EQ(cellInfo->ConvertTechToCellType(RadioTech::RADIO_TECHNOLOGY_WCDMA), WCDMA);
237 EXPECT_EQ(cellInfo->ConvertTechToCellType(RadioTech::RADIO_TECHNOLOGY_HSPAP), WCDMA);
238 EXPECT_EQ(cellInfo->ConvertTechToCellType(RadioTech::RADIO_TECHNOLOGY_HSPA), WCDMA);
239 EXPECT_EQ(cellInfo->ConvertTechToCellType(RadioTech::RADIO_TECHNOLOGY_LTE), LTE);
240 EXPECT_EQ(cellInfo->ConvertTechToCellType(RadioTech::RADIO_TECHNOLOGY_LTE_CA), LTE);
241 EXPECT_EQ(cellInfo->ConvertTechToCellType(RadioTech::RADIO_TECHNOLOGY_TD_SCDMA), TDSCDMA);
242 EXPECT_EQ(cellInfo->ConvertTechToCellType(RadioTech::RADIO_TECHNOLOGY_1XRTT), CDMA);
243 EXPECT_EQ(cellInfo->ConvertTechToCellType(RadioTech::RADIO_TECHNOLOGY_EVDO), CDMA);
244 EXPECT_EQ(cellInfo->ConvertTechToCellType(RadioTech::RADIO_TECHNOLOGY_EHRPD), CDMA);
245 EXPECT_EQ(cellInfo->ConvertTechToCellType(RadioTech::RADIO_TECHNOLOGY_NR), NR);
246 EXPECT_EQ(cellInfo->ConvertTechToCellType(RadioTech::RADIO_TECHNOLOGY_UNKNOWN), NONE);
247 EXPECT_EQ(cellInfo->ConvertRatToCellType(TelRilRatType::NETWORK_TYPE_GSM), GSM);
248 EXPECT_EQ(cellInfo->ConvertRatToCellType(TelRilRatType::NETWORK_TYPE_WCDMA), WCDMA);
249 EXPECT_EQ(cellInfo->ConvertRatToCellType(TelRilRatType::NETWORK_TYPE_LTE), LTE);
250 EXPECT_EQ(cellInfo->ConvertRatToCellType(TelRilRatType::NETWORK_TYPE_CDMA), CDMA);
251 EXPECT_EQ(cellInfo->ConvertRatToCellType(TelRilRatType::NETWORK_TYPE_TDSCDMA), TDSCDMA);
252 EXPECT_EQ(cellInfo->ConvertRatToCellType(TelRilRatType::NETWORK_TYPE_NR), NR);
253 EXPECT_EQ(cellInfo->ConvertRatToCellType(TelRilRatType::NETWORK_TYPE_UNKNOWN), NONE);
254 }
255
256 /**
257 * @tc.number Telephony_CellInfo_004
258 * @tc.name test error branch
259 * @tc.desc Function test
260 */
261 HWTEST_F(BranchTest, Telephony_CellInfo_004, Function | MediumTest | Level1)
262 {
263 auto telRilManager = std::make_shared<TelRilManager>();
264 auto simManager = std::make_shared<SimManager>(telRilManager);
265 auto networkSearchManager_ = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
266 auto cellInfo = std::make_shared<CellInfo>(networkSearchManager_, 1);
267 int32_t SIGNAL_FOUR_BARS = 4;
268 cellInfo->InitCellSignalBar(SIGNAL_FOUR_BARS);
269 cellInfo->UpdateCellLocation(0, 10, 9);
270 cellInfo->UpdateCellLocation(1, 11, 8);
271 cellInfo->UpdateCellLocation(2, 12, 7);
272 cellInfo->UpdateCellLocation(3, 13, 6);
273 cellInfo->UpdateCellLocation(4, 14, 5);
274 cellInfo->UpdateCellLocation(5, 15, 4);
275 cellInfo->UpdateCellLocation(6, 16, 3);
276 cellInfo->GetCurrentSignalLevelGsm(0);
277 cellInfo->GetCurrentSignalLevelLte(0);
278 cellInfo->GetCurrentSignalLevelCdma(0);
279 cellInfo->GetCurrentSignalLevelTdscdma(0);
280 cellInfo->GetCurrentSignalLevelNr(0);
281 cellInfo->GetCellLocationExt(CellInformation::CellType::CELL_TYPE_NONE);
282 cellInfo->GetCellLocationExt(CellInformation::CellType::CELL_TYPE_LTE);
283 cellInfo->GetCellLocationExt(CellInformation::CellType::CELL_TYPE_NR);
284 EXPECT_EQ(cellInfo->GetCurrentSignalLevelCdma(-40), SIGNAL_FOUR_BARS);
285 EXPECT_EQ(cellInfo->GetCurrentSignalLevelWcdma(-40), SIGNAL_FOUR_BARS);
286 EXPECT_EQ(cellInfo->GetCurrentSignalLevelLte(-40), SIGNAL_FOUR_BARS);
287 EXPECT_EQ(cellInfo->GetCurrentSignalLevelGsm(-40), SIGNAL_FOUR_BARS);
288 EXPECT_EQ(cellInfo->GetCurrentSignalLevelTdscdma(-40), SIGNAL_FOUR_BARS);
289 EXPECT_EQ(cellInfo->GetCurrentSignalLevelNr(-40), SIGNAL_FOUR_BARS);
290 }
291
292 /**
293 * @tc.number Telephony_CellInfo_005
294 * @tc.name test error branch
295 * @tc.desc Function test
296 */
297 HWTEST_F(BranchTest, Telephony_CellInfo_005, Function | MediumTest | Level1)
298 {
299 auto telRilManager = std::make_shared<TelRilManager>();
300 auto simManager = std::make_shared<SimManager>(telRilManager);
301 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
302 auto cellInfo = std::make_shared<CellInfo>(networkSearchManager, INVALID_SLOTID);
303 auto event = AppExecFwk::InnerEvent::Get(0);
304 cellInfo->ProcessNeighboringCellInfo(event);
305 cellInfo->ProcessCurrentCellInfo(event);
306 event = nullptr;
307 cellInfo->ProcessNeighboringCellInfo(event);
308 cellInfo->ProcessCurrentCellInfo(event);
309 auto cellListNearbyInfo = std::make_shared<CellListNearbyInfo>();
310 auto cellListCurrentInfo = std::make_shared<CellListCurrentInformation>();
311 auto eventNearby = AppExecFwk::InnerEvent::Get(0, cellListNearbyInfo);
312 auto eventCurrent = AppExecFwk::InnerEvent::Get(0, cellListCurrentInfo);
313 cellInfo->ProcessNeighboringCellInfo(eventNearby);
314 cellInfo->ProcessCurrentCellInfo(eventCurrent);
315 CellNearbyInfo cellInfoNearby;
316 cellInfoNearby.ratType = 1;
317 cellListNearbyInfo->itemNum = 1;
318 cellListNearbyInfo->cellNearbyInfo.push_back(cellInfoNearby);
319 CurrentCellInformation cellInfoCurrent;
320 cellInfoCurrent.ratType = 1;
321 cellListCurrentInfo->itemNum = 1;
322 cellListCurrentInfo->cellCurrentInfo.push_back(cellInfoCurrent);
323 cellInfo->ProcessNeighboringCellInfo(eventNearby);
324 cellInfo->ProcessCurrentCellInfo(eventCurrent);
325
326 cellInfo = std::make_shared<CellInfo>(networkSearchManager, SLOT_ID_0);
327 cellInfo->UpdateCellLocation(1, 1, 1);
328 sptr<CellInformation> gsmCellInfo = new GsmCellInformation;
329 EXPECT_TRUE(cellInfo->ProcessCellLocation(gsmCellInfo, GSM, 1, 1));
330 }
331
332 /**
333 * @tc.number Telephony_CellInfo_006
334 * @tc.name test error branch
335 * @tc.desc Function test
336 */
337 HWTEST_F(BranchTest, Telephony_CellInfo_006, Function | MediumTest | Level1)
338 {
339 auto telRilManager = std::make_shared<TelRilManager>();
340 auto simManager = std::make_shared<SimManager>(telRilManager);
341 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
342 auto cellInfo = std::make_shared<CellInfo>(networkSearchManager, INVALID_SLOTID);
343 sptr<CellInformation> nwCellInfo = new GsmCellInformation;
344 EXPECT_FALSE(cellInfo->ProcessCellLocation(nwCellInfo, GSM, 0, 0));
345 nwCellInfo = new LteCellInformation;
346 EXPECT_FALSE(cellInfo->ProcessCellLocation(nwCellInfo, LTE, 0, 0));
347 nwCellInfo = new WcdmaCellInformation;
348 EXPECT_FALSE(cellInfo->ProcessCellLocation(nwCellInfo, WCDMA, 0, 0));
349 nwCellInfo = new TdscdmaCellInformation;
350 EXPECT_FALSE(cellInfo->ProcessCellLocation(nwCellInfo, TDSCDMA, 0, 0));
351 nwCellInfo = new NrCellInformation;
352 EXPECT_FALSE(cellInfo->ProcessCellLocation(nwCellInfo, NR, 0, 0));
353 }
354
355 /**
356 * @tc.number Telephony_NetworkType_001
357 * @tc.name test error branch
358 * @tc.desc Function test
359 */
360 HWTEST_F(BranchTest, Telephony_NetworkType_001, Function | MediumTest | Level1)
361 {
362 auto telRilManager = std::make_shared<TelRilManager>();
363 auto simManager = std::make_shared<SimManager>(telRilManager);
364 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
365 auto networkType = std::make_unique<NetworkType>(networkSearchManager, INVALID_SLOTID);
366 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_PREFERRED_NETWORK_MODE);
367 networkType->ProcessGetPreferredNetwork(event);
368 event = nullptr;
369 networkType->ProcessGetPreferredNetwork(event);
370 }
371
372 /**
373 * @tc.number Telephony_ImsRegInfoCallbackProxy_001
374 * @tc.name test error branch
375 * @tc.desc Function test
376 */
377 HWTEST_F(BranchTest, Telephony_ImsRegInfoCallbackProxy_001, Function | MediumTest | Level1)
378 {
379 sptr<ISystemAbilityManager> systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
380 if (systemAbilityMgr == nullptr) {
381 TELEPHONY_LOGE("Telephony_ImsRegInfoCallbackProxy systemAbilityMgr is nullptr");
382 return;
383 }
384 sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CORE_SERVICE_SYS_ABILITY_ID);
385 if (remote == nullptr) {
386 TELEPHONY_LOGE("Telephony_ImsRegInfoCallbackProxy remote is nullptr");
387 return;
388 }
389 auto imsRegInfoCallbackProxy = std::make_shared<ImsRegInfoCallbackProxy>(remote);
390 ImsRegInfo info;
391 imsRegInfoCallbackProxy->OnImsRegInfoChanged(0, ImsServiceType::TYPE_VOICE, info);
392 }
393
394 /**
395 * @tc.number Telephony_SimFileManager_001
396 * @tc.name test error branch
397 * @tc.desc Function test
398 */
399 HWTEST_F(BranchTest, Telephony_SimFileManager_001, Function | MediumTest | Level1)
400 {
401 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
402 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
403 EventFwk::MatchingSkills matchingSkills;
404 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
405 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
406 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
407 std::weak_ptr<SimStateManager>(simStateManager) };
408 const std::u16string emptyStr = Str8ToStr16("");
409 const std::u16string mailName = Str8ToStr16("张三");
410 const std::u16string mailnumber = Str8ToStr16("12345678901");
411 const std::u16string alphaTag = Str8ToStr16("");
412 const std::u16string phoneNumber = Str8ToStr16("123456789");
413 simFileManager.ClearData();
414 EXPECT_EQ(simFileManager.GetSimOperatorNumeric(), u"");
415 simFileManager.GetISOCountryCodeForSim();
416 EXPECT_EQ(simFileManager.GetSimSpn(), u"");
417 EXPECT_EQ(simFileManager.GetSimEons("46001", 1, true), u"");
418 EXPECT_EQ(simFileManager.GetSimIccId(), u"");
419 EXPECT_EQ(simFileManager.GetLocaleFromDefaultSim(), u"");
420 EXPECT_EQ(simFileManager.GetSimGid1(), u"");
421 EXPECT_EQ(simFileManager.GetSimGid2(), u"");
422 EXPECT_EQ(simFileManager.GetSimTelephoneNumber(), u"");
423 EXPECT_EQ(simFileManager.GetSimTeleNumberIdentifier(), u"");
424 EXPECT_EQ(simFileManager.GetSimIst(), u"");
425 EXPECT_EQ(simFileManager.GetVoiceMailIdentifier(), u"");
426 EXPECT_EQ(simFileManager.GetVoiceMailNumber(), u"");
427 EXPECT_EQ(simFileManager.GetIccFile(), nullptr);
428 EXPECT_EQ(simFileManager.GetIccFileController(), nullptr);
429 auto event = AppExecFwk::InnerEvent::Get(0);
430 event = nullptr;
431 simFileManager.ProcessEvent(event);
432 simFileManager.SetImsi("46001");
433 simFileManager.SetOpName("46001");
434 simFileManager.SetOpKey("CMCC");
435 simFileManager.SetOpKeyExt("opkeyext");
436 EXPECT_EQ(simFileManager.ObtainSpnCondition(true, "46001"), 0);
437 EXPECT_FALSE(simFileManager.SetVoiceMailInfo(mailName, mailnumber));
438 EXPECT_FALSE(simFileManager.SetSimTelephoneNumber(alphaTag, phoneNumber));
439 EXPECT_FALSE(simFileManager.HasSimCard());
440 EXPECT_NE(simFileManager.GetIMSI(), u"46001");
441 EXPECT_EQ(simFileManager.GetOpKey(), u"CMCC");
442 EXPECT_EQ(simFileManager.GetOpName(), u"46001");
443 EXPECT_EQ(simFileManager.GetOpKeyExt(), u"opkeyext");
444 }
445
446 /**
447 * @tc.number Telephony_SimFileManager_002
448 * @tc.name test error branch
449 * @tc.desc Function test
450 */
451 HWTEST_F(BranchTest, Telephony_SimFileManager_002, Function | MediumTest | Level1)
452 {
453 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
454 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
455 EventFwk::MatchingSkills matchingSkills;
456 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
457 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
458 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
459 std::weak_ptr<SimStateManager>(simStateManager) };
460 auto tech = std::make_shared<VoiceRadioTechnology>();
461 simFileManager.ChangeSimFileByCardType(SimFileManager::IccType::ICC_TYPE_USIM);
462 EXPECT_EQ(
463 simFileManager.GetIccTypeByCardType(CardType::SINGLE_MODE_RUIM_CARD), SimFileManager::IccType::ICC_TYPE_CDMA);
464 EXPECT_EQ(simFileManager.GetIccTypeByCardType(CardType::DUAL_MODE_UG_CARD), SimFileManager::IccType::ICC_TYPE_GSM);
465 EXPECT_EQ(
466 simFileManager.GetIccTypeByCardType(CardType::SINGLE_MODE_USIM_CARD), SimFileManager::IccType::ICC_TYPE_USIM);
467 tech->actType = TelRilRadioTech::RADIO_TECHNOLOGY_EHRPD;
468 EXPECT_EQ(simFileManager.GetIccTypeByTech(tech), SimFileManager::IccType::ICC_TYPE_CDMA);
469 tech->actType = TelRilRadioTech::RADIO_TECHNOLOGY_1XRTT;
470 EXPECT_EQ(simFileManager.GetIccTypeByTech(tech), SimFileManager::IccType::ICC_TYPE_CDMA);
471 tech->actType = TelRilRadioTech::RADIO_TECHNOLOGY_WCDMA;
472 EXPECT_EQ(simFileManager.GetIccTypeByTech(tech), SimFileManager::IccType::ICC_TYPE_USIM);
473 tech->actType = TelRilRadioTech::RADIO_TECHNOLOGY_LTE_CA;
474 EXPECT_EQ(simFileManager.GetIccTypeByTech(tech), SimFileManager::IccType::ICC_TYPE_USIM);
475 tech->actType = TelRilRadioTech::RADIO_TECHNOLOGY_LTE;
476 EXPECT_EQ(simFileManager.GetIccTypeByTech(tech), SimFileManager::IccType::ICC_TYPE_USIM);
477 tech->actType = TelRilRadioTech::RADIO_TECHNOLOGY_GSM;
478 EXPECT_EQ(simFileManager.GetIccTypeByTech(tech), SimFileManager::IccType::ICC_TYPE_USIM);
479 tech->actType = TelRilRadioTech::RADIO_TECHNOLOGY_TD_SCDMA;
480 EXPECT_EQ(simFileManager.GetIccTypeByTech(tech), SimFileManager::IccType::ICC_TYPE_USIM);
481 tech->actType = TelRilRadioTech::RADIO_TECHNOLOGY_HSPA;
482 EXPECT_EQ(simFileManager.GetIccTypeByTech(tech), SimFileManager::IccType::ICC_TYPE_USIM);
483 EXPECT_TRUE(simFileManager.IsValidType(SimFileManager::IccType::ICC_TYPE_CDMA));
484 tech = nullptr;
485 EXPECT_EQ(simFileManager.GetIccTypeByTech(tech), SimFileManager::IccType::ICC_TYPE_USIM);
486 EXPECT_EQ(simFileManager.GetIccTypeByTech(nullptr), SimFileManager::IccType::ICC_TYPE_USIM);
487 }
488
489 /**
490 * @tc.number Telephony_SimFileManager_003
491 * @tc.name test error branch
492 * @tc.desc Function test
493 */
494 HWTEST_F(BranchTest, Telephony_SimFileManager_003, Function | MediumTest | Level1)
495 {
496 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
497 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
498 EventFwk::MatchingSkills matchingSkills;
499 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
500 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
501 SimFileManager simFileManager { subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
502 std::weak_ptr<SimStateManager>(simStateManager) };
503 EXPECT_TRUE(simFileManager.IsCTCardType(CardType::SINGLE_MODE_RUIM_CARD));
504 EXPECT_TRUE(simFileManager.IsCTCardType(CardType::CT_NATIONAL_ROAMING_CARD));
505 EXPECT_TRUE(simFileManager.IsCTCardType(CardType::DUAL_MODE_TELECOM_LTE_CARD));
506 EXPECT_FALSE(simFileManager.IsCTCardType(CardType::UNKNOWN_CARD));
507 std::string iccId = "";
508 EXPECT_FALSE(simFileManager.IsCTIccId(iccId));
509 iccId = "8986060";
510 EXPECT_TRUE(simFileManager.IsCTIccId(iccId));
511 iccId = "8985302";
512 EXPECT_TRUE(simFileManager.IsCTIccId(iccId));
513 EXPECT_FALSE(simFileManager.IsCTSimCard());
514 std::shared_ptr<SimFile> simFile = std::make_shared<SimFile>(simStateManager);
515 simFileManager.simFile_ = simFile;
516 auto simStateManagerTwo = std::make_shared<SimStateManager>(telRilManager);
517 auto simStateHandle = std::make_shared<SimStateHandle>(simStateManagerTwo);
518 simStateManager->simStateHandle_ = simStateHandle;
519 simStateHandle->externalType_ = CardType::SINGLE_MODE_RUIM_CARD;
520 simFile->iccId_ = "8986030";
521 EXPECT_TRUE(simFileManager.IsCTSimCard());
522 simStateHandle->externalType_ = CardType::UNKNOWN_CARD;
523 simFile->operatorNumeric_ = "20404";
524 EXPECT_TRUE(simFileManager.IsCTSimCard());
525 simFile->operatorNumeric_ = "45431";
526 EXPECT_FALSE(simFileManager.IsCTSimCard());
527 simFile->operatorNumeric_ = "46003";
528 EXPECT_TRUE(simFileManager.IsCTSimCard());
529 simFile->iccId_ = "8985231";
530 EXPECT_FALSE(simFileManager.IsCTSimCard());
531 simStateManager->simStateHandle_ = nullptr;
532 }
533
534 /**
535 * @tc.number Telephony_SimFile_001
536 * @tc.name test error branch
537 * @tc.desc Function test
538 */
539 HWTEST_F(BranchTest, Telephony_SimFile_001, Function | MediumTest | Level1)
540 {
541 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
542 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
543 std::shared_ptr<SimFile> simFile = std::make_shared<SimFile>(simStateManager);
544 auto event = AppExecFwk::InnerEvent::Get(0);
545 event = nullptr;
546 simFile->ProcessEvent(event);
547 simFile->ObtainSpnPhase(false, event);
548 simFile->ProcessSpnGeneral(event);
549 simFile->ProcessSpnCphs(event);
550 simFile->ProcessSpnShortCphs(event);
551 simFile->InitMemberFunc();
552 simFile->ProcessFileLoaded(false);
553 simFile->ProcessFileLoaded(true);
554 simFile->ProcessIccRefresh(ELEMENTARY_FILE_MBDN);
555 simFile->ProcessIccRefresh(ELEMENTARY_FILE_MAILBOX_CPHS);
556 simFile->ProcessIccRefresh(ELEMENTARY_FILE_CSP_CPHS);
557 simFile->ProcessIccRefresh(ELEMENTARY_FILE_FDN);
558 simFile->ProcessIccRefresh(ELEMENTARY_FILE_MSISDN);
559 simFile->ProcessIccRefresh(ELEMENTARY_FILE_CFIS);
560 simFile->ProcessIccRefresh(ELEMENTARY_FILE_CFF_CPHS);
561 EXPECT_EQ(simFile->ObtainIsoCountryCode(), "");
562 simFile->imsi_ = "1234567890";
563 EXPECT_EQ(simFile->ObtainIsoCountryCode(), "");
564 simFile->lengthOfMnc_ = OBTAIN_SPN_GENERAL;
565 simFile->CheckMncLengthForAdDone();
566 simFile->lengthOfMnc_ = UNKNOWN_MNC;
567 simFile->CheckMncLengthForAdDone();
568 simFile->lengthOfMnc_ = UNINITIALIZED_MNC;
569 simFile->CheckMncLengthForAdDone();
570 EXPECT_FALSE(simFile->CphsVoiceMailAvailable());
571 EXPECT_FALSE(simFile->ProcessIccReady(event));
572 EXPECT_TRUE(simFile->ProcessGetAdDone(event));
573 EXPECT_TRUE(simFile->ProcessVoiceMailCphs(event));
574 EXPECT_TRUE(simFile->ProcessGetMwisDone(event));
575 EXPECT_TRUE(simFile->ProcessGetMbdnDone(event));
576 }
577
578 /**
579 * @tc.number Telephony_SimFile_002
580 * @tc.name test error branch
581 * @tc.desc Function test
582 */
583 HWTEST_F(BranchTest, Telephony_SimFile_002, Function | MediumTest | Level1)
584 {
585 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
586 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
587 std::shared_ptr<SimFile> simFile = std::make_shared<SimFile>(simStateManager);
588 auto event = AppExecFwk::InnerEvent::Get(0);
589 event = nullptr;
590 std::string testStr = "";
591 EXPECT_TRUE(simFile->ProcessGetCphsMailBoxDone(event));
592 EXPECT_TRUE(simFile->ProcessGetMbiDone(event));
593 EXPECT_TRUE(simFile->ProcessGetCfisDone(event));
594 EXPECT_TRUE(simFile->ProcessGetCffDone(event));
595 EXPECT_TRUE(simFile->ProcessObtainIMSIDone(event));
596 EXPECT_TRUE(simFile->ProcessGetIccIdDone(event));
597 EXPECT_TRUE(simFile->ProcessGetPlmnActDone(event));
598 EXPECT_TRUE(simFile->ProcessGetOplmnActDone(event));
599 EXPECT_TRUE(simFile->ProcessGetSpdiDone(event));
600 EXPECT_TRUE(simFile->ProcessGetMsisdnDone(event));
601 simFile->ProcessSetMsisdnDone(event);
602 EXPECT_TRUE(simFile->ProcessObtainGid1Done(event));
603 EXPECT_TRUE(simFile->ProcessObtainGid2Done(event));
604 EXPECT_FALSE(simFile->ProcessSmsOnSim(event));
605 EXPECT_TRUE(simFile->ProcessGetCspCphs(event));
606 EXPECT_TRUE(simFile->ProcessGetInfoCphs(event));
607 EXPECT_TRUE(simFile->ProcessGetSstDone(event));
608 EXPECT_FALSE(simFile->ProcessGetSmsDone(event));
609 EXPECT_TRUE(simFile->ProcessGetAllSmsDone(event));
610 EXPECT_TRUE(simFile->ProcessGetHplmActDone(event));
611 EXPECT_TRUE(simFile->ProcessGetEhplmnDone(event));
612 EXPECT_TRUE(simFile->ProcessGetPnnDone(event));
613 EXPECT_TRUE(simFile->ProcessGetOplDone(event));
614 EXPECT_TRUE(simFile->ProcessGetOpl5gDone(event));
615 EXPECT_FALSE(simFile->ProcessUpdateDone(event));
616 EXPECT_TRUE(simFile->ProcessSetCphsMailbox(event));
617 EXPECT_TRUE(simFile->ProcessGetFplmnDone(event));
618 EXPECT_TRUE(simFile->ProcessSetMbdn(event));
619 EXPECT_FALSE(simFile->ProcessMarkSms(event));
620 EXPECT_TRUE(simFile->ProcessObtainSpnPhase(event));
621 EXPECT_TRUE(simFile->ProcessObtainLiLanguage(event));
622 EXPECT_TRUE(simFile->ProcessObtainPlLanguage(event));
623 }
624
625 /**
626 * @tc.number Telephony_SimFile_003
627 * @tc.name test error branch
628 * @tc.desc Function test
629 */
630 HWTEST_F(BranchTest, Telephony_SimFile_003, Function | MediumTest | Level1)
631 {
632 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
633 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
634 std::shared_ptr<SimFile> simFile = std::make_shared<SimFile>(simStateManager);
635 auto event = AppExecFwk::InnerEvent::Get(0);
636 std::string mailName = "";
637 std::string mailNumber = "1234";
638 simFile->indexOfMailbox_ = 0;
639 simFile->UpdateVoiceMail("", "");
640 EXPECT_FALSE(simFile->UpdateVoiceMail(mailName, mailNumber));
641 simFile->efCfis_ = (unsigned char *)mailNumber.c_str();
642 simFile->imsi_ = "123";
643 simFile->lengthOfMnc_ = UNKNOWN_MNC;
644 EXPECT_EQ(simFile->ObtainSimOperator(), "");
645 simFile->lengthOfMnc_ = UNINITIALIZED_MNC;
646 EXPECT_EQ(simFile->ObtainSimOperator(), "");
647 EXPECT_TRUE(simFile->ProcessGetCphsMailBoxDone(event));
648 EXPECT_TRUE(simFile->ProcessGetMbiDone(event));
649 EXPECT_TRUE(simFile->ProcessGetCfisDone(event));
650 EXPECT_TRUE(simFile->ProcessGetCffDone(event));
651 EXPECT_TRUE(simFile->ProcessObtainIMSIDone(event));
652 EXPECT_TRUE(simFile->ProcessGetIccIdDone(event));
653 EXPECT_TRUE(simFile->ProcessGetPlmnActDone(event));
654 EXPECT_TRUE(simFile->ProcessGetOplmnActDone(event));
655 EXPECT_TRUE(simFile->ProcessGetSpdiDone(event));
656 EXPECT_TRUE(simFile->ProcessGetMsisdnDone(event));
657 simFile->ProcessSetMsisdnDone(event);
658 EXPECT_TRUE(simFile->ProcessObtainGid1Done(event));
659 EXPECT_TRUE(simFile->ProcessObtainGid2Done(event));
660 EXPECT_FALSE(simFile->ProcessSmsOnSim(event));
661 EXPECT_TRUE(simFile->ProcessGetCspCphs(event));
662 EXPECT_TRUE(simFile->ProcessGetInfoCphs(event));
663 EXPECT_TRUE(simFile->ProcessGetSstDone(event));
664 EXPECT_FALSE(simFile->ProcessGetSmsDone(event));
665 EXPECT_TRUE(simFile->ProcessGetAllSmsDone(event));
666 EXPECT_TRUE(simFile->ProcessGetHplmActDone(event));
667 EXPECT_TRUE(simFile->ProcessGetEhplmnDone(event));
668 EXPECT_TRUE(simFile->ProcessGetPnnDone(event));
669 EXPECT_TRUE(simFile->ProcessGetOplDone(event));
670 EXPECT_FALSE(simFile->ProcessUpdateDone(event));
671 EXPECT_TRUE(simFile->ProcessGetFplmnDone(event));
672 }
673
674 /**
675 * @tc.number Telephony_SimFile_004
676 * @tc.name test error branch
677 * @tc.desc Function test
678 */
679 HWTEST_F(BranchTest, Telephony_SimFile_004, Function | MediumTest | Level1)
680 {
681 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
682 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
683 std::shared_ptr<SimFile> simFile = std::make_shared<SimFile>(simStateManager);
684 std::string operatorNum = "";
685 EXPECT_EQ(simFile->ObtainSpnCondition(true, operatorNum), 0);
686 simFile->displayConditionOfSpn_ = OBTAIN_SPN_GENERAL;
687 EXPECT_GT(simFile->ObtainSpnCondition(false, operatorNum), 0);
688 simFile->displayConditionOfSpn_ = -1;
689 EXPECT_EQ(simFile->ObtainSpnCondition(false, operatorNum), 0);
690 EXPECT_EQ(simFile->ObtainCallForwardStatus(), 0);
691 EXPECT_EQ(simFile->ObtainUsimFunctionHandle(), nullptr);
692 EXPECT_EQ(simFile->AnalysisBcdPlmn(operatorNum, operatorNum), "");
693 simFile->ProcessElementaryFileCsp(operatorNum);
694 simFile->AnalysisElementaryFileSpdi(operatorNum);
695 simFile->ProcessSmses(operatorNum);
696 simFile->ProcessSms(operatorNum);
697 std::vector<std::string> emptyRecords = {};
698 std::vector<std::string> records = { "46000", "46002", "46004", "46007", "46008" };
699 simFile->ParsePnn(emptyRecords);
700 simFile->ParseOpl(emptyRecords);
701 simFile->ParsePnn(records);
702 simFile->ParseOpl(records);
703 std::vector<std::string> invalidRecords = { "64F0100000GGGG02", "64F0000000GGGG01" };
704 simFile->ParseOpl(invalidRecords);
705 std::vector<std::string> invalidPlmnRecords = { "F640100000FFFE02", "F640000000FFFE01" };
706 simFile->ParseOpl(invalidPlmnRecords);
707 std::vector<std::string> records5g = { "64F0100000FFFE02", "64F0000000FFFE01" };
708 simFile->ParseOpl(records5g);
709 SimFile::SpnStatus newStatus;
710 EXPECT_TRUE(simFile->IsContinueGetSpn(false, SimFile::SpnStatus::OBTAIN_SPN_NONE, newStatus));
711 EXPECT_TRUE(simFile->IsContinueGetSpn(true, SimFile::SpnStatus::OBTAIN_SPN_NONE, newStatus));
712 EXPECT_FALSE(simFile->IsContinueGetSpn(true, SimFile::SpnStatus::OBTAIN_SPN_START, newStatus));
713 EXPECT_FALSE(simFile->IsContinueGetSpn(true, SimFile::SpnStatus::OBTAIN_SPN_GENERAL, newStatus));
714 EXPECT_FALSE(simFile->IsContinueGetSpn(true, SimFile::SpnStatus::OBTAIN_OPERATOR_NAMESTRING, newStatus));
715 EXPECT_FALSE(simFile->IsContinueGetSpn(true, SimFile::SpnStatus::OBTAIN_OPERATOR_NAME_SHORTFORM, newStatus));
716 EXPECT_EQ(simFile->ObtainExtensionElementaryFile(ELEMENTARY_FILE_MSISDN), ELEMENTARY_FILE_EXT5);
717 EXPECT_EQ(simFile->ObtainExtensionElementaryFile(ELEMENTARY_FILE_SPN), ELEMENTARY_FILE_EXT1);
718 EXPECT_EQ(simFile->ParseSpn(operatorNum, 0), "");
719 EXPECT_EQ(simFile->ParseSpn("CMCC", OBTAIN_SPN_NONE), "");
720 EXPECT_EQ(simFile->ParseSpn("CMCC", OBTAIN_SPN_START), "");
721 EXPECT_EQ(simFile->ParseSpn("CMCC", OBTAIN_SPN_GENERAL), "\xCC");
722 EXPECT_EQ(simFile->ParseSpn("CMCC", OBTAIN_OPERATOR_NAMESTRING), "\xC0\xCC");
723 EXPECT_EQ(simFile->ParseSpn("CMCC", OBTAIN_OPERATOR_NAME_SHORTFORM), "\xC0\xCC");
724 EXPECT_EQ(simFile->ParseSpn("", 0), "");
725 }
726
727 /**
728 * @tc.number Telephony_SimFile_005
729 * @tc.name test error branch
730 * @tc.desc Function test
731 */
732 HWTEST_F(BranchTest, Telephony_SimFile_005, Function | MediumTest | Level1)
733 {
734 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
735 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
736 std::shared_ptr<SimFile> simFile = std::make_shared<SimFile>(simStateManager);
737 std::vector<std::string> emptyRecords = {};
738 simFile->ParseOpl5g(emptyRecords);
739 EXPECT_TRUE(simFile->opl5gFiles_.empty());
740 std::vector<std::string> records = { "46000", "46002", "46004", "46007", "46008" };
741 simFile->ParseOpl5g(records);
742 EXPECT_TRUE(simFile->opl5gFiles_.empty());
743 std::vector<std::string> invalidRecords = { "64F010000000GGGGGG02", "64F000000000GGGGGG01" };
744 simFile->ParseOpl5g(invalidRecords);
745 EXPECT_TRUE(simFile->opl5gFiles_.empty());
746 std::vector<std::string> invalidPlmnRecords = { "F64010000000FFFFFE02", "F64000000000FFFFFE01" };
747 simFile->ParseOpl5g(invalidPlmnRecords);
748 EXPECT_TRUE(simFile->opl5gFiles_.empty());
749 std::vector<std::string> records5g = { "64F010000000FFFFFE02", "64F000000000FFFFFE01" };
750 simFile->ParseOpl5g(records5g);
751 EXPECT_FALSE(simFile->opl5gFiles_.empty());
752 }
753
754 /**
755 * @tc.number Telephony_SimFile_006
756 * @tc.name test error branch
757 * @tc.desc Function test
758 */
759 HWTEST_F(BranchTest, Telephony_SimFile_006, Function | MediumTest | Level1)
760 {
761 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
762 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
763 std::shared_ptr<SimFile> simFile = std::make_shared<SimFile>(simStateManager);
764 EventFwk::MatchingSkills matchingSkills;
765 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
766 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
767 auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
768 std::weak_ptr<SimStateManager>(simStateManager));
769 simFileManager->Init(0);
770 auto event = AppExecFwk::InnerEvent::Get(0);
771 event = nullptr;
772 EXPECT_FALSE(simFile->ProcessIccLocked(event));
773 }
774
775 /**
776 * @tc.number Telephony_ISimFile_001
777 * @tc.name test error branch
778 * @tc.desc Function test
779 */
780 HWTEST_F(BranchTest, Telephony_ISimFile_001, Function | MediumTest | Level1)
781 {
782 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
783 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
784 std::shared_ptr<IsimFile> iSimFile = std::make_shared<IsimFile>(simStateManager);
785 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_READY, 1);
786 iSimFile->InitMemberFunc();
787 iSimFile->ProcessEvent(event);
788 event = AppExecFwk::InnerEvent::Get(0, 1);
789 iSimFile->ProcessEvent(event);
790 EXPECT_TRUE(iSimFile->ProcessGetIccidDone(event));
791 EXPECT_TRUE(iSimFile->ProcessGetImsiDone(event));
792 EXPECT_TRUE(iSimFile->ProcessGetImpiDone(event));
793 EXPECT_TRUE(iSimFile->ProcessGetIstDone(event));
794 event = nullptr;
795 iSimFile->ProcessEvent(event);
796 EXPECT_FALSE(iSimFile->ProcessIccReady(event));
797 EXPECT_EQ(iSimFile->ObtainIsimImpi(), "");
798 EXPECT_EQ(iSimFile->ObtainIsimDomain(), "");
799 EXPECT_EQ(iSimFile->ObtainIsimImpu(), nullptr);
800 EXPECT_EQ(iSimFile->ObtainIsimIst(), "");
801 EXPECT_EQ(iSimFile->ObtainIsimPcscf(), nullptr);
802 EXPECT_FALSE(iSimFile->UpdateVoiceMail("", ""));
803 EXPECT_EQ(iSimFile->ObtainSpnCondition(true, ""), 0);
804 EXPECT_EQ(iSimFile->ObtainIsoCountryCode(), "");
805 iSimFile->ProcessFileLoaded(false);
806 iSimFile->ProcessLockedAllFilesFetched();
807 EXPECT_FALSE(iSimFile->ProcessIsimRefresh(event));
808 EXPECT_TRUE(iSimFile->ProcessGetImsiDone(event));
809 EXPECT_TRUE(iSimFile->ProcessGetIccidDone(event));
810 EXPECT_TRUE(iSimFile->ProcessGetImpiDone(event));
811 EXPECT_TRUE(iSimFile->ProcessGetIstDone(event));
812 }
813
814 /**
815 * @tc.number Telephony_RuimFile_001
816 * @tc.name test error branch
817 * @tc.desc Function test
818 */
819 HWTEST_F(BranchTest, Telephony_RuimFile_001, Function | MediumTest | Level1)
820 {
821 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
822 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
823 std::shared_ptr<RuimFile> rUimFile = std::make_shared<RuimFile>(simStateManager);
824 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_READY, 1);
825 rUimFile->InitMemberFunc();
826 rUimFile->ProcessEvent(event);
827 event = AppExecFwk::InnerEvent::Get(0, 1);
828 rUimFile->ProcessEvent(event);
829 rUimFile->ProcessFileLoaded(false);
830 unsigned char spnData[10] = { 0 };
831 rUimFile->ParseSpnName(IccDiallingNumberConstant::CSIM_SPN_OCTET, spnData, 0);
832 rUimFile->ParseSpnName(IccDiallingNumberConstant::CSIM_SPN_LATIN, spnData, 0);
833 rUimFile->ParseSpnName(IccDiallingNumberConstant::CSIM_SPN_IA5, spnData, 0);
834 rUimFile->ParseSpnName(IccDiallingNumberConstant::CSIM_SPN_7BIT_ALPHABET, spnData, 0);
835 rUimFile->ParseSpnName(IccDiallingNumberConstant::NAME_CHAR_POS, spnData, 0);
836 EXPECT_TRUE(rUimFile->ProcessGetIccidDone(event));
837 EXPECT_TRUE(rUimFile->ProcessGetImsiDone(event));
838 EXPECT_TRUE(rUimFile->ProcessGetSpnDone(event));
839 event = nullptr;
840 rUimFile->ProcessEvent(event);
841 EXPECT_EQ(rUimFile->ObtainSimOperator(), "");
842 EXPECT_EQ(rUimFile->ObtainIsoCountryCode(), "");
843 rUimFile->imsi_ = "12345678";
844 EXPECT_EQ(rUimFile->ObtainSimOperator(), "12345");
845 EXPECT_EQ(rUimFile->ObtainIsoCountryCode(), "");
846 EXPECT_EQ(rUimFile->ObtainMdnNumber(), "");
847 EXPECT_EQ(rUimFile->ObtainCdmaMin(), "");
848 EXPECT_EQ(rUimFile->ObtainPrlVersion(), "");
849 EXPECT_EQ(rUimFile->ObtainNAI(), "");
850 EXPECT_EQ(rUimFile->ObtainMdn(), "");
851 EXPECT_EQ(rUimFile->ObtainMin(), "");
852 EXPECT_EQ(rUimFile->ObtainSid(), "");
853 EXPECT_EQ(rUimFile->ObtainNid(), "");
854 EXPECT_FALSE(rUimFile->ObtainCsimSpnDisplayCondition());
855 EXPECT_EQ(rUimFile->ObtainSpnCondition(true, ""), 0);
856 EXPECT_FALSE(rUimFile->UpdateVoiceMail("", ""));
857 EXPECT_TRUE(rUimFile->ProcessGetImsiDone(event));
858 EXPECT_TRUE(rUimFile->ProcessGetIccidDone(event));
859 EXPECT_TRUE(rUimFile->ProcessGetSubscriptionDone(event));
860 EXPECT_TRUE(rUimFile->ProcessGetSpnDone(event));
861 }
862
863 /**
864 * @tc.number Telephony_RuimFile_002
865 * @tc.name test error branch
866 * @tc.desc Function test
867 */
868 HWTEST_F(BranchTest, Telephony_RuimFile_002, Function | MediumTest | Level1)
869 {
870 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
871 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
872 std::shared_ptr<RuimFile> rUimFile = std::make_shared<RuimFile>(simStateManager);
873 EventFwk::MatchingSkills matchingSkills;
874 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
875 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
876 auto simFileManager = std::make_shared<SimFileManager>(subcribeInfo, std::weak_ptr<ITelRilManager>(telRilManager),
877 std::weak_ptr<SimStateManager>(simStateManager));
878 simFileManager->Init(0);
879 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_READY, 1);
880 event = nullptr;
881 EXPECT_FALSE(rUimFile->ProcessIccLocked(event));
882 }
883
884 /**
885 * @tc.number Telephony_IccFileController_001
886 * @tc.name test error branch
887 * @tc.desc Function test
888 */
889 HWTEST_F(BranchTest, Telephony_IccFileController_001, Function | MediumTest | Level1)
890 {
891 std::shared_ptr<IccFileController> iccFileController = std::make_shared<SimFileController>(1);
892 auto event = AppExecFwk::InnerEvent::Get(0);
893 iccFileController->ProcessEvent(event);
894 event = nullptr;
895 iccFileController->ProcessEvent(event);
896 iccFileController->telRilManager_ = nullptr;
897 iccFileController->ObtainElementFileForPublic(ELEMENTARY_FILE_ICCID);
898 iccFileController->ObtainElementFileForPublic(ELEMENTARY_FILE_PL);
899 iccFileController->ObtainElementFileForPublic(ELEMENTARY_FILE_ADN);
900 iccFileController->ObtainElementFileForPublic(ELEMENTARY_FILE_FDN);
901 iccFileController->ObtainElementFileForPublic(ELEMENTARY_FILE_MSISDN);
902 iccFileController->ObtainElementFileForPublic(ELEMENTARY_FILE_SDN);
903 iccFileController->ObtainElementFileForPublic(ELEMENTARY_FILE_EXT1);
904 iccFileController->ObtainElementFileForPublic(ELEMENTARY_FILE_EXT2);
905 iccFileController->ObtainElementFileForPublic(ELEMENTARY_FILE_EXT3);
906 iccFileController->ObtainElementFileForPublic(ELEMENTARY_FILE_PBR);
907 iccFileController->ObtainElementFileForPublic(ELEMENTARY_FILE_IMG);
908 iccFileController->ObtainElementFileForPublic(0);
909 EXPECT_TRUE(iccFileController->IsFixedNumberType(ELEMENTARY_FILE_ADN));
910 EXPECT_TRUE(iccFileController->IsFixedNumberType(ELEMENTARY_FILE_FDN));
911 EXPECT_TRUE(iccFileController->IsFixedNumberType(ELEMENTARY_FILE_USIM_ADN));
912 iccFileController->SetRilManager(iccFileController->telRilManager_);
913 EXPECT_TRUE(iccFileController->IsFixedNumberType(ELEMENTARY_FILE_USIM_IAP));
914 EXPECT_FALSE(iccFileController->IsFixedNumberType(0));
915 }
916
917 /**
918 * @tc.number Telephony_CoreManagerInner_001
919 * @tc.name test error branch
920 * @tc.desc Function test
921 */
922 HWTEST_F(BranchTest, Telephony_CoreManagerInner_001, Function | MediumTest | Level1)
923 {
924 CoreManagerInner mInner;
925 auto event = AppExecFwk::InnerEvent::Get(0);
926 event = nullptr;
927 mInner.OnInit(nullptr, nullptr, nullptr);
928 mInner.SetTelRilMangerObj(nullptr);
929 EXPECT_TRUE(mInner.IsInitFinished());
930 EXPECT_FALSE(mInner.IsInitFinishedForTelRil());
931 EXPECT_EQ(mInner.GetDefaultSlotId(), 0);
932 EXPECT_GT(mInner.GetMaxSimCount(), 0);
933 EXPECT_GT(mInner.SetRadioState(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
934 EXPECT_GT(mInner.GetRadioState(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
935 EXPECT_GT(mInner.ShutDown(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
936 EXPECT_GT(mInner.Dial(0, 0, "", 0, nullptr), TELEPHONY_ERR_SUCCESS);
937 EXPECT_GT(mInner.Reject(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
938 EXPECT_GT(mInner.Hangup(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
939 EXPECT_GT(mInner.Answer(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
940 EXPECT_GT(mInner.GetCallList(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
941 EXPECT_GT(mInner.HoldCall(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
942 EXPECT_GT(mInner.UnHoldCall(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
943 EXPECT_GT(mInner.SwitchCall(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
944 EXPECT_GT(mInner.CombineConference(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
945 EXPECT_GT(mInner.SeparateConference(0, 0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
946 EXPECT_GT(mInner.CallSupplement(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
947 EXPECT_GT(mInner.SetDataPermitted(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
948 DataProfile mDataProfile;
949 EXPECT_GT(mInner.SetInitApnInfo(0, 0, mDataProfile, nullptr), TELEPHONY_ERR_SUCCESS);
950 ActivateDataParam mActivateDataParam;
951 EXPECT_GT(mInner.ActivatePdpContext(0, 0, mActivateDataParam, nullptr), TELEPHONY_ERR_SUCCESS);
952 DeactivateDataParam mDeactivateDataParam;
953 EXPECT_GT(mInner.DeactivatePdpContext(0, 0, mDeactivateDataParam, nullptr), TELEPHONY_ERR_SUCCESS);
954 EXPECT_GT(mInner.GetPdpContextList(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
955 EXPECT_GT(mInner.GetLinkBandwidthInfo(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
956 LinkBandwidthRule mLinkBandwidthRule;
957 EXPECT_GT(mInner.SetLinkBandwidthReportingRule(0, 0, mLinkBandwidthRule, nullptr), TELEPHONY_ERR_SUCCESS);
958 bool airplaneMode = false;
959 EXPECT_GT(mInner.GetAirplaneMode(airplaneMode), TELEPHONY_ERR_SUCCESS);
960 EXPECT_GT(mInner.UpdateRadioOn(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
961 EXPECT_GT(mInner.GetLinkCapability(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
962 }
963
964 /**
965 * @tc.number Telephony_CoreManagerInner_002
966 * @tc.name test error branch
967 * @tc.desc Function test
968 */
969 HWTEST_F(BranchTest, Telephony_CoreManagerInner_002, Function | MediumTest | Level1)
970 {
971 CoreManagerInner mInner;
972 EXPECT_GT(mInner.StopDTMF(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
973 EXPECT_GT(mInner.StartDTMF(0, 0, 'A', 0, nullptr), TELEPHONY_ERR_SUCCESS);
974 EXPECT_GT(mInner.SendDTMF(0, 0, 'A', 0, nullptr), TELEPHONY_ERR_SUCCESS);
975 DtmfParam mDtmfParam;
976 EXPECT_GT(mInner.SendDTMF(0, 0, mDtmfParam, nullptr), TELEPHONY_ERR_SUCCESS);
977 EXPECT_GT(mInner.GetSignalStrength(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
978 EXPECT_GT(mInner.GetCsRegStatus(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
979 EXPECT_GT(mInner.GetPsRegStatus(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
980 EXPECT_GT(mInner.SetCallPreferenceMode(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
981 EXPECT_GT(mInner.GetCallPreferenceMode(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
982 EXPECT_GT(mInner.SetUssd(0, 0, "", nullptr), TELEPHONY_ERR_SUCCESS);
983 EXPECT_GT(mInner.GetUssd(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
984 EXPECT_GT(mInner.GetMute(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
985 EXPECT_GT(mInner.SetMute(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
986 EXPECT_GT(mInner.GetEmergencyCallList(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
987 std::vector<EmergencyCall> eccVec;
988 EXPECT_GT(mInner.SetEmergencyCallList(0, 0, eccVec, nullptr), TELEPHONY_ERR_SUCCESS);
989 EXPECT_GT(mInner.GetCallFailReason(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
990 EXPECT_GT(mInner.GetOperatorInfo(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
991 EXPECT_GT(mInner.GetCellInfoList(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
992 EXPECT_GT(mInner.GetCurrentCellInfo(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
993 }
994
995 /**
996 * @tc.number Telephony_CoreManagerInner_003
997 * @tc.name test error branch
998 * @tc.desc Function test
999 */
1000 HWTEST_F(BranchTest, Telephony_CoreManagerInner_003, Function | MediumTest | Level1)
1001 {
1002 CoreManagerInner mInner;
1003 mInner.DcPhysicalLinkActiveUpdate(0, true);
1004 int32_t radioTech;
1005 EXPECT_NE(mInner.GetPsRadioTech(0, radioTech), TELEPHONY_ERR_SUCCESS);
1006 EXPECT_NE(mInner.GetCsRadioTech(0, radioTech), TELEPHONY_ERR_SUCCESS);
1007 EXPECT_EQ(mInner.GetPsRegState(0), -1);
1008 EXPECT_EQ(mInner.GetRadioState(0), -1);
1009 EXPECT_EQ(mInner.GetCsRegState(0), -1);
1010 EXPECT_EQ(mInner.GetPsRoamingState(0), -1);
1011 ImsRegInfo info;
1012 EXPECT_EQ(mInner.GetImsRegStatus(0, ImsServiceType::TYPE_VOICE, info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1013 sptr<NetworkInformation> networkInfo = new (std::nothrow) NetworkInformation();
1014 sptr<INetworkSearchCallback> callback = nullptr;
1015 EXPECT_FALSE(mInner.SetNetworkSelectionMode(0, 1, networkInfo, true, callback));
1016 EXPECT_NE(mInner.SetRadioState(0, true, 0, callback), TELEPHONY_ERR_SUCCESS);
1017 EXPECT_NE(mInner.GetRadioState(0, callback), TELEPHONY_ERR_SUCCESS);
1018 EXPECT_NE(mInner.GetNetworkSearchInformation(0, callback), TELEPHONY_ERR_SUCCESS);
1019 EXPECT_NE(mInner.GetNetworkSelectionMode(0, callback), TELEPHONY_ERR_SUCCESS);
1020 EXPECT_NE(mInner.GetPreferredNetwork(0, callback), TELEPHONY_ERR_SUCCESS);
1021 EXPECT_NE(mInner.SetPreferredNetwork(0, 0, callback), TELEPHONY_ERR_SUCCESS);
1022 std::vector<sptr<SignalInformation>> signals;
1023 mInner.GetSignalInfoList(0, signals);
1024 EXPECT_EQ(signals, std::vector<sptr<SignalInformation>>());
1025 std::vector<sptr<CellInformation>> cellInfo;
1026 EXPECT_EQ(mInner.GetCellInfoList(0, cellInfo), TELEPHONY_ERR_LOCAL_PTR_NULL);
1027 ASSERT_TRUE(cellInfo.empty());
1028 EXPECT_EQ(mInner.GetOperatorNumeric(0), std::u16string());
1029 std::u16string operatorName = u"";
1030 EXPECT_NE(mInner.GetOperatorName(0, operatorName), TELEPHONY_ERR_SUCCESS);
1031 EXPECT_EQ(operatorName, std::u16string());
1032 std::u16string countryCode = u"";
1033 EXPECT_NE(mInner.GetIsoCountryCodeForNetwork(0, countryCode), TELEPHONY_ERR_SUCCESS);
1034 EXPECT_EQ(countryCode, std::u16string());
1035 std::u16string result = u"";
1036 EXPECT_NE(mInner.GetImei(0, result), TELEPHONY_ERR_SUCCESS);
1037 EXPECT_EQ(result, std::u16string());
1038 EXPECT_NE(mInner.GetImeiSv(0, result), TELEPHONY_ERR_SUCCESS);
1039 EXPECT_EQ(result, std::u16string());
1040 EXPECT_NE(mInner.GetMeid(0, result), TELEPHONY_ERR_SUCCESS);
1041 EXPECT_EQ(result, std::u16string());
1042 EXPECT_NE(mInner.GetUniqueDeviceId(0, result), TELEPHONY_ERR_SUCCESS);
1043 EXPECT_EQ(result, std::u16string());
1044 sptr<NetworkState> networkState = nullptr;
1045 mInner.GetNetworkStatus(0, networkState);
1046 EXPECT_EQ(networkState, nullptr);
1047 }
1048
1049 /**
1050 * @tc.number Telephony_CoreManagerInner_004
1051 * @tc.name test error branch
1052 * @tc.desc Function test
1053 */
1054 HWTEST_F(BranchTest, Telephony_CoreManagerInner_004, Function | MediumTest | Level1)
1055 {
1056 CoreManagerInner mInner;
1057 EXPECT_EQ(mInner.ObtainSpnCondition(0, false, ""), 0);
1058 std::u16string result;
1059 EXPECT_GT(mInner.GetSimSpn(0, result), TELEPHONY_ERR_SUCCESS);
1060 EXPECT_GT(mInner.GetShowNumber(0, result), TELEPHONY_ERR_SUCCESS);
1061 EXPECT_GT(mInner.GetShowName(0, result), TELEPHONY_ERR_SUCCESS);
1062 EXPECT_GT(mInner.GetSimOperatorNumeric(0, result), TELEPHONY_ERR_SUCCESS);
1063 EXPECT_GT(mInner.GetISOCountryCodeForSim(0, result), TELEPHONY_ERR_SUCCESS);
1064 EXPECT_GT(mInner.GetSimIccId(0, result), TELEPHONY_ERR_SUCCESS);
1065 EXPECT_GT(mInner.GetIMSI(0, result), TELEPHONY_ERR_SUCCESS);
1066 EXPECT_EQ(mInner.GetLocaleFromDefaultSim(0), std::u16string());
1067 EXPECT_GT(mInner.GetSimGid1(0, result), TELEPHONY_ERR_SUCCESS);
1068 EXPECT_EQ(mInner.GetSimGid2(0), std::u16string());
1069 EXPECT_GT(mInner.GetSimTelephoneNumber(0, result), TELEPHONY_ERR_SUCCESS);
1070 EXPECT_EQ(mInner.GetSimTeleNumberIdentifier(0), std::u16string());
1071 EXPECT_GT(mInner.GetVoiceMailIdentifier(0, result), TELEPHONY_ERR_SUCCESS);
1072 EXPECT_GT(mInner.GetVoiceMailNumber(0, result), TELEPHONY_ERR_SUCCESS);
1073 EXPECT_EQ(mInner.GetSimIst(0), std::u16string());
1074 EXPECT_GT(mInner.SetVoiceMailInfo(0, u"", u""), TELEPHONY_ERR_SUCCESS);
1075 bool boolResult = false;
1076 EXPECT_GT(mInner.HasOperatorPrivileges(0, boolResult), TELEPHONY_ERR_SUCCESS);
1077 EXPECT_GT(mInner.HasSimCard(0, boolResult), TELEPHONY_ERR_SUCCESS);
1078 EXPECT_GT(mInner.SendEnvelopeCmd(0, ""), TELEPHONY_ERR_SUCCESS);
1079 EXPECT_GT(mInner.SendTerminalResponseCmd(0, ""), TELEPHONY_ERR_SUCCESS);
1080 EXPECT_GT(mInner.SendTerminalResponseCmd(0, ""), TELEPHONY_ERR_SUCCESS);
1081 EXPECT_GT(mInner.DelSmsIcc(0, 0), TELEPHONY_ERR_SUCCESS);
1082 EXPECT_FALSE(mInner.IsSimActive(0));
1083 EXPECT_GT(mInner.SetShowName(0, u""), TELEPHONY_ERR_SUCCESS);
1084 EXPECT_GT(mInner.IsCTSimCard(0, boolResult), TELEPHONY_ERR_SUCCESS);
1085 LockStatusResponse response;
1086 PersoLockInfo lockInfo;
1087 EXPECT_GT(mInner.UnlockSimLock(0, lockInfo, response), TELEPHONY_ERR_SUCCESS);
1088 EXPECT_GT(mInner.UnlockPin(0, "", response), TELEPHONY_ERR_SUCCESS);
1089 EXPECT_GT(mInner.UnlockPuk(0, "", "", response), TELEPHONY_ERR_SUCCESS);
1090 EXPECT_GT(mInner.AlterPin(0, "", "", response), TELEPHONY_ERR_SUCCESS);
1091 LockInfo options;
1092 EXPECT_GT(mInner.SetLockState(0, options, response), TELEPHONY_ERR_SUCCESS);
1093 EXPECT_GT(mInner.UnlockPin2(0, "", response), TELEPHONY_ERR_SUCCESS);
1094 EXPECT_GT(mInner.UnlockPuk2(0, "", "", response), TELEPHONY_ERR_SUCCESS);
1095 EXPECT_GT(mInner.AlterPin2(0, "", "", response), TELEPHONY_ERR_SUCCESS);
1096 std::shared_ptr<DiallingNumbersInfo> diallingNumbers = std::make_shared<DiallingNumbersInfo>();
1097 EXPECT_GT(mInner.AddIccDiallingNumbers(0, 0, diallingNumbers), TELEPHONY_ERR_SUCCESS);
1098 EXPECT_GT(mInner.DelIccDiallingNumbers(0, 0, diallingNumbers), TELEPHONY_ERR_SUCCESS);
1099 EXPECT_GT(mInner.UpdateIccDiallingNumbers(0, 0, diallingNumbers), TELEPHONY_ERR_SUCCESS);
1100 EXPECT_EQ(mInner.GetNrState(0), NrState::NR_STATE_NOT_SUPPORT);
1101 EXPECT_NE(mInner.SendUpdateCellLocationRequest(0), TELEPHONY_ERR_SUCCESS);
1102 EXPECT_FALSE(mInner.IsNrSupported(0));
1103 }
1104
1105 /**
1106 * @tc.number Telephony_CoreManagerInner_005
1107 * @tc.name test error branch
1108 * @tc.desc Function test
1109 */
1110 HWTEST_F(BranchTest, Telephony_CoreManagerInner_005, Function | MediumTest | Level1)
1111 {
1112 CoreManagerInner mInner;
1113 OperatorConfig mOperatorConfig;
1114 EXPECT_GT(mInner.GetOperatorConfigs(0, mOperatorConfig), TELEPHONY_ERR_SUCCESS);
1115 IccAccountInfo mIccAccountInfo;
1116 EXPECT_GT(mInner.GetSimAccountInfo(0, mIccAccountInfo), TELEPHONY_ERR_SUCCESS);
1117 std::vector<IccAccountInfo> iccAccountInfoList;
1118 EXPECT_GT(mInner.GetActiveSimAccountInfoList(iccAccountInfoList), TELEPHONY_ERR_SUCCESS);
1119 LockState lockState;
1120 EXPECT_NE(mInner.GetLockState(0, LockType::PIN_LOCK, lockState), TELEPHONY_ERR_SUCCESS);
1121 EXPECT_NE(mInner.SendCallSetupRequestResult(0, true), TELEPHONY_ERR_SUCCESS);
1122 SimState simState = SimState::SIM_STATE_UNKNOWN;
1123 EXPECT_NE(mInner.GetSimState(0, simState), TELEPHONY_ERR_SUCCESS);
1124 CardType cardType = CardType::UNKNOWN_CARD;
1125 EXPECT_NE(mInner.GetCardType(0, cardType), TELEPHONY_ERR_SUCCESS);
1126 EXPECT_EQ(mInner.RefreshSimState(0), TELEPHONY_ERR_SUCCESS);
1127 EXPECT_NE(mInner.GetSlotId(0), TELEPHONY_ERR_SUCCESS);
1128 EXPECT_NE(mInner.GetSimId(0), TELEPHONY_ERR_SUCCESS);
1129 mInner.SetDefaultCellularDataSlotId(0);
1130 mInner.SetDefaultSmsSlotId(0);
1131 mInner.SetDefaultVoiceSlotId(0);
1132 std::u16string test = u"";
1133 EXPECT_NE(mInner.GetOpName(0, test), TELEPHONY_ERR_SUCCESS);
1134 EXPECT_NE(mInner.GetOpKeyExt(0, test), TELEPHONY_ERR_SUCCESS);
1135 EXPECT_NE(mInner.GetOpKey(test), TELEPHONY_ERR_SUCCESS);
1136 EXPECT_NE(mInner.GetOpKey(0, test), TELEPHONY_ERR_SUCCESS);
1137 mInner.GetDefaultVoiceSlotId();
1138 mInner.GetDefaultSmsSlotId();
1139 mInner.GetDefaultCellularDataSlotId();
1140 int32_t slotId = INVALID_VALUE;
1141 mInner.GetPrimarySlotId(slotId);
1142 int32_t dsdsMode = INVALID_VALUE;
1143 mInner.GetDsdsMode(dsdsMode);
1144 mInner.SetDsdsMode(0);
1145 EXPECT_NE(mInner.SaveImsSwitch(0, 0), TELEPHONY_ERR_SUCCESS);
1146 int32_t imsSwitchValue = 0;
1147 EXPECT_NE(mInner.SaveImsSwitch(0, imsSwitchValue), TELEPHONY_ERR_SUCCESS);
1148 std::vector<std::string> result;
1149 EXPECT_EQ(mInner.ObtainAllSmsOfIcc(0), result);
1150 std::string pduData = "test";
1151 std::string smsc = "test";
1152 EXPECT_GT(mInner.UpdateSmsIcc(0, 0, 0, pduData, smsc), TELEPHONY_ERR_SUCCESS);
1153 EXPECT_GT(mInner.AddSmsToIcc(0, 0, pduData, smsc), TELEPHONY_ERR_SUCCESS);
1154 }
1155
1156 /**
1157 * @tc.number Telephony_CoreManagerInner_006
1158 * @tc.name test error branch
1159 * @tc.desc Function test
1160 */
1161 HWTEST_F(BranchTest, Telephony_CoreManagerInner_006, Function | MediumTest | Level1)
1162 {
1163 CoreManagerInner mInner;
1164 auto event = AppExecFwk::InnerEvent::Get(0);
1165 event = nullptr;
1166 EXPECT_GT(mInner.GetClip(0, event), TELEPHONY_ERR_SUCCESS);
1167 EXPECT_GT(mInner.SetClip(0, 0, event), TELEPHONY_ERR_SUCCESS);
1168 EXPECT_GT(mInner.GetClir(0, event), TELEPHONY_ERR_SUCCESS);
1169 EXPECT_GT(mInner.SetClir(0, 0, event), TELEPHONY_ERR_SUCCESS);
1170 EXPECT_GT(mInner.SetCallWaiting(0, 0, event), TELEPHONY_ERR_SUCCESS);
1171 CallTransferParam mCallTransferParam;
1172 EXPECT_GT(mInner.SetCallTransferInfo(0, mCallTransferParam, event), TELEPHONY_ERR_SUCCESS);
1173 EXPECT_GT(mInner.GetCallTransferInfo(0, 0, event), TELEPHONY_ERR_SUCCESS);
1174 EXPECT_GT(mInner.GetCallWaiting(0, event), TELEPHONY_ERR_SUCCESS);
1175 EXPECT_GT(mInner.GetCallRestriction(0, "", event), TELEPHONY_ERR_SUCCESS);
1176 CallRestrictionParam mCallRestrictionParam;
1177 EXPECT_GT(mInner.SetCallRestriction(0, mCallRestrictionParam, event), TELEPHONY_ERR_SUCCESS);
1178 EXPECT_GT(mInner.SetBarringPassword(0, "", "", "", event), TELEPHONY_ERR_SUCCESS);
1179 std::shared_ptr<AppExecFwk::EventHandler> handler;
1180 sptr<NetworkSearchCallBackBase> callback = nullptr;
1181 mInner.RegisterCellularDataObject(callback);
1182 mInner.UnRegisterCellularDataObject(callback);
1183 mInner.RegisterCellularCallObject(callback);
1184 mInner.UnRegisterCellularCallObject(callback);
1185 EXPECT_EQ(mInner.RegisterCoreNotify(INVALID_SLOTID, handler, RadioEvent::RADIO_NR_STATE_CHANGED, nullptr),
1186 TELEPHONY_ERR_LOCAL_PTR_NULL);
1187 EXPECT_EQ(mInner.UnRegisterCoreNotify(INVALID_SLOTID, handler, RadioEvent::RADIO_NR_STATE_CHANGED),
1188 TELEPHONY_ERR_LOCAL_PTR_NULL);
1189 EXPECT_EQ(mInner.RegisterCoreNotify(INVALID_SLOTID, handler, RadioEvent::RADIO_SIM_STATE_READY, nullptr),
1190 TELEPHONY_ERR_LOCAL_PTR_NULL);
1191 EXPECT_EQ(mInner.UnRegisterCoreNotify(INVALID_SLOTID, handler, RadioEvent::RADIO_SIM_GET_RADIO_PROTOCOL),
1192 TELEPHONY_ERR_LOCAL_PTR_NULL);
1193 EXPECT_EQ(mInner.RegisterCoreNotify(INVALID_SLOTID, handler, RadioEvent::RADIO_SIM_STATE_READY, nullptr),
1194 TELEPHONY_ERR_LOCAL_PTR_NULL);
1195 EXPECT_EQ(mInner.UnRegisterCoreNotify(INVALID_SLOTID, handler, RadioEvent::RADIO_SIM_GET_RADIO_PROTOCOL),
1196 TELEPHONY_ERR_LOCAL_PTR_NULL);
1197 int32_t tokenId = 123456789;
1198 sptr<SimAccountCallback> simAccountCallback;
1199 int32_t imsSwitchValue = 1;
1200 EXPECT_EQ(mInner.RegisterSimAccountCallback(tokenId, simAccountCallback), TELEPHONY_ERR_LOCAL_PTR_NULL);
1201 EXPECT_EQ(mInner.UnregisterSimAccountCallback(tokenId), TELEPHONY_ERR_LOCAL_PTR_NULL);
1202 EXPECT_EQ(mInner.GetSmscAddr(INVALID_SLOTID, 1, handler), TELEPHONY_ERR_LOCAL_PTR_NULL);
1203 EXPECT_EQ(mInner.QueryImsSwitch(INVALID_SLOTID, imsSwitchValue), TELEPHONY_ERROR);
1204 EXPECT_GT(mInner.SetVoNRSwitch(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
1205 }
1206
1207 /**
1208 * @tc.number Telephony_CoreManagerInner_007
1209 * @tc.name test error branch
1210 * @tc.desc Function test
1211 */
1212 HWTEST_F(BranchTest, Telephony_CoreManagerInner_007, Function | MediumTest | Level1)
1213 {
1214 CoreManagerInner mInner;
1215 GsmSimMessageParam mGsmSimMessageParam;
1216 EXPECT_GT(mInner.SendGsmSms(0, 0, mGsmSimMessageParam, nullptr), TELEPHONY_ERR_SUCCESS);
1217 EXPECT_GT(mInner.SendSmsMoreMode(0, 0, mGsmSimMessageParam, nullptr), TELEPHONY_ERR_SUCCESS);
1218 EXPECT_GT(mInner.SendCdmaSms(0, 0, "", 0L, nullptr), TELEPHONY_ERR_SUCCESS);
1219 SimMessageParam mSimMessageParam;
1220 EXPECT_GT(mInner.AddSimMessage(0, 0, mSimMessageParam, nullptr), TELEPHONY_ERR_SUCCESS);
1221 EXPECT_GT(mInner.GetCdmaCBConfig(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
1222 EXPECT_GT(mInner.SetSmscAddr(0, 0, 0, "", nullptr), TELEPHONY_ERR_SUCCESS);
1223 EXPECT_GT(mInner.DelSimMessage(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
1224 EXPECT_GT(mInner.SendSmsAck(0, 0, true, 0, nullptr), TELEPHONY_ERR_SUCCESS);
1225 EXPECT_GT(mInner.GetCBConfig(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
1226 CBConfigParam mCBConfigParam;
1227 EXPECT_GT(mInner.SetCBConfig(0, 0, mCBConfigParam, nullptr), TELEPHONY_ERR_SUCCESS);
1228 CdmaCBConfigInfoList mCdmaCBConfigInfoList;
1229 EXPECT_GT(mInner.SetCdmaCBConfig(0, 0, mCdmaCBConfigInfoList, nullptr), TELEPHONY_ERR_SUCCESS);
1230 EXPECT_GT(mInner.GetNetworkSearchInformation(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
1231 EXPECT_GT(mInner.GetNetworkSelectionMode(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
1232 EXPECT_GT(mInner.AddCdmaSimMessage(0, 0, 0, "", nullptr), TELEPHONY_ERR_SUCCESS);
1233 EXPECT_GT(mInner.DelCdmaSimMessage(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
1234 CdmaSimMessageParam mCdmaSimMessageParam;
1235 EXPECT_GT(mInner.UpdateCdmaSimMessage(0, 0, mCdmaSimMessageParam, nullptr), TELEPHONY_ERR_SUCCESS);
1236 EXPECT_GT(mInner.SetPreferredNetworkPara(0, 0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
1237 EXPECT_GT(mInner.GetPreferredNetworkPara(0, 0, nullptr), TELEPHONY_ERR_SUCCESS);
1238 std::vector<std::shared_ptr<DiallingNumbersInfo>> result;
1239 EXPECT_GT(mInner.QueryIccDiallingNumbers(0, 0, result), TELEPHONY_ERR_SUCCESS);
1240 EXPECT_EQ(mInner.GetCellLocation(0), nullptr);
1241 EXPECT_EQ(mInner.GetPhoneType(0), PhoneType::PHONE_TYPE_IS_NONE);
1242 EXPECT_NE(mInner.NotifyCallStatusToNetworkSearch(0, 0), TELEPHONY_ERR_SUCCESS);
1243 NrMode mode = NrMode::NR_MODE_UNKNOWN;
1244 EXPECT_NE(mInner.GetNrOptionMode(0, mode), TELEPHONY_ERR_SUCCESS);
1245 EXPECT_EQ(mode, NrMode::NR_MODE_UNKNOWN);
1246 EXPECT_EQ(mInner.GetFrequencyType(0), FrequencyType::FREQ_TYPE_UNKNOWN);
1247 EXPECT_NE(mInner.SetModemInit(-1, 0), TELEPHONY_ERR_SUCCESS);
1248 }
1249
1250 /**
1251 * @tc.number Telephony_TagService_001
1252 * @tc.name test error branch
1253 * @tc.desc Function test
1254 */
1255 HWTEST_F(BranchTest, Telephony_TagService_001, Function | MediumTest | Level1)
1256 {
1257 std::vector<uint8_t> parameter = {};
1258 std::string testEmptyStr = "";
1259 std::string testStr = "12345";
1260 std::string testCnStr = "123456";
1261 std::shared_ptr<TagService> tagService = std::make_shared<TagService>(testEmptyStr);
1262 std::shared_ptr<TagService> tagService1 = std::make_shared<TagService>(testStr);
1263 std::shared_ptr<TagService> tagService2 = std::make_shared<TagService>(testCnStr);
1264 EXPECT_NE(tagService->GetTagCode(), 1);
1265 EXPECT_NE(tagService1->GetTagCode(), 1);
1266 EXPECT_NE(tagService2->GetTagCode(), 1);
1267 EXPECT_FALSE(tagService->Next());
1268 EXPECT_FALSE(tagService1->Next());
1269 EXPECT_FALSE(tagService2->Next());
1270 }
1271
1272 /**
1273 * @tc.number Telephony_SimSmsController_001
1274 * @tc.name test error branch
1275 * @tc.desc Function test
1276 */
1277 HWTEST_F(BranchTest, Telephony_SimSmsController_001, Function | MediumTest | Level1)
1278 {
1279 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1280 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1281 std::shared_ptr<Telephony::SimSmsController> simSmsController = std::make_shared<SimSmsController>(simStateManager);
1282 auto event = AppExecFwk::InnerEvent::Get(0);
1283 auto eventGet = simSmsController->BuildCallerInfo(SIM_SMS_GET_COMPLETED);
1284 auto eventUpdate = simSmsController->BuildCallerInfo(SIM_SMS_UPDATE_COMPLETED);
1285 auto eventWrite = simSmsController->BuildCallerInfo(SIM_SMS_WRITE_COMPLETED);
1286 auto eventDelete = simSmsController->BuildCallerInfo(SIM_SMS_DELETE_COMPLETED);
1287 simSmsController->ProcessLoadDone(event);
1288 simSmsController->ProcessUpdateDone(event);
1289 simSmsController->ProcessWriteDone(event);
1290 simSmsController->ProcessDeleteDone(event);
1291 simSmsController->ProcessDeleteDone(event);
1292 simSmsController->ProcessEvent(event);
1293 simSmsController->ProcessEvent(eventGet);
1294 simSmsController->ProcessEvent(eventUpdate);
1295 simSmsController->ProcessEvent(eventWrite);
1296 simSmsController->ProcessEvent(eventDelete);
1297 EventFwk::MatchingSkills matchingSkills;
1298 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
1299 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
1300 std::shared_ptr<Telephony::SimFileManager> simFileManager =
1301 std::make_shared<SimFileManager>(subcribeInfo, telRilManager, simStateManager);
1302 simSmsController->SetRilAndFileManager(telRilManager, simFileManager);
1303 simFileManager = nullptr;
1304 simSmsController->SetRilAndFileManager(telRilManager, simFileManager);
1305 telRilManager = nullptr;
1306 simSmsController->SetRilAndFileManager(telRilManager, simFileManager);
1307 std::string smsc = "";
1308 std::string pdu = "";
1309 EXPECT_FALSE(simSmsController->IsCdmaCardType());
1310 }
1311
1312 /**
1313 * @tc.number Telephony_MultiSimController_001
1314 * @tc.name test error branch
1315 * @tc.desc Function test
1316 */
1317 HWTEST_F(BranchTest, Telephony_MultiSimController_001, Function | MediumTest | Level1)
1318 {
1319 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1320 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
1321 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
1322 std::shared_ptr<Telephony::MultiSimController> multiSimController =
1323 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
1324 multiSimController->SortCache();
1325 std::shared_ptr<RadioProtocolController> radioProtocolController = nullptr;
1326 EXPECT_FALSE(multiSimController->InitData(0));
1327 EXPECT_GT(multiSimController->SetDefaultSmsSlotId(0), TELEPHONY_ERR_SUCCESS);
1328 EXPECT_FALSE(multiSimController->RefreshActiveIccAccountInfoList());
1329 EXPECT_FALSE(multiSimController->IsSimActive(0));
1330 EXPECT_FALSE(multiSimController->ForgetAllData());
1331 EXPECT_FALSE(multiSimController->ForgetAllData(0));
1332 EXPECT_FALSE(multiSimController->IsValidData(0));
1333 EXPECT_TRUE(multiSimController->AnnouncePrimarySimIdChanged(0));
1334 EXPECT_TRUE(multiSimController->AnnounceDefaultVoiceSimIdChanged(0));
1335 EXPECT_TRUE(multiSimController->AnnounceDefaultSmsSimIdChanged(0));
1336 EXPECT_TRUE(multiSimController->AnnounceDefaultCellularDataSimIdChanged(0));
1337 AAFwk::Want want;
1338 EXPECT_FALSE(multiSimController->PublishSimFileEvent(want, 0, ""));
1339 EXPECT_FALSE(multiSimController->InitShowNumber(0));
1340 EXPECT_FALSE(multiSimController->InitIccId(0));
1341 EXPECT_FALSE(multiSimController->GetListFromDataBase());
1342 }
1343
1344 /**
1345 * @tc.number Telephony_MultiSimController_002
1346 * @tc.name test error branch
1347 * @tc.desc Function test
1348 */
1349 HWTEST_F(BranchTest, Telephony_MultiSimController_002, Function | MediumTest | Level1)
1350 {
1351 std::u16string testU16Str = u"";
1352 std::string testStr = "";
1353 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1354 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
1355 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
1356 std::shared_ptr<Telephony::MultiSimController> multiSimController =
1357 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
1358 multiSimController->GetDefaultVoiceSlotId();
1359 EXPECT_NE(multiSimController->SetDefaultVoiceSlotId(0), TELEPHONY_ERR_SUCCESS);
1360 multiSimController->GetDefaultSmsSlotId();
1361 IccAccountInfo mIccAccountInfo;
1362 EXPECT_NE(multiSimController->GetSimAccountInfo(0, false, mIccAccountInfo), TELEPHONY_ERR_SUCCESS);
1363 multiSimController->GetDefaultCellularDataSlotId();
1364 EXPECT_EQ(multiSimController->SetDefaultCellularDataSlotId(0), TELEPHONY_ERR_SUCCESS);
1365 multiSimController->GetPrimarySlotId();
1366 EXPECT_NE(multiSimController->GetShowNumber(0, testU16Str), TELEPHONY_ERR_SUCCESS);
1367 EXPECT_NE(multiSimController->SetShowNumber(0, testU16Str, false), TELEPHONY_ERR_SUCCESS);
1368 multiSimController->SetShowNumberToDB(0, testU16Str);
1369 EXPECT_NE(multiSimController->GetShowName(0, testU16Str), TELEPHONY_ERR_SUCCESS);
1370 EXPECT_NE(multiSimController->SetShowName(0, testU16Str, false), TELEPHONY_ERR_SUCCESS);
1371 EXPECT_NE(multiSimController->SetActiveSim(0, 1, false), TELEPHONY_ERR_SUCCESS);
1372 EXPECT_NE(multiSimController->GetSlotId(1), TELEPHONY_ERR_SUCCESS);
1373 EXPECT_NE(multiSimController->SaveImsSwitch(0, 1), TELEPHONY_ERR_SUCCESS);
1374 int32_t imsSwitchValue;
1375 EXPECT_NE(multiSimController->QueryImsSwitch(0, imsSwitchValue), TELEPHONY_ERR_SUCCESS);
1376 std::vector<IccAccountInfo> iccAccountInfoList = {};
1377 EXPECT_NE(multiSimController->GetActiveSimAccountInfoList(false, iccAccountInfoList), TELEPHONY_ERR_SUCCESS);
1378 multiSimController->radioProtocolController_ = nullptr;
1379 EXPECT_NE(multiSimController->GetRadioProtocolTech(0), TELEPHONY_ERR_SUCCESS);
1380 EXPECT_NE(multiSimController->GetFirstActivedSlotId(), TELEPHONY_ERR_SUCCESS);
1381 EXPECT_NE(multiSimController->UpdateDataByIccId(0, testStr), TELEPHONY_ERR_SUCCESS);
1382 EXPECT_NE(multiSimController->InsertData(0, testStr), TELEPHONY_ERR_SUCCESS);
1383 }
1384
1385 /**
1386 * @tc.number Telephony_MultiSimController_003
1387 * @tc.name test error branch
1388 * @tc.desc Function test
1389 */
1390 HWTEST_F(BranchTest, Telephony_MultiSimController_003, Function | MediumTest | Level1)
1391 {
1392 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1393 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
1394 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
1395 std::shared_ptr<Telephony::MultiSimController> multiSimController =
1396 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
1397 multiSimController->UpdateOpKeyInfo();
1398 EXPECT_FALSE(multiSimController->IsValidData(-1));
1399 }
1400
1401 /**
1402 * @tc.number Telephony_MultiSimController_004
1403 * @tc.name test error branch
1404 * @tc.desc Function test
1405 */
1406 HWTEST_F(BranchTest, Telephony_MultiSimController_004, Function | MediumTest | Level1)
1407 {
1408 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1409 telRilManager->OnInit();
1410 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr};
1411 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr};
1412 for (int32_t slotId = 0; slotId < 2; slotId++) {
1413 simStateManager[slotId] = std::make_shared<SimStateManager>(telRilManager);
1414 if (simStateManager[slotId] != nullptr) {
1415 simStateManager[slotId]->Init(slotId);
1416 }
1417 simFileManager[slotId] = SimFileManager::CreateInstance(std::weak_ptr<ITelRilManager>(telRilManager),
1418 std::weak_ptr<SimStateManager>(simStateManager[slotId]));
1419 if (simFileManager[slotId] != nullptr) {
1420 simFileManager[slotId]->Init(slotId);
1421 }
1422 }
1423 std::shared_ptr<Telephony::MultiSimController> multiSimController =
1424 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
1425 multiSimController->Init();
1426 telRilManager->InitTelExtraModule(2);
1427 simStateManager.resize(3);
1428 simFileManager.resize(3);
1429 simStateManager[2] = std::make_shared<SimStateManager>(telRilManager);
1430 if (simStateManager[2] != nullptr) {
1431 simStateManager[2]->Init(2);
1432 }
1433 simFileManager[2] = SimFileManager::CreateInstance(std::weak_ptr<ITelRilManager>(telRilManager),
1434 std::weak_ptr<SimStateManager>(simStateManager[2]));
1435 if (simFileManager[2] != nullptr) {
1436 simFileManager[2]->Init(2);
1437 }
1438 multiSimController->AddExtraManagers(simStateManager[2], simFileManager[2]);
1439 multiSimController->ForgetAllData(0);
1440 multiSimController->simStateManager_[0]->simStateHandle_->iccState_.simStatus_ = 1;
1441 multiSimController->simStateManager_[0]->simStateHandle_->iccState_.simType_ = 2;
1442 multiSimController->simStateManager_[0]->simStateHandle_->iccid_ = "898600520123F0102670";
1443 multiSimController->simStateManager_[0]->simStateHandle_->externalType_ = CardType::SINGLE_MODE_USIM_CARD;
1444 multiSimController->simStateManager_[0]->simStateHandle_->externalState_ = SimState::SIM_STATE_READY;
1445 EXPECT_FALSE(multiSimController->InitData(0));
1446 EXPECT_FALSE(multiSimController->InitData(0));
1447 EXPECT_TRUE(multiSimController->InitShowNumber(0));
1448 std::vector<IccAccountInfo> iccAccountInfoList;
1449 EXPECT_GE(multiSimController->GetActiveSimAccountInfoList(false, iccAccountInfoList), TELEPHONY_ERR_SUCCESS);
1450 EXPECT_GE(multiSimController->GetActiveSimAccountInfoList(true, iccAccountInfoList), TELEPHONY_ERR_SUCCESS);
1451 EXPECT_GE(multiSimController->SaveImsSwitch(0, 1), TELEPHONY_ERR_SUCCESS);
1452 int32_t imsSwitchValue;
1453 EXPECT_GE(multiSimController->QueryImsSwitch(0, imsSwitchValue), TELEPHONY_ERR_SUCCESS);
1454 EXPECT_FALSE(multiSimController->IsSetActiveSimInProgress(0));
1455 EXPECT_FALSE(multiSimController->IsSetPrimarySlotIdInProgress());
1456 }
1457
1458 /**
1459 * @tc.number Telephony_SimManager_001
1460 * @tc.name test error branch
1461 * @tc.desc Function test
1462 */
1463 HWTEST_F(BranchTest, Telephony_SimManager_001, Function | MediumTest | Level1)
1464 {
1465 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1466 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
1467 std::u16string testStr = u"";
1468 EXPECT_GT(simManager->SetShowNumber(0, testStr), TELEPHONY_ERR_SUCCESS);
1469 EXPECT_GT(simManager->SetShowNumber(INVALID_SLOTID, testStr), TELEPHONY_ERR_SUCCESS);
1470 EXPECT_GT(simManager->GetSimOperatorNumeric(0, testStr), TELEPHONY_ERR_SUCCESS);
1471 EXPECT_GT(simManager->GetSimOperatorNumeric(INVALID_SLOTID, testStr), TELEPHONY_ERR_SUCCESS);
1472 bool boolResult = false;
1473 EXPECT_GT(simManager->HasSimCard(0, boolResult), TELEPHONY_ERR_SUCCESS);
1474 EXPECT_GT(simManager->HasSimCard(INVALID_SLOTID, boolResult), TELEPHONY_ERR_SUCCESS);
1475 SimState simState = SimState::SIM_STATE_UNKNOWN;
1476 EXPECT_GE(simManager->GetSimState(0, simState), TELEPHONY_ERR_SUCCESS);
1477 EXPECT_GE(simManager->GetSimState(INVALID_SLOTID, simState), TELEPHONY_ERR_SUCCESS);
1478 CardType cardType = CardType::UNKNOWN_CARD;
1479 EXPECT_NE(simManager->GetCardType(0, cardType), TELEPHONY_ERR_SUCCESS);
1480 EXPECT_NE(simManager->GetCardType(INVALID_SLOTID, cardType), TELEPHONY_ERR_SUCCESS);
1481 EXPECT_NE(simManager->SetModemInit(0, 0), TELEPHONY_ERR_SUCCESS);
1482 EXPECT_NE(simManager->SetModemInit(INVALID_SLOTID, 0), TELEPHONY_ERR_SUCCESS);
1483 LockType mLockType = LockType::PIN_LOCK;
1484 LockState lockState;
1485 EXPECT_NE(simManager->GetLockState(0, mLockType, lockState), TELEPHONY_ERR_SUCCESS);
1486 EXPECT_NE(simManager->GetLockState(INVALID_SLOTID, mLockType, lockState), TELEPHONY_ERR_SUCCESS);
1487 EXPECT_NE(simManager->RefreshSimState(0), TELEPHONY_ERR_SUCCESS);
1488 EXPECT_NE(simManager->RefreshSimState(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
1489 }
1490
1491 /**
1492 * @tc.number Telephony_SimManager_002
1493 * @tc.name test error branch
1494 * @tc.desc Function test
1495 */
1496 HWTEST_F(BranchTest, Telephony_SimManager_002, Function | MediumTest | Level1)
1497 {
1498 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1499 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
1500 std::u16string testStr = u"";
1501 EXPECT_GT(simManager->GetISOCountryCodeForSim(0, testStr), TELEPHONY_ERR_SUCCESS);
1502 EXPECT_GT(simManager->GetISOCountryCodeForSim(INVALID_SLOTID, testStr), TELEPHONY_ERR_SUCCESS);
1503 EXPECT_GT(simManager->SetShowName(0, testStr), TELEPHONY_ERR_SUCCESS);
1504 EXPECT_GT(simManager->SetShowName(INVALID_SLOTID, testStr), TELEPHONY_ERR_SUCCESS);
1505 EXPECT_GT(simManager->GetSimSpn(0, testStr), TELEPHONY_ERR_SUCCESS);
1506 EXPECT_GT(simManager->GetSimSpn(INVALID_SLOTID, testStr), TELEPHONY_ERR_SUCCESS);
1507 std::u16string result = u"";
1508 EXPECT_GT(simManager->GetSimIccId(0, result), TELEPHONY_ERR_SUCCESS);
1509 EXPECT_GT(simManager->GetSimIccId(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
1510 EXPECT_GT(simManager->GetIMSI(0, result), TELEPHONY_ERR_SUCCESS);
1511 EXPECT_GT(simManager->GetIMSI(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
1512 EXPECT_EQ(simManager->GetLocaleFromDefaultSim(0), testStr);
1513 EXPECT_EQ(simManager->GetLocaleFromDefaultSim(INVALID_SLOTID), testStr);
1514 EXPECT_GT(simManager->GetSimGid1(0, result), TELEPHONY_ERR_SUCCESS);
1515 EXPECT_GT(simManager->GetSimGid1(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
1516 EXPECT_EQ(simManager->GetSimGid2(0), testStr);
1517 EXPECT_EQ(simManager->GetSimGid2(INVALID_SLOTID), testStr);
1518 EXPECT_EQ(simManager->GetSimEons(0, "46001", 1, true), testStr);
1519 EXPECT_EQ(simManager->GetSimEons(INVALID_SLOTID, "46001", 1, true), testStr);
1520 EXPECT_GT(simManager->GetShowNumber(0, result), TELEPHONY_ERR_SUCCESS);
1521 EXPECT_GT(simManager->GetShowNumber(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
1522 EXPECT_GT(simManager->GetShowName(0, result), TELEPHONY_ERR_SUCCESS);
1523 EXPECT_GT(simManager->GetShowName(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
1524 EXPECT_GT(simManager->GetSimTelephoneNumber(0, result), TELEPHONY_ERR_SUCCESS);
1525 EXPECT_GT(simManager->GetSimTelephoneNumber(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
1526 EXPECT_EQ(simManager->GetSimTeleNumberIdentifier(0), testStr);
1527 EXPECT_EQ(simManager->GetSimTeleNumberIdentifier(INVALID_SLOTID), testStr);
1528 EXPECT_GT(simManager->GetVoiceMailIdentifier(0, result), TELEPHONY_ERR_SUCCESS);
1529 EXPECT_GT(simManager->GetVoiceMailIdentifier(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
1530 EXPECT_GT(simManager->GetVoiceMailNumber(0, result), TELEPHONY_ERR_SUCCESS);
1531 EXPECT_GT(simManager->GetVoiceMailNumber(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
1532 EXPECT_EQ(simManager->GetSimIst(0), testStr);
1533 EXPECT_EQ(simManager->GetSimIst(INVALID_SLOTID), testStr);
1534 EXPECT_NE(simManager->GetOpName(0, testStr), TELEPHONY_ERR_SUCCESS);
1535 EXPECT_NE(simManager->GetOpName(INVALID_SLOTID, testStr), TELEPHONY_ERR_SUCCESS);
1536 EXPECT_NE(simManager->GetOpKey(0, testStr), TELEPHONY_ERR_SUCCESS);
1537 EXPECT_NE(simManager->GetOpKey(INVALID_SLOTID, testStr), TELEPHONY_ERR_SUCCESS);
1538 EXPECT_NE(simManager->GetOpKeyExt(0, testStr), TELEPHONY_ERR_SUCCESS);
1539 EXPECT_NE(simManager->GetOpKeyExt(INVALID_SLOTID, testStr), TELEPHONY_ERR_SUCCESS);
1540 EXPECT_GT(simManager->SetVoiceMailInfo(0, testStr, testStr), TELEPHONY_ERR_SUCCESS);
1541 EXPECT_GT(simManager->SetVoiceMailInfo(INVALID_SLOTID, testStr, testStr), TELEPHONY_ERR_SUCCESS);
1542 EXPECT_GT(simManager->SetActiveSim(0, 1), TELEPHONY_ERR_SUCCESS);
1543 EXPECT_GT(simManager->SetActiveSim(INVALID_SLOTID, 1), TELEPHONY_ERR_SUCCESS);
1544 }
1545
1546 /**
1547 * @tc.number Telephony_SimManager_003
1548 * @tc.name test error branch
1549 * @tc.desc Function test
1550 */
1551 HWTEST_F(BranchTest, Telephony_SimManager_003, Function | MediumTest | Level1)
1552 {
1553 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1554 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
1555 simManager->SetDefaultVoiceSlotId(0);
1556 simManager->SetDefaultVoiceSlotId(INVALID_SLOTID);
1557 simManager->SetDefaultSmsSlotId(0);
1558 simManager->SetDefaultSmsSlotId(INVALID_SLOTID);
1559 simManager->SetDefaultCellularDataSlotId(0);
1560 simManager->SetDefaultCellularDataSlotId(INVALID_SLOTID);
1561 simManager->SetPrimarySlotId(INVALID_SLOTID);
1562 simManager->GetDefaultVoiceSlotId();
1563 simManager->GetDefaultSmsSlotId();
1564 simManager->GetDefaultCellularDataSlotId();
1565 int32_t slotId = INVALID_VALUE;
1566 simManager->GetPrimarySlotId(slotId);
1567 EXPECT_NE(simManager->GetSlotId(1), TELEPHONY_ERR_SUCCESS);
1568 EXPECT_NE(simManager->GetSimId(0), TELEPHONY_ERR_SUCCESS);
1569 std::vector<IccAccountInfo> iccAccountInfoList;
1570 EXPECT_GT(simManager->GetActiveSimAccountInfoList(false, iccAccountInfoList), TELEPHONY_ERR_SUCCESS);
1571 OperatorConfig mOperatorConfig;
1572 EXPECT_GT(simManager->GetOperatorConfigs(0, mOperatorConfig), TELEPHONY_ERR_SUCCESS);
1573 EXPECT_GT(simManager->GetOperatorConfigs(INVALID_SLOTID, mOperatorConfig), TELEPHONY_ERR_SUCCESS);
1574 bool boolResult = false;
1575 EXPECT_GT(simManager->HasOperatorPrivileges(0, boolResult), TELEPHONY_ERR_SUCCESS);
1576 EXPECT_GT(simManager->HasOperatorPrivileges(INVALID_SLOTID, boolResult), TELEPHONY_ERR_SUCCESS);
1577 int32_t testRadioProtocolTech = static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_UNKNOWN);
1578 EXPECT_EQ(simManager->GetRadioProtocolTech(0), testRadioProtocolTech);
1579 EXPECT_EQ(simManager->GetRadioProtocolTech(INVALID_SLOTID), testRadioProtocolTech);
1580 EXPECT_GT(simManager->SendEnvelopeCmd(0, ""), TELEPHONY_ERR_SUCCESS);
1581 EXPECT_GT(simManager->SendEnvelopeCmd(INVALID_SLOTID, ""), TELEPHONY_ERR_SUCCESS);
1582 EXPECT_GT(simManager->SendTerminalResponseCmd(0, ""), TELEPHONY_ERR_SUCCESS);
1583 EXPECT_GT(simManager->SendTerminalResponseCmd(INVALID_SLOTID, ""), TELEPHONY_ERR_SUCCESS);
1584 EXPECT_NE(simManager->SendCallSetupRequestResult(0, true), TELEPHONY_ERR_SUCCESS);
1585 EXPECT_NE(simManager->SendCallSetupRequestResult(INVALID_SLOTID, true), TELEPHONY_ERR_SUCCESS);
1586 std::string testAddress = "";
1587 EXPECT_GT(simManager->AddSmsToIcc(0, 1, testAddress, testAddress), TELEPHONY_ERR_SUCCESS);
1588 EXPECT_GT(simManager->AddSmsToIcc(INVALID_SLOTID, 1, testAddress, testAddress), TELEPHONY_ERR_SUCCESS);
1589 EXPECT_GT(simManager->UpdateSmsIcc(0, 1, 1, testAddress, testAddress), TELEPHONY_ERR_SUCCESS);
1590 EXPECT_GT(simManager->UpdateSmsIcc(INVALID_SLOTID, 1, 1, testAddress, testAddress), TELEPHONY_ERR_SUCCESS);
1591 EXPECT_GT(simManager->DelSmsIcc(0, 1), TELEPHONY_ERR_SUCCESS);
1592 EXPECT_GT(simManager->DelSmsIcc(INVALID_SLOTID, 1), TELEPHONY_ERR_SUCCESS);
1593 std::vector<std::string> result;
1594 EXPECT_EQ(simManager->ObtainAllSmsOfIcc(0), result);
1595 EXPECT_EQ(simManager->ObtainAllSmsOfIcc(INVALID_SLOTID), result);
1596 }
1597
1598 /**
1599 * @tc.number Telephony_SimManager_004
1600 * @tc.name test error branch
1601 * @tc.desc Function test
1602 */
1603 HWTEST_F(BranchTest, Telephony_SimManager_004, Function | MediumTest | Level1)
1604 {
1605 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1606 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
1607 std::vector<std::shared_ptr<DiallingNumbersInfo>> list;
1608 EXPECT_GT(simManager->QueryIccDiallingNumbers(0, 1, list), TELEPHONY_ERR_SUCCESS);
1609 EXPECT_GT(simManager->QueryIccDiallingNumbers(INVALID_SLOTID, 1, list), TELEPHONY_ERR_SUCCESS);
1610 EXPECT_GT(simManager->AddIccDiallingNumbers(0, 1, nullptr), TELEPHONY_ERR_SUCCESS);
1611 EXPECT_GT(simManager->AddIccDiallingNumbers(INVALID_SLOTID, 1, nullptr), TELEPHONY_ERR_SUCCESS);
1612 EXPECT_GT(simManager->DelIccDiallingNumbers(0, 1, nullptr), TELEPHONY_ERR_SUCCESS);
1613 EXPECT_GT(simManager->DelIccDiallingNumbers(INVALID_SLOTID, 1, nullptr), TELEPHONY_ERR_SUCCESS);
1614 EXPECT_GT(simManager->UpdateIccDiallingNumbers(0, 1, nullptr), TELEPHONY_ERR_SUCCESS);
1615 EXPECT_GT(simManager->UpdateIccDiallingNumbers(INVALID_SLOTID, 1, nullptr), TELEPHONY_ERR_SUCCESS);
1616 simManager->RegisterCoreNotify(0, nullptr, 1);
1617 simManager->RegisterCoreNotify(INVALID_SLOTID, nullptr, 1);
1618 simManager->UnRegisterCoreNotify(0, nullptr, 1);
1619 simManager->UnRegisterCoreNotify(INVALID_SLOTID, nullptr, 1);
1620 EXPECT_NE(simManager->SaveImsSwitch(0, 1), TELEPHONY_ERR_SUCCESS);
1621 EXPECT_NE(simManager->SaveImsSwitch(INVALID_SLOTID, 1), TELEPHONY_ERR_SUCCESS);
1622 int32_t imsSwitchValue;
1623 int32_t tokenId = -1;
1624 EXPECT_NE(simManager->QueryImsSwitch(0, imsSwitchValue), TELEPHONY_ERR_SUCCESS);
1625 EXPECT_NE(simManager->QueryImsSwitch(INVALID_SLOTID, imsSwitchValue), TELEPHONY_ERR_SUCCESS);
1626 EXPECT_NE(simManager->RegisterSimAccountCallback(tokenId, nullptr), TELEPHONY_ERR_SUCCESS);
1627 EXPECT_NE(simManager->UnregisterSimAccountCallback(tokenId), TELEPHONY_ERR_SUCCESS);
1628 int32_t dsdsMode = INVALID_VALUE;
1629 simManager->GetDsdsMode(dsdsMode);
1630 simManager->SetDsdsMode(0);
1631 std::string testString = "";
1632 EXPECT_NE(simManager->ObtainSpnCondition(0, true, testString), TELEPHONY_ERR_SUCCESS);
1633 EXPECT_NE(simManager->ObtainSpnCondition(INVALID_SLOTID, true, testString), TELEPHONY_ERR_SUCCESS);
1634 SimAuthenticationResponse mResponse;
1635 EXPECT_NE(simManager->SimAuthentication(0, static_cast<AuthType>(0), "", mResponse), TELEPHONY_ERR_SUCCESS);
1636 EXPECT_NE(
1637 simManager->SimAuthentication(INVALID_SLOTID, static_cast<AuthType>(0), "", mResponse), TELEPHONY_ERR_SUCCESS);
1638 EXPECT_NE(simManager->SimAuthentication(0, AuthType::SIM_AUTH_EAP_SIM_TYPE, "", mResponse), TELEPHONY_ERR_SUCCESS);
1639 EXPECT_NE(simManager->SimAuthentication(INVALID_SLOTID, AuthType::SIM_AUTH_EAP_SIM_TYPE, "", mResponse),
1640 TELEPHONY_ERR_SUCCESS);
1641 EXPECT_NE(simManager->SendSimMatchedOperatorInfo(0, 0, "NULL", ""), TELEPHONY_ERR_SUCCESS);
1642 }
1643
1644 /**
1645 * @tc.number Telephony_SimManager_005
1646 * @tc.name test error branch
1647 * @tc.desc Function test
1648 */
1649 HWTEST_F(BranchTest, Telephony_SimManager_005, Function | MediumTest | Level1)
1650 {
1651 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1652 std::shared_ptr<Telephony::SimManager> simManager = std::make_shared<SimManager>(telRilManager);
1653 std::string password = "1234";
1654 LockStatusResponse mLockStatusResponse;
1655 EXPECT_GT(simManager->UnlockPin(0, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1656 EXPECT_GT(simManager->UnlockPin(INVALID_SLOTID, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1657 EXPECT_GT(simManager->UnlockPuk(0, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1658 EXPECT_GT(simManager->UnlockPuk(INVALID_SLOTID, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1659 EXPECT_GT(simManager->AlterPin(0, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1660 EXPECT_GT(simManager->AlterPin(INVALID_SLOTID, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1661 LockInfo mLockInfo;
1662 EXPECT_GT(simManager->SetLockState(0, mLockInfo, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1663 EXPECT_GT(simManager->SetLockState(INVALID_SLOTID, mLockInfo, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1664 EXPECT_GT(simManager->UnlockPin2(0, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1665 EXPECT_GT(simManager->UnlockPin2(INVALID_SLOTID, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1666 EXPECT_GT(simManager->UnlockPuk2(0, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1667 EXPECT_GT(simManager->UnlockPuk2(INVALID_SLOTID, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1668 EXPECT_GT(simManager->AlterPin2(0, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1669 EXPECT_GT(simManager->AlterPin2(INVALID_SLOTID, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1670 PersoLockInfo mPersoLockInfo;
1671 EXPECT_GT(simManager->UnlockSimLock(0, mPersoLockInfo, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1672 EXPECT_GT(simManager->UnlockSimLock(INVALID_SLOTID, mPersoLockInfo, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1673 EXPECT_FALSE(simManager->IsSimActive(0));
1674 EXPECT_FALSE(simManager->IsSimActive(INVALID_SLOTID));
1675 IccAccountInfo mIccAccountInfo;
1676 EXPECT_GT(simManager->GetSimAccountInfo(0, false, mIccAccountInfo), TELEPHONY_ERR_SUCCESS);
1677 EXPECT_GT(simManager->GetSimAccountInfo(INVALID_SLOTID, false, mIccAccountInfo), TELEPHONY_ERR_SUCCESS);
1678 bool isCTSimCard = false;
1679 EXPECT_GT(simManager->IsCTSimCard(0, isCTSimCard), TELEPHONY_ERR_SUCCESS);
1680 EXPECT_GT(simManager->IsCTSimCard(INVALID_SLOTID, isCTSimCard), TELEPHONY_ERR_SUCCESS);
1681 }
1682
1683 /**
1684 * @tc.number Telephony_SimStateManager_001
1685 * @tc.name test error branch
1686 * @tc.desc Function test
1687 */
1688 HWTEST_F(BranchTest, Telephony_SimStateManager_001, Function | MediumTest | Level1)
1689 {
1690 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1691 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1692 simStateManager->RegisterCoreNotify(nullptr, 1);
1693 simStateManager->UnRegisterCoreNotify(nullptr, 1);
1694 EXPECT_FALSE(simStateManager->HasSimCard());
1695 std::string password = "1234";
1696 LockStatusResponse mLockStatusResponse;
1697 EXPECT_GT(simStateManager->UnlockPin(0, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1698 EXPECT_GT(simStateManager->UnlockPuk(0, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1699 EXPECT_GT(simStateManager->AlterPin(0, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1700 LockInfo mLockInfo;
1701 EXPECT_GT(simStateManager->SetLockState(0, mLockInfo, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1702 mLockInfo.lockType = LockType::PIN_LOCK;
1703 mLockInfo.lockState = LockState::LOCK_ERROR;
1704 EXPECT_GT(simStateManager->SetLockState(0, mLockInfo, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1705 mLockInfo.lockState = LockState::LOCK_ON;
1706 EXPECT_GT(simStateManager->SetLockState(0, mLockInfo, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1707 LockInfo testLockInfo;
1708 LockState lockState;
1709 EXPECT_GT(simStateManager->GetLockState(0, testLockInfo.lockType, lockState), TELEPHONY_ERR_SUCCESS);
1710 LockType lockType = LockType::PIN_LOCK;
1711 EXPECT_GT(simStateManager->GetLockState(0, lockType, lockState), TELEPHONY_ERR_SUCCESS);
1712 EXPECT_GT(simStateManager->UnlockPin2(0, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1713 EXPECT_GT(simStateManager->UnlockPuk2(0, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1714 EXPECT_GT(simStateManager->AlterPin2(0, password, password, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1715 PersoLockInfo mPersoLockInfo;
1716 EXPECT_GT(simStateManager->UnlockSimLock(0, mPersoLockInfo, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1717 SimAuthenticationResponse mResponse;
1718 EXPECT_NE(
1719 simStateManager->SimAuthentication(0, AuthType::SIM_AUTH_EAP_SIM_TYPE, "", mResponse), TELEPHONY_ERR_SUCCESS);
1720 auto simStateManagerTwo = std::make_shared<SimStateManager>(telRilManager);
1721 simStateManager->simStateHandle_ = std::make_shared<SimStateHandle>(simStateManagerTwo);
1722 EXPECT_GE(simStateManager->GetCardType(), CardType::UNKNOWN_CARD);
1723 EXPECT_GT(simStateManager->UnlockSimLock(0, mPersoLockInfo, mLockStatusResponse), TELEPHONY_ERR_SUCCESS);
1724 }
1725
1726 /**
1727 * @tc.number Telephony_SimStateHandle_001
1728 * @tc.name test error branch
1729 * @tc.desc Function test
1730 */
1731 HWTEST_F(BranchTest, Telephony_SimStateHandle_001, Function | MediumTest | Level1)
1732 {
1733 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1734 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1735 auto simStateHandle = std::make_shared<SimStateHandle>(simStateManager);
1736 simStateHandle->iccState_.simStatus_ = 1;
1737 simStateHandle->slotId_ = INVALID_SLOTID;
1738 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STATE_CHANGED);
1739 simStateHandle->ProcessEvent(event);
1740 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_CHANGE);
1741 simStateHandle->ProcessEvent(event);
1742 event = AppExecFwk::InnerEvent::Get(MSG_SIM_GET_ICC_STATUS_DONE);
1743 simStateHandle->ProcessEvent(event);
1744 event = AppExecFwk::InnerEvent::Get(MSG_SIM_UNLOCK_PIN_DONE);
1745 simStateHandle->ProcessEvent(event);
1746 event = AppExecFwk::InnerEvent::Get(MSG_SIM_UNLOCK_PUK_DONE);
1747 simStateHandle->ProcessEvent(event);
1748 event = AppExecFwk::InnerEvent::Get(MSG_SIM_CHANGE_PIN_DONE);
1749 simStateHandle->ProcessEvent(event);
1750 event = AppExecFwk::InnerEvent::Get(MSG_SIM_UNLOCK_PIN2_DONE);
1751 simStateHandle->ProcessEvent(event);
1752 event = AppExecFwk::InnerEvent::Get(MSG_SIM_UNLOCK_PUK2_DONE);
1753 simStateHandle->ProcessEvent(event);
1754 event = AppExecFwk::InnerEvent::Get(MSG_SIM_CHANGE_PIN2_DONE);
1755 simStateHandle->ProcessEvent(event);
1756 event = AppExecFwk::InnerEvent::Get(MSG_SIM_UNLOCK_SIMLOCK_DONE);
1757 simStateHandle->ProcessEvent(event);
1758 event = AppExecFwk::InnerEvent::Get(MSG_SIM_ENABLE_PIN_DONE);
1759 simStateHandle->ProcessEvent(event);
1760 event = AppExecFwk::InnerEvent::Get(MSG_SIM_CHECK_PIN_DONE);
1761 simStateHandle->ProcessEvent(event);
1762 event = AppExecFwk::InnerEvent::Get(MSG_SIM_GET_REALTIME_ICC_STATUS_DONE);
1763 simStateHandle->ProcessEvent(event);
1764 event = AppExecFwk::InnerEvent::Get(MSG_SIM_AUTHENTICATION_DONE);
1765 simStateHandle->ProcessEvent(event);
1766 event = AppExecFwk::InnerEvent::Get(MSG_SIM_SEND_NCFG_OPER_INFO_DONE);
1767 simStateHandle->ProcessEvent(event);
1768 EXPECT_EQ(simStateHandle->GetAidByCardType(CardType::SINGLE_MODE_RUIM_CARD), CDMA_FAKE_AID);
1769 EXPECT_EQ(simStateHandle->GetAidByCardType(CardType::SINGLE_MODE_SIM_CARD), GSM_FAKE_AID);
1770 EXPECT_EQ(simStateHandle->GetAidByCardType(CardType::DUAL_MODE_CG_CARD), GSM_FAKE_AID);
1771 EXPECT_EQ(simStateHandle->GetAidByCardType(CardType::CT_NATIONAL_ROAMING_CARD), GSM_FAKE_AID);
1772 EXPECT_EQ(simStateHandle->GetAidByCardType(CardType::CU_DUAL_MODE_CARD), GSM_FAKE_AID);
1773 EXPECT_EQ(simStateHandle->GetAidByCardType(CardType::DUAL_MODE_TELECOM_LTE_CARD), GSM_FAKE_AID);
1774 EXPECT_EQ(simStateHandle->GetAidByCardType(CardType::DUAL_MODE_UG_CARD), GSM_FAKE_AID);
1775 EXPECT_EQ(simStateHandle->GetAidByCardType(CardType::UNKNOWN_CARD), USIM_AID);
1776 }
1777
1778 /**
1779 * @tc.number Telephony_SimStateHandle_002
1780 * @tc.name test error branch
1781 * @tc.desc Function test
1782 */
1783 HWTEST_F(BranchTest, Telephony_SimStateHandle_002, Function | MediumTest | Level1)
1784 {
1785 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
1786 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
1787 auto simStateHandle = std::make_shared<SimStateHandle>(simStateManager);
1788 simStateHandle->iccState_.simStatus_ = 1;
1789 simStateHandle->slotId_ = INVALID_SLOTID;
1790 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STATE_CHANGED);
1791 simStateHandle->IsRadioStateUnavailable(event);
1792 auto radioState = std::make_shared<Int32Parcel>(ModemPowerState::CORE_SERVICE_POWER_NOT_AVAILABLE);
1793 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STATE_CHANGED, radioState);
1794 EXPECT_TRUE(simStateHandle->IsRadioStateUnavailable(event));
1795 }
1796 /**
1797 * @tc.number Telephony_NetworkRegister_001
1798 * @tc.name test error branch
1799 * @tc.desc Function test
1800 */
1801 HWTEST_F(BranchTest, Telephony_NetworkRegister_001, Function | MediumTest | Level1)
1802 {
1803 auto telRilManager = std::make_shared<TelRilManager>();
1804 auto simManager = std::make_shared<SimManager>(telRilManager);
1805 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
1806 auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
1807 auto networkRegister = std::make_shared<NetworkRegister>(networkSearchState, networkSearchManager, INVALID_SLOTID);
1808 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(0, 1);
1809 auto psRegInfo = std::make_shared<PsRegStatusResultInfo>();
1810 auto csRegInfo = std::make_shared<CsRegStatusInfo>();
1811 networkRegister->ProcessPsRegister(psRegInfo);
1812 networkRegister->ProcessCsRegister(csRegInfo);
1813 networkRegister->ProcessChannelConfigInfo(event);
1814 networkRegister->NotifyNrFrequencyChanged();
1815 psRegInfo = nullptr;
1816 csRegInfo = nullptr;
1817 networkRegister->ProcessPsRegister(psRegInfo);
1818 networkRegister->ProcessCsRegister(csRegInfo);
1819 EXPECT_EQ(networkRegister->ConvertRegFromRil(NetworkRegister::NetworkRegister::RilRegister::REG_STATE_SEARCH),
1820 RegServiceState::REG_STATE_SEARCH);
1821 EXPECT_EQ(networkRegister->ConvertRegFromRil(NetworkRegister::RilRegister::REG_STATE_NOT_REG),
1822 RegServiceState::REG_STATE_NO_SERVICE);
1823 EXPECT_EQ(networkRegister->ConvertRegFromRil(NetworkRegister::RilRegister::REG_STATE_NO_SERVICE),
1824 RegServiceState::REG_STATE_NO_SERVICE);
1825 EXPECT_EQ(networkRegister->ConvertRegFromRil(NetworkRegister::RilRegister::REG_STATE_INVALID),
1826 RegServiceState::REG_STATE_UNKNOWN);
1827 EXPECT_EQ(networkRegister->ConvertRegFromRil(NetworkRegister::RilRegister::REG_STATE_ROAMING),
1828 RegServiceState::REG_STATE_IN_SERVICE);
1829 EXPECT_EQ(networkRegister->ConvertRegFromRil(NetworkRegister::RilRegister::REG_STATE_HOME_ONLY),
1830 RegServiceState::REG_STATE_IN_SERVICE);
1831 EXPECT_EQ(networkRegister->ConvertRegFromRil(NetworkRegister::RilRegister::REG_STATE_EMERGENCY_ONLY),
1832 RegServiceState::REG_STATE_EMERGENCY_ONLY);
1833 }
1834
1835 /**
1836 * @tc.number Telephony_NetworkRegister_002
1837 * @tc.name test error branch
1838 * @tc.desc Function test
1839 */
1840 HWTEST_F(BranchTest, Telephony_NetworkRegister_002, Function | MediumTest | Level1)
1841 {
1842 auto telRilManager = std::make_shared<TelRilManager>();
1843 auto simManager = std::make_shared<SimManager>(telRilManager);
1844 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
1845 auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
1846 auto networkRegister = std::make_shared<NetworkRegister>(networkSearchState, networkSearchManager, INVALID_SLOTID);
1847 networkRegister->InitNrConversionConfig();
1848 std::string config = "";
1849 EXPECT_FALSE(networkRegister->IsValidConfig(config));
1850 config = "ConfigD";
1851 EXPECT_TRUE(networkRegister->IsValidConfig(config));
1852 int32_t rrcState = 1;
1853 EXPECT_NE(networkRegister->GetRrcConnectionState(rrcState), TELEPHONY_ERR_SUCCESS);
1854 EXPECT_EQ(networkRegister->HandleRrcStateChanged(0), TELEPHONY_ERR_SUCCESS);
1855 EXPECT_EQ(networkRegister->HandleRrcStateChanged(1), TELEPHONY_ERR_SUCCESS);
1856 EXPECT_GT(
1857 networkRegister->GetTechnologyByNrConfig(RadioTech::RADIO_TECHNOLOGY_NR), RadioTech::RADIO_TECHNOLOGY_INVALID);
1858 EXPECT_GT(
1859 networkRegister->GetTechnologyByNrConfig(RadioTech::RADIO_TECHNOLOGY_LTE), RadioTech::RADIO_TECHNOLOGY_INVALID);
1860 EXPECT_EQ(networkRegister->NotifyStateChange(), TELEPHONY_ERR_SUCCESS);
1861 EXPECT_GE(networkRegister->RevertLastTechnology(), TELEPHONY_ERR_SUCCESS);
1862 EXPECT_EQ(networkRegister->GetSystemPropertiesConfig(config), TELEPHONY_ERR_SUCCESS);
1863 int32_t nsaState = 1;
1864 EXPECT_EQ(networkRegister->UpdateNsaState(nsaState), nsaState);
1865 }
1866
1867 /**
1868 * @tc.number Telephony_NetworkRegister_003
1869 * @tc.name test error branch
1870 * @tc.desc Function test
1871 */
1872 HWTEST_F(BranchTest, Telephony_NetworkRegister_003, Function | MediumTest | Level1)
1873 {
1874 auto telRilManager = std::make_shared<TelRilManager>();
1875 auto simManager = std::make_shared<SimManager>(telRilManager);
1876 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
1877 auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
1878 auto networkRegister = std::make_shared<NetworkRegister>(networkSearchState, networkSearchManager, INVALID_SLOTID);
1879 EXPECT_EQ(
1880 networkRegister->ConvertTechFromRil(TelRilRadioTech::RADIO_TECHNOLOGY_GSM), RadioTech::RADIO_TECHNOLOGY_GSM);
1881 EXPECT_EQ(networkRegister->ConvertTechFromRil(TelRilRadioTech::RADIO_TECHNOLOGY_1XRTT),
1882 RadioTech::RADIO_TECHNOLOGY_1XRTT);
1883 EXPECT_EQ(
1884 networkRegister->ConvertTechFromRil(TelRilRadioTech::RADIO_TECHNOLOGY_HSPA), RadioTech::RADIO_TECHNOLOGY_HSPA);
1885 EXPECT_EQ(networkRegister->ConvertTechFromRil(TelRilRadioTech::RADIO_TECHNOLOGY_HSPAP),
1886 RadioTech::RADIO_TECHNOLOGY_HSPAP);
1887 EXPECT_EQ(networkRegister->ConvertTechFromRil(TelRilRadioTech::RADIO_TECHNOLOGY_NR),
1888 RadioTech::RADIO_TECHNOLOGY_NR);
1889 EXPECT_EQ(networkRegister->ConvertTechFromRil(TelRilRadioTech::RADIO_TECHNOLOGY_WCDMA),
1890 RadioTech::RADIO_TECHNOLOGY_WCDMA);
1891 EXPECT_EQ(
1892 networkRegister->ConvertTechFromRil(TelRilRadioTech::RADIO_TECHNOLOGY_LTE), RadioTech::RADIO_TECHNOLOGY_LTE);
1893 EXPECT_EQ(
1894 networkRegister->ConvertTechFromRil(TelRilRadioTech::RADIO_TECHNOLOGY_EVDO), RadioTech::RADIO_TECHNOLOGY_EVDO);
1895 EXPECT_EQ(networkRegister->ConvertTechFromRil(TelRilRadioTech::RADIO_TECHNOLOGY_EHRPD),
1896 RadioTech::RADIO_TECHNOLOGY_EHRPD);
1897 EXPECT_EQ(networkRegister->ConvertTechFromRil(TelRilRadioTech::RADIO_TECHNOLOGY_TD_SCDMA),
1898 RadioTech::RADIO_TECHNOLOGY_TD_SCDMA);
1899 EXPECT_EQ(networkRegister->ConvertTechFromRil(TelRilRadioTech::RADIO_TECHNOLOGY_LTE_CA),
1900 RadioTech::RADIO_TECHNOLOGY_LTE_CA);
1901 EXPECT_EQ(networkRegister->ConvertTechFromRil(TelRilRadioTech::RADIO_TECHNOLOGY_INVALID),
1902 RadioTech::RADIO_TECHNOLOGY_UNKNOWN);
1903 }
1904
1905 /**
1906 * @tc.number Telephony_OperatorName_001
1907 * @tc.name test error branch
1908 * @tc.desc Function test
1909 */
1910 HWTEST_F(BranchTest, Telephony_OperatorName_001, Function | MediumTest | Level1)
1911 {
1912 EventFwk::MatchingSkills matchingSkills;
1913 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
1914 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1915 auto telRilManager = std::make_shared<TelRilManager>();
1916 auto simManager = std::make_shared<SimManager>(telRilManager);
1917 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
1918 auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
1919 auto operatorName = std::make_shared<OperatorName>(
1920 subscriberInfo, networkSearchState, simManager, networkSearchManager, INVALID_SLOTID);
1921 auto operatorInfo = std::make_shared<OperatorInfoResult>();
1922 std::string plmn = "";
1923 bool showPlmn = true;
1924 std::string numeric = "qwe";
1925 std::vector<std::string> pnnCust;
1926 sptr<NetworkState> networkState;
1927 operatorName->NotifyGsmSpnChanged(RegServiceState::REG_STATE_IN_SERVICE, networkState, "");
1928 operatorName->NotifyCdmaSpnChanged(RegServiceState::REG_STATE_IN_SERVICE, networkState, "");
1929 operatorName->UpdateOperatorConfig();
1930 operatorName->UpdatePnnCust(pnnCust);
1931 operatorName->UpdateOplCust(pnnCust);
1932 EXPECT_EQ(operatorName->GetPlmn(networkState, true), "");
1933 networkState = new NetworkState;
1934 operatorName->UpdatePlmn(RegServiceState::REG_STATE_IN_SERVICE, networkState, 1, plmn, showPlmn);
1935 operatorName->UpdatePlmn(RegServiceState::REG_STATE_NO_SERVICE, networkState, 1, plmn, showPlmn);
1936 operatorName->UpdatePlmn(RegServiceState::REG_STATE_EMERGENCY_ONLY, networkState, 1, plmn, showPlmn);
1937 operatorName->UpdatePlmn(RegServiceState::REG_STATE_SEARCH, networkState, 1, plmn, showPlmn);
1938 operatorName->UpdatePlmn(RegServiceState::REG_STATE_UNKNOWN, networkState, 1, plmn, showPlmn);
1939 operatorName->UpdatePlmn(RegServiceState::REG_STATE_POWER_OFF, networkState, 1, plmn, showPlmn);
1940 operatorName->UpdateSpn(RegServiceState::REG_STATE_IN_SERVICE, networkState, 1, plmn, showPlmn);
1941 operatorName->NotifyGsmSpnChanged(RegServiceState::REG_STATE_IN_SERVICE, networkState, "");
1942 operatorName->NotifyCdmaSpnChanged(RegServiceState::REG_STATE_IN_SERVICE, networkState, "");
1943 operatorName->GsmOperatorInfo(operatorInfo);
1944 operatorName->HandleOperatorInfo(operatorInfo);
1945 operatorName->TrySetLongOperatorNameWithTranslation();
1946 operatorName->NotifySpnChanged();
1947 operatorName->CdmaOperatorInfo(operatorInfo);
1948 operatorInfo = nullptr;
1949 operatorName->GsmOperatorInfo(operatorInfo);
1950 operatorName->CdmaOperatorInfo(operatorInfo);
1951 EXPECT_EQ(operatorName->GetCurrentLac(), 0);
1952 EXPECT_TRUE(operatorName->GetNetworkStatus() == nullptr);
1953 EXPECT_EQ(operatorName->GetCustomName(plmn), "");
1954 EXPECT_EQ(operatorName->GetCustomName(numeric), "");
1955 EXPECT_EQ(operatorName->GetCustSpnRule(true), 0);
1956 operatorName->displayConditionCust_ = 1;
1957 EXPECT_NE(operatorName->GetCustSpnRule(true), 0);
1958 operatorName->simManager_ = nullptr;
1959 EXPECT_EQ(operatorName->GetEons(plmn, 1, true), "");
1960 }
1961
1962 /**
1963 * @tc.number Telephony_OperatorName_002
1964 * @tc.name test error branch
1965 * @tc.desc Function test
1966 */
1967 HWTEST_F(BranchTest, Telephony_OperatorName_002, Function | MediumTest | Level1)
1968 {
1969 EventFwk::MatchingSkills matchingSkills;
1970 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
1971 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1972 auto telRilManager = std::make_shared<TelRilManager>();
1973 auto simManager = std::make_shared<SimManager>(telRilManager);
1974 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
1975 auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
1976 auto operatorName = std::make_shared<OperatorName>(
1977 subscriberInfo, networkSearchState, simManager, networkSearchManager, INVALID_SLOTID);
1978 operatorName->enableCust_ = true;
1979 std::string plmn = "46000";
1980 std::vector<std::string> pnnCust;
1981 pnnCust.push_back("CMCC,ChinaMobile");
1982 std::vector<std::string> oplCust;
1983 oplCust.push_back("0,0,0,46000");
1984 sptr<NetworkState> networkState;
1985 operatorName->csSpnFormat_ = "*";
1986 operatorName->UpdatePnnCust(pnnCust);
1987 operatorName->UpdateOplCust(oplCust);
1988 EXPECT_EQ(operatorName->GetCustEons(plmn, 1, false, false), "");
1989 bool showSpn = true;
1990 operatorName->UpdateSpn(RegServiceState::REG_STATE_IN_SERVICE, networkState, 1, plmn, showSpn);
1991 operatorName->NotifyCdmaSpnChanged(RegServiceState::REG_STATE_IN_SERVICE, networkState, "ChinaMobile");
1992 std::shared_ptr<OperatorInfoResult> operatorResult = std::make_shared<OperatorInfoResult>();
1993 operatorResult->flag = NetworkSearchManagerInner::SERIAL_NUMBER_EXEMPT;
1994 operatorName->HandleOperatorInfo(operatorResult);
1995 operatorName->TrySetLongOperatorNameWithTranslation();
1996 }
1997
1998 /**
1999 * @tc.number Telephony_NetworkSearchState_001
2000 * @tc.name test error branch
2001 * @tc.desc Function test
2002 */
2003 HWTEST_F(BranchTest, Telephony_NetworkSearchState_001, Function | MediumTest | Level1)
2004 {
2005 auto telRilManager = std::make_shared<TelRilManager>();
2006 auto simManager = std::make_shared<SimManager>(telRilManager);
2007 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
2008 auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
2009 const std::string longName = "";
2010 const std::string shortName = "";
2011 const std::string numeric = "";
2012 ImsServiceStatus imsServiceStatus;
2013 ImsRegInfo info;
2014 EXPECT_TRUE(networkSearchState->GetNetworkStatus() == nullptr);
2015 networkSearchState->NotifyStateChange();
2016 networkSearchState->CsRadioTechChange();
2017 networkSearchState->NotifyPsRegStatusChange();
2018 networkSearchState->NotifyPsRoamingStatusChange();
2019 networkSearchState->NotifyPsRadioTechChange();
2020 networkSearchState->NotifyEmergencyChange();
2021 networkSearchState->NotifyNrStateChange();
2022 networkSearchState->NotifyImsStateChange(ImsServiceType::TYPE_VOICE, info);
2023 networkSearchState->Init();
2024 networkSearchState->SetImsServiceStatus(imsServiceStatus);
2025 networkSearchState->NotifyStateChange();
2026 networkSearchState->CsRadioTechChange();
2027 imsServiceStatus.supportImsUt = true;
2028 networkSearchState->SetImsServiceStatus(imsServiceStatus);
2029 networkSearchState->SetOperatorInfo(longName, shortName, numeric, DomainType::DOMAIN_TYPE_PS);
2030 networkSearchState->SetEmergency(true);
2031 networkSearchState->IsEmergency();
2032 networkSearchState->SetNetworkType(RadioTech::RADIO_TECHNOLOGY_GSM, DomainType::DOMAIN_TYPE_PS);
2033 networkSearchState->SetNetworkState(RegServiceState::REG_STATE_IN_SERVICE, DomainType::DOMAIN_TYPE_PS);
2034 networkSearchState->SetNetworkStateToRoaming(RoamingType::ROAMING_STATE_UNSPEC, DomainType::DOMAIN_TYPE_PS);
2035 networkSearchState->SetInitial();
2036 networkSearchState->SetNrState(NrState::NR_STATE_NOT_SUPPORT);
2037 networkSearchState->SetCfgTech(RadioTech::RADIO_TECHNOLOGY_EVDO);
2038 networkSearchState->SetImsStatus(true);
2039 networkSearchState->SetImsStatus(false);
2040 networkSearchState->SetLongOperatorName(longName, DomainType::DOMAIN_TYPE_PS);
2041 networkSearchState->NotifyPsRegStatusChange();
2042 networkSearchState->NotifyPsRoamingStatusChange();
2043 networkSearchState->NotifyPsRadioTechChange();
2044 networkSearchState->NotifyEmergencyChange();
2045 networkSearchState->NotifyNrStateChange();
2046 EXPECT_EQ(networkSearchState->GetImsStatus(ImsServiceType::TYPE_VOICE, info), 0);
2047 EXPECT_EQ(networkSearchState->GetImsStatus(ImsServiceType::TYPE_VIDEO, info), 0);
2048 EXPECT_EQ(networkSearchState->GetImsStatus(ImsServiceType::TYPE_UT, info), 0);
2049 EXPECT_EQ(networkSearchState->GetImsStatus(ImsServiceType::TYPE_SMS, info), 0);
2050 }
2051
2052 /**
2053 * @tc.number Telephony_NetworkSearchManager_001
2054 * @tc.name test error branch
2055 * @tc.desc Function test
2056 */
2057 HWTEST_F(BranchTest, Telephony_NetworkSearchManager_001, Function | MediumTest | Level1)
2058 {
2059 auto telRilManager = std::make_shared<TelRilManager>();
2060 std::shared_ptr<SimManager> simManager = nullptr;
2061 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
2062 sptr<NetworkInformation> networkInfo = nullptr;
2063 ImsRegInfo info;
2064 std::u16string testStr = u"";
2065 sptr<INetworkSearchCallback> networkSearchCallback = nullptr;
2066 networkSearchManager->SetRadioState(INVALID_SLOTID, true, 1);
2067 networkSearchManager->SetRadioState(INVALID_SLOTID, true, 1, networkSearchCallback);
2068 EXPECT_EQ(networkSearchManager->GetRadioState(INVALID_SLOTID), ModemPowerState::CORE_SERVICE_POWER_NOT_AVAILABLE);
2069 EXPECT_NE(networkSearchManager->GetNetworkSearchInformation(INVALID_SLOTID, networkSearchCallback),
2070 TELEPHONY_ERR_SUCCESS);
2071 EXPECT_FALSE(networkSearchManager->SetNetworkSelectionMode(INVALID_SLOTID, 1, networkInfo, true));
2072 int32_t slotId = 0;
2073 EXPECT_FALSE(networkSearchManager->SetNetworkSelectionMode(slotId, 1, networkInfo, true));
2074 EXPECT_NE(
2075 networkSearchManager->SetNetworkSelectionMode(INVALID_SLOTID, 1, networkInfo, true, networkSearchCallback),
2076 TELEPHONY_ERR_SUCCESS);
2077 EXPECT_NE(networkSearchManager->GetPreferredNetwork(INVALID_SLOTID, networkSearchCallback), TELEPHONY_ERR_SUCCESS);
2078 EXPECT_NE(networkSearchManager->GetPreferredNetwork(slotId, networkSearchCallback), TELEPHONY_ERR_SUCCESS);
2079 int32_t networkMode = 0;
2080 EXPECT_NE(networkSearchManager->SetCachePreferredNetworkValue(INVALID_SLOTID, networkMode), TELEPHONY_ERR_SUCCESS);
2081 EXPECT_NE(networkSearchManager->GetCachePreferredNetworkValue(INVALID_SLOTID, networkMode), TELEPHONY_ERR_SUCCESS);
2082 EXPECT_NE(
2083 networkSearchManager->SetPreferredNetwork(INVALID_SLOTID, 1, networkSearchCallback), TELEPHONY_ERR_SUCCESS);
2084 std::u16string result = u"";
2085 EXPECT_NE(networkSearchManager->GetIsoCountryCodeForNetwork(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
2086 EXPECT_EQ(result, testStr);
2087 EXPECT_NE(networkSearchManager->GetImei(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
2088 EXPECT_EQ(result, testStr);
2089 EXPECT_NE(networkSearchManager->GetImeiSv(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
2090 EXPECT_EQ(result, testStr);
2091 EXPECT_EQ(networkSearchManager->GetImsRegStatus(INVALID_SLOTID, ImsServiceType::TYPE_SMS, info),
2092 TELEPHONY_ERR_LOCAL_PTR_NULL);
2093 EXPECT_NE(networkSearchManager->GetUniqueDeviceId(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
2094 EXPECT_EQ(result, testStr);
2095 EXPECT_NE(networkSearchManager->GetMeid(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
2096 EXPECT_EQ(result, testStr);
2097 EXPECT_EQ(networkSearchManager->GetResidentNetworkNumeric(INVALID_SLOTID), std::string());
2098 networkSearchManager->SetResidentNetworkNumeric(0, "");
2099 }
2100
2101 /**
2102 * @tc.number Telephony_NetworkSearchManager_002
2103 * @tc.name test error branch
2104 * @tc.desc Function test
2105 */
2106 HWTEST_F(BranchTest, Telephony_NetworkSearchManager_002, Function | MediumTest | Level1)
2107 {
2108 auto telRilManager = std::make_shared<TelRilManager>();
2109 auto simManager = std::make_shared<SimManager>(telRilManager);
2110 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
2111 auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
2112 auto networkSearchHandler =
2113 std::make_shared<NetworkSearchHandler>(networkSearchManager, telRilManager, simManager, INVALID_SLOTID);
2114 auto inner = std::make_shared<NetworkSearchManagerInner>();
2115 inner->networkSearchState_ = networkSearchState;
2116 inner->observerHandler_ = std::make_unique<ObserverHandler>();
2117 inner->networkSearchHandler_ = networkSearchHandler;
2118 int32_t tokenId = 123456789;
2119 std::u16string imei = u"";
2120 std::u16string imeiSv = u"";
2121 sptr<ImsRegInfoCallback> callback = nullptr;
2122 networkSearchManager->SetLocateUpdate(INVALID_SLOTID);
2123 networkSearchManager->GetVoiceTech(INVALID_SLOTID);
2124 networkSearchManager->AddManagerInner(INVALID_SLOTID, inner);
2125 networkSearchManager->DcPhysicalLinkActiveUpdate(INVALID_SLOTID, true);
2126 networkSearchManager->NotifyPsRoamingOpenChanged(INVALID_SLOTID);
2127 networkSearchManager->NotifyPsRoamingCloseChanged(INVALID_SLOTID);
2128 networkSearchManager->NotifyPsConnectionAttachedChanged(INVALID_SLOTID);
2129 networkSearchManager->NotifyPsConnectionDetachedChanged(INVALID_SLOTID);
2130 networkSearchManager->NotifyPsRatChanged(INVALID_SLOTID);
2131 networkSearchManager->NotifyEmergencyOpenChanged(INVALID_SLOTID);
2132 networkSearchManager->NotifyEmergencyCloseChanged(INVALID_SLOTID);
2133 networkSearchManager->NotifyNrStateChanged(INVALID_SLOTID);
2134 networkSearchManager->NotifyNrFrequencyChanged(INVALID_SLOTID);
2135 networkSearchManager->TriggerSimRefresh(INVALID_SLOTID);
2136 networkSearchManager->TriggerTimezoneRefresh(INVALID_SLOTID);
2137 networkSearchManager->SetRadioStateValue(INVALID_SLOTID, ModemPowerState::CORE_SERVICE_POWER_NOT_AVAILABLE);
2138 networkSearchManager->SetNetworkSelectionValue(INVALID_SLOTID, SelectionMode::MODE_TYPE_UNKNOWN);
2139 networkSearchManager->SetImei(INVALID_SLOTID, imei);
2140 networkSearchManager->SetImeiSv(INVALID_SLOTID, imeiSv);
2141 networkSearchManager->UpdateCellLocation(INVALID_SLOTID, 1, 1, 1);
2142 networkSearchManager->SetMeid(INVALID_SLOTID, imei);
2143 networkSearchManager->SetFrequencyType(INVALID_SLOTID, FrequencyType::FREQ_TYPE_MMWAVE);
2144 networkSearchManager->SetRadioFirstPowerOn(INVALID_SLOTID, true);
2145 networkSearchManager->SetLocalAirplaneMode(INVALID_SLOTID, true);
2146 bool state = false;
2147 networkSearchManager->GetLocalAirplaneMode(INVALID_SLOTID, state);
2148 EXPECT_TRUE(networkSearchManager->GetNetworkSearchInformationValue(INVALID_SLOTID) == nullptr);
2149 EXPECT_TRUE(networkSearchManager->GetNetworkSearchState(INVALID_SLOTID) != nullptr);
2150 EXPECT_TRUE(networkSearchManager->IsRadioFirstPowerOn(INVALID_SLOTID));
2151 EXPECT_EQ(networkSearchManager->RegisterImsRegInfoCallback(
2152 INVALID_SLOTID, ImsServiceType::TYPE_SMS, tokenId, callback),
2153 TELEPHONY_ERR_ARGUMENT_NULL);
2154 EXPECT_EQ(networkSearchManager->UnregisterImsRegInfoCallback(INVALID_SLOTID, ImsServiceType::TYPE_SMS, tokenId),
2155 TELEPHONY_SUCCESS);
2156 }
2157
2158 /**
2159 * @tc.number Telephony_NetworkSearchManager_003
2160 * @tc.name test error branch
2161 * @tc.desc Function test
2162 */
2163 HWTEST_F(BranchTest, Telephony_NetworkSearchManager_003, Function | MediumTest | Level1)
2164 {
2165 auto telRilManager = std::make_shared<TelRilManager>();
2166 std::shared_ptr<SimManager> simManager = nullptr;
2167 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
2168 auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
2169 auto networkSearchHandler =
2170 std::make_shared<NetworkSearchHandler>(networkSearchManager, telRilManager, simManager, INVALID_SLOTID);
2171 sptr<INetworkSearchCallback> networkSearchCallback = nullptr;
2172 networkSearchManager->TriggerSimRefresh(INVALID_SLOTID);
2173 networkSearchManager->RegisterCoreNotify(INVALID_SLOTID, networkSearchHandler, 1);
2174 networkSearchManager->UnRegisterCoreNotify(INVALID_SLOTID, networkSearchHandler, 1);
2175 int32_t radioTech;
2176 std::u16string testStr = u"";
2177 std::u16string result = u"";
2178 EXPECT_NE(networkSearchManager->GetPsRadioTech(INVALID_SLOTID, radioTech), TELEPHONY_ERR_SUCCESS);
2179 EXPECT_NE(networkSearchManager->GetCsRadioTech(INVALID_SLOTID, radioTech), TELEPHONY_ERR_SUCCESS);
2180 EXPECT_EQ(networkSearchManager->GetOperatorNumeric(INVALID_SLOTID), testStr);
2181 EXPECT_NE(networkSearchManager->GetOperatorName(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
2182 EXPECT_EQ(result, testStr);
2183 std::vector<sptr<Telephony::SignalInformation>> signals;
2184 networkSearchManager->GetSignalInfoList(INVALID_SLOTID, signals);
2185 EXPECT_TRUE(signals.empty());
2186 std::vector<sptr<CellInformation>> cellInfo;
2187 networkSearchManager->GetCellInfoList(INVALID_SLOTID, cellInfo);
2188 EXPECT_TRUE(cellInfo.empty());
2189
2190 EXPECT_NE(networkSearchManager->SendUpdateCellLocationRequest(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
2191 EXPECT_TRUE(networkSearchManager->GetCellLocation(INVALID_SLOTID) == nullptr);
2192 bool airplaneMode = false;
2193 EXPECT_NE(networkSearchManager->GetAirplaneMode(airplaneMode), TELEPHONY_ERR_SUCCESS);
2194 EXPECT_NE(networkSearchManager->UpdateRadioOn(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
2195 EXPECT_NE(networkSearchManager->UpdateNrOptionMode(INVALID_SLOTID, NrMode::NR_MODE_UNKNOWN), TELEPHONY_SUCCESS);
2196 int32_t status = 0;
2197 EXPECT_NE(networkSearchManager->UpdateRrcConnectionState(INVALID_SLOTID, status), TELEPHONY_SUCCESS);
2198 EXPECT_EQ(status, 0);
2199 NrMode mode = NrMode::NR_MODE_UNKNOWN;
2200 EXPECT_NE(networkSearchManager->GetNrOptionMode(INVALID_SLOTID, mode), TELEPHONY_ERR_SUCCESS);
2201 EXPECT_NE(networkSearchManager->GetNrOptionMode(INVALID_SLOTID, networkSearchCallback), TELEPHONY_ERR_SUCCESS);
2202 EXPECT_EQ(mode, NrMode::NR_MODE_UNKNOWN);
2203 EXPECT_NE(networkSearchManager->SetNrOptionMode(INVALID_SLOTID, 1), TELEPHONY_SUCCESS);
2204 EXPECT_NE(networkSearchManager->SetNrOptionMode(INVALID_SLOTID, 1, networkSearchCallback), TELEPHONY_ERR_SUCCESS);
2205 }
2206
2207 /**
2208 * @tc.number Telephony_NetworkSearchManager_004
2209 * @tc.name test error branch
2210 * @tc.desc Function test
2211 */
2212 HWTEST_F(BranchTest, Telephony_NetworkSearchManager_004, Function | MediumTest | Level1)
2213 {
2214 auto telRilManager = std::make_shared<TelRilManager>();
2215 std::shared_ptr<SimManager> simManager = nullptr;
2216 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
2217 auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
2218 auto networkSearchHandler =
2219 std::make_shared<NetworkSearchHandler>(networkSearchManager, telRilManager, simManager, INVALID_SLOTID);
2220 auto inner = std::make_shared<NetworkSearchManagerInner>();
2221 inner->networkSearchState_ = networkSearchState;
2222 inner->observerHandler_ = std::make_unique<ObserverHandler>();
2223 inner->networkSearchHandler_ = networkSearchHandler;
2224 std::string version = "";
2225 EXPECT_NE(networkSearchManager->GetBasebandVersion(INVALID_SLOTID, version), TELEPHONY_ERR_SUCCESS);
2226 EXPECT_EQ(version, "");
2227 EXPECT_FALSE(networkSearchManager->IsNrSupported(INVALID_SLOTID));
2228 sptr<NetworkState> networkState = nullptr;
2229 EXPECT_NE(networkSearchManager->GetNetworkStatus(INVALID_SLOTID, networkState), TELEPHONY_ERR_SUCCESS);
2230 EXPECT_TRUE(networkState == nullptr);
2231 NrMode mode = NrMode::NR_MODE_UNKNOWN;
2232 EXPECT_NE(networkSearchManager->GetNrOptionMode(INVALID_SLOTID, mode), TELEPHONY_ERR_SUCCESS);
2233 EXPECT_EQ(mode, NrMode::NR_MODE_UNKNOWN);
2234 EXPECT_NE(networkSearchManager->NotifyCallStatusToNetworkSearch(INVALID_SLOTID, 0), TELEPHONY_ERR_SUCCESS);
2235 networkSearchManager->AddManagerInner(INVALID_SLOTID, inner);
2236 EXPECT_EQ(networkSearchManager->GetFrequencyType(INVALID_SLOTID), FrequencyType::FREQ_TYPE_UNKNOWN);
2237 EXPECT_EQ(networkSearchManager->GetNrState(INVALID_SLOTID), NrState::NR_STATE_NOT_SUPPORT);
2238 EXPECT_EQ(networkSearchManager->GetPsRegState(INVALID_SLOTID), TELEPHONY_ERROR);
2239 EXPECT_EQ(networkSearchManager->GetCsRegState(INVALID_SLOTID), TELEPHONY_ERROR);
2240 EXPECT_EQ(networkSearchManager->GetPsRoamingState(INVALID_SLOTID), TELEPHONY_ERROR);
2241 std::int32_t networkAbilityType = 0;
2242 std::int32_t networkAbilityState = 0;
2243 EXPECT_EQ(networkSearchManager->GetNetworkCapability(INVALID_SLOTID, networkAbilityType, networkAbilityState),
2244 TELEPHONY_ERR_SUCCESS);
2245 EXPECT_NE(networkSearchManager->SetNetworkCapability(INVALID_SLOTID, networkAbilityType, networkAbilityState),
2246 TELEPHONY_ERR_SUCCESS);
2247 EXPECT_NE(networkSearchManager->FactoryReset(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
2248 }
2249
2250 /**
2251 * @tc.number Telephony_NetworkSearchManager_005
2252 * @tc.name test error branch
2253 * @tc.desc Function test
2254 */
2255 HWTEST_F(BranchTest, Telephony_NetworkSearchManager_005, Function | MediumTest | Level1)
2256 {
2257 auto telRilManager = std::make_shared<TelRilManager>();
2258 std::shared_ptr<SimManager> simManager = nullptr;
2259 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
2260 auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
2261 auto networkSearchHandler =
2262 std::make_shared<NetworkSearchHandler>(networkSearchManager, telRilManager, simManager, INVALID_SLOTID);
2263 networkSearchManager->OnInit();
2264 sptr<INetworkSearchCallback> networkSearchCallback = nullptr;
2265 sptr<NetworkSearchCallBackBase> callback = nullptr;
2266 int32_t status = 0;
2267 std::string version = "";
2268 std::u16string result = u"";
2269 std::vector<NetworkInformation> operatorInfo;
2270 networkSearchManager->GetRadioState(INVALID_SLOTID, networkSearchCallback);
2271 networkSearchManager->SetNetworkSearchResultValue(INVALID_SLOTID, 0, operatorInfo);
2272 EXPECT_NE(
2273 networkSearchManager->GetNetworkSelectionMode(INVALID_SLOTID, networkSearchCallback), TELEPHONY_ERR_SUCCESS);
2274 int32_t slotId = 0;
2275 EXPECT_NE(networkSearchManager->SetPreferredNetwork(slotId, 1, networkSearchCallback), TELEPHONY_ERR_SUCCESS);
2276 EXPECT_NE(networkSearchManager->GetPreferredNetwork(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
2277 EXPECT_NE(networkSearchManager->GetPreferredNetwork(slotId), TELEPHONY_ERR_SUCCESS);
2278 EXPECT_NE(networkSearchManager->GetUniqueDeviceId(INVALID_SLOTID, result), TELEPHONY_ERR_SUCCESS);
2279 EXPECT_NE(networkSearchManager->HandleRrcStateChanged(INVALID_SLOTID, status), TELEPHONY_ERR_SUCCESS);
2280 EXPECT_NE(networkSearchManager->HandleRrcStateChanged(slotId, status), TELEPHONY_ERR_SUCCESS);
2281 EXPECT_NE(networkSearchManager->RevertLastTechnology(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
2282 EXPECT_NE(networkSearchManager->RevertLastTechnology(slotId), TELEPHONY_ERR_SUCCESS);
2283 EXPECT_NE(networkSearchManager->GetRrcConnectionState(INVALID_SLOTID, status), TELEPHONY_ERR_SUCCESS);
2284 EXPECT_NE(networkSearchManager->UpdateRrcConnectionState(slotId, status), TELEPHONY_ERR_SUCCESS);
2285 NrMode mode = NrMode::NR_MODE_UNKNOWN;
2286 EXPECT_NE(networkSearchManager->GetNrOptionMode(slotId, mode), TELEPHONY_ERR_SUCCESS);
2287 EXPECT_NE(networkSearchManager->SetNrOptionMode(slotId, 1), TELEPHONY_ERR_SUCCESS);
2288 EXPECT_NE(networkSearchManager->SetNrOptionMode(slotId, 1, networkSearchCallback), TELEPHONY_ERR_SUCCESS);
2289 EXPECT_EQ(networkSearchManager->GetNrState(slotId), NrState::NR_STATE_NOT_SUPPORT);
2290 EXPECT_NE(networkSearchManager->NotifyCallStatusToNetworkSearch(slotId, 0), TELEPHONY_ERR_SUCCESS);
2291 EXPECT_NE(networkSearchManager->HandleNotifyStateChangeWithDelay(INVALID_SLOTID, false), TELEPHONY_ERR_SUCCESS);
2292 EXPECT_FALSE(networkSearchManager->IsNeedDelayNotify(INVALID_SLOTID));
2293 EXPECT_NE(networkSearchManager->ProcessNotifyStateChangeEvent(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
2294 EXPECT_FALSE(networkSearchManager->RemoveManagerInner(INVALID_SLOTID));
2295 networkSearchManager->UnRegisterCoreNotify(slotId, networkSearchHandler, 1);
2296 networkSearchManager->UnRegisterCellularDataObject(callback);
2297 }
2298
2299 /**
2300 * @tc.number Telephony_NetworkSearchManager_006
2301 * @tc.name test error branch
2302 * @tc.desc Function test
2303 */
2304 HWTEST_F(BranchTest, Telephony_NetworkSearchManager_006, Function | MediumTest | Level1)
2305 {
2306 auto telRilManager = std::make_shared<TelRilManager>();
2307 std::shared_ptr<SimManager> simManager = nullptr;
2308 auto nsm = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
2309 auto networkSearchState = std::make_shared<NetworkSearchState>(nsm, INVALID_SLOTID);
2310 auto networkSearchHandler =
2311 std::make_shared<NetworkSearchHandler>(nsm, telRilManager, simManager, INVALID_SLOTID);
2312 nsm->OnInit();
2313 auto inner = std::make_shared<NetworkSearchManagerInner>();
2314 inner->networkSearchState_ = networkSearchState;
2315 inner->observerHandler_ = std::make_unique<ObserverHandler>();
2316 inner->networkSearchHandler_ = networkSearchHandler;
2317 nsm->delayTime_ = 1;
2318 int32_t status = 0;
2319 int32_t tokenId = 123456789;
2320 ImsRegInfo info;
2321 sptr<INetworkSearchCallback> networkSearchCallback = nullptr;
2322 nsm->AddManagerInner(INVALID_SLOTID, inner);
2323 nsm->RevertLastTechnology(INVALID_SLOTID);
2324 nsm->IsNeedDelayNotify(INVALID_SLOTID);
2325 nsm->HandleNotifyStateChangeWithDelay(INVALID_SLOTID, true);
2326 nsm->HandleNotifyStateChangeWithDelay(INVALID_SLOTID, false);
2327 nsm->InitSimRadioProtocol(INVALID_SLOTID);
2328 nsm->UnregisterImsRegInfoCallback(INVALID_SLOTID, ImsServiceType::TYPE_SMS, tokenId);
2329 EXPECT_EQ(nsm->HandleRrcStateChanged(INVALID_SLOTID, 0), TELEPHONY_ERR_FAIL);
2330 EXPECT_EQ(nsm->HandleRrcStateChanged(INVALID_SLOTID, 1), TELEPHONY_ERR_SUCCESS);
2331 EXPECT_EQ(nsm->UpdateRrcConnectionState(INVALID_SLOTID, status), TELEPHONY_ERR_SUCCESS);
2332 EXPECT_NE(nsm->SetNrOptionMode(INVALID_SLOTID, -1), TELEPHONY_SUCCESS);
2333 EXPECT_NE(nsm->SetNrOptionMode(INVALID_SLOTID, -1, networkSearchCallback), TELEPHONY_SUCCESS);
2334 EXPECT_EQ(nsm->NotifyCallStatusToNetworkSearch(INVALID_SLOTID, 0), TELEPHONY_ERR_SUCCESS);
2335 EXPECT_EQ(nsm->NotifyCallStatusToNetworkSearch(INVALID_SLOTID, -1), TELEPHONY_ERR_SUCCESS);
2336 inner->networkSearchState_ = nullptr;
2337 EXPECT_EQ(nsm->GetImsRegStatus(0, ImsServiceType::TYPE_VOICE, info), TELEPHONY_ERR_LOCAL_PTR_NULL);
2338 EXPECT_FALSE(nsm->IsNeedDelayNotify(INVALID_SLOTID));
2339 inner->networkSearchHandler_ = nullptr;
2340 EXPECT_EQ(nsm->SendUpdateCellLocationRequest(INVALID_SLOTID), TELEPHONY_ERR_LOCAL_PTR_NULL);
2341 EXPECT_TRUE(nsm->RemoveManagerInner(INVALID_SLOTID));
2342 nsm->SetBasebandVersion(INVALID_SLOTID, "");
2343 nsm->ConvertNetworkModeToCapabilityType(CORE_NETWORK_MODE_NR);
2344 nsm->ConvertNetworkModeToCapabilityType(-1);
2345 EXPECT_EQ(nsm->GetFrequencyType(INVALID_SLOTID), FrequencyType::FREQ_TYPE_UNKNOWN);
2346 }
2347
2348 /**
2349 * @tc.number Telephony_TelRilModem_001
2350 * @tc.name test error branch
2351 * @tc.desc Function test
2352 */
2353 HWTEST_F(BranchTest, Telephony_TelRilModem_001, Function | MediumTest | Level1)
2354 {
2355 std::shared_ptr<ObserverHandler> observerHandler = std::make_shared<ObserverHandler>();
2356
2357 std::vector<std::shared_ptr<ObserverHandler>> observerHandlers;
2358 observerHandlers.push_back(observerHandler);
2359 std::shared_ptr<TelRilModem> telRilModem =
2360 std::make_shared<TelRilModem>(SLOT_ID_0, nullptr, observerHandlers[SLOT_ID_0], nullptr);
2361 if (telRilModem != nullptr) {
2362 telRilModem->RadioStateUpdated(ModemPowerState::CORE_SERVICE_POWER_ON);
2363 EXPECT_EQ(telRilModem->OnRilAdapterHostDied(), TELEPHONY_ERR_SUCCESS);
2364 }
2365 }
2366
2367 /**
2368 * @tc.number Telephony_NetworkSearchHandler_001
2369 * @tc.name test error branch
2370 * @tc.desc Function test
2371 */
2372 HWTEST_F(BranchTest, Telephony_NetworkSearchHandler_001, Function | MediumTest | Level1)
2373 {
2374 std::shared_ptr<TelRilManager> telRilManager = nullptr;
2375 auto simManager = std::make_shared<SimManager>(telRilManager);
2376 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
2377 auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
2378 auto networkSearchHandler =
2379 std::make_shared<NetworkSearchHandler>(networkSearchManager, telRilManager, simManager, INVALID_SLOTID);
2380 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_CHANGE, 1);
2381 networkSearchHandler->GetRadioStateResponse(event);
2382 networkSearchHandler->SetRadioStateResponse(event);
2383 networkSearchHandler->GetNetworkSelectionModeResponse(event);
2384 networkSearchHandler->SetNetworkSelectionModeResponse(event);
2385 EXPECT_TRUE(networkSearchHandler->Init());
2386 networkSearchHandler->UnregisterEvents();
2387 networkSearchHandler->DcPhysicalLinkActiveUpdate(event);
2388 networkSearchHandler->ProcessEvent(event);
2389 networkSearchHandler->RadioStateChange(event);
2390 networkSearchHandler->RadioRestrictedState(event);
2391 networkSearchHandler->RadioRilDataRegState(event);
2392 networkSearchHandler->RadioRilVoiceRegState(event);
2393 networkSearchHandler->RadioSignalStrength(event);
2394 networkSearchHandler->RadioRilOperator(event);
2395 networkSearchHandler->GetPreferredNetworkResponse(event);
2396 networkSearchHandler->SetPreferredNetworkResponse(event);
2397 networkSearchHandler->RadioGetImei(event);
2398 networkSearchHandler->RadioGetImeiSv(event);
2399 networkSearchHandler->RadioGetMeid(event);
2400 event = nullptr;
2401 networkSearchHandler->ProcessEvent(event);
2402 networkSearchHandler->DcPhysicalLinkActiveUpdate(event);
2403 networkSearchHandler->UpdateImsServiceStatus(event);
2404 networkSearchHandler->UpdateImsRegisterState(event);
2405 networkSearchHandler->GetRadioStateResponse(event);
2406 networkSearchHandler->SetRadioStateResponse(event);
2407 networkSearchHandler->ImsiLoadedReady(event);
2408 networkSearchHandler->RadioStateChange(event);
2409 networkSearchHandler->RadioRestrictedState(event);
2410 networkSearchHandler->RadioRilDataRegState(event);
2411 networkSearchHandler->RadioRilVoiceRegState(event);
2412 networkSearchHandler->RadioSignalStrength(event);
2413 networkSearchHandler->RadioRilOperator(event);
2414 networkSearchHandler->GetNetworkSelectionModeResponse(event);
2415 networkSearchHandler->SetNetworkSelectionModeResponse(event);
2416 networkSearchHandler->GetPreferredNetworkResponse(event);
2417 networkSearchHandler->SetPreferredNetworkResponse(event);
2418 networkSearchHandler->RadioNitzUpdate(event);
2419 networkSearchHandler->RadioGetImei(event);
2420 networkSearchHandler->RadioGetMeid(event);
2421 EXPECT_TRUE(networkSearchHandler->GetCellLocation() == nullptr);
2422 }
2423
2424 /**
2425 * @tc.number Telephony_NetworkSearchHandler_002
2426 * @tc.name test error branch
2427 * @tc.desc Function test
2428 */
2429 HWTEST_F(BranchTest, Telephony_NetworkSearchHandler_002, Function | MediumTest | Level1)
2430 {
2431 std::shared_ptr<TelRilManager> telRilManager = nullptr;
2432 auto simManager = std::make_shared<SimManager>(telRilManager);
2433 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
2434 auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
2435 auto networkSearchHandler =
2436 std::make_shared<NetworkSearchHandler>(networkSearchManager, telRilManager, simManager, INVALID_SLOTID);
2437 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_CHANGE, 1);
2438 std::vector<sptr<SignalInformation>> signals;
2439 std::vector<sptr<CellInformation>> cells;
2440 EXPECT_TRUE(networkSearchHandler->Init());
2441 NetworkSearchResult mResult;
2442 MessageParcel parcel;
2443 mResult.Marshalling(parcel);
2444 mResult.ReadFromParcel(parcel);
2445 mResult.Unmarshalling(parcel);
2446 networkSearchHandler->RadioGetCurrentCellInfo(event);
2447 networkSearchHandler->RadioCurrentCellInfoUpdate(event);
2448 networkSearchHandler->RadioChannelConfigInfo(event);
2449 networkSearchHandler->RadioVoiceTechChange(event);
2450 networkSearchHandler->SimStateChange(event);
2451 networkSearchHandler->SimRecordsLoaded(event);
2452 networkSearchHandler->AutoTimeChange(event);
2453 networkSearchHandler->AutoTimeZoneChange(event);
2454 networkSearchHandler->AirplaneModeChange(event);
2455 networkSearchHandler->RadioGetBasebandVersion(event);
2456 networkSearchHandler->SetNrOptionModeResponse(event);
2457 networkSearchHandler->GetNrOptionModeResponse(event);
2458 networkSearchHandler->RadioGetRrcConnectionState(event);
2459 networkSearchHandler->RadioResidentNetworkChange(event);
2460 event = nullptr;
2461 networkSearchHandler->RadioGetCurrentCellInfo(event);
2462 networkSearchHandler->RadioCurrentCellInfoUpdate(event);
2463 networkSearchHandler->RadioChannelConfigInfo(event);
2464 networkSearchHandler->RadioVoiceTechChange(event);
2465 networkSearchHandler->RadioOnState();
2466 networkSearchHandler->GetSignalInfo(signals);
2467 networkSearchHandler->GetCellInfoList(cells);
2468 networkSearchHandler->UpdateCellLocation(1, 1, 1);
2469 networkSearchHandler->TimezoneRefresh();
2470 networkSearchHandler->SetCellRequestMinInterval(1);
2471 networkSearchHandler->RadioOffOrUnavailableState(1);
2472 networkSearchHandler->RadioGetNeighboringCellInfo(event);
2473 networkSearchHandler->RadioGetBasebandVersion(event);
2474 networkSearchHandler->SetNrOptionModeResponse(event);
2475 networkSearchHandler->GetNrOptionModeResponse(event);
2476 networkSearchHandler->RadioGetRrcConnectionState(event);
2477 networkSearchHandler->RadioResidentNetworkChange(event);
2478 EXPECT_EQ(networkSearchHandler->GetPhoneType(), PhoneType::PHONE_TYPE_IS_NONE);
2479 }
2480
2481 /**
2482 * @tc.number Telephony_NetworkSearchHandler_003
2483 * @tc.name test error branch
2484 * @tc.desc Function test
2485 */
2486 HWTEST_F(BranchTest, Telephony_NetworkSearchHandler_003, Function | MediumTest | Level1)
2487 {
2488 std::shared_ptr<TelRilManager> telRilManager = nullptr;
2489 auto simManager = std::make_shared<SimManager>(telRilManager);
2490 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
2491 auto networkSearchHandler =
2492 std::make_shared<NetworkSearchHandler>(networkSearchManager, telRilManager, simManager, INVALID_SLOTID);
2493 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::DELAY_NOTIFY_STATE_CHANGE);
2494 event = nullptr;
2495 int32_t status = RRC_IDLE_STATUS;
2496 networkSearchHandler->HandleDelayNotifyEvent(event);
2497 networkSearchHandler->NetworkSearchResult(event);
2498 networkSearchHandler->RadioGetNeighboringCellInfo(event);
2499 networkSearchHandler->RadioGetImeiSv(event);
2500 EXPECT_EQ(networkSearchHandler->HandleRrcStateChanged(status), TELEPHONY_ERR_LOCAL_PTR_NULL);
2501 EXPECT_EQ(networkSearchHandler->RevertLastTechnology(), TELEPHONY_ERR_LOCAL_PTR_NULL);
2502
2503 EXPECT_TRUE(networkSearchHandler->Init());
2504 event = AppExecFwk::InnerEvent::Get(RadioEvent::DELAY_NOTIFY_STATE_CHANGE);
2505 networkSearchHandler->HandleDelayNotifyEvent(event);
2506 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_NETWORK_SEARCH_RESULT);
2507 networkSearchHandler->NetworkSearchResult(event);
2508 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_NEIGHBORING_CELL_INFO);
2509 networkSearchHandler->RadioGetNeighboringCellInfo(event);
2510 EXPECT_EQ(networkSearchHandler->HandleRrcStateChanged(status), TELEPHONY_ERR_SUCCESS);
2511 EXPECT_EQ(networkSearchHandler->RevertLastTechnology(), TELEPHONY_ERR_SUCCESS);
2512 networkSearchHandler->IsPowerOnPrimaryRadioWhenNoSim();
2513 }
2514
2515 /**
2516 * @tc.number Telephony_SimFileController_001
2517 * @tc.name test error branch
2518 * @tc.desc Function test
2519 */
2520 HWTEST_F(BranchTest, Telephony_SimFileController_001, Function | MediumTest | Level1)
2521 {
2522 auto simFileController = std::make_shared<SimFileController>(INVALID_SLOTID);
2523 EXPECT_EQ(simFileController->ObtainElementFilePath(0), "");
2524 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_SMS), "");
2525 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_VOICE_MAIL_INDICATOR_CPHS), "");
2526 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_CFF_CPHS), "");
2527 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_SPN_CPHS), "");
2528 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_INFO_CPHS), "");
2529 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_MAILBOX_CPHS), "");
2530 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_SPN_SHORT_CPHS), "");
2531 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_SST), "");
2532 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_GID1), "");
2533 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_GID2), "");
2534 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_SPN), "");
2535 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_AD), "");
2536 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_PNN), "");
2537 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_MBDN), "");
2538 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_EXT6), "");
2539 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_MBI), "");
2540 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_MWIS), "");
2541 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_CFIS), "");
2542 EXPECT_NE(simFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSP_CPHS), "");
2543 }
2544
2545 /**
2546 * @tc.number Telephony_CsimFileController_001
2547 * @tc.name test error branch
2548 * @tc.desc Function test
2549 */
2550 HWTEST_F(BranchTest, Telephony_CsimFileController_001, Function | MediumTest | Level1)
2551 {
2552 auto csimFileController = std::make_shared<CsimFileController>(INVALID_SLOTID);
2553 EXPECT_NE(csimFileController->ObtainElementFilePath(0), "");
2554 EXPECT_NE(csimFileController->ObtainElementFilePath(ELEMENTARY_FILE_SMS), "");
2555 EXPECT_NE(csimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CST), "");
2556 EXPECT_NE(csimFileController->ObtainElementFilePath(ELEMENTARY_FILE_FDN), "");
2557 EXPECT_NE(csimFileController->ObtainElementFilePath(ELEMENTARY_FILE_MSISDN), "");
2558 EXPECT_NE(csimFileController->ObtainElementFilePath(ELEMENTARY_FILE_RUIM_SPN), "");
2559 EXPECT_NE(csimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSIM_LI), "");
2560 EXPECT_NE(csimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSIM_MDN), "");
2561 EXPECT_NE(csimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSIM_IMSIM), "");
2562 EXPECT_NE(csimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSIM_CDMAHOME), "");
2563 EXPECT_NE(csimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSIM_EPRL), "");
2564 EXPECT_NE(csimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSIM_MIPUPP), "");
2565 EXPECT_NE(csimFileController->ObtainElementFilePath(ELEMENTARY_FILE_PCSCF), "");
2566 }
2567
2568 /**
2569 * @tc.number Telephony_RuimFileController_001
2570 * @tc.name test error branch
2571 * @tc.desc Function test
2572 */
2573 HWTEST_F(BranchTest, Telephony_RuimFileController_001, Function | MediumTest | Level1)
2574 {
2575 auto rUimFileController = std::make_shared<RuimFileController>(INVALID_SLOTID);
2576 EXPECT_EQ(rUimFileController->ObtainElementFilePath(0), "");
2577 EXPECT_NE(rUimFileController->ObtainElementFilePath(ELEMENTARY_FILE_SMS), "");
2578 EXPECT_NE(rUimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CST), "");
2579 EXPECT_NE(rUimFileController->ObtainElementFilePath(ELEMENTARY_FILE_RUIM_SPN), "");
2580 EXPECT_NE(rUimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSIM_LI), "");
2581 EXPECT_NE(rUimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSIM_MDN), "");
2582 EXPECT_NE(rUimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSIM_IMSIM), "");
2583 EXPECT_NE(rUimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSIM_CDMAHOME), "");
2584 EXPECT_NE(rUimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSIM_EPRL), "");
2585 }
2586
2587 /**
2588 * @tc.number Telephony_IsimFileController_001
2589 * @tc.name test error branch
2590 * @tc.desc Function test
2591 */
2592 HWTEST_F(BranchTest, Telephony_IsimFileController_001, Function | MediumTest | Level1)
2593 {
2594 auto iSimFileController = std::make_shared<IsimFileController>(INVALID_SLOTID);
2595 EXPECT_EQ(iSimFileController->ObtainElementFilePath(0), "");
2596 EXPECT_NE(iSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_IMPI), "");
2597 EXPECT_NE(iSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_IMPU), "");
2598 EXPECT_NE(iSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_DOMAIN), "");
2599 EXPECT_NE(iSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_IST), "");
2600 EXPECT_NE(iSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_PCSCF), "");
2601 }
2602
2603 /**
2604 * @tc.number Telephony_UsimFileController_001
2605 * @tc.name test error branch
2606 * @tc.desc Function test
2607 */
2608 HWTEST_F(BranchTest, Telephony_UsimFileController_001, Function | MediumTest | Level1)
2609 {
2610 auto uSimFileController = std::make_shared<UsimFileController>(INVALID_SLOTID);
2611 EXPECT_NE(uSimFileController->ObtainElementFilePath(0), "");
2612 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_IMPI), "");
2613 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_SMS), "");
2614 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_EXT5), "");
2615 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_EXT6), "");
2616 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_MWIS), "");
2617 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_MBI), "");
2618 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_SPN), "");
2619 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_AD), "");
2620 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_MBDN), "");
2621 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_PNN), "");
2622 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_OPL), "");
2623 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_OPL5G), "");
2624 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_SPDI), "");
2625 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_SST), "");
2626 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CFIS), "");
2627 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_MAILBOX_CPHS), "");
2628 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_VOICE_MAIL_INDICATOR_CPHS), "");
2629 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CFF_CPHS), "");
2630 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_SPN_CPHS), "");
2631 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_SPN_SHORT_CPHS), "");
2632 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_FDN), "");
2633 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_SDN), "");
2634 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_EXT3), "");
2635 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_MSISDN), "");
2636 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_EXT2), "");
2637 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_INFO_CPHS), "");
2638 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_CSP_CPHS), "");
2639 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_GID1), "");
2640 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_GID2), "");
2641 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_LI), "");
2642 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_PLMN_W_ACT), "");
2643 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_OPLMN_W_ACT), "");
2644 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_HPLMN_W_ACT), "");
2645 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_EHPLMN), "");
2646 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_FPLMN), "");
2647 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_LRPLMNSI), "");
2648 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_HPPLMN), "");
2649 EXPECT_NE(uSimFileController->ObtainElementFilePath(ELEMENTARY_FILE_PBR), "");
2650 }
2651
2652 /**
2653 * @tc.number Telephony_RadioProtocolController_001
2654 * @tc.name test error branch
2655 * @tc.desc Function test
2656 */
2657 HWTEST_F(BranchTest, Telephony_RadioProtocolController_001, Function | MediumTest | Level1)
2658 {
2659 auto telRilManager = std::make_shared<TelRilManager>();
2660 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(INVALID_SLOTID, 1);
2661 auto radioProtocolController =
2662 std::make_shared<RadioProtocolController>(std::weak_ptr<TelRilManager>(telRilManager));
2663 radioProtocolController->UnRegisterEvents();
2664 radioProtocolController->ProcessGetRadioProtocol(event);
2665 radioProtocolController->ProcessCheckRadioProtocol(event);
2666 radioProtocolController->ProcessSetRadioProtocolComplete(event);
2667 radioProtocolController->communicatingSlotCount_ = 1;
2668 radioProtocolController->ProcessCheckRadioProtocol(event);
2669 radioProtocolController->communicatingSlotCount_ = true;
2670 radioProtocolController->ProcessCheckRadioProtocol(event);
2671 radioProtocolController->ProcessRadioProtocolNotify(event);
2672 radioProtocolController->ProcessSetRadioProtocolTimeout(event);
2673 radioProtocolController->ProcessActiveSimToRilResponse(event);
2674 event = nullptr;
2675 radioProtocolController->ProcessEvent(event);
2676 radioProtocolController->ProcessGetRadioProtocol(event);
2677 radioProtocolController->ProcessCheckRadioProtocol(event);
2678 radioProtocolController->ProcessUpdateRadioProtocol(event);
2679 radioProtocolController->ProcessRadioProtocolNotify(event);
2680 radioProtocolController->ProcessSetRadioProtocolComplete(event);
2681 radioProtocolController->ProcessSetRadioProtocolTimeout(event);
2682 radioProtocolController->ProcessActiveSimToRilResponse(event);
2683 radioProtocolController->BuildRadioProtocolForCommunication(
2684 RadioProtocolPhase::RADIO_PROTOCOL_PHASE_CHECK, RadioProtocolStatus::RADIO_PROTOCOL_STATUS_FAIL);
2685 radioProtocolController->BuildRadioProtocolForCommunication(
2686 RadioProtocolPhase::RADIO_PROTOCOL_PHASE_COMPLETE, RadioProtocolStatus::RADIO_PROTOCOL_STATUS_FAIL);
2687 radioProtocolController->BuildRadioProtocolForCommunication(
2688 RadioProtocolPhase::RADIO_PROTOCOL_PHASE_INITIAL, RadioProtocolStatus::RADIO_PROTOCOL_STATUS_FAIL);
2689 radioProtocolController->BuildRadioProtocolForCommunication(
2690 RadioProtocolPhase::RADIO_PROTOCOL_PHASE_NOTIFY, RadioProtocolStatus::RADIO_PROTOCOL_STATUS_FAIL);
2691 radioProtocolController->BuildRadioProtocolForCommunication(
2692 RadioProtocolPhase::RADIO_PROTOCOL_PHASE_UPDATE, RadioProtocolStatus::RADIO_PROTOCOL_STATUS_FAIL);
2693 EXPECT_TRUE(radioProtocolController->RadioProtocolControllerPoll());
2694 EXPECT_FALSE(radioProtocolController->SetRadioProtocol(INVALID_SLOTID));
2695 radioProtocolController->isCommunicating_ = true;
2696 EXPECT_FALSE(radioProtocolController->SetRadioProtocol(INVALID_SLOTID));
2697 telRilManager = nullptr;
2698 std::vector<RadioProtocol> radioProtocol;
2699 radioProtocolController->SendRadioProtocolEvent(radioProtocol, 1);
2700 radioProtocolController->UnRegisterEvents();
2701 radioProtocolController->GetRadioProtocol(INVALID_SLOTID);
2702 EXPECT_FALSE(radioProtocolController->SetActiveSimToRil(INVALID_SLOTID, 1, 1));
2703 }
2704
2705 /**
2706 * @tc.number Telephony_StkController_001
2707 * @tc.name test error branch
2708 * @tc.desc Function test
2709 */
2710 HWTEST_F(BranchTest, Telephony_StkController_001, Function | MediumTest | Level1)
2711 {
2712 std::string name = "StkController_";
2713 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_CALL_SETUP, 1);
2714 std::shared_ptr<TelRilManager> telRilManager = nullptr;
2715 std::shared_ptr<Telephony::SimStateManager> simStateManager = std::make_shared<SimStateManager>(telRilManager);
2716 auto stkController = std::make_shared<StkController>(telRilManager, simStateManager, INVALID_SLOTID);
2717 std::string strCmd = "";
2718 stkController->UnRegisterEvents();
2719 stkController->ProcessEvent(event);
2720 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_IS_READY, 1);
2721 stkController->ProcessEvent(event);
2722 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_CHANGE, 1);
2723 stkController->ProcessEvent(event);
2724 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_SESSION_END, 1);
2725 stkController->ProcessEvent(event);
2726 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_PROACTIVE_COMMAND, 1);
2727 stkController->ProcessEvent(event);
2728 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_ALPHA_NOTIFY, 1);
2729 stkController->ProcessEvent(event);
2730 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_EVENT_NOTIFY, 1);
2731 stkController->ProcessEvent(event);
2732 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_ICC_REFRESH, 1);
2733 stkController->ProcessEvent(event);
2734 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_SEND_TERMINAL_RESPONSE, 1);
2735 stkController->ProcessEvent(event);
2736 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_SEND_ENVELOPE, 1);
2737 stkController->ProcessEvent(event);
2738 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_SEND_CALL_SETUP_REQUEST_RESULT, 1);
2739 stkController->ProcessEvent(event);
2740 event = nullptr;
2741 stkController->ProcessEvent(event);
2742 EXPECT_EQ(stkController->SendCallSetupRequestResult(true), TELEPHONY_ERR_FAIL);
2743 EXPECT_GT(stkController->SendTerminalResponseCmd(strCmd), TELEPHONY_ERR_SUCCESS);
2744 EXPECT_GT(stkController->SendEnvelopeCmd(strCmd), TELEPHONY_ERR_SUCCESS);
2745 }
2746
2747 /**
2748 * @tc.number Telephony_IccOperatorRule_001
2749 * @tc.name test error branch
2750 * @tc.desc Function test
2751 */
2752 HWTEST_F(BranchTest, Telephony_IccOperatorRule_001, Function | MediumTest | Level1)
2753 {
2754 auto iccOperatorRule = std::make_shared<IccOperatorRule>();
2755 auto operatorMatchingRule = std::make_shared<OperatorMatchingRule>();
2756 std::string numIt = "123";
2757 IccOperatorRule result;
2758 std::string::const_iterator hexStrBeg = numIt.begin();
2759 std::string::const_iterator hexStrEnd = numIt.begin();
2760 std::vector<IccOperatorRule> list;
2761 std::string_view certHash;
2762 std::string_view packageName;
2763 std::string hexStr = "12";
2764 std::string iccidFromSim = "";
2765 std::string iccidRegex = "";
2766 int32_t len = 1;
2767 EXPECT_FALSE(iccOperatorRule->DecodeTLVTagRule(hexStrBeg, hexStrEnd, result, len));
2768 EXPECT_FALSE(iccOperatorRule->DecodeTLVTagCertPkg(hexStrBeg, hexStrEnd, result));
2769 EXPECT_FALSE(iccOperatorRule->DecodeTLVTagLimits(hexStrBeg, hexStrEnd, result));
2770 EXPECT_FALSE(iccOperatorRule->CreateFromTLV(hexStrBeg, hexStrEnd, list));
2771 EXPECT_FALSE(iccOperatorRule->CreateFromTLV(numIt, list));
2772 EXPECT_TRUE(iccOperatorRule->Matche(certHash, packageName));
2773 EXPECT_TRUE(iccOperatorRule->SetPackageNameByHexStr(hexStr));
2774 EXPECT_FALSE(operatorMatchingRule->IccidRegexMatch(iccidFromSim, iccidRegex));
2775 EXPECT_FALSE(operatorMatchingRule->ImsiRegexMatch(iccidFromSim, iccidRegex));
2776 EXPECT_FALSE(operatorMatchingRule->SpnRegexMatch(iccidFromSim, iccidRegex));
2777 EXPECT_TRUE(operatorMatchingRule->SpnRegexMatch(iccidFromSim, "null"));
2778 EXPECT_FALSE(operatorMatchingRule->PrefixMatch(iccidFromSim, iccidRegex));
2779 }
2780
2781 /**
2782 * @tc.number Telephony_SIMUtils_001
2783 * @tc.name test error branch
2784 * @tc.desc Function test
2785 */
2786 HWTEST_F(BranchTest, Telephony_SIMUtils_001, Function | MediumTest | Level1)
2787 {
2788 auto simUtils = std::make_shared<SIMUtils>();
2789 char spnData = '0';
2790 std::string str = "";
2791 int byteslen = 1;
2792 EXPECT_EQ(simUtils->HexCharConvertToInt(spnData), 0);
2793 spnData = 'B';
2794 EXPECT_GT(simUtils->HexCharConvertToInt(spnData), 0);
2795 spnData = 'b';
2796 EXPECT_GT(simUtils->HexCharConvertToInt(spnData), 0);
2797 EXPECT_TRUE(simUtils->HexStringConvertToBytes(str, byteslen) == nullptr);
2798 str = "123";
2799 unsigned char *bytes = (unsigned char *)str.c_str();
2800 std::shared_ptr<unsigned char> bytesTwo = std::make_shared<unsigned char>(1);
2801 simUtils->ArrayCopy(bytes, 1, bytes, 1, 1);
2802 EXPECT_TRUE(simUtils->HexStringConvertToBytes(str, byteslen) == nullptr);
2803 str = "1";
2804 EXPECT_TRUE(simUtils->IsShowableAsciiOnly(str));
2805 EXPECT_TRUE(simUtils->HexStringConvertToBytes(str, byteslen) == nullptr);
2806 byteslen = 2;
2807 str = "12";
2808 EXPECT_TRUE(simUtils->HexStringConvertToBytes(str, byteslen) != nullptr);
2809 EXPECT_EQ(simUtils->BytesConvertToHexString(nullptr, 1), "");
2810 EXPECT_NE(simUtils->BytesConvertToHexString(bytes, 1), "");
2811 int outChar16Len = 1;
2812 EXPECT_TRUE(simUtils->CharsConvertToChar16(nullptr, 1, outChar16Len, true) == nullptr);
2813 EXPECT_TRUE(simUtils->CharsConvertToChar16(bytes, 0, outChar16Len, true) == nullptr);
2814 EXPECT_TRUE(simUtils->CharsConvertToChar16(bytes, BYTES_LENGTH, outChar16Len, true) == nullptr);
2815 EXPECT_TRUE(simUtils->CharsConvertToChar16(bytes, 1, outChar16Len, true) == nullptr);
2816 EXPECT_FALSE(simUtils->CharsConvertToChar16(bytes, OBTAIN_SPN_GENERAL, outChar16Len, true) == nullptr);
2817 EXPECT_FALSE(simUtils->CharsConvertToChar16(bytes, OBTAIN_SPN_GENERAL, outChar16Len, false) == nullptr);
2818 EXPECT_FALSE(simUtils->CharsConvertToChar16(bytes, MAX_ENGLISH_NAME * OBTAIN_SPN_GENERAL, outChar16Len, false)
2819 == nullptr);
2820 EXPECT_NE(simUtils->Gsm7bitConvertToString(bytes, 1), "");
2821 EXPECT_EQ(simUtils->DiallingNumberStringFieldConvertToString(bytesTwo, 0, 0, 1), "");
2822 EXPECT_EQ(simUtils->DiallingNumberStringFieldConvertToString(nullptr, 0, 1, 1), "");
2823 }
2824
2825 /**
2826 * @tc.number Telephony_SIMUtils_002
2827 * @tc.name test error branch
2828 * @tc.desc Function test
2829 */
2830 HWTEST_F(BranchTest, Telephony_SIMUtils_002, Function | MediumTest | Level1)
2831 {
2832 auto simUtils = std::make_shared<SIMUtils>();
__anone0a3918b0202null2833 unsigned char *data(new unsigned char[5] { 0x81, 0x02, 0xA9, 0xC8, 0xC8 });
2834 EXPECT_EQ(
2835 simUtils->DiallingNumberStringFieldConvertToString(std::shared_ptr<unsigned char>(data), 0, 5, 0), "哈哈");
__anone0a3918b0302null2836 unsigned char *data2(new unsigned char[4] { 0x81, 0x01, 0xAA, 0xCA });
2837 EXPECT_EQ(simUtils->DiallingNumberStringFieldConvertToString(std::shared_ptr<unsigned char>(data2), 0, 4, 0), "啊");
__anone0a3918b0402null2838 unsigned char *data3(new unsigned char[6] { 0x81, 0x03, 0xCE, 0xDC, 0xDC, 0xDC });
2839 EXPECT_EQ(
2840 simUtils->DiallingNumberStringFieldConvertToString(std::shared_ptr<unsigned char>(data3), 0, 6, 0), "杜杜杜");
__anone0a3918b0502null2841 unsigned char *data4(new unsigned char[6] { 0x82, 0x02, 0x4E, 0x2A, 0xE2, 0x80 });
2842 EXPECT_EQ(
2843 simUtils->DiallingNumberStringFieldConvertToString(std::shared_ptr<unsigned char>(data4), 0, 6, 0), "二个");
__anone0a3918b0602null2844 unsigned char *data5(new unsigned char[11] { 0x82, 0x07, 0x82, 0x80, 0x38, 0x30, 0x32, 0x35, 0x45, 0x46, 0xB3 });
2845 EXPECT_EQ(simUtils->DiallingNumberStringFieldConvertToString(std::shared_ptr<unsigned char>(data5), 0, 11, 0),
2846 "8025EF芳");
__anone0a3918b0702null2847 unsigned char *data6(new unsigned char[5] { 0x80, 0x4E, 0x2D, 0x56, 0xFD });
2848 EXPECT_EQ(
2849 simUtils->DiallingNumberStringFieldConvertToString(std::shared_ptr<unsigned char>(data6), 0, 5, 0), "中国");
__anone0a3918b0802null2850 unsigned char *data7(new unsigned char[9] { 0x80, 0x67, 0x5C, 0x00, 0x31, 0x00, 0x30, 0x5A, 0x18 });
2851 EXPECT_EQ(
2852 simUtils->DiallingNumberStringFieldConvertToString(std::shared_ptr<unsigned char>(data7), 0, 9, 0), "杜10娘");
__anone0a3918b0902null2853 unsigned char *data8(new unsigned char[39] { 0x81, 0x0E, 0x08, 0x9B, 0xB8, 0xC7, 0xBD,
2854 0xCB, 0xB9, 0x20, 0xBA, 0xB0, 0xB1, 0xB8, 0xBD, 0xB5, 0xC2, 0xFF,
2855 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x04, 0x81, 0x1A, 0x50,
2856 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF});
2857 EXPECT_EQ(simUtils->DiallingNumberStringFieldConvertToString(std::shared_ptr<unsigned char>(data8), 0, 39, 0),
2858 "Личный кабинет");
2859 }
2860
2861 /**
2862 * @tc.number Telephony_SimNumberDecode_001
2863 * @tc.name test error branch
2864 * @tc.desc Function test
2865 */
2866 HWTEST_F(BranchTest, Telephony_SimNumberDecode_001, Function | MediumTest | Level1)
2867 {
2868 auto simNumberDecode = std::make_shared<SimNumberDecode>();
2869 std::string number = "a";
2870 EXPECT_FALSE(simNumberDecode->IsValidNumberString(number));
2871 EXPECT_TRUE(simNumberDecode->chooseExtendedByType(1) != nullptr);
2872 EXPECT_TRUE(simNumberDecode->chooseExtendedByType(OBTAIN_SPN_GENERAL) != nullptr);
2873 char spnData = '0';
2874 uint8_t result = 1;
2875 EXPECT_TRUE(simNumberDecode->CharToBCD(spnData, result, 1));
2876 spnData = 'a';
2877 EXPECT_FALSE(simNumberDecode->CharToBCD(spnData, result, BYTES_LENGTH));
2878 EXPECT_TRUE(simNumberDecode->BcdToChar(1, spnData, 1));
2879 EXPECT_FALSE(simNumberDecode->BcdToChar(VALUE_LENGTH, spnData, BYTES_LENGTH));
2880 EXPECT_FALSE(simNumberDecode->BcdToChar(VALUE_LENGTH, spnData, 1));
2881 number = "+-";
2882 std::vector<uint8_t> bcdCodes;
2883 std::shared_ptr<unsigned char> bytesData = nullptr;
2884 EXPECT_FALSE(simNumberDecode->NumberConvertToBCD(number, bcdCodes, true, BYTES_LENGTH));
2885 number = "0+";
2886 EXPECT_TRUE(simNumberDecode->NumberConvertToBCD(number, bcdCodes, true, 1));
2887 EXPECT_EQ(simNumberDecode->BCDConvertToString(bytesData, 1, 1, 1), "");
2888 bytesData = std::make_shared<unsigned char>(1);
2889 EXPECT_EQ(simNumberDecode->BCDConvertToString(bytesData, 1, 1, 1), "");
2890 bcdCodes.push_back(1);
2891 bcdCodes.push_back(LO_FOUR_LENGTH);
2892 std::vector<uint8_t>::const_iterator codeBeg = bcdCodes.begin();
2893 std::vector<uint8_t>::const_iterator codeEnd = bcdCodes.end();
2894 EXPECT_FALSE(simNumberDecode->BCDSectionConvertToString(codeBeg, codeEnd, number, BYTES_LENGTH));
2895 EXPECT_FALSE(simNumberDecode->BCDSectionConvertToString(codeBeg, codeEnd, number, 1));
2896 EXPECT_TRUE(simNumberDecode->BCDConvertToString(codeBeg, codeEnd, number, BYTES_LENGTH));
2897 EXPECT_TRUE(simNumberDecode->BCDConvertToString(codeBeg, codeEnd, number, 1));
2898 }
2899
2900 /**
2901 * @tc.number Telephony_IccFile_001
2902 * @tc.name test error branch
2903 * @tc.desc Function test
2904 */
2905 HWTEST_F(BranchTest, Telephony_IccFile_001, Function | MediumTest | Level1)
2906 {
2907 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
2908 auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
2909 std::shared_ptr<IccFile> iccFile = std::make_shared<IsimFile>(simStateManager);
2910 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(StateMessage::MSG_ICC_REFRESH, 1);
2911 iccFile->ProcessEvent(event);
2912 event = nullptr;
2913 iccFile->ProcessEvent(event);
2914 std::shared_ptr<AppExecFwk::EventHandler> handler = nullptr;
2915 iccFile->RegisterCoreNotify(handler, RadioEvent::RADIO_SIM_RECORDS_LOADED);
2916 iccFile->RegisterCoreNotify(handler, RadioEvent::RADIO_SIM_RECORDS_LOADED);
2917 iccFile->UnRegisterCoreNotify(handler, RadioEvent::RADIO_SIM_RECORDS_LOADED);
2918 iccFile->UnRegisterCoreNotify(handler, RadioEvent::RADIO_SIM_GET_RADIO_PROTOCOL);
2919 iccFile->imsi_ = "123";
2920 iccFile->RegisterCoreNotify(handler, RadioEvent::RADIO_IMSI_LOADED_READY);
2921 iccFile->UnRegisterCoreNotify(handler, RadioEvent::RADIO_IMSI_LOADED_READY);
2922 std::string plmn = "";
2923 EXPECT_EQ(iccFile->ObtainEons(plmn, 1, true), "");
2924 plmn = "123";
2925 iccFile->UpdateSPN(plmn);
2926 EXPECT_EQ(iccFile->ObtainEons(plmn, 1, true), "");
2927 auto plmnNetworkName = std::make_shared<PlmnNetworkName>();
2928 iccFile->pnnFiles_.push_back(plmnNetworkName);
2929 EXPECT_EQ(iccFile->ObtainEons(plmn, 1, true), "");
2930 auto opl = std::make_shared<OperatorPlmnInfo>();
2931 opl->plmnNumeric = "123";
2932 opl->lacStart = 0;
2933 opl->lacEnd = 0xfffe;
2934 opl->pnnRecordId = 1;
2935 iccFile->oplFiles_.push_back(opl);
2936 iccFile->oplFiles_.push_back(nullptr);
2937 EXPECT_EQ(iccFile->ObtainEons(plmn, 0, true), "");
2938 EXPECT_EQ(iccFile->ObtainEons(plmn, 0, false), "");
2939 }
2940
2941 /**
2942 * @tc.number Telephony_IccFile_002
2943 * @tc.name test error branch
2944 * @tc.desc Function test
2945 */
2946 HWTEST_F(BranchTest, Telephony_IccFile_002, Function | MediumTest | Level1) {
2947 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
2948 auto simStateManager = std::make_shared<SimStateManager>(telRilManager);
2949 std::shared_ptr<IccFile> iccFile = std::make_shared<IsimFile>(simStateManager);
2950 std::string iccId = "123456";
2951 iccFile->SwapPairsForIccId(iccId);
2952 EXPECT_EQ(iccId, "214365");
2953 iccId = "12341A56";
2954 iccFile->SwapPairsForIccId(iccId);
2955 EXPECT_EQ(iccId, "2143");
2956 iccId = "1234F156";
2957 iccFile->SwapPairsForIccId(iccId);
2958 EXPECT_EQ(iccId, "2143165");
2959 iccId = "1234A156";
2960 iccFile->SwapPairsForIccId(iccId);
2961 EXPECT_EQ(iccId, "21431");
2962 iccId = "1234AB56TF";
2963 iccFile->GetFullIccid(iccId);
2964 EXPECT_EQ(iccId, "2143BA65FT");
2965 std::string langData = "";
2966 EXPECT_EQ(iccFile->ObtainValidLanguage(langData), "");
2967 langData = "000011286F050400000000010203FF";
2968 EXPECT_EQ(iccFile->ObtainValidLanguage(langData), "");
2969 }
2970
2971 /**
2972 * @tc.number Telephony_SimRdbHelper_001
2973 * @tc.name test error branch
2974 * @tc.desc Function test
2975 */
2976 HWTEST_F(BranchTest, Telephony_SimRdbHelper_001, Function | MediumTest | Level1)
2977 {
2978 TELEPHONY_LOGI("Telephony_SimRdbHelper_001");
2979 auto simRdbHelper = std::make_shared<SimRdbHelper>();
2980 SimRdbInfo simBean;
2981 std::string iccId = "";
2982 std::vector<SimRdbInfo> vec;
2983 EXPECT_GE(simRdbHelper->GetDefaultMainCardSlotId(), DATA_STORAGE_ERR_PERMISSION_ERR);
2984 EXPECT_GE(simRdbHelper->GetDefaultMessageCardSlotId(), DATA_STORAGE_ERR_PERMISSION_ERR);
2985 EXPECT_GE(simRdbHelper->GetDefaultCellularDataCardSlotId(), DATA_STORAGE_ERR_PERMISSION_ERR);
2986 EXPECT_GE(simRdbHelper->GetDefaultVoiceCardSlotId(), DATA_STORAGE_ERR_PERMISSION_ERR);
2987 EXPECT_GE(simRdbHelper->SetDefaultMainCard(INVALID_SLOTID), DATA_STORAGE_ERR_PERMISSION_ERR);
2988 EXPECT_GE(simRdbHelper->SetDefaultVoiceCard(INVALID_SLOTID), DATA_STORAGE_ERR_PERMISSION_ERR);
2989 EXPECT_GE(simRdbHelper->SetDefaultMessageCard(INVALID_SLOTID), DATA_STORAGE_ERR_PERMISSION_ERR);
2990 EXPECT_GE(simRdbHelper->SetDefaultCellularData(INVALID_SLOTID), DATA_STORAGE_ERR_PERMISSION_ERR);
2991 EXPECT_GE(simRdbHelper->QueryDataByIccId(iccId, simBean), DATA_STORAGE_ERR_PERMISSION_ERR);
2992 EXPECT_GE(simRdbHelper->QueryAllData(vec), DATA_STORAGE_ERR_PERMISSION_ERR);
2993 EXPECT_GE(simRdbHelper->QueryAllValidData(vec), DATA_STORAGE_ERR_PERMISSION_ERR);
2994 }
2995
2996 /**
2997 * @tc.number Telephony_SimRdbHelper_002
2998 * @tc.name test error branch
2999 * @tc.desc Function test
3000 */
3001 HWTEST_F(BranchTest, Telephony_SimRdbHelper_002, Function | MediumTest | Level1)
3002 {
3003 TELEPHONY_LOGI("Telephony_SimRdbHelper_002");
3004 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
3005 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
3006 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
3007 std::shared_ptr<Telephony::MultiSimController> multiSimController =
3008 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
3009 multiSimController->InitData(0);
3010 multiSimController->ForgetAllData();
3011 auto simRdbHelper = std::make_shared<SimRdbHelper>();
3012 SimRdbInfo simBean;
3013 std::string iccId = "empty_slot0";
3014 std::vector<SimRdbInfo> vec;
3015 EXPECT_GE(simRdbHelper->UpdateOpKeyInfo(), DATA_STORAGE_ERR_PERMISSION_ERR);
3016 EXPECT_GE(simRdbHelper->ClearData(), DATA_STORAGE_ERR_PERMISSION_ERR);
3017 DataShare::DataShareValuesBucket values;
3018 DataShare::DataShareValueObject slotObj(0);
3019 DataShare::DataShareValueObject iccidObj(iccId);
3020 DataShare::DataShareValueObject valueObj(ACTIVE);
3021 values.Put(SimData::SLOT_INDEX, slotObj);
3022 values.Put(SimData::ICC_ID, iccidObj);
3023 values.Put(SimData::CARD_ID, iccidObj); // iccId == cardId by now
3024 values.Put(SimData::IS_ACTIVE, valueObj);
3025 int64_t id;
3026 EXPECT_GE(simRdbHelper->InsertData(id, values), DATA_STORAGE_ERR_PERMISSION_ERR);
3027 DataShare::DataShareValuesBucket valuesExt;
3028 DataShare::DataShareValueObject mccObj("460");
3029 DataShare::DataShareValueObject mncObj("09");
3030 valuesExt.Put(SimData::MCC, mccObj);
3031 valuesExt.Put(SimData::MNC, mncObj);
3032 DataShare::DataSharePredicates predicates;
3033 predicates.EqualTo(SimData::ICC_ID, iccId);
3034 EXPECT_GE(simRdbHelper->UpdateDataByIccId(iccId, valuesExt), DATA_STORAGE_ERR_PERMISSION_ERR);
3035 EXPECT_GE(simRdbHelper->QueryDataByIccId(iccId, simBean), DATA_STORAGE_ERR_PERMISSION_ERR);
3036 EXPECT_GE(simRdbHelper->QueryAllData(vec), DATA_STORAGE_ERR_PERMISSION_ERR);
3037 EXPECT_GE(simRdbHelper->QueryAllValidData(vec), DATA_STORAGE_ERR_PERMISSION_ERR);
3038 int curSimId = multiSimController->GetSimId(0);
3039 DataShare::DataShareValuesBucket valuesNumber;
3040 DataShare::DataShareValueObject numberObj("123569877456");
3041 valuesNumber.Put(SimData::PHONE_NUMBER, numberObj);
3042 EXPECT_GE(simRdbHelper->UpdateDataBySimId(curSimId, valuesNumber), DATA_STORAGE_ERR_PERMISSION_ERR);
3043 multiSimController->ForgetAllData(0);
3044 }
3045
3046 /**
3047 * @tc.number Telephony_MultiSimMonitor_001
3048 * @tc.name test error branch
3049 * @tc.desc Function test
3050 */
3051 HWTEST_F(BranchTest, Telephony_MultiSimMonitor_001, Function | MediumTest | Level1)
3052 {
3053 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
3054 auto simStateManagerPtr = std::make_shared<SimStateManager>(telRilManager);
3055 auto telRilManagerWeak = std::weak_ptr<TelRilManager>(telRilManager);
3056 EventFwk::MatchingSkills matchingSkills;
3057 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
3058 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
3059 auto simFileManagerPtr = std::make_shared<Telephony::SimFileManager>(
3060 subcribeInfo, telRilManagerWeak, std::weak_ptr<Telephony::SimStateManager>(simStateManagerPtr));
3061 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { simStateManagerPtr,
3062 simStateManagerPtr };
3063 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { simFileManagerPtr, simFileManagerPtr };
3064 std::shared_ptr<Telephony::MultiSimController> multiSimController =
3065 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
3066 std::vector<std::weak_ptr<Telephony::SimFileManager>> simFileManagerWeak = {
3067 std::weak_ptr<Telephony::SimFileManager>(simFileManagerPtr),
3068 std::weak_ptr<Telephony::SimFileManager>(simFileManagerPtr)
3069 };
3070 auto multiSimMonitor = std::make_shared<MultiSimMonitor>(multiSimController, simStateManager, simFileManagerWeak);
3071 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_RECORDS_LOADED, 1);
3072 multiSimMonitor->isSimAccountLoaded_.resize(SIM_SLOT_COUNT, 0);
3073 multiSimMonitor->initDataRemainCount_.resize(SIM_SLOT_COUNT, 5);
3074 multiSimMonitor->ProcessEvent(event);
3075 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_CHANGE, 1);
3076 multiSimMonitor->ProcessEvent(event);
3077 event = AppExecFwk::InnerEvent::Get(RadioProtocolEvent::MSG_SIM_FORGET_ALLDATA, 1);
3078 multiSimMonitor->ProcessEvent(event);
3079 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_SIMLOCK, 1);
3080 multiSimMonitor->ProcessEvent(event);
3081 event = nullptr;
3082 multiSimMonitor->ProcessEvent(event);
3083 multiSimMonitor->InitData(INVALID_SLOTID);
3084 multiSimMonitor->InitData(0);
3085 multiSimMonitor->RefreshData(INVALID_SLOTID);
3086 multiSimMonitor->RefreshData(0);
3087 multiSimMonitor->NotifySimAccountChanged();
3088 int32_t tokenId = 123456789;
3089 sptr<SimAccountCallback> callback = nullptr;
3090 EXPECT_GT(multiSimMonitor->RegisterSimAccountCallback(tokenId, callback), TELEPHONY_ERROR);
3091 EXPECT_EQ(multiSimMonitor->UnregisterSimAccountCallback(tokenId), TELEPHONY_ERROR);
3092 }
3093
3094 /**
3095 * @tc.number Telephony_MultiSimMonitor_002
3096 * @tc.name test error branch
3097 * @tc.desc Function test
3098 */
3099 HWTEST_F(BranchTest, Telephony_MultiSimMonitor_002, Function | MediumTest | Level1)
3100 {
3101 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
3102 auto simStateManagerPtr = std::make_shared<SimStateManager>(telRilManager);
3103 auto telRilManagerWeak = std::weak_ptr<TelRilManager>(telRilManager);
3104 EventFwk::MatchingSkills matchingSkills;
3105 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
3106 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
3107 auto simFileManagerPtr = std::make_shared<Telephony::SimFileManager>(
3108 subcribeInfo, telRilManagerWeak, std::weak_ptr<Telephony::SimStateManager>(simStateManagerPtr));
3109 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { simStateManagerPtr,
3110 simStateManagerPtr };
3111 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { simFileManagerPtr, simFileManagerPtr };
3112 std::shared_ptr<Telephony::MultiSimController> multiSimController =
3113 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
3114 std::vector<std::weak_ptr<Telephony::SimFileManager>> simFileManagerWeak = {
3115 std::weak_ptr<Telephony::SimFileManager>(simFileManagerPtr),
3116 std::weak_ptr<Telephony::SimFileManager>(simFileManagerPtr)
3117 };
3118 auto multiSimMonitor = std::make_shared<MultiSimMonitor>(multiSimController, simStateManager, simFileManagerWeak);
3119 multiSimMonitor->AddExtraManagers(simStateManagerPtr, simFileManagerPtr);
3120 auto simStateHandle = std::make_shared<SimStateHandle>(simStateManagerPtr);
3121 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SIM_STATE_READY, 0);
3122 multiSimMonitor->ProcessEvent(event);
3123 multiSimMonitor->RegisterCoreNotify(0, simStateHandle, RadioEvent::RADIO_SIM_ACCOUNT_LOADED);
3124 multiSimMonitor->IsVSimSlotId(0);
3125 multiSimMonitor->RegisterSimNotify(0);
3126 multiSimMonitor->UnRegisterSimNotify();
3127 }
3128
3129 /**
3130 * @tc.number Telephony_MultiSimMonitor_003
3131 * @tc.name test error branch
3132 * @tc.desc Function test
3133 */
3134 HWTEST_F(BranchTest, Telephony_MultiSimMonitor_003, Function | MediumTest | Level1)
3135 {
3136 std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
3137 auto simStateManagerPtr = std::make_shared<SimStateManager>(telRilManager);
3138 auto telRilManagerWeak = std::weak_ptr<TelRilManager>(telRilManager);
3139 EventFwk::MatchingSkills matchingSkills;
3140 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
3141 EventFwk::CommonEventSubscribeInfo subcribeInfo(matchingSkills);
3142 auto simFileManagerPtr = std::make_shared<Telephony::SimFileManager>(
3143 subcribeInfo, telRilManagerWeak, std::weak_ptr<Telephony::SimStateManager>(simStateManagerPtr));
3144 std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { simStateManagerPtr,
3145 simStateManagerPtr };
3146 std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { simFileManagerPtr, simFileManagerPtr };
3147 std::shared_ptr<Telephony::MultiSimController> multiSimController =
3148 std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
3149 std::vector<std::weak_ptr<Telephony::SimFileManager>> simFileManagerWeak = {
3150 std::weak_ptr<Telephony::SimFileManager>(simFileManagerPtr),
3151 std::weak_ptr<Telephony::SimFileManager>(simFileManagerPtr)
3152 };
3153 std::shared_ptr<MultiSimMonitor> multiSimMonitor =
3154 std::make_shared<MultiSimMonitor>(multiSimController, simStateManager, simFileManagerWeak);
3155 multiSimMonitor->AddExtraManagers(simStateManagerPtr, simFileManagerPtr);
3156 EventFwk::MatchingSkills matchSkills;
3157 matchingSkills.AddEvent(DATASHARE_READY_EVENT);
3158 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchSkills);
3159 subscriberInfo.SetThreadMode(CommonEventSubscribeInfo::COMMON);
3160 }
3161
3162 /**
3163 * @tc.number Telephony_ImsCoreServiceCallbackProxy_001
3164 * @tc.name test error branch
3165 * @tc.desc Function test
3166 */
3167 HWTEST_F(BranchTest, Telephony_ImsCoreServiceCallbackProxy_001, Function | MediumTest | Level1)
3168 {
3169 sptr<ISystemAbilityManager> systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
3170 if (systemAbilityMgr == nullptr) {
3171 TELEPHONY_LOGE("Telephony_ImsCoreServiceCallbackProxy systemAbilityMgr is nullptr");
3172 return;
3173 }
3174 sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CORE_SERVICE_SYS_ABILITY_ID);
3175 if (remote == nullptr) {
3176 TELEPHONY_LOGE("Telephony_ImsCoreServiceCallbackProxy remote is nullptr");
3177 return;
3178 }
3179 auto imsCoreServiceCallbackProxy = std::make_shared<ImsCoreServiceCallbackProxy>(remote);
3180 ImsServiceStatus imsServiceStatus;
3181 EXPECT_GE(imsCoreServiceCallbackProxy->UpdateImsServiceStatusChanged(INVALID_SLOTID, imsServiceStatus), 0);
3182 ImsRegistrationStatus imsRegStatus;
3183 EXPECT_GE(imsCoreServiceCallbackProxy->GetImsRegistrationStatusResponse(INVALID_SLOTID, imsRegStatus), 0);
3184 auto imsCoreServiceCallbackStub = std::make_shared<ImsCoreServiceCallbackStub>();
3185 MessageParcel data;
3186 MessageParcel reply;
3187 MessageOption option;
3188 EXPECT_GE(imsCoreServiceCallbackStub->OnRemoteRequest(0, data, reply, option), 0);
3189 }
3190
3191 /**
3192 * @tc.number Telephony_ImsCoreServiceProxy_001
3193 * @tc.name test error branch
3194 * @tc.desc Function test
3195 */
3196 HWTEST_F(BranchTest, Telephony_ImsCoreServiceProxy_001, Function | MediumTest | Level1)
3197 {
3198 sptr<ISystemAbilityManager> systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
3199 if (systemAbilityMgr == nullptr) {
3200 TELEPHONY_LOGE("Telephony_ImsCoreServiceProxy systemAbilityMgr is nullptr");
3201 return;
3202 }
3203 sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_IMS_SYS_ABILITY_ID);
3204 if (remote == nullptr) {
3205 TELEPHONY_LOGE("Telephony_ImsCoreServiceProxy remote is nullptr");
3206 return;
3207 }
3208 auto imsCoreServiceProxy = std::make_shared<ImsCoreServiceProxy>(remote);
3209 EXPECT_GE(imsCoreServiceProxy->GetImsRegistrationStatus(0), 0);
3210 EXPECT_GE(imsCoreServiceProxy->RegisterImsCoreServiceCallback(nullptr), 0);
3211 }
3212
3213 /**
3214 * @tc.number Telephony_CoreServiceClient_001
3215 * @tc.name test error branch
3216 * @tc.desc Function test
3217 */
3218 HWTEST_F(BranchTest, Telephony_CoreServiceClient_001, Function | MediumTest | Level1)
3219 {
3220 auto coreServiceClient = std::make_shared<CoreServiceClient>();
3221 coreServiceClient->OnRemoteDied(nullptr);
3222 auto recipient = std::make_shared<CoreServiceClient::CoreServiceDeathRecipient>(CoreServiceClient::GetInstance());
3223 recipient->OnRemoteDied(nullptr);
3224 EXPECT_GE(coreServiceClient->GetNetworkSelectionMode(INVALID_SLOTID, nullptr), 0);
3225 EXPECT_NE(coreServiceClient->RefreshSimState(INVALID_SLOTID), 0);
3226 EXPECT_GE(coreServiceClient->GetPreferredNetwork(INVALID_SLOTID, nullptr), 0);
3227 EXPECT_GE(coreServiceClient->SetPreferredNetwork(INVALID_SLOTID, 0, nullptr), 0);
3228 }
3229
3230 /**
3231 * @tc.number Telephony_SignalInformation_001
3232 * @tc.name test error branch
3233 * @tc.desc Function test
3234 */
3235 HWTEST_F(BranchTest, Telephony_SignalInformation_001, Function | MediumTest | Level1)
3236 {
3237 std::shared_ptr<SignalInformation> wCdmaSignalInformation = std::make_shared<WcdmaSignalInformation>();
3238 std::shared_ptr<SignalInformation> nrSignalInformation = std::make_shared<NrSignalInformation>();
3239 std::shared_ptr<SignalInformation> cdmaSignalInformation = std::make_shared<CdmaSignalInformation>();
3240 std::shared_ptr<SignalInformation> tdScdmaSignalInformation = std::make_shared<TdScdmaSignalInformation>();
3241 std::shared_ptr<SignalInformation> gsmSignalInformation = std::make_shared<GsmSignalInformation>();
3242 Parcel parcel;
3243 gsmSignalInformation->SignalInformation::Unmarshalling(parcel);
3244 EXPECT_GE(wCdmaSignalInformation->GetSignalIntensity(), 0);
3245 EXPECT_GE(nrSignalInformation->GetSignalIntensity(), 0);
3246 EXPECT_GE(cdmaSignalInformation->GetSignalIntensity(), 0);
3247 EXPECT_GE(tdScdmaSignalInformation->GetSignalIntensity(), 0);
3248 EXPECT_GE(gsmSignalInformation->GetSignalIntensity(), 0);
3249 std::shared_ptr<CellLocation> cellLocation = std::make_shared<GsmCellLocation>();
3250 cellLocation->CellLocation::Unmarshalling(parcel);
3251 std::shared_ptr<GsmCellLocation> gsmCellLocation = std::make_shared<GsmCellLocation>();
3252 EXPECT_GE(gsmCellLocation->GetCellId(), 0);
3253 }
3254
3255 HWTEST_F(BranchTest, Telephony_NrSsbInfo, Function | MediumTest | Level1)
3256 {
3257 auto telRilManager = std::make_shared<TelRilManager>();
3258 auto simManager = std::make_shared<SimManager>(telRilManager);
3259 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
3260 auto nrSsbInfo = std::make_shared<NrSsbInfo>(networkSearchManager, INVALID_SLOTID);
3261
3262 EXPECT_FALSE(nrSsbInfo->FillNrSsbIdInformation(nullptr));
3263
3264 std::shared_ptr<NrSsbInformation> nrCellSsbIdsInfo = std::make_shared<NrSsbInformation>();
3265 EXPECT_TRUE(nrSsbInfo->FillNrSsbIdInformation(nrCellSsbIdsInfo));
3266
3267 AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr);
3268 EXPECT_FALSE(nrSsbInfo->ProcessGetNrSsbId(event));
3269
3270 EXPECT_FALSE(nrSsbInfo->UpdateNrSsbIdInfo(SLOT_ID_0, nullptr));
3271
3272 std::shared_ptr<NrCellSsbIds> nrCellSsbIds = std::make_shared<NrCellSsbIds>();
3273 nrSsbInfo->nrCellSsbIdsInfo_ = nullptr;
3274 EXPECT_FALSE(nrSsbInfo->UpdateNrSsbIdInfo(SLOT_ID_0, nrCellSsbIds));
3275
3276 nrSsbInfo->nrCellSsbIdsInfo_ = std::make_shared<NrCellSsbInfo>();
3277 EXPECT_TRUE(nrSsbInfo->UpdateNrSsbIdInfo(SLOT_ID_0, nrCellSsbIds));
3278
3279 nrCellSsbIds->nbCellCount = 5;
3280 EXPECT_FALSE(nrSsbInfo->UpdateNrSsbIdInfo(SLOT_ID_0, nrCellSsbIds));
3281 }
3282
3283 HWTEST_F(BranchTest, Telephony_RadioInfo, Function | MediumTest | Level1)
3284 {
3285 auto telRilManager = std::make_shared<TelRilManager>();
3286 auto simManager = std::make_shared<SimManager>(telRilManager);
3287 auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
3288 auto radioInfo = std::make_shared<RadioInfo>(networkSearchManager, INVALID_SLOTID);
3289
3290 AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr);
3291 radioInfo->ProcessGetRadioState(event);
3292 radioInfo->ProcessSetRadioState(event);
3293
3294 std::shared_ptr<NetworkSearchManager> nsm = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
3295 radioInfo->RadioFirstPowerOn(nsm, ModemPowerState::CORE_SERVICE_POWER_OFF);
3296 radioInfo->ProcessGetImei(event);
3297 radioInfo->ProcessGetImeiSv(event);
3298 radioInfo->ProcessGetMeid(event);
3299 radioInfo->ProcessVoiceTechChange(event);
3300 radioInfo->ProcessGetBasebandVersion(event);
3301 radioInfo->ProcessGetRrcConnectionState(event);
3302 radioInfo->ProcessSetNrOptionMode(event);
3303 radioInfo->ProcessGetNrOptionMode(event);
3304 EXPECT_EQ(radioInfo->RadioTechToPhoneType(RadioTech::RADIO_TECHNOLOGY_1XRTT, RadioTech::RADIO_TECHNOLOGY_LTE),
3305 PhoneType::PHONE_TYPE_IS_CDMA);
3306 EXPECT_EQ(radioInfo->RadioTechToPhoneType(RadioTech::RADIO_TECHNOLOGY_EVDO, RadioTech::RADIO_TECHNOLOGY_LTE),
3307 PhoneType::PHONE_TYPE_IS_CDMA);
3308 EXPECT_EQ(radioInfo->RadioTechToPhoneType(RadioTech::RADIO_TECHNOLOGY_EHRPD, RadioTech::RADIO_TECHNOLOGY_LTE),
3309 PhoneType::PHONE_TYPE_IS_CDMA);
3310
3311 EXPECT_EQ(radioInfo->RadioTechToPhoneType(RadioTech::RADIO_TECHNOLOGY_UNKNOWN, RadioTech::RADIO_TECHNOLOGY_LTE),
3312 PhoneType::PHONE_TYPE_IS_GSM);
3313 EXPECT_EQ(radioInfo->RadioTechToPhoneType(RadioTech::RADIO_TECHNOLOGY_UNKNOWN, RadioTech::RADIO_TECHNOLOGY_LTE_CA),
3314 PhoneType::PHONE_TYPE_IS_GSM);
3315 EXPECT_EQ(radioInfo->RadioTechToPhoneType(RadioTech::RADIO_TECHNOLOGY_UNKNOWN, RadioTech::RADIO_TECHNOLOGY_NR),
3316 PhoneType::PHONE_TYPE_IS_GSM);
3317 }
3318 } // namespace Telephony
3319 } // namespace OHOS
3320