1 /*
2  * Copyright (C) 2023-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 <gtest/gtest.h>
18 #include <string_ex.h>
19 
20 #include "common_event_manager.h"
21 #include "common_event_support.h"
22 #include "core_service.h"
23 #include "core_service_client.h"
24 #include "core_service_dump_helper.h"
25 #include "core_service_hisysevent.h"
26 #include "network_search_manager.h"
27 #include "network_search_test_callback_stub.h"
28 #include "operator_name.h"
29 #include "operator_name_utils.h"
30 #include "security_token.h"
31 #include "sim_manager.h"
32 #include "tel_ril_manager.h"
33 #include "telephony_log_wrapper.h"
34 
35 namespace OHOS {
36 namespace Telephony {
37 using namespace testing::ext;
38 std::shared_ptr<SimManager> g_simManagerPtr = nullptr;
39 
40 namespace {
41 constexpr int32_t SLEEP_TIME_SECONDS = 3;
42 constexpr int32_t SLOT_ID = 0;
43 const int32_t INVALID_SLOTID = -1;
44 constexpr int32_t NR_NSA_OPTION_ONLY = 1;
45 constexpr int32_t SIGNAL_STRENGTH_GOOD = 3;
46 const std::string NITZ_STR = "23/10/16,09:10:33+32,00";
47 const std::string NITZ_STR_INVALID = "202312102359";
48 constexpr int32_t LTE_RSSI_GOOD = -80;
49 } // namespace
50 
51 class CoreServiceBranchTest : public testing::Test {
52 public:
53     static void SetUpTestCase();
54     static void TearDownTestCase();
55     void SetUp();
56     void TearDown();
57 };
SetUpTestCase()58 void CoreServiceBranchTest::SetUpTestCase()
59 {
60     DelayedSingleton<CoreService>::GetInstance()->Init();
61     auto iSimManager = DelayedSingleton<CoreService>::GetInstance()->simManager_;
62     if (iSimManager == nullptr) {
63         return;
64     }
65     g_simManagerPtr = std::static_pointer_cast<SimManager>(iSimManager);
66 }
67 
TearDownTestCase()68 void CoreServiceBranchTest::TearDownTestCase()
69 {
70     if (g_simManagerPtr != nullptr && g_simManagerPtr->multiSimMonitor_ != nullptr) {
71         g_simManagerPtr->multiSimMonitor_->remainCount_ = 0;
72         sleep(SLEEP_TIME_SECONDS);
73     }
74     auto telRilManager = DelayedSingleton<CoreService>::GetInstance()->telRilManager_;
75     if (telRilManager == nullptr) {
76         return;
77     }
78     auto handler = telRilManager->handler_;
79     if (handler != nullptr) {
80         handler->RemoveAllEvents();
81         handler->SendEvent(0, 0, AppExecFwk::EventQueue::Priority::HIGH);
82         sleep(SLEEP_TIME_SECONDS);
83     }
84     telRilManager->DisConnectRilInterface();
85     telRilManager->DeInit();
86     DelayedSingleton<CoreService>::GetInstance()->Stop();
87     DelayedSingleton<CoreService>::DestroyInstance();
88 }
89 
SetUp()90 void CoreServiceBranchTest::SetUp() {}
91 
TearDown()92 void CoreServiceBranchTest::TearDown() {}
93 
94 /**
95  * @tc.number   Telephony_CoreService_NetWork_001
96  * @tc.name     test normal branch
97  * @tc.desc     Function test
98  */
99 HWTEST_F(CoreServiceBranchTest, Telephony_CoreService_NetWork_001, Function | MediumTest | Level1)
100 {
101     SecurityToken token;
102     int32_t psRadioTech;
103     EXPECT_GE(
104         DelayedSingleton<CoreService>::GetInstance()->GetPsRadioTech(SLOT_ID, psRadioTech), TELEPHONY_ERR_SUCCESS);
105     sptr<NetworkInformation> networkInfo = new (std::nothrow) NetworkInformation();
106     networkInfo->SetOperateInformation("CHINA MOBILE", "CMCC", "46000",
107         static_cast<int32_t>(NetworkPlmnState::NETWORK_PLMN_STATE_AVAILABLE),
108         static_cast<int32_t>(NetworkRat::NETWORK_LTE));
109     sptr<NetworkSearchTestCallbackStub> callback(new NetworkSearchTestCallbackStub());
110     int32_t result = DelayedSingleton<CoreService>::GetInstance()->SetNetworkSelectionMode(
111         SLOT_ID, static_cast<int32_t>(SelectionMode::MODE_TYPE_MANUAL), networkInfo, true, callback);
112     EXPECT_GE(result, TELEPHONY_ERR_SUCCESS);
113     std::vector<sptr<SignalInformation>> signals;
114     result = DelayedSingleton<CoreService>::GetInstance()->GetSignalInfoList(SLOT_ID, signals);
115     DelayedSingleton<CoreService>::GetInstance()->GetOperatorNumeric(SLOT_ID);
116     EXPECT_GE(result, TELEPHONY_ERR_SUCCESS);
117     std::u16string u16OperatorName = u"";
118     result = DelayedSingleton<CoreService>::GetInstance()->GetOperatorName(SLOT_ID, u16OperatorName);
119     EXPECT_GE(result, TELEPHONY_ERR_SUCCESS);
120     sptr<NetworkState> networkState = nullptr;
121     DelayedSingleton<CoreService>::GetInstance()->GetNetworkState(SLOT_ID, networkState);
122     DelayedSingleton<CoreService>::GetInstance()->SetRadioState(SLOT_ID, false, callback);
123     DelayedSingleton<CoreService>::GetInstance()->SetRadioState(SLOT_ID, false, callback);
124     EXPECT_GE(result, TELEPHONY_ERR_SUCCESS);
125 }
126 
127 /**
128  * @tc.number   Telephony_CoreService_NetWork_001
129  * @tc.name     test normal branch
130  * @tc.desc     Function test
131  */
132 HWTEST_F(CoreServiceBranchTest, Telephony_CoreService_NetWork_002, Function | MediumTest | Level1)
133 {
134     SecurityToken token;
135     sptr<NetworkSearchTestCallbackStub> callback(new NetworkSearchTestCallbackStub());
136     DelayedSingleton<CoreService>::GetInstance()->GetPreferredNetwork(SLOT_ID, callback);
137     DelayedSingleton<CoreService>::GetInstance()->SetPreferredNetwork(SLOT_ID, 1, callback);
138     int32_t networkCapabilityType = 1;
139     int32_t networkCapabilityState = 1;
140     DelayedSingleton<CoreService>::GetInstance()->GetNetworkCapability(
141         SLOT_ID, networkCapabilityType, networkCapabilityState);
142     DelayedSingleton<CoreService>::GetInstance()->SetNetworkCapability(
143         SLOT_ID, networkCapabilityType, networkCapabilityState);
144     std::vector<sptr<CellInformation>> cellList;
145     int32_t result = DelayedSingleton<CoreService>::GetInstance()->GetCellInfoList(SLOT_ID, cellList);
146     DelayedSingleton<CoreService>::GetInstance()->SendUpdateCellLocationRequest(SLOT_ID);
147     DelayedSingleton<CoreService>::GetInstance()->FactoryReset(SLOT_ID);
148     std::u16string u16Ret = u"";
149     DelayedSingleton<CoreService>::GetInstance()->GetIsoCountryCodeForNetwork(SLOT_ID, u16Ret);
150     DelayedSingleton<CoreService>::GetInstance()->GetImei(SLOT_ID, u16Ret);
151     DelayedSingleton<CoreService>::GetInstance()->GetImeiSv(SLOT_ID, u16Ret);
152     DelayedSingleton<CoreService>::GetInstance()->GetMeid(SLOT_ID, u16Ret);
153     DelayedSingleton<CoreService>::GetInstance()->GetUniqueDeviceId(SLOT_ID, u16Ret);
154     DelayedSingleton<CoreService>::GetInstance()->IsNrSupported(SLOT_ID);
155     DelayedSingleton<CoreService>::GetInstance()->GetPreferredNetwork(SLOT_ID, callback);
156     DelayedSingleton<CoreService>::GetInstance()->SetNrOptionMode(SLOT_ID, NR_NSA_OPTION_ONLY, callback);
157     DelayedSingleton<CoreService>::GetInstance()->GetNetworkSearchInformation(SLOT_ID, callback);
158     DelayedSingleton<CoreService>::GetInstance()->GetNrOptionMode(SLOT_ID, callback);
159     DelayedSingleton<CoreService>::GetInstance()->GetNetworkSelectionMode(SLOT_ID, callback);
160     EXPECT_GE(result, TELEPHONY_ERR_SUCCESS);
161 }
162 
163 /**
164  * @tc.number   Telephony_CoreService_Sim_001
165  * @tc.name     test normal branch
166  * @tc.desc     Function test
167  */
168 HWTEST_F(CoreServiceBranchTest, Telephony_CoreService_Sim_001, Function | MediumTest | Level1)
169 {
170     SecurityToken token;
171     bool hasSimCard = false;
172     DelayedSingleton<CoreService>::GetInstance()->HasSimCard(SLOT_ID, hasSimCard);
173     SimState simState = SimState::SIM_STATE_UNKNOWN;
174     DelayedSingleton<CoreService>::GetInstance()->GetSimState(SLOT_ID, simState);
175     CardType cardType = CardType::UNKNOWN_CARD;
176     int32_t result = DelayedSingleton<CoreService>::GetInstance()->GetCardType(SLOT_ID, cardType);
177     std::u16string countryCode;
178     DelayedSingleton<CoreService>::GetInstance()->GetISOCountryCodeForSim(SLOT_ID, countryCode);
179     std::u16string testU16Str = u"";
180     DelayedSingleton<CoreService>::GetInstance()->GetSimSpn(SLOT_ID, testU16Str);
181     DelayedSingleton<CoreService>::GetInstance()->GetSimIccId(SLOT_ID, testU16Str);
182     DelayedSingleton<CoreService>::GetInstance()->GetSimOperatorNumeric(SLOT_ID, testU16Str);
183     DelayedSingleton<CoreService>::GetInstance()->GetIMSI(SLOT_ID, testU16Str);
184     DelayedSingleton<CoreService>::GetInstance()->IsSimActive(SLOT_ID);
185     int32_t simId = 1;
186     DelayedSingleton<CoreService>::GetInstance()->GetSlotId(simId);
187     DelayedSingleton<CoreService>::GetInstance()->GetLocaleFromDefaultSim();
188     DelayedSingleton<CoreService>::GetInstance()->GetSimGid1(SLOT_ID, testU16Str);
189     DelayedSingleton<CoreService>::GetInstance()->GetSimGid2(SLOT_ID);
190     int32_t lac = 1;
191     bool longNameRequired = true;
192     std::string plmn = "46001";
193     DelayedSingleton<CoreService>::GetInstance()->GetSimEons(SLOT_ID, plmn, lac, longNameRequired);
194     IccAccountInfo info;
195     DelayedSingleton<CoreService>::GetInstance()->GetSimAccountInfo(SLOT_ID, info);
196     DelayedSingleton<CoreService>::GetInstance()->SetDefaultVoiceSlotId(SLOT_ID);
197     DelayedSingleton<CoreService>::GetInstance()->GetDefaultVoiceSlotId();
198     DelayedSingleton<CoreService>::GetInstance()->GetDefaultVoiceSimId(simId);
199     int32_t dsdsMode = 0;
200     DelayedSingleton<CoreService>::GetInstance()->GetDsdsMode(dsdsMode);
201     DelayedSingleton<CoreService>::GetInstance()->GetPrimarySlotId(result);
202     const std::u16string cardNumber = Str8ToStr16("SimNumber12345678901");
203     DelayedSingleton<CoreService>::GetInstance()->SetShowNumber(SLOT_ID, cardNumber);
204     DelayedSingleton<CoreService>::GetInstance()->GetShowNumber(SLOT_ID, testU16Str);
205     const std::u16string cardName = Str8ToStr16("SimNameZhang");
206     DelayedSingleton<CoreService>::GetInstance()->SetShowName(SLOT_ID, cardName);
207     DelayedSingleton<CoreService>::GetInstance()->GetShowName(SLOT_ID, testU16Str);
208     std::vector<IccAccountInfo> iccAccountInfoList = {};
209     DelayedSingleton<CoreService>::GetInstance()->GetActiveSimAccountInfoList(iccAccountInfoList);
210     EXPECT_GE(DelayedSingleton<CoreService>::GetInstance()->GetShowName(SLOT_ID, testU16Str), TELEPHONY_ERR_SUCCESS);
211 }
212 
213 /**
214  * @tc.number   Telephony_CoreService_Sim_002
215  * @tc.name     test normal branch
216  * @tc.desc     Function test
217  */
218 HWTEST_F(CoreServiceBranchTest, Telephony_CoreService_Sim_002, Function | MediumTest | Level1)
219 {
220     SecurityToken token;
221     DelayedSingleton<CoreService>::GetInstance()->RefreshSimState(SLOT_ID);
222     std::u16string testU16Str = u"";
223     int32_t result = DelayedSingleton<CoreService>::GetInstance()->GetSimTelephoneNumber(SLOT_ID, testU16Str);
224     DelayedSingleton<CoreService>::GetInstance()->GetSimTeleNumberIdentifier(SLOT_ID);
225     std::string number = "01234567890123456789";
226     DelayedSingleton<CoreService>::GetInstance()->SetVoiceCallForwarding(SLOT_ID, true, number);
227     DelayedSingleton<CoreService>::GetInstance()->GetOpKey(SLOT_ID, testU16Str);
228     DelayedSingleton<CoreService>::GetInstance()->GetOpKeyExt(SLOT_ID, testU16Str);
229     DelayedSingleton<CoreService>::GetInstance()->GetOpName(SLOT_ID, testU16Str);
230     ImsRegInfo mImsRegInfo;
231     DelayedSingleton<CoreService>::GetInstance()->GetImsRegStatus(SLOT_ID, ImsServiceType::TYPE_VOICE, mImsRegInfo);
232     SimAuthenticationResponse response = { 0 };
233     AuthType authType = AuthType::SIM_AUTH_EAP_SIM_TYPE;
234     std::string authData = "1234";
235     DelayedSingleton<CoreService>::GetInstance()->SimAuthentication(SLOT_ID, authType, authData, response);
236     bool isCTSimCard = false;
237     DelayedSingleton<CoreService>::GetInstance()->IsCTSimCard(SLOT_ID, isCTSimCard);
238     EXPECT_GE(result, TELEPHONY_ERR_SUCCESS);
239 }
240 
241 /**
242  * @tc.number   Telephony_CoreService_Stub_001
243  * @tc.name     test normal branch
244  * @tc.desc     Function test
245  */
246 HWTEST_F(CoreServiceBranchTest, Telephony_CoreService_Stub_001, Function | MediumTest | Level1)
247 {
248     uint32_t maxCode = static_cast<uint32_t>(CoreServiceInterfaceCode::FACTORY_RESET);
249     for (uint32_t code = 0; code <= maxCode; code++) {
250         if (code == static_cast<uint32_t>(CoreServiceInterfaceCode::HAS_OPERATOR_PRIVILEGES)) {
251             continue;
252         }
253         MessageParcel data;
254         MessageParcel reply;
255         MessageOption option;
256         data.WriteInterfaceToken(CoreServiceStub::GetDescriptor());
257         DelayedSingleton<CoreService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
258     }
259     std::string version;
260     EXPECT_GE(
261         DelayedSingleton<CoreService>::GetInstance()->GetBasebandVersion(SLOT_ID, version), TELEPHONY_ERR_SUCCESS);
262 }
263 
264 /**
265  * @tc.number   Telephony_CoreService_Stub_002
266  * @tc.name     test normal branch
267  * @tc.desc     Function test
268  */
269 HWTEST_F(CoreServiceBranchTest, Telephony_CoreService_Stub_002, Function | MediumTest | Level1)
270 {
271     SecurityToken token;
272     int32_t slotId = SLOT_ID;
273     uint32_t maxCode = static_cast<uint32_t>(CoreServiceInterfaceCode::FACTORY_RESET);
274     for (uint32_t code = 0; code <= maxCode; code++) {
275         MessageParcel data;
276         MessageParcel reply;
277         MessageOption option;
278         data.WriteInterfaceToken(CoreServiceStub::GetDescriptor());
279         data.WriteInt32(slotId);
280         DelayedSingleton<CoreService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
281     }
282     std::string version;
283     EXPECT_GE(
284         DelayedSingleton<CoreService>::GetInstance()->GetBasebandVersion(SLOT_ID, version), TELEPHONY_ERR_SUCCESS);
285 }
286 
287 /**
288  * @tc.number   Telephony_CoreService_Stub_003
289  * @tc.name     test normal branch
290  * @tc.desc     Function test
291  */
292 HWTEST_F(CoreServiceBranchTest, Telephony_CoreService_Stub_003, Function | MediumTest | Level1)
293 {
294     SecurityToken token;
295     int32_t slotId = SLOT_ID;
296     sptr<NetworkSearchTestCallbackStub> callback(new NetworkSearchTestCallbackStub());
297     uint32_t maxCode = static_cast<uint32_t>(CoreServiceInterfaceCode::FACTORY_RESET);
298     for (uint32_t code = 0; code <= maxCode; code++) {
299         if (code == static_cast<uint32_t>(CoreServiceInterfaceCode::HAS_OPERATOR_PRIVILEGES)) {
300             continue;
301         }
302         MessageParcel data;
303         MessageParcel reply;
304         MessageOption option;
305         data.WriteInterfaceToken(CoreServiceStub::GetDescriptor());
306         data.WriteInt32(slotId);
307         data.WriteRemoteObject(callback->AsObject().GetRefPtr());
308         DelayedSingleton<CoreService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
309     }
310     std::string version;
311     EXPECT_GE(
312         DelayedSingleton<CoreService>::GetInstance()->GetBasebandVersion(SLOT_ID, version), TELEPHONY_ERR_SUCCESS);
313 }
314 
315 /**
316  * @tc.number   Telephony_CoreService_Stub_004
317  * @tc.name     test normal branch
318  * @tc.desc     Function test
319  */
320 HWTEST_F(CoreServiceBranchTest, Telephony_CoreService_Stub_004, Function | MediumTest | Level1)
321 {
322     SecurityToken token;
323     int32_t slotId = SLOT_ID;
324     sptr<NetworkSearchTestCallbackStub> callback(new NetworkSearchTestCallbackStub());
325     DelayedSingleton<CoreService>::GetInstance()->GetRadioState(slotId, callback);
326     auto simManager = DelayedSingleton<CoreService>::GetInstance()->simManager_;
327     auto networkSearchManager_ = DelayedSingleton<CoreService>::GetInstance()->networkSearchManager_;
328     auto telRilManager_ = DelayedSingleton<CoreService>::GetInstance()->telRilManager_;
329     DelayedSingleton<CoreService>::GetInstance()->simManager_ = nullptr;
330     DelayedSingleton<CoreService>::GetInstance()->networkSearchManager_ = nullptr;
331     DelayedSingleton<CoreService>::GetInstance()->telRilManager_ = nullptr;
332     DelayedSingleton<CoreService>::GetInstance()->GetRadioState(slotId, callback);
333     uint32_t maxCode = static_cast<uint32_t>(CoreServiceInterfaceCode::FACTORY_RESET);
334     for (uint32_t code = 0; code <= maxCode; code++) {
335         MessageParcel data;
336         MessageParcel reply;
337         MessageOption option;
338         data.WriteInterfaceToken(CoreServiceStub::GetDescriptor());
339         data.WriteInt32(slotId);
340         data.WriteRemoteObject(callback->AsObject().GetRefPtr());
341         DelayedSingleton<CoreService>::GetInstance()->OnRemoteRequest(code, data, reply, option);
342     }
343     DelayedSingleton<CoreService>::GetInstance()->simManager_ = simManager;
344     DelayedSingleton<CoreService>::GetInstance()->networkSearchManager_ = networkSearchManager_;
345     DelayedSingleton<CoreService>::GetInstance()->telRilManager_ = telRilManager_;
346     std::vector<std::u16string> args = { u"test", u"test1" };
347     DelayedSingleton<CoreService>::GetInstance()->Dump(slotId, args);
348     slotId--;
349     DelayedSingleton<CoreService>::GetInstance()->Dump(slotId, args);
350     DelayedSingleton<CoreService>::GetInstance()->state_ = ServiceRunningState::STATE_RUNNING;
351     DelayedSingleton<CoreService>::GetInstance()->OnStart();
352     DelayedSingleton<CoreService>::GetInstance()->OnStop();
353     EXPECT_EQ(DelayedSingleton<CoreService>::GetInstance()->GetServiceRunningState(),
354         static_cast<int32_t>(ServiceRunningState::STATE_NOT_START));
355 }
356 
357 /**
358  * @tc.number   Telephony_CoreService_DumpHelper_001
359  * @tc.name     test normal branch
360  * @tc.desc     Function test
361  */
362 HWTEST_F(CoreServiceBranchTest, Telephony_CoreService_DumpHelper_001, Function | MediumTest | Level1)
363 {
364     auto telRilManager = std::make_shared<TelRilManager>();
365     if (telRilManager == nullptr) {
366         return;
367     }
368     telRilManager->OnInit();
369     DelayedSingleton<CoreService>::GetInstance()->telRilManager_ = telRilManager;
370     int32_t slotCount = DelayedSingleton<CoreService>::GetInstance()->GetMaxSimCount();
371     auto simManager = std::make_shared<SimManager>(telRilManager);
372     if (simManager == nullptr) {
373         return;
374     }
375     simManager->OnInit(slotCount);
376     DelayedSingleton<CoreService>::GetInstance()->simManager_ = simManager;
377     auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
378     if (networkSearchManager == nullptr) {
379         return;
380     }
381     networkSearchManager->OnInit();
382     DelayedSingleton<CoreService>::GetInstance()->networkSearchManager_ = networkSearchManager;
383 
384     auto coreServiceDumpHelper = std::make_shared<CoreServiceDumpHelper>();
385     std::vector<std::string> argsInStr;
386     std::string result;
387     coreServiceDumpHelper->ShowHelp(result);
388     coreServiceDumpHelper->ShowCoreServiceTimeInfo(result);
389     int32_t slotId = SLOT_ID;
390     bool hasSimCard = false;
391     simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = ICC_CARD_ABSENT;
392     DelayedSingleton<CoreService>::GetInstance()->HasSimCard(slotId, hasSimCard);
393     EXPECT_FALSE(hasSimCard);
394     coreServiceDumpHelper->ShowCoreServiceInfo(result);
395     simManager->simStateManager_[slotId]->simStateHandle_->iccState_.simStatus_ = ICC_CONTENT_READY;
396     DelayedSingleton<CoreService>::GetInstance()->HasSimCard(slotId, hasSimCard);
397     EXPECT_TRUE(hasSimCard);
398     coreServiceDumpHelper->ShowCoreServiceInfo(result);
399     coreServiceDumpHelper->Dump(argsInStr, result);
400     EXPECT_FALSE(result.empty());
401     if (simManager->multiSimMonitor_ != nullptr) {
402         simManager->multiSimMonitor_->remainCount_ = 0;
403         sleep(SLEEP_TIME_SECONDS);
404     }
405 }
406 
407 /**
408  * @tc.number   Telephony_CoreService_HiSysEvent_001
409  * @tc.name     test normal branch
410  * @tc.desc     Function test
411  */
412 HWTEST_F(CoreServiceBranchTest, Telephony_CoreService_HiSysEvent_001, Function | MediumTest | Level1)
413 {
414     auto coreServiceHiSysEvent = std::make_shared<CoreServiceHiSysEvent>();
415     int32_t slotId = SLOT_ID;
416     int32_t argInt = SLOT_ID;
417     std::string argStr = "";
418     coreServiceHiSysEvent->WriteSignalLevelBehaviorEvent(slotId, argInt);
419     coreServiceHiSysEvent->WriteNetworkStateBehaviorEvent(slotId, argInt, argInt, argInt);
420     coreServiceHiSysEvent->WriteDefaultDataSlotIdBehaviorEvent(slotId);
421     coreServiceHiSysEvent->WriteSimStateBehaviorEvent(slotId, argInt);
422     coreServiceHiSysEvent->WriteDialCallFaultEvent(slotId, argInt, argStr);
423     coreServiceHiSysEvent->WriteAnswerCallFaultEvent(slotId, argInt, argStr);
424     coreServiceHiSysEvent->WriteHangUpFaultEvent(slotId, argInt, argStr);
425     coreServiceHiSysEvent->WriteSmsSendFaultEvent(
426         slotId, SmsMmsMessageType::SMS_SHORT_MESSAGE, SmsMmsErrorCode::SMS_ERROR_NULL_POINTER, argStr);
427     coreServiceHiSysEvent->WriteSmsReceiveFaultEvent(
428         slotId, SmsMmsMessageType::SMS_SHORT_MESSAGE, SmsMmsErrorCode::SMS_ERROR_NULL_POINTER, argStr);
429     coreServiceHiSysEvent->WriteDataActivateFaultEvent(
430         slotId, argInt, CellularDataErrorCode::DATA_ERROR_PS_NOT_ATTACH, argStr);
431     coreServiceHiSysEvent->WriteAirplaneModeChangeEvent(argInt);
432 }
433 
434 /**
435  * @tc.number   Telephony_MultiSimController_003
436  * @tc.name     test error branch
437  * @tc.desc     Function test
438  */
439 HWTEST_F(CoreServiceBranchTest, Telephony_MultiSimController_003, Function | MediumTest | Level1)
440 {
441     std::shared_ptr<TelRilManager> telRilManager = std::make_shared<TelRilManager>();
442     std::vector<std::shared_ptr<Telephony::SimStateManager>> simStateManager = { nullptr, nullptr };
443     std::vector<std::shared_ptr<Telephony::SimFileManager>> simFileManager = { nullptr, nullptr };
444     std::shared_ptr<Telephony::MultiSimController> multiSimController =
445         std::make_shared<MultiSimController>(telRilManager, simStateManager, simFileManager);
446     std::shared_ptr<RadioProtocolController> radioProtocolController = nullptr;
447     multiSimController->PublishSetPrimaryEvent(true);
448     multiSimController->EncryptIccId("");
449     multiSimController->getDefaultMainSlotByIccId();
450     multiSimController->CheckIfNeedSwitchMainSlotId();
451     multiSimController->IsAllModemInitDone();
452     multiSimController->ReCheckPrimary();
453     int simId = 0;
454     multiSimController->GetTargetDefaultSimId(INVALID_SLOTID, simId);
455     multiSimController->GetTargetSimId(INVALID_SLOTID, simId);
456     std::string iccId = "";
457     multiSimController->GetTargetIccId(INVALID_SLOTID, iccId);
458 
459     EXPECT_FALSE(multiSimController->IsValidSlotId(INVALID_SLOTID));
460     multiSimController->maxCount_ = 1;
461     EXPECT_FALSE(multiSimController->InitPrimary());
462     multiSimController->maxCount_ = 2;
463     EXPECT_FALSE(multiSimController->InitPrimary());
464     EXPECT_TRUE(multiSimController->IsAllCardsReady());
465     EXPECT_FALSE(multiSimController->IsAllCardsLoaded());
466 }
467 
468 /**
469  * @tc.number   Telephony_OperatorName_002
470  * @tc.name     test error branch
471  * @tc.desc     Function test
472  */
473 HWTEST_F(CoreServiceBranchTest, Telephony_OperatorName_002, Function | MediumTest | Level1)
474 {
475     EventFwk::MatchingSkills matchingSkills;
476     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
477     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
478     auto telRilManager = std::make_shared<TelRilManager>();
479     auto simManager = std::make_shared<SimManager>(telRilManager);
480     auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
481     auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
482     auto operatorName = std::make_shared<OperatorName>(
483         subscriberInfo, networkSearchState, simManager, networkSearchManager, INVALID_SLOTID);
484     std::string numeric = "";
485     EXPECT_FALSE(operatorName->isCMCard(numeric));
486     EXPECT_FALSE(operatorName->isCUCard(numeric));
487     EXPECT_FALSE(operatorName->isCTCard(numeric));
488     EXPECT_FALSE(operatorName->isCBCard(numeric));
489     EXPECT_FALSE(operatorName->isCMDomestic(numeric));
490     EXPECT_FALSE(operatorName->isCUDomestic(numeric));
491     EXPECT_FALSE(operatorName->isCTDomestic(numeric));
492     EXPECT_FALSE(operatorName->isCBDomestic(numeric));
493 }
494 
495 /**
496  * @tc.number   Telephony_OperatorNameCMCC_001
497  * @tc.name     test error branch
498  * @tc.desc     Function test
499  */
500 HWTEST_F(CoreServiceBranchTest, Telephony_OperatorNameCMCC_001, Function | MediumTest | Level1)
501 {
502     EventFwk::MatchingSkills matchingSkills;
503     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
504     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
505     auto telRilManager = std::make_shared<TelRilManager>();
506     auto simManager = std::make_shared<SimManager>(telRilManager);
507     auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
508     auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
509     auto operatorName = std::make_shared<OperatorName>(
510         subscriberInfo, networkSearchState, simManager, networkSearchManager, INVALID_SLOTID);
511     std::string simPlmn = "46000";
512     std::string netPlmn = "46031";
513     EXPECT_TRUE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
514     simPlmn = "46001";
515     netPlmn = "46031";
516     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
517     simPlmn = "46003";
518     netPlmn = "46031";
519     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
520     simPlmn = "46015";
521     netPlmn = "46031";
522     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
523     simPlmn = "46018";
524     netPlmn = "46031";
525     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
526     simPlmn = "46000";
527     netPlmn = "46050";
528     EXPECT_TRUE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
529     simPlmn = "46001";
530     netPlmn = "46050";
531     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
532     simPlmn = "46003";
533     netPlmn = "46050";
534     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
535     simPlmn = "46015";
536     netPlmn = "46050";
537     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
538     simPlmn = "46018";
539     netPlmn = "46050";
540     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
541 }
542 
543 /**
544  * @tc.number   Telephony_OperatorNameCUCC_001
545  * @tc.name     test error branch
546  * @tc.desc     Function test
547  */
548 HWTEST_F(CoreServiceBranchTest, Telephony_OperatorCUCC_001, Function | MediumTest | Level1)
549 {
550     EventFwk::MatchingSkills matchingSkills;
551     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
552     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
553     auto telRilManager = std::make_shared<TelRilManager>();
554     auto simManager = std::make_shared<SimManager>(telRilManager);
555     auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
556     auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
557     auto operatorName = std::make_shared<OperatorName>(
558         subscriberInfo, networkSearchState, simManager, networkSearchManager, INVALID_SLOTID);
559     std::string simPlmn = "46001";
560     std::string netPlmn = "46022";
561     EXPECT_TRUE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
562     simPlmn = "46000";
563     netPlmn = "46022";
564     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
565     simPlmn = "46003";
566     netPlmn = "46022";
567     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
568     simPlmn = "46015";
569     netPlmn = "46022";
570     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
571     simPlmn = "46018";
572     netPlmn = "46022";
573     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
574     simPlmn = "46001";
575     netPlmn = "46061";
576     EXPECT_TRUE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
577     simPlmn = "46000";
578     netPlmn = "46061";
579     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
580     simPlmn = "46003";
581     netPlmn = "46061";
582     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
583     simPlmn = "46015";
584     netPlmn = "46061";
585     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
586     simPlmn = "46018";
587     netPlmn = "46061";
588     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
589 }
590 
591 /**
592  * @tc.number   Telephony_OperatorNameCTCC_001
593  * @tc.name     test error branch
594  * @tc.desc     Function test
595  */
596 HWTEST_F(CoreServiceBranchTest, Telephony_OperatorNameCTCC_001, Function | MediumTest | Level1)
597 {
598     EventFwk::MatchingSkills matchingSkills;
599     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
600     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
601     auto telRilManager = std::make_shared<TelRilManager>();
602     auto simManager = std::make_shared<SimManager>(telRilManager);
603     auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
604     auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
605     auto operatorName = std::make_shared<OperatorName>(
606         subscriberInfo, networkSearchState, simManager, networkSearchManager, INVALID_SLOTID);
607     std::string simPlmn = "46003";
608     std::string netPlmn = "46021";
609     EXPECT_TRUE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
610     simPlmn = "46000";
611     netPlmn = "46021";
612     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
613     simPlmn = "46001";
614     netPlmn = "46021";
615     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
616     simPlmn = "46015";
617     netPlmn = "46021";
618     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
619     simPlmn = "46018";
620     netPlmn = "46021";
621     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
622     simPlmn = "46003";
623     netPlmn = "46060";
624     EXPECT_TRUE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
625     simPlmn = "46000";
626     netPlmn = "46060";
627     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
628     simPlmn = "46001";
629     netPlmn = "46060";
630     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
631     simPlmn = "46015";
632     netPlmn = "46060";
633     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
634     simPlmn = "46018";
635     netPlmn = "46060";
636     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
637 }
638 
639 /**
640  * @tc.number   Telephony_OperatorNameCBCC_001
641  * @tc.name     test error branch
642  * @tc.desc     Function test
643  */
644 HWTEST_F(CoreServiceBranchTest, Telephony_OperatorNameCBCC_001, Function | MediumTest | Level1)
645 {
646     EventFwk::MatchingSkills matchingSkills;
647     matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
648     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
649     auto telRilManager = std::make_shared<TelRilManager>();
650     auto simManager = std::make_shared<SimManager>(telRilManager);
651     auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
652     auto networkSearchState = std::make_shared<NetworkSearchState>(networkSearchManager, INVALID_SLOTID);
653     auto operatorName = std::make_shared<OperatorName>(
654         subscriberInfo, networkSearchState, simManager, networkSearchManager, INVALID_SLOTID);
655     std::string simPlmn = "46015";
656     std::string netPlmn = "46032";
657     EXPECT_TRUE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
658     simPlmn = "46000";
659     netPlmn = "46032";
660     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
661     simPlmn = "46001";
662     netPlmn = "46032";
663     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
664     simPlmn = "46003";
665     netPlmn = "46032";
666     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
667     simPlmn = "46018";
668     netPlmn = "46032";
669     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
670     simPlmn = "46015";
671     netPlmn = "46051";
672     EXPECT_TRUE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
673     simPlmn = "46000";
674     netPlmn = "46051";
675     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
676     simPlmn = "46001";
677     netPlmn = "46051";
678     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
679     simPlmn = "46003";
680     netPlmn = "46051";
681     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
682     simPlmn = "46018";
683     netPlmn = "46051";
684     EXPECT_FALSE(operatorName->isDomesticRoaming(simPlmn, netPlmn));
685 }
686 
687 /**
688  * @tc.number   Telephony_OperatorNameUtils_001
689  * @tc.name     test error branch
690  * @tc.desc     Function test
691  */
692 HWTEST_F(CoreServiceBranchTest, Telephony_OperatorNameUtils_001, Function | MediumTest | Level1)
693 {
694     OperatorNameUtils::GetInstance().Init();
695     char *content = nullptr;
696     const char *path = "etc/telephony/a.json";
697     EXPECT_GT(OperatorNameUtils::GetInstance().LoaderJsonFile(content, path), TELEPHONY_ERR_SUCCESS);
698     std::string numeric = "46000";
699     EXPECT_NE(OperatorNameUtils::GetInstance().GetCustomName(numeric), "");
700 }
701 
702 /**
703  * @tc.number   Telephony_TelRilManager_001
704  * @tc.name     test error branch
705  * @tc.desc     Function test
706  */
707 HWTEST_F(CoreServiceBranchTest, Telephony_TelRilManager_001, Function | MediumTest | Level1)
708 {
709     OHOS::HDI::ServiceManager::V1_0::ServiceStatus status = { "test", 0, SERVIE_STATUS_STOP, "test" };
710     auto telRilManager = std::make_shared<TelRilManager>();
711     telRilManager->HandleRilInterfaceStatusCallback(status);
712     status.serviceName = "ril_service";
713     telRilManager->HandleRilInterfaceStatusCallback(status);
714     status.deviceClass = DEVICE_CLASS_DEFAULT;
715     telRilManager->rilInterface_ = nullptr;
716     telRilManager->HandleRilInterfaceStatusCallback(status);
717     EXPECT_TRUE(status.status == SERVIE_STATUS_STOP);
718 }
719 
720 /**
721  * @tc.number   Telephony_NitzUpdate_001
722  * @tc.name     test normal branch
723  * @tc.desc     Function test
724  */
725 HWTEST_F(CoreServiceBranchTest, Telephony_NitzUpdate_001, Function | MediumTest | Level1)
726 {
727     auto telRilManager = std::make_shared<TelRilManager>();
728     auto simManager = std::make_shared<SimManager>(telRilManager);
729     auto networkSearchManager = std::make_shared<NetworkSearchManager>(telRilManager, simManager);
730     auto nitzUpdate = std::make_shared<NitzUpdate>(networkSearchManager, SLOT_ID);
731     auto event = AppExecFwk::InnerEvent::Get(0);
732     nitzUpdate->ProcessNitzUpdate(event);
733     nitzUpdate->ProcessTimeZone();
734     std::string countryCode = "";
735     nitzUpdate->UpdateCountryCode(countryCode);
736     countryCode = "cn";
737     nitzUpdate->UpdateCountryCode(countryCode);
738     nitzUpdate->AutoTimeChange();
739     NitzUpdate::NetworkTime networkTime;
740     std::string nitzStr = NITZ_STR;
741     EXPECT_TRUE(nitzUpdate->NitzParse(nitzStr, networkTime));
742     nitzUpdate->ProcessTime(networkTime);
743     int64_t networkTimeSec = nitzUpdate->lastNetworkTime_;
744     nitzUpdate->IsValidTime(networkTimeSec);
745     nitzUpdate->SaveTime(networkTimeSec);
746     nitzUpdate->IsAutoTime();
747     nitzStr = NITZ_STR_INVALID;
748     EXPECT_FALSE(nitzUpdate->NitzParse(nitzStr, networkTime));
749 }
750 
751 /**
752  * @tc.number   Telephony_IsAllowedInsertApn_001
753  * @tc.name     test normal branch
754  * @tc.desc     Function test
755  */
756 HWTEST_F(CoreServiceBranchTest, Telephony_IsAllowedInsertApn_001, Function | MediumTest | Level1)
757 {
758     std::string jsonValue = "";
759     auto coreServiceClient = std::make_shared<CoreServiceClient>();
760     coreServiceClient->OnRemoteDied(nullptr);
761     auto recipient = std::make_shared<CoreServiceClient::CoreServiceDeathRecipient>(CoreServiceClient::GetInstance());
762     recipient->OnRemoteDied(nullptr);
763     TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
764     if (TELEPHONY_EXT_WRAPPER.telephonyExtWrapperHandle_ != nullptr) {
765         EXPECT_EQ(TELEPHONY_EXT_WRAPPER.isAllowedInsertApn_ != nullptr, true);
766     }
767     EXPECT_TRUE(coreServiceClient->IsAllowedInsertApn(jsonValue));
768 }
769 
770 /**
771  * @tc.number   Telephony_GetTargetOpkey_001
772  * @tc.name     test normal branch
773  * @tc.desc     Function test
774  */
775 HWTEST_F(CoreServiceBranchTest, Telephony_GetTargetOpkey_001, Function | MediumTest | Level1)
776 {
777     std::u16string opkey;
778     auto coreServiceClient = std::make_shared<CoreServiceClient>();
779     coreServiceClient->OnRemoteDied(nullptr);
780     auto recipient = std::make_shared<CoreServiceClient::CoreServiceDeathRecipient>(CoreServiceClient::GetInstance());
781     recipient->OnRemoteDied(nullptr);
782     int32_t result = coreServiceClient->GetTargetOpkey(SLOT_ID, opkey);
783     EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
784 }
785 
786 /**
787  * @tc.number   Telephony_SignalInformationExt_001
788  * @tc.name     test normal branch
789  * @tc.desc     Function test
790  */
791 HWTEST_F(CoreServiceBranchTest, Telephony_SignalInformation_001, Function | MediumTest | Level1)
792 {
793     std::shared_ptr<SignalInformation> gsm = std::make_shared<GsmSignalInformation>();
794     std::shared_ptr<SignalInformation> cdma = std::make_shared<CdmaSignalInformation>();
795     std::shared_ptr<SignalInformation> wcdma = std::make_shared<WcdmaSignalInformation>();
796     std::shared_ptr<SignalInformation> lte = std::make_shared<LteSignalInformation>();
797     std::shared_ptr<SignalInformation> nr = std::make_shared<NrSignalInformation>();
798     std::shared_ptr<SignalInformation> tdScdma = std::make_shared<TdScdmaSignalInformation>();
799     if (gsm == nullptr || cdma == nullptr || wcdma == nullptr || lte == nullptr || nr == nullptr ||
800         tdScdma == nullptr) {
801         return;
802     }
803     gsm->GetSignalLevel();
804     gsm->SetSignalLevel(SIGNAL_STRENGTH_GOOD);
805     EXPECT_EQ(gsm->GetSignalLevel(), SIGNAL_STRENGTH_GOOD);
806     cdma->GetSignalLevel();
807     cdma->SetSignalLevel(SIGNAL_STRENGTH_GOOD);
808     EXPECT_EQ(cdma->GetSignalLevel(), SIGNAL_STRENGTH_GOOD);
809     wcdma->GetSignalLevel();
810     wcdma->SetSignalLevel(SIGNAL_STRENGTH_GOOD);
811     EXPECT_EQ(wcdma->GetSignalLevel(), SIGNAL_STRENGTH_GOOD);
812     lte->GetSignalLevel();
813     lte->SetSignalLevel(SIGNAL_STRENGTH_GOOD);
814     EXPECT_EQ(lte->GetSignalLevel(), SIGNAL_STRENGTH_GOOD);
815     nr->GetSignalLevel();
816     nr->SetSignalLevel(SIGNAL_STRENGTH_GOOD);
817     EXPECT_EQ(nr->GetSignalLevel(), SIGNAL_STRENGTH_GOOD);
818     tdScdma->GetSignalLevel();
819     tdScdma->SetSignalLevel(SIGNAL_STRENGTH_GOOD);
820     EXPECT_EQ(tdScdma->GetSignalLevel(), SIGNAL_STRENGTH_GOOD);
821 }
822 
823 /**
824  * @tc.number   Telephony_SignalInfo_001
825  * @tc.name     test normal branch
826  * @tc.desc     Function test
827  */
828 HWTEST_F(CoreServiceBranchTest, Telephony_SignalInfo_001, Function | MediumTest | Level1)
829 {
830     auto signalInfo = std::make_shared<SignalInfo>();
831     Rssi signalIntensity;
832     signalIntensity.lte.rsrp = LTE_RSSI_GOOD;
833     signalInfo->ProcessSignalIntensity(SLOT_ID, &signalIntensity);
834     EXPECT_TRUE(signalInfo->ProcessLte(signalIntensity.lte));
835 }
836 } // namespace Telephony
837 } // namespace OHOS
838