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 "bluetooth_call_client.h"
18 #include "bluetooth_call_manager.h"
19 #include "bluetooth_call_service.h"
20 #include "bluetooth_connection.h"
21 #include "iremote_broker.h"
22 #include "call_ability_callback.h"
23 #include "call_ability_connect_callback.h"
24 #include "call_ability_report_proxy.h"
25 #include "call_connect_ability.h"
26 #include "call_control_manager.h"
27 #include "call_manager_client.h"
28 #include "call_manager_hisysevent.h"
29 #include "call_number_utils.h"
30 #include "call_policy.h"
31 #include "call_records_manager.h"
32 #include "call_request_event_handler_helper.h"
33 #include "call_request_handler.h"
34 #include "call_request_process.h"
35 #include "call_setting_manager.h"
36 #include "call_state_report_proxy.h"
37 #include "call_status_manager.h"
38 #include "cellular_call_connection.h"
39 #include "common_event_manager.h"
40 #include "common_event_support.h"
41 #include "cs_call.h"
42 #include "cs_conference.h"
43 #include "distributed_call_manager.h"
44 #include "gtest/gtest.h"
45 #include "i_voip_call_manager_service.h"
46 #include "ims_call.h"
47 #include "ims_conference.h"
48 #include "incoming_call_notification.h"
49 #include "missed_call_notification.h"
50 #include "ott_call.h"
51 #include "ott_conference.h"
52 #include "reject_call_sms.h"
53 #include "report_call_info_handler.h"
54 #include "satellite_call.h"
55 #include "surface_utils.h"
56 #include "telephony_errors.h"
57 #include "telephony_hisysevent.h"
58 #include "telephony_log_wrapper.h"
59 #include "video_call_state.h"
60 #include "video_control_manager.h"
61 #include "voip_call_manager_proxy.h"
62 #include "voip_call.h"
63 #include "accesstoken_kit.h"
64 #include "token_setproc.h"
65 #include "nativetoken_kit.h"
66 #include "number_identity_data_base_helper.h"
67 #include "call_ability_callback_death_recipient.h"
68 #include "app_state_observer.h"
69 #include "call_ability_callback_proxy.h"
70 #include "super_privacy_manager_client.h"
71 #include "call_status_callback.h"
72 #include "satellite_call_control.h"
73 #include "proximity_sensor.h"
74 #include "status_bar.h"
75 #include "wired_headset.h"
76 #include "call_status_policy.h"
77 
78 namespace OHOS {
79 namespace Telephony {
80 using namespace testing::ext;
81 
82 namespace {
83 const int32_t INVALID_SLOTID = 2;
84 const int32_t SIM1_SLOTID = 0;
85 const int32_t DEFAULT_INDEX = 1;
86 const int16_t CAMERA_ROTATION_0 = 0;
87 const int16_t CAMERA_ROTATION_90 = 90;
88 const int16_t CAMERA_ROTATION_180 = 180;
89 const int16_t CAMERA_ROTATION_270 = 270;
90 const int32_t INVALID_MODE = 0;
91 const int32_t VALID_CALLID = 1;
92 const int32_t ERROR_CALLID = -1;
93 const int32_t ONE_TIME = 1;
94 const int32_t STEP_1 = 1;
95 const int32_t SOURCE_CALL = 2;
96 constexpr int16_t DEFAULT_TIME = 0;
97 constexpr const char *TEST_STR = "123";
98 constexpr const char *LONG_STR =
99     "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
100     "111111111";
101 } // namespace
102 
103 class DemoHandler : public AppExecFwk::EventHandler {
104 public:
DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> & eventRunner)105     explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &eventRunner) : AppExecFwk::EventHandler(eventRunner)
106     {}
~DemoHandler()107     virtual ~DemoHandler() {}
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)108     void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
109 };
110 
111 class ZeroBranch2Test : public testing::Test {
112 public:
113     void SetUp();
114     void TearDown();
115     static void SetUpTestCase();
116     static void TearDownTestCase();
117 };
118 
SetUp()119 void ZeroBranch2Test::SetUp() {}
120 
TearDown()121 void ZeroBranch2Test::TearDown() {}
122 
SetUpTestCase()123 void ZeroBranch2Test::SetUpTestCase()
124 {
125     constexpr int permissionNum = 1;
126     const char *perms[permissionNum] = {
127         "ohos.permission.GET_TELEPHONY_STATE"
128     };
129     NativeTokenInfoParams infoInstance = {
130         .dcapsNum = 0,  // Indicates the capsbility list of the sa.
131         .permsNum = permissionNum,
132         .aclsNum = 0,  // acls is the list of rights thar can be escalated.
133         .dcaps = nullptr,
134         .perms = perms,
135         .acls = nullptr,
136         .processName = "ZeroBranch2Test",
137         .aplStr = "system_basic",
138     };
139     uint64_t tokenId = GetAccessTokenId(&infoInstance);
140     SetSelfTokenID(tokenId);
141     auto result = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
142     EXPECT_EQ(result, Security::AccessToken::RET_SUCCESS);
143 }
144 
TearDownTestCase()145 void ZeroBranch2Test::TearDownTestCase() {}
146 
CreateDataShareHelper(std::string uri)147 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(std::string uri)
148 {
149     auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
150     if (saManager == nullptr) {
151         printf("Get system ability mgr failed.");
152         return nullptr;
153     }
154     auto remoteObj = saManager->GetSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
155     if (remoteObj == nullptr) {
156         printf("GetSystemAbility Service Failed.");
157         return nullptr;
158     }
159     return DataShare::DataShareHelper::Creator(remoteObj, uri);
160 }
161 
162 /**
163  * @tc.number   Telephony_CallRequestHandler_001
164  * @tc.name     test error branch
165  * @tc.desc     Function test
166  */
167 HWTEST_F(ZeroBranch2Test, Telephony_CallRequestHandler_001, Function | MediumTest | Level1)
168 {
169     std::unique_ptr<CallRequestHandler> callRequestHandler = std::make_unique<CallRequestHandler>();
170     ASSERT_NE(callRequestHandler->DialCall(), TELEPHONY_ERR_SUCCESS);
171     ASSERT_NE(callRequestHandler->AnswerCall(1, 1), TELEPHONY_ERR_SUCCESS);
172     std::string content = "";
173     ASSERT_NE(callRequestHandler->RejectCall(1, true, content), TELEPHONY_ERR_SUCCESS);
174     ASSERT_NE(callRequestHandler->HangUpCall(1), TELEPHONY_ERR_SUCCESS);
175     ASSERT_NE(callRequestHandler->HoldCall(1), TELEPHONY_ERR_SUCCESS);
176     ASSERT_NE(callRequestHandler->UnHoldCall(1), TELEPHONY_ERR_SUCCESS);
177     ASSERT_NE(callRequestHandler->SwitchCall(1), TELEPHONY_ERR_SUCCESS);
178     ASSERT_NE(callRequestHandler->CombineConference(1), TELEPHONY_ERR_SUCCESS);
179     ASSERT_NE(callRequestHandler->SeparateConference(1), TELEPHONY_ERR_SUCCESS);
180     ASSERT_NE(callRequestHandler->KickOutFromConference(1), TELEPHONY_ERR_SUCCESS);
181     std::u16string test = u"";
182     ASSERT_NE(callRequestHandler->StartRtt(1, test), TELEPHONY_ERR_SUCCESS);
183     ASSERT_NE(callRequestHandler->StopRtt(1), TELEPHONY_ERR_SUCCESS);
184     std::vector<std::string> emptyRecords = {};
185     ASSERT_NE(callRequestHandler->JoinConference(1, emptyRecords), TELEPHONY_ERR_SUCCESS);
186 }
187 
188 /**
189  * @tc.number   Telephony_CallRequestProcess_001
190  * @tc.name     test error branch
191  * @tc.desc     Function test
192  */
193 HWTEST_F(ZeroBranch2Test, Telephony_CallRequestProcess_001, Function | MediumTest | Level1)
194 {
195     std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
196     callRequestProcess->DialRequest();
197     callRequestProcess->AnswerRequest(1, 1);
198     std::string content = "";
199     callRequestProcess->RejectRequest(1, true, content);
200     callRequestProcess->HangUpRequest(1);
201     callRequestProcess->HoldRequest(1);
202     callRequestProcess->UnHoldRequest(1);
203     callRequestProcess->SwitchRequest(1);
204     callRequestProcess->CombineConferenceRequest(1);
205     callRequestProcess->SeparateConferenceRequest(1);
206     callRequestProcess->KickOutFromConferenceRequest(1);
207     std::u16string test = u"";
208     callRequestProcess->StartRttRequest(1, test);
209     callRequestProcess->StopRttRequest(1);
210     std::vector<std::string> numberList = {};
211     callRequestProcess->JoinConference(1, numberList);
212     DialParaInfo mDialParaInfo;
213     callRequestProcess->UpdateCallReportInfo(mDialParaInfo, TelCallState::CALL_STATUS_INCOMING);
214     callRequestProcess->HandleDialFail();
215     callRequestProcess->GetOtherRingingCall(1);
216     callRequestProcess->CarrierDialProcess(mDialParaInfo);
217     callRequestProcess->IsDialCallForDsda(mDialParaInfo);
218     bool isEcc = false;
219     std::string phoneNumber = "123456789012";
220     callRequestProcess->HandleEccCallForDsda(phoneNumber, mDialParaInfo, isEcc);
221     callRequestProcess->VoiceMailDialProcess(mDialParaInfo);
222     callRequestProcess->OttDialProcess(mDialParaInfo);
223     CellularCallInfo mCellularCallInfo;
224     callRequestProcess->PackCellularCallInfo(mDialParaInfo, mCellularCallInfo);
225     std::vector<std::u16string> testList = {};
226     callRequestProcess->IsFdnNumber(testList, content);
227     callRequestProcess->IsDsdsMode3();
228     callRequestProcess->DisconnectOtherSubIdCall(1, 0, 0);
229     callRequestProcess->DisconnectOtherCallForVideoCall(1);
230     ASSERT_FALSE(callRequestProcess->IsDsdsMode5());
231 }
232 
233 /**
234  * @tc.number   Telephony_CallRequestProcess_002
235  * @tc.name     test error branch
236  * @tc.desc     Function test
237  */
238 HWTEST_F(ZeroBranch2Test, Telephony_CallRequestProcess_002, Function | MediumTest | Level1)
239 {
240     std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
241     callRequestProcess->HoldOrDisconnectedCall(VALID_CALLID, SIM1_SLOTID, 1);
242     DialParaInfo mDialParaInfo;
243     sptr<CallBase> call = new CSCall(mDialParaInfo);
244     call->SetCallId(VALID_CALLID);
245     call->SetCallType(CallType::TYPE_VOIP);
246     call->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
247     call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
248     callRequestProcess->AddOneCallObject(call);
249     callRequestProcess->AnswerRequest(VALID_CALLID, static_cast<int>(CallType::TYPE_VOIP));
250     callRequestProcess->AnswerRequest(VALID_CALLID, static_cast<int>(CallType::TYPE_CS));
251     callRequestProcess->NeedAnswerVTAndEndActiveVO(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
252     callRequestProcess->NeedAnswerVTAndEndActiveVO(ERROR_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
253     callRequestProcess->NeedAnswerVOAndEndActiveVT(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VOICE));
254     callRequestProcess->NeedAnswerVOAndEndActiveVT(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
255     sptr<CallBase> voipCall = new VoIPCall(mDialParaInfo);
256     voipCall->SetCallId(VALID_CALLID);
257     voipCall->SetCallType(CallType::TYPE_VOIP);
258     voipCall->SetTelCallState(TelCallState::CALL_STATUS_HOLDING);
259     voipCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_HOLD);
260     callRequestProcess->AddOneCallObject(voipCall);
261     callRequestProcess->NeedAnswerVTAndEndActiveVO(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
262     callRequestProcess->NeedAnswerVTAndEndActiveVO(ERROR_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
263     callRequestProcess->NeedAnswerVOAndEndActiveVT(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VOICE));
264     callRequestProcess->NeedAnswerVOAndEndActiveVT(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
265     callRequestProcess->GetOtherRingingCall(VALID_CALLID);
266     callRequestProcess->GetOtherRingingCall(ERROR_CALLID);
267     callRequestProcess->HoldOrDisconnectedCall(VALID_CALLID, SIM1_SLOTID,
268         static_cast<int>(VideoStateType::TYPE_VIDEO));
269     callRequestProcess->HoldOrDisconnectedCall(VALID_CALLID, SIM1_SLOTID,
270         static_cast<int>(VideoStateType::TYPE_VOICE));
271     std::list<int32_t> list = {1, 2, -1, 0};
272     bool noOtherCall = false;
273     callRequestProcess->IsExistCallOtherSlot(list, SIM1_SLOTID, noOtherCall);
274     sptr<CallBase> dialCall = new IMSCall(mDialParaInfo);
275     dialCall->SetCallId(VALID_CALLID);
276     dialCall->SetCallType(CallType::TYPE_VOIP);
277     dialCall->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
278     dialCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_DIALING);
279     callRequestProcess->AddOneCallObject(dialCall);
280     sptr<CallBase> incomingCall = new CSCall(mDialParaInfo);
281     incomingCall->SetCallType(CallType::TYPE_CS);
282     bool flagForConference = false;
283     callRequestProcess->HandleCallWaitingNumZero(incomingCall, call, SIM1_SLOTID, 1, flagForConference);
284     callRequestProcess->HandleCallWaitingNumZero(incomingCall, voipCall, SIM1_SLOTID, 2, flagForConference);
285     callRequestProcess->HandleCallWaitingNumZero(incomingCall, dialCall, SIM1_SLOTID, 2, flagForConference);
286     callRequestProcess->DisconnectOtherCallForVideoCall(VALID_CALLID);
287     ASSERT_TRUE(flagForConference);
288 }
289 
290 /**
291  * @tc.number   Telephony_CallRequestProcess_003
292  * @tc.name     test error branch
293  * @tc.desc     Function test
294  */
295 HWTEST_F(ZeroBranch2Test, Telephony_CallRequestProcess_003, Function | MediumTest | Level1)
296 {
297     std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
298     DialParaInfo mDialParaInfo;
299     sptr<CallBase> call = nullptr;
300     callRequestProcess->DeleteOneCallObject(call);
301     call = new CSCall(mDialParaInfo);
302     call->SetCallId(VALID_CALLID);
303     call->SetCallType(CallType::TYPE_VOIP);
304     call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
305     call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
306     callRequestProcess->AddOneCallObject(call);
307     callRequestProcess->DisconnectOtherSubIdCall(VALID_CALLID, SIM1_SLOTID,
308         static_cast<int>(VideoStateType::TYPE_VIDEO));
309     sptr<CallBase> dialCall = new IMSCall(mDialParaInfo);
310     dialCall->SetCallId(2);
311     dialCall->SetCallType(CallType::TYPE_VOIP);
312     dialCall->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
313     dialCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_DIALING);
314     callRequestProcess->AddOneCallObject(dialCall);
315     callRequestProcess->DisconnectOtherSubIdCall(VALID_CALLID, SIM1_SLOTID,
316         static_cast<int>(VideoStateType::TYPE_VIDEO));
317     callRequestProcess->DisconnectOtherCallForVideoCall(VALID_CALLID);
318     callRequestProcess->DisconnectOtherCallForVideoCall(ERROR_CALLID);
319     std::string content = "";
320     callRequestProcess->RejectRequest(VALID_CALLID, true, content);
321     callRequestProcess->RejectRequest(2, true, content);
322     callRequestProcess->HoldRequest(VALID_CALLID);
323     callRequestProcess->HoldRequest(2);
324     callRequestProcess->CombineConferenceRequest(VALID_CALLID);
325     callRequestProcess->SeparateConferenceRequest(VALID_CALLID);
326     callRequestProcess->KickOutFromConferenceRequest(VALID_CALLID);
327     std::u16string msg = u"";
328     callRequestProcess->StartRttRequest(VALID_CALLID, msg);
329     callRequestProcess->StartRttRequest(2, msg);
330     callRequestProcess->StopRttRequest(VALID_CALLID);
331     callRequestProcess->StopRttRequest(2);
332     std::vector<std::string> numberList;
333     callRequestProcess->JoinConference(VALID_CALLID, numberList);
334     callRequestProcess->JoinConference(2, numberList);
335     callRequestProcess->isFirstDialCallAdded_ = true;
336     callRequestProcess->HandleDialFail();
337     callRequestProcess->DeleteOneCallObject(call);
338     callRequestProcess->DeleteOneCallObject(dialCall);
339     ASSERT_TRUE(callRequestProcess->isFirstDialCallAdded_);
340 }
341 
342 /**
343  * @tc.number   Telephony_CallObjectManager_001
344  * @tc.name     test error branch
345  * @tc.desc     Function test
346  */
347 HWTEST_F(ZeroBranch2Test, Telephony_CallObjectManager_001, Function | MediumTest | Level1)
348 {
349     CallObjectManager::HasNewCall();
350     DialParaInfo mDialParaInfo;
351     sptr<CallBase> csCall = new CSCall(mDialParaInfo);
352     csCall->SetCallType(CallType::TYPE_CS);
353     csCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_DIALING);
354     CallObjectManager::AddOneCallObject(csCall);
355     CallObjectManager::HasNewCall();
356     csCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_CREATE);
357     CallObjectManager::HasNewCall();
358     csCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_CONNECTING);
359     CallObjectManager::HasNewCall();
360     CallObjectManager::HasRingingMaximum();
361     csCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
362     CallObjectManager::HasRingingMaximum();
363     CallObjectManager::HasDialingMaximum();
364     csCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
365     CallObjectManager::HasDialingMaximum();
366     std::string number = "";
367     CallObjectManager::IsCallExist(number);
368     number = "test";
369     bool res = CallObjectManager::IsCallExist(number);
370     CallObjectManager::HasVideoCall();
371     csCall->SetVideoStateType(VideoStateType::TYPE_VIDEO);
372     CallObjectManager::HasVideoCall();
373     csCall->SetCallType(CallType::TYPE_VOIP);
374     CallObjectManager::HasVideoCall();
375     CallObjectManager::GetCallInfoList(DEFAULT_INDEX);
376     csCall->SetCallType(CallType::TYPE_OTT);
377     CallObjectManager::GetCallInfoList(SIM1_SLOTID);
378     CallObjectManager::GetCallInfoList(DEFAULT_INDEX);
379     ASSERT_FALSE(res);
380 }
381 
382 /**
383  * @tc.number   Telephony_CallObjectManager_002
384  * @tc.name     test error branch
385  * @tc.desc     Function test
386  */
387 HWTEST_F(ZeroBranch2Test, Telephony_CallObjectManager_002, Function | MediumTest | Level1)
388 {
389     DialParaInfo mDialParaInfo;
390     sptr<CallBase> csCall = new CSCall(mDialParaInfo);
391     csCall->callId_ = 0;
392     csCall->callType_ = CallType::TYPE_VOIP;
393     csCall->callRunningState_ = CallRunningState::CALL_RUNNING_STATE_RINGING;
394     csCall->callState_ = TelCallState::CALL_STATUS_ACTIVE;
395     CallObjectManager::AddOneCallObject(csCall);
396     CallObjectManager::GetOneCallObject(0);
397     std::list<int32_t> list;
398     CallObjectManager::GetVoipCallList(list);
399     CallObjectManager::GetVoipCallNum();
400     CallObjectManager::GetAllCallList();
401     bool hasRingingCall = false;
402     CallObjectManager::HasRingingCall(hasRingingCall);
403     csCall->callRunningState_ = CallRunningState::CALL_RUNNING_STATE_HOLD;
404 CallObjectManager::HasHoldCall(hasRingingCall);
405     ASSERT_FALSE(CallObjectManager::IsCallExist(CallType::TYPE_VOIP, TelCallState::CALL_STATUS_ACTIVE));
406     CallObjectManager::DeleteOneCallObject(0);
407 }
408 
409 /**
410  * @tc.number   Telephony_CallNumberUtils_001
411  * @tc.name     test error branch
412  * @tc.desc     Function test
413  */
414 HWTEST_F(ZeroBranch2Test, Telephony_CallNumberUtils_001, Function | MediumTest | Level1)
415 {
416     std::string emptyStr = "";
417     std::string phoneNumber = "123456789012";
418     std::string countryCode = "gr";
419     std::string formatNumber = "";
420     NumberMarkInfo numberMarkInfo;
421     ASSERT_NE(DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumber(emptyStr, emptyStr, formatNumber),
422         TELEPHONY_ERR_SUCCESS);
423     EXPECT_EQ(DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumber(phoneNumber, emptyStr, formatNumber),
424         TELEPHONY_ERR_SUCCESS);
425     EXPECT_EQ(
426         DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumber(phoneNumber, countryCode, formatNumber),
427         TELEPHONY_ERR_SUCCESS);
428     ASSERT_GE(
429         DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumberToE164(emptyStr, emptyStr, formatNumber),
430         TELEPHONY_ERR_SUCCESS);
431     EXPECT_EQ(
432         DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumberToE164(phoneNumber, emptyStr, formatNumber),
433         TELEPHONY_ERR_SUCCESS);
434     EXPECT_EQ(DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumberToE164(
435         phoneNumber, countryCode, formatNumber), TELEPHONY_ERR_SUCCESS);
436     ASSERT_NE(DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumberToNational(
437         emptyStr, emptyStr, formatNumber), TELEPHONY_ERR_SUCCESS);
438     ASSERT_NE(DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumberToInternational(
439         emptyStr, emptyStr, formatNumber), TELEPHONY_ERR_SUCCESS);
440     ASSERT_FALSE(DelayedSingleton<CallNumberUtils>::GetInstance()->IsValidSlotId(INVALID_SLOTID));
441     ASSERT_TRUE(DelayedSingleton<CallNumberUtils>::GetInstance()->IsValidSlotId(0));
442     EXPECT_NE(DelayedSingleton<CallNumberUtils>::GetInstance()->QueryYellowPageAndMarkInfo(
443         numberMarkInfo, phoneNumber), TELEPHONY_ERR_LOCAL_PTR_NULL);
444 }
445 
446 /**
447  * @tc.number   Telephony_CallNumberUtils_002
448  * @tc.name     test error branch
449  * @tc.desc     Function test
450  */
451 HWTEST_F(ZeroBranch2Test, Telephony_CallNumberUtils_002, Function | MediumTest | Level1)
452 {
453     std::string emptyStr = "";
454     std::string phoneNumber = "123456789012";
455     std::string numberLocation = "";
456     EXPECT_NE(DelayedSingleton<CallNumberUtils>::GetInstance()->QueryNumberLocationInfo(numberLocation, emptyStr),
457         TELEPHONY_ERR_SUCCESS);
458     std::shared_ptr<NumberIdentityDataBaseHelper> callDataPtr =
459         DelayedSingleton<NumberIdentityDataBaseHelper>::GetInstance();
460     printf("NUMBER_IDENTITY_URI: %s\n", callDataPtr->NUMBER_IDENTITY_URI);
461     auto helper = CreateDataShareHelper(callDataPtr->NUMBER_IDENTITY_URI);
462     if (helper != nullptr) {
463         helper->Release();
464         EXPECT_EQ(DelayedSingleton<CallNumberUtils>::GetInstance()->
465             QueryNumberLocationInfo(numberLocation, phoneNumber), TELEPHONY_ERR_SUCCESS);
466     } else {
467         printf("helper is null");
468         EXPECT_NE(DelayedSingleton<CallNumberUtils>::GetInstance()->
469             QueryNumberLocationInfo(numberLocation, phoneNumber), TELEPHONY_ERR_SUCCESS);
470     }
471 }
472 
473 /**
474  * @tc.number   Telephony_CellularCallConnection_001
475  * @tc.name     test error branch
476  * @tc.desc     Function test
477  */
478 HWTEST_F(ZeroBranch2Test, Telephony_CellularCallConnection_001, Function | MediumTest | Level1)
479 {
480     std::shared_ptr<CellularCallConnection> cellularCallConnection =
481         DelayedSingleton<CellularCallConnection>::GetInstance();
482     CellularCallInfo mCellularCallInfo;
483     ASSERT_NE(cellularCallConnection->Dial(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
484     ASSERT_NE(cellularCallConnection->HangUp(
485         mCellularCallInfo, CallSupplementType::TYPE_DEFAULT), TELEPHONY_ERR_SUCCESS);
486     ASSERT_NE(cellularCallConnection->Reject(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
487     ASSERT_NE(cellularCallConnection->Answer(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
488     ASSERT_NE(cellularCallConnection->HoldCall(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
489     ASSERT_NE(cellularCallConnection->UnHoldCall(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
490     ASSERT_NE(cellularCallConnection->SwitchCall(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
491     bool enabled = false;
492     ASSERT_NE(cellularCallConnection->IsEmergencyPhoneNumber("", 0, enabled), TELEPHONY_ERR_SUCCESS);
493     ASSERT_NE(cellularCallConnection->CombineConference(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
494     ASSERT_NE(cellularCallConnection->SeparateConference(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
495     ASSERT_NE(cellularCallConnection->KickOutFromConference(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
496     ASSERT_NE(cellularCallConnection->StartDtmf('a', mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
497     ASSERT_NE(cellularCallConnection->StopDtmf(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
498     ASSERT_NE(cellularCallConnection->GetCallTransferInfo(
499         CallTransferType::TRANSFER_TYPE_BUSY, 0), TELEPHONY_ERR_SUCCESS);
500     ASSERT_NE(cellularCallConnection->SetCallWaiting(true, 0), TELEPHONY_ERR_SUCCESS);
501     ASSERT_NE(cellularCallConnection->GetCallWaiting(0), TELEPHONY_ERR_SUCCESS);
502     CallRestrictionInfo mCallRestrictionInfo;
503     ASSERT_NE(cellularCallConnection->SetCallRestriction(mCallRestrictionInfo, 0), TELEPHONY_ERR_SUCCESS);
504     ASSERT_NE(cellularCallConnection->GetCallRestriction(
505         CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING, 0), TELEPHONY_ERR_SUCCESS);
506     ASSERT_NE(cellularCallConnection->SetCallPreferenceMode(0, 1), TELEPHONY_ERR_SUCCESS);
507 }
508 
509 /**
510  * @tc.number   Telephony_CellularCallConnection_002
511  * @tc.name     test error branch
512  * @tc.desc     Function test
513  */
514 HWTEST_F(ZeroBranch2Test, Telephony_CellularCallConnection_002, Function | MediumTest | Level1)
515 {
516     CallTransferInfo mCallTransferInfo;
517     std::shared_ptr<CellularCallConnection> cellularCallConnection =
518         DelayedSingleton<CellularCallConnection>::GetInstance();
519     ASSERT_NE(cellularCallConnection->SetCallTransferInfo(mCallTransferInfo, 0), TELEPHONY_ERR_SUCCESS);
520     bool result;
521     ASSERT_NE(cellularCallConnection->CanSetCallTransferTime(0, result), TELEPHONY_ERR_SUCCESS);
522     ASSERT_NE(cellularCallConnection->GetImsSwitchStatus(0, result), TELEPHONY_ERR_SUCCESS);
523     ASSERT_NE(cellularCallConnection->SetImsConfig(ImsConfigItem::ITEM_VIDEO_QUALITY, "", 0), TELEPHONY_ERR_SUCCESS);
524     ASSERT_NE(cellularCallConnection->SetImsConfig(ImsConfigItem::ITEM_VIDEO_QUALITY, 1, 0), TELEPHONY_ERR_SUCCESS);
525     ASSERT_NE(cellularCallConnection->GetImsConfig(ImsConfigItem::ITEM_VIDEO_QUALITY, 0), TELEPHONY_ERR_SUCCESS);
526     ASSERT_NE(
527         cellularCallConnection->SetImsFeatureValue(FeatureType::TYPE_VOICE_OVER_LTE, 1, 0), TELEPHONY_ERR_SUCCESS);
528     ASSERT_NE(cellularCallConnection->GetImsFeatureValue(FeatureType::TYPE_VOICE_OVER_LTE, 0), TELEPHONY_ERR_SUCCESS);
529     std::vector<std::string> numberList = {};
530     ASSERT_NE(cellularCallConnection->InviteToConference(numberList, 0), TELEPHONY_ERR_SUCCESS);
531     ASSERT_NE(cellularCallConnection->SetMute(0, 0), TELEPHONY_ERR_SUCCESS);
532     ASSERT_NE(cellularCallConnection->SendDtmf('a', ""), TELEPHONY_ERR_SUCCESS);
533     ASSERT_NE(
534         cellularCallConnection->SendDtmfString("", "", PhoneNetType::PHONE_TYPE_GSM, 1, 0), TELEPHONY_ERR_SUCCESS);
535     ASSERT_NE(cellularCallConnection->RegisterCallBack(nullptr), TELEPHONY_ERR_SUCCESS);
536     ASSERT_NE(cellularCallConnection->SetImsSwitchStatus(0, true), TELEPHONY_ERR_SUCCESS);
537     ASSERT_NE(cellularCallConnection->ConnectService(), TELEPHONY_ERR_SUCCESS);
538     cellularCallConnection->ClearAllCalls();
539     std::string testStr = "";
540     ASSERT_NE(cellularCallConnection->ControlCamera(SIM1_SLOTID, DEFAULT_INDEX, testStr, 1, 1), TELEPHONY_ERR_SUCCESS);
541     ASSERT_NE(
542         cellularCallConnection->SetPreviewWindow(SIM1_SLOTID, DEFAULT_INDEX, testStr, nullptr), TELEPHONY_ERR_SUCCESS);
543     ASSERT_NE(
544         cellularCallConnection->SetDisplayWindow(SIM1_SLOTID, DEFAULT_INDEX, testStr, nullptr), TELEPHONY_ERR_SUCCESS);
545     float zoomRatio = 1;
546     ASSERT_NE(cellularCallConnection->SetCameraZoom(zoomRatio), TELEPHONY_ERR_SUCCESS);
547     ASSERT_NE(cellularCallConnection->SetPausePicture(SIM1_SLOTID, DEFAULT_INDEX, testStr), TELEPHONY_ERR_SUCCESS);
548     ASSERT_NE(cellularCallConnection->SetDeviceDirection(SIM1_SLOTID, DEFAULT_INDEX, 1), TELEPHONY_ERR_SUCCESS);
549     ASSERT_NE(cellularCallConnection->CancelCallUpgrade(SIM1_SLOTID, DEFAULT_INDEX), TELEPHONY_ERR_SUCCESS);
550     ASSERT_NE(cellularCallConnection->RequestCameraCapabilities(SIM1_SLOTID, DEFAULT_INDEX), TELEPHONY_ERR_SUCCESS);
551 }
552 
553 /**
554  * @tc.number   Telephony_CellularCallConnection_003
555  * @tc.name     test error branch
556  * @tc.desc     Function test
557  */
558 HWTEST_F(ZeroBranch2Test, Telephony_CellularCallConnection_003, Function | MediumTest | Level1)
559 {
560     CellularCallInfo mCellularCallInfo;
561     std::shared_ptr<CellularCallConnection> cellularCallConnection =
562         DelayedSingleton<CellularCallConnection>::GetInstance();
563     std::u16string test = u"";
564     ASSERT_NE(cellularCallConnection->StartRtt(mCellularCallInfo, test), TELEPHONY_ERR_SUCCESS);
565     ASSERT_NE(cellularCallConnection->StopRtt(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
566     ASSERT_NE(cellularCallConnection->SendUpdateCallMediaModeRequest(
567         mCellularCallInfo, ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_SUCCESS);
568     ASSERT_NE(cellularCallConnection->RegisterCallBackFun(), TELEPHONY_ERR_SUCCESS);
569     ASSERT_NE(cellularCallConnection->ReConnectService(), TELEPHONY_ERR_SUCCESS);
570     ASSERT_NE(cellularCallConnection->PostDialProceed(mCellularCallInfo, true), TELEPHONY_ERR_SUCCESS);
571 }
572 
573 /**
574  * @tc.number   Telephony_CellularCallConnection_004
575  * @tc.name     test error branch
576  * @tc.desc     Function test
577  */
578 HWTEST_F(ZeroBranch2Test, Telephony_CellularCallConnection_004, Function | MediumTest | Level1)
579 {
580     CellularCallInfo mCellularCallInfo;
581     std::shared_ptr<CellularCallConnection> cellularCallConnection =
582         DelayedSingleton<CellularCallConnection>::GetInstance();
583     std::u16string test = u"";
584     int32_t state = 0;
585     cellularCallConnection->SetVoNRState(SIM1_SLOTID, state);
586     cellularCallConnection->GetVoNRState(SIM1_SLOTID, state);
587     int res = cellularCallConnection->CloseUnFinishedUssd(SIM1_SLOTID);
588     CellularCallConnection::SystemAbilityListener listen;
589     int32_t systemAbilityId = 1;
590     std::string deviceId = "123";
591     listen.OnAddSystemAbility(systemAbilityId, deviceId);
592     listen.OnRemoveSystemAbility(systemAbilityId, deviceId);
593     ASSERT_NE(res, TELEPHONY_ERR_SUCCESS);
594 }
595 
596 /**
597  * @tc.number   Telephony_CallPolicy_001
598  * @tc.name     test error branch
599  * @tc.desc     Function test
600  */
601 HWTEST_F(ZeroBranch2Test, Telephony_CallPolicy_001, Function | MediumTest | Level1)
602 {
603     CallPolicy mCallPolicy;
604     std::u16string testEmptyStr = u"";
605     AppExecFwk::PacMap mPacMap;
606     mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true);
607     mPacMap.PutIntValue("dialType", static_cast<int32_t>(DialType::DIAL_CARRIER_TYPE));
608     ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
609     mPacMap.PutIntValue("dialType", static_cast<int32_t>(DialType::DIAL_VOICE_MAIL_TYPE));
610     ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
611     mPacMap.PutIntValue("callType", static_cast<int32_t>(CallType::TYPE_CS));
612     ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
613     mPacMap.PutIntValue("dialScene", static_cast<int32_t>(DialScene::CALL_NORMAL));
614     ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
615     ASSERT_NE(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, false), TELEPHONY_ERR_SUCCESS);
616     mPacMap.PutIntValue("dialScene", static_cast<int32_t>(DialScene::CALL_PRIVILEGED));
617     ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
618     ASSERT_NE(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, false), TELEPHONY_ERR_SUCCESS);
619     mPacMap.PutIntValue("dialScene", static_cast<int32_t>(DialScene::CALL_EMERGENCY));
620     mPacMap.PutIntValue("videoState", static_cast<int32_t>(VideoStateType::TYPE_VOICE));
621     ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
622     ASSERT_NE(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, false), TELEPHONY_ERR_SUCCESS);
623     mPacMap.PutIntValue("dialType", static_cast<int32_t>(DialType::DIAL_VOICE_MAIL_TYPE));
624     ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
625     ASSERT_NE(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, false), TELEPHONY_ERR_SUCCESS);
626     ASSERT_NE(mCallPolicy.AnswerCallPolicy(0, INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
627     ASSERT_NE(mCallPolicy.AnswerCallPolicy(0, 0), TELEPHONY_ERR_SUCCESS);
628     ASSERT_NE(mCallPolicy.RejectCallPolicy(0), TELEPHONY_ERR_SUCCESS);
629     ASSERT_GE(mCallPolicy.HoldCallPolicy(0), TELEPHONY_ERR_SUCCESS);
630     ASSERT_NE(mCallPolicy.UnHoldCallPolicy(0), TELEPHONY_ERR_SUCCESS);
631     ASSERT_NE(mCallPolicy.HangUpPolicy(0), TELEPHONY_ERR_SUCCESS);
632     ASSERT_NE(mCallPolicy.SwitchCallPolicy(0), TELEPHONY_ERR_SUCCESS);
633     ASSERT_GE(mCallPolicy.VideoCallPolicy(0), TELEPHONY_ERR_SUCCESS);
634     ASSERT_NE(mCallPolicy.StartRttPolicy(0), TELEPHONY_ERR_SUCCESS);
635     ASSERT_NE(mCallPolicy.StopRttPolicy(0), TELEPHONY_ERR_SUCCESS);
636     ASSERT_NE(mCallPolicy.IsValidSlotId(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
637     ASSERT_FALSE(mCallPolicy.IsSupportVideoCall(mPacMap));
638     ASSERT_GE(mCallPolicy.CanDialMulityCall(mPacMap, false), TELEPHONY_ERR_SUCCESS);
639 }
640 
641 /**
642  * @tc.number   Telephony_CallPolicy_002
643  * @tc.name     test error branch
644  * @tc.desc     Function test
645  */
646 HWTEST_F(ZeroBranch2Test, Telephony_CallPolicy_002, Function | MediumTest | Level1)
647 {
648     CallPolicy mCallPolicy;
649     ASSERT_EQ(mCallPolicy.IsValidSlotId(0), TELEPHONY_ERR_SUCCESS);
650     ASSERT_NE(mCallPolicy.EnableVoLtePolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
651     ASSERT_EQ(mCallPolicy.EnableVoLtePolicy(0), TELEPHONY_ERR_SUCCESS);
652     ASSERT_NE(mCallPolicy.DisableVoLtePolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
653     ASSERT_EQ(mCallPolicy.DisableVoLtePolicy(0), TELEPHONY_ERR_SUCCESS);
654     ASSERT_NE(mCallPolicy.IsVoLteEnabledPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
655     ASSERT_EQ(mCallPolicy.IsVoLteEnabledPolicy(0), TELEPHONY_ERR_SUCCESS);
656     ASSERT_NE(mCallPolicy.GetCallWaitingPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
657     ASSERT_EQ(mCallPolicy.GetCallWaitingPolicy(0), TELEPHONY_ERR_SUCCESS);
658     ASSERT_NE(mCallPolicy.SetCallWaitingPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
659     ASSERT_EQ(mCallPolicy.SetCallWaitingPolicy(0), TELEPHONY_ERR_SUCCESS);
660     ASSERT_NE(mCallPolicy.GetCallRestrictionPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
661     ASSERT_EQ(mCallPolicy.GetCallRestrictionPolicy(0), TELEPHONY_ERR_SUCCESS);
662     ASSERT_NE(mCallPolicy.SetCallRestrictionPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
663     ASSERT_EQ(mCallPolicy.SetCallRestrictionPolicy(0), TELEPHONY_ERR_SUCCESS);
664     ASSERT_NE(mCallPolicy.GetCallTransferInfoPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
665     ASSERT_EQ(mCallPolicy.GetCallTransferInfoPolicy(0), TELEPHONY_ERR_SUCCESS);
666     ASSERT_NE(mCallPolicy.SetCallTransferInfoPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
667     ASSERT_EQ(mCallPolicy.SetCallTransferInfoPolicy(0), TELEPHONY_ERR_SUCCESS);
668     ASSERT_NE(mCallPolicy.SetCallPreferenceModePolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
669     ASSERT_EQ(mCallPolicy.SetCallPreferenceModePolicy(0), TELEPHONY_ERR_SUCCESS);
670     ASSERT_NE(mCallPolicy.GetImsConfigPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
671     ASSERT_EQ(mCallPolicy.GetImsConfigPolicy(0), TELEPHONY_ERR_SUCCESS);
672     ASSERT_NE(mCallPolicy.SetImsConfigPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
673     ASSERT_EQ(mCallPolicy.SetImsConfigPolicy(0), TELEPHONY_ERR_SUCCESS);
674     ASSERT_NE(mCallPolicy.GetImsFeatureValuePolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
675     ASSERT_EQ(mCallPolicy.GetImsFeatureValuePolicy(0), TELEPHONY_ERR_SUCCESS);
676     ASSERT_NE(mCallPolicy.SetImsFeatureValuePolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
677     ASSERT_EQ(mCallPolicy.SetImsFeatureValuePolicy(0), TELEPHONY_ERR_SUCCESS);
678     std::vector<std::string> numberList = {};
679     ASSERT_NE(mCallPolicy.InviteToConferencePolicy(0, numberList), TELEPHONY_ERR_SUCCESS);
680 }
681 
682 /**
683  * @tc.number   Telephony_CallPolicy_003
684  * @tc.name     test error branch
685  * @tc.desc     Function test
686  */
687 HWTEST_F(ZeroBranch2Test, Telephony_CallPolicy_003, Function | MediumTest | Level1)
688 {
689     CallPolicy callPolicy;
690     AppExecFwk::PacMap videoExtras;
691     videoExtras.PutIntValue("videoState", static_cast<int>(VideoStateType::TYPE_VIDEO));
692     callPolicy.CanDialMulityCall(videoExtras, false);
693     AppExecFwk::PacMap voiceExtras;
694     voiceExtras.PutIntValue("videoState", static_cast<int>(VideoStateType::TYPE_VOICE));
695     callPolicy.CanDialMulityCall(voiceExtras, false);
696     DialParaInfo info;
697     sptr<CallBase> call = new CSCall(info);
698     call->SetCallType(CallType::TYPE_CS);
699     call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
700     callPolicy.AddOneCallObject(call);
701     callPolicy.IsVoiceCallValid(VideoStateType::TYPE_VIDEO);
702     callPolicy.IsVoiceCallValid(VideoStateType::TYPE_VOICE);
703     call->SetVideoStateType(VideoStateType::TYPE_VIDEO);
704     callPolicy.IsVoiceCallValid(VideoStateType::TYPE_VOICE);
705     call->SetCallType(CallType::TYPE_VOIP);
706     callPolicy.IsVoiceCallValid(VideoStateType::TYPE_VOICE);
707     call->SetVideoStateType(VideoStateType::TYPE_VOICE);
708     call->SetCallType(CallType::TYPE_CS);
709     callPolicy.IsVoiceCallValid(VideoStateType::TYPE_VOICE);
710     callPolicy.IsValidCallType(CallType::TYPE_CS);
711     callPolicy.IsValidCallType(CallType::TYPE_IMS);
712     callPolicy.IsValidCallType(CallType::TYPE_OTT);
713     callPolicy.IsValidCallType(CallType::TYPE_SATELLITE);
714     callPolicy.IsValidCallType(CallType::TYPE_VOIP);
715     callPolicy.CanDialMulityCall(videoExtras, false);
716     callPolicy.CanDialMulityCall(voiceExtras, false);
717     call->SetVideoStateType(VideoStateType::TYPE_VIDEO);
718     callPolicy.CanDialMulityCall(videoExtras, false);
719     callPolicy.CanDialMulityCall(voiceExtras, false);
720     call->SetCallId(VALID_CALLID);
721     call->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
722     callPolicy.RejectCallPolicy(VALID_CALLID);
723     callPolicy.AnswerCallPolicy(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VOICE));
724     callPolicy.AnswerCallPolicy(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
725     call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
726     callPolicy.RejectCallPolicy(VALID_CALLID);
727     callPolicy.AnswerCallPolicy(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VOICE));
728     callPolicy.AnswerCallPolicy(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
729     call->SetTelCallState(TelCallState::CALL_STATUS_WAITING);
730     callPolicy.RejectCallPolicy(VALID_CALLID);
731     callPolicy.AnswerCallPolicy(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VOICE));
732     callPolicy.AnswerCallPolicy(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
733     ASSERT_GE(callPolicy.RejectCallPolicy(VALID_CALLID), TELEPHONY_ERR_SUCCESS);
734 }
735 
736 /**
737  * @tc.number   Telephony_CallPolicy_004
738  * @tc.name     test error branch
739  * @tc.desc     Function test
740  */
741 HWTEST_F(ZeroBranch2Test, Telephony_CallPolicy_004, Function | MediumTest | Level1)
742 {
743     CallPolicy callPolicy;
744     DialParaInfo info;
745     sptr<CallBase> call = new CSCall(info);
746     call->SetCallType(CallType::TYPE_CS);
747     call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
748     call->SetCallId(VALID_CALLID);
749     callPolicy.AddOneCallObject(call);
750     callPolicy.HoldCallPolicy(VALID_CALLID);
751     callPolicy.UnHoldCallPolicy(VALID_CALLID);
752     call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_HOLD);
753     callPolicy.HoldCallPolicy(VALID_CALLID);
754     callPolicy.UnHoldCallPolicy(VALID_CALLID);
755     call->SetTelCallState(TelCallState::CALL_STATUS_IDLE);
756     callPolicy.HangUpPolicy(VALID_CALLID);
757     call->SetTelCallState(TelCallState::CALL_STATUS_DISCONNECTING);
758     callPolicy.HangUpPolicy(VALID_CALLID);
759     call->SetTelCallState(TelCallState::CALL_STATUS_DISCONNECTED);
760     callPolicy.HangUpPolicy(VALID_CALLID);
761     callPolicy.SwitchCallPolicy(VALID_CALLID);
762     sptr<CallBase> imsCall = new IMSCall(info);
763     imsCall->SetCallType(CallType::TYPE_IMS);
764     imsCall->SetCallId(2);
765     callPolicy.AddOneCallObject(imsCall);
766     imsCall->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
767     ASSERT_EQ(callPolicy.SwitchCallPolicy(VALID_CALLID), CALL_ERR_ILLEGAL_CALL_OPERATION);
768     imsCall->SetTelCallState(TelCallState::CALL_STATUS_ALERTING);
769     ASSERT_EQ(callPolicy.SwitchCallPolicy(VALID_CALLID), CALL_ERR_ILLEGAL_CALL_OPERATION);
770     call->SetTelCallState(TelCallState::CALL_STATUS_HOLDING);
771     ASSERT_EQ(callPolicy.SwitchCallPolicy(VALID_CALLID), CALL_ERR_ILLEGAL_CALL_OPERATION);
772     imsCall->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
773     ASSERT_EQ(callPolicy.SwitchCallPolicy(VALID_CALLID), TELEPHONY_ERR_SUCCESS);
774     callPolicy.VideoCallPolicy(VALID_CALLID);
775     callPolicy.StartRttPolicy(VALID_CALLID);
776     callPolicy.StartRttPolicy(2);
777     callPolicy.StopRttPolicy(VALID_CALLID);
778     callPolicy.StopRttPolicy(2);
779     call->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
780     callPolicy.StartRttPolicy(VALID_CALLID);
781     callPolicy.StopRttPolicy(VALID_CALLID);
782     std::vector<std::string> numberList;
783     callPolicy.InviteToConferencePolicy(VALID_CALLID, numberList);
784     numberList.push_back("");
785     numberList.push_back("123");
786     numberList.push_back(
787         "19119080646435437102938190283912471651865851478647016881846814376871464810514786470168818468143768714648");
788     ASSERT_GE(callPolicy.InviteToConferencePolicy(VALID_CALLID, numberList), TELEPHONY_ERR_SUCCESS);
789 }
790 
791 /**
792  * @tc.number   Telephony_CallPolicy_005
793  * @tc.name     test error branch
794  * @tc.desc     Function test
795  */
796 HWTEST_F(ZeroBranch2Test, Telephony_CallPolicy_005, Function | MediumTest | Level1)
797 {
798     CallPolicy callPolicy;
799     ASSERT_EQ(callPolicy.IsValidSlotId(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
800     ASSERT_EQ(callPolicy.EnableVoLtePolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
801     ASSERT_EQ(callPolicy.DisableVoLtePolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
802     ASSERT_EQ(callPolicy.IsVoLteEnabledPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
803     ASSERT_EQ(callPolicy.VoNRStatePolicy(INVALID_SLOTID, -1), CALL_ERR_INVALID_SLOT_ID);
804     ASSERT_EQ(callPolicy.GetCallWaitingPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
805     ASSERT_EQ(callPolicy.SetCallWaitingPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
806     ASSERT_EQ(callPolicy.GetCallRestrictionPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
807     ASSERT_EQ(callPolicy.SetCallRestrictionPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
808     ASSERT_EQ(callPolicy.GetCallTransferInfoPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
809     ASSERT_EQ(callPolicy.SetCallTransferInfoPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
810     ASSERT_EQ(callPolicy.SetCallPreferenceModePolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
811     ASSERT_EQ(callPolicy.GetImsConfigPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
812     ASSERT_EQ(callPolicy.SetImsConfigPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
813     ASSERT_EQ(callPolicy.GetImsFeatureValuePolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
814     ASSERT_EQ(callPolicy.SetImsFeatureValuePolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
815     ASSERT_EQ(callPolicy.CloseUnFinishedUssdPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
816 }
817 
818 /**
819  * @tc.number   Telephony_CallPolicy_006
820  * @tc.name     test error branch
821  * @tc.desc     Function test
822  */
823 HWTEST_F(ZeroBranch2Test, Telephony_CallPolicy_006, Function | MediumTest | Level1)
824 {
825     CallPolicy callPolicy;
826     bool isEcc = false;
827     int32_t slotId = 0;
828     callPolicy.HasNormalCall(isEcc, slotId, CallType::TYPE_IMS);
829     bool isAirplaneModeOn = false;
830     callPolicy.GetAirplaneMode(isAirplaneModeOn);
831     ASSERT_EQ(isAirplaneModeOn, false);
832 }
833 
834 /**
835  * @tc.number   Telephony_ReportCallInfoHandler_001
836  * @tc.name     test error branch
837  * @tc.desc     Function test
838  */
839 HWTEST_F(ZeroBranch2Test, Telephony_ReportCallInfoHandler_001, Function | MediumTest | Level1)
840 {
841     CallDetailInfo mCallDetailInfo;
842     DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateCallReportInfo(mCallDetailInfo);
843     CallDetailsInfo mCallDetailsInfo;
844     ASSERT_NE(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateCallsReportInfo(mCallDetailsInfo),
845         TELEPHONY_ERR_SUCCESS);
846     DisconnectedDetails mDisconnectedDetails;
847     ASSERT_NE(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateDisconnectedCause(mDisconnectedDetails),
848         TELEPHONY_ERR_SUCCESS);
849     CellularCallEventInfo mCellularCallEventInfo;
850     ASSERT_NE(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateEventResultInfo(mCellularCallEventInfo),
851         TELEPHONY_ERR_SUCCESS);
852     OttCallEventInfo mOttCallEventInfo;
853     ASSERT_NE(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateOttEventInfo(mOttCallEventInfo),
854         TELEPHONY_ERR_SUCCESS);
855     DelayedSingleton<ReportCallInfoHandler>::GetInstance()->Init();
856     ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateCallReportInfo(mCallDetailInfo),
857         TELEPHONY_ERR_SUCCESS);
858     ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateCallsReportInfo(mCallDetailsInfo),
859         TELEPHONY_ERR_SUCCESS);
860     ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateDisconnectedCause(mDisconnectedDetails),
861         TELEPHONY_ERR_SUCCESS);
862     ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateEventResultInfo(mCellularCallEventInfo),
863         TELEPHONY_ERR_SUCCESS);
864     ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateOttEventInfo(mOttCallEventInfo),
865         TELEPHONY_ERR_SUCCESS);
866     CallModeReportInfo mCallModeRequestInfo;
867     ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->ReceiveImsCallModeRequest(mCallModeRequestInfo),
868         TELEPHONY_ERR_SUCCESS);
869     CallModeReportInfo mCallModeResponseInfo;
870     ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->ReceiveImsCallModeResponse(mCallModeResponseInfo),
871         TELEPHONY_ERR_SUCCESS);
872 }
873 
874 /**
875  * @tc.number   Telephony_VideoControlManager_001
876  * @tc.name     test error branch
877  * @tc.desc     Function test
878  */
879 HWTEST_F(ZeroBranch2Test, Telephony_VideoControlManager_001, Function | MediumTest | Level1)
880 {
881     std::u16string testEmptyStr = u"";
882     std::u16string testStr = u"123";
883     std::string testEmptyStr_ = "";
884     std::string testStr_ = "123";
885     int32_t callId = 1;
886     uint64_t tempSurfaceId = std::stoull(testStr_);
887     auto surface = SurfaceUtils::GetInstance()->GetSurface(tempSurfaceId);
888     if (surface == nullptr) {
889         testStr_ = "";
890     }
891     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->ControlCamera(callId, testEmptyStr, 1, 1),
892         TELEPHONY_ERR_SUCCESS);
893     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->ControlCamera(callId, testStr, 1, 1),
894         TELEPHONY_ERR_SUCCESS);
895     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetPreviewWindow(callId, testEmptyStr_, nullptr),
896         TELEPHONY_ERR_SUCCESS);
897     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetPreviewWindow(callId, testStr_, surface),
898         TELEPHONY_ERR_SUCCESS);
899     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDisplayWindow(callId, testEmptyStr_, nullptr),
900         TELEPHONY_ERR_SUCCESS);
901     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDisplayWindow(callId, testStr_, surface),
902         TELEPHONY_ERR_SUCCESS);
903     float zoomRatio = 11;
904     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetCameraZoom(zoomRatio), TELEPHONY_ERR_SUCCESS);
905     zoomRatio = 0.01;
906     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetCameraZoom(zoomRatio), TELEPHONY_ERR_SUCCESS);
907     zoomRatio = 1;
908     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetCameraZoom(zoomRatio), TELEPHONY_ERR_SUCCESS);
909     ASSERT_NE(
910         DelayedSingleton<VideoControlManager>::GetInstance()->SetPausePicture(callId, testStr), TELEPHONY_ERR_SUCCESS);
911     int32_t rotation = CAMERA_ROTATION_0;
912     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDeviceDirection(callId, rotation),
913         TELEPHONY_ERR_SUCCESS);
914     rotation = CAMERA_ROTATION_90;
915     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDeviceDirection(callId, rotation),
916         TELEPHONY_ERR_SUCCESS);
917     rotation = CAMERA_ROTATION_180;
918     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDeviceDirection(callId, rotation),
919         TELEPHONY_ERR_SUCCESS);
920     rotation = CAMERA_ROTATION_270;
921     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDeviceDirection(callId, rotation),
922         TELEPHONY_ERR_SUCCESS);
923     rotation = 1;
924     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDeviceDirection(callId, rotation),
925         TELEPHONY_ERR_SUCCESS);
926     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->CancelCallUpgrade(callId), TELEPHONY_ERR_SUCCESS);
927     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->RequestCameraCapabilities(callId),
928         TELEPHONY_ERR_SUCCESS);
929 }
930 
931 /**
932  * @tc.number   Telephony_VideoControlManager_002
933  * @tc.name     test error branch
934  * @tc.desc     Function test
935  */
936 HWTEST_F(ZeroBranch2Test, Telephony_VideoControlManager_002, Function | MediumTest | Level1)
937 {
938     int32_t callId = 1;
939     std::u16string testStr = u"123";
940     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->OpenCamera(callId, testStr, 0, 0),
941         TELEPHONY_ERR_SUCCESS);
942     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->CloseCamera(callId, testStr, 0, 0),
943         TELEPHONY_ERR_SUCCESS);
944     ImsCallMode mode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
945     CallMediaModeInfo imsCallModeInfo;
946     ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->ReportImsCallModeInfo(imsCallModeInfo),
947         TELEPHONY_ERR_SUCCESS);
948     ASSERT_NE(
949         DelayedSingleton<VideoControlManager>::GetInstance()->UpdateImsCallMode(callId, mode), TELEPHONY_ERR_SUCCESS);
950     ASSERT_FALSE(DelayedSingleton<VideoControlManager>::GetInstance()->ContainCameraID(""));
951     ASSERT_FALSE(DelayedSingleton<VideoControlManager>::GetInstance()->IsPngFile(""));
952     VideoWindow mVideoWindow;
953     mVideoWindow.width = -1;
954     mVideoWindow.height = 1;
955     ASSERT_FALSE(DelayedSingleton<VideoControlManager>::GetInstance()->CheckWindow(mVideoWindow));
956     mVideoWindow.width = 1;
957     mVideoWindow.height = -1;
958     ASSERT_FALSE(DelayedSingleton<VideoControlManager>::GetInstance()->CheckWindow(mVideoWindow));
959     mVideoWindow.width = -1;
960     mVideoWindow.height = -1;
961     ASSERT_FALSE(DelayedSingleton<VideoControlManager>::GetInstance()->CheckWindow(mVideoWindow));
962     mVideoWindow.width = 1;
963     mVideoWindow.height = 1;
964     mVideoWindow.z = 2;
965     ASSERT_FALSE(DelayedSingleton<VideoControlManager>::GetInstance()->CheckWindow(mVideoWindow));
966     mVideoWindow.z = 0;
967     ASSERT_TRUE(DelayedSingleton<VideoControlManager>::GetInstance()->CheckWindow(mVideoWindow));
968     mVideoWindow.z = 1;
969     ASSERT_TRUE(DelayedSingleton<VideoControlManager>::GetInstance()->CheckWindow(mVideoWindow));
970 }
971 } // namespace Telephony
972 } // namespace OHOS
973