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 ZeroBranch4Test : public testing::Test {
112 public:
113     void SetUp();
114     void TearDown();
115     static void SetUpTestCase();
116     static void TearDownTestCase();
117 };
118 
SetUp()119 void ZeroBranch4Test::SetUp() {}
120 
TearDown()121 void ZeroBranch4Test::TearDown() {}
122 
SetUpTestCase()123 void ZeroBranch4Test::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 = "ZeroBranch4Test",
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 ZeroBranch4Test::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_Ott_Conference_001
164  * @tc.name     test error branch
165  * @tc.desc     Function test
166  */
167 HWTEST_F(ZeroBranch4Test, Telephony_Ott_Conference_001, Function | MediumTest | Level3)
168 {
169     OttConference ottConference;
170     ottConference.state_ = CONFERENCE_STATE_IDLE;
171     ASSERT_EQ(ottConference.JoinToConference(1), CALL_ERR_ILLEGAL_CALL_OPERATION);
172     ottConference.state_ = CONFERENCE_STATE_CREATING;
173     ASSERT_EQ(ottConference.JoinToConference(1), TELEPHONY_SUCCESS);
174     for (uint16_t i = 0; i <= CS_CONFERENCE_MAX_CALLS_CNT + 1; ++i) {
175         ottConference.subCallIdSet_.insert(i);
176     }
177     ASSERT_EQ(ottConference.CanCombineConference(), CALL_ERR_CONFERENCE_CALL_EXCEED_LIMIT);
178     ottConference.subCallIdSet_.clear();
179     ottConference.subCallIdSet_.insert(1);
180     ASSERT_EQ(ottConference.LeaveFromConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
181     ASSERT_EQ(ottConference.LeaveFromConference(1), TELEPHONY_SUCCESS);
182     ottConference.subCallIdSet_.clear();
183     ottConference.subCallIdSet_.insert(1);
184     ASSERT_EQ(ottConference.HoldConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
185     ottConference.state_ = CONFERENCE_STATE_HOLDING;
186     ASSERT_EQ(ottConference.HoldConference(-1), TELEPHONY_SUCCESS);
187     ASSERT_EQ(ottConference.HoldConference(1), TELEPHONY_SUCCESS);
188     ASSERT_EQ(ottConference.CanCombineConference(), TELEPHONY_SUCCESS);
189     ottConference.subCallIdSet_.insert(1);
190     ottConference.state_ = CONFERENCE_STATE_ACTIVE;
191     ASSERT_EQ(ottConference.CanSeparateConference(), TELEPHONY_SUCCESS);
192     ASSERT_EQ(ottConference.CanKickOutFromConference(), TELEPHONY_SUCCESS);
193     ottConference.subCallIdSet_.clear();
194     ASSERT_EQ(ottConference.CanSeparateConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
195     ASSERT_EQ(ottConference.CanKickOutFromConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
196 }
197 
198 /**
199  * @tc.number   Telephony_Cs_Conference_001
200  * @tc.name     test error branch
201  * @tc.desc     Function test
202  */
203 HWTEST_F(ZeroBranch4Test, Telephony_Cs_Conference_001, Function | MediumTest | Level3)
204 {
205     CsConference csConference;
206     csConference.state_ = CONFERENCE_STATE_IDLE;
207     ASSERT_EQ(csConference.JoinToConference(1), CALL_ERR_ILLEGAL_CALL_OPERATION);
208     csConference.state_ = CONFERENCE_STATE_CREATING;
209     ASSERT_EQ(csConference.JoinToConference(1), TELEPHONY_SUCCESS);
210     for (uint16_t i = 0; i <= CS_CONFERENCE_MAX_CALLS_CNT + 1; ++i) {
211         csConference.subCallIdSet_.insert(i);
212     }
213     ASSERT_EQ(csConference.CanCombineConference(), CALL_ERR_CONFERENCE_CALL_EXCEED_LIMIT);
214     csConference.subCallIdSet_.clear();
215     csConference.subCallIdSet_.insert(1);
216     ASSERT_EQ(csConference.LeaveFromConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
217     ASSERT_EQ(csConference.LeaveFromConference(1), TELEPHONY_SUCCESS);
218     csConference.subCallIdSet_.clear();
219     csConference.subCallIdSet_.insert(1);
220     ASSERT_EQ(csConference.HoldConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
221     csConference.state_ = CONFERENCE_STATE_HOLDING;
222     ASSERT_EQ(csConference.HoldConference(-1), TELEPHONY_SUCCESS);
223     ASSERT_EQ(csConference.HoldConference(1), TELEPHONY_SUCCESS);
224     ASSERT_EQ(csConference.CanCombineConference(), TELEPHONY_SUCCESS);
225     csConference.subCallIdSet_.insert(1);
226     csConference.state_ = CONFERENCE_STATE_ACTIVE;
227     ASSERT_EQ(csConference.CanSeparateConference(), TELEPHONY_SUCCESS);
228     ASSERT_EQ(csConference.CanKickOutFromConference(), TELEPHONY_SUCCESS);
229     csConference.subCallIdSet_.clear();
230     ASSERT_EQ(csConference.CanSeparateConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
231     ASSERT_EQ(csConference.CanKickOutFromConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
232 }
233 
234 /**
235  * @tc.number   Telephony_Ims_Conference_001
236  * @tc.name     test error branch
237  * @tc.desc     Function test
238  */
239 HWTEST_F(ZeroBranch4Test, Telephony_Ims_Conference_001, Function | MediumTest | Level3)
240 {
241     ImsConference imsConference;
242     imsConference.state_ = CONFERENCE_STATE_IDLE;
243     ASSERT_EQ(imsConference.JoinToConference(1), CALL_ERR_ILLEGAL_CALL_OPERATION);
244     imsConference.state_ = CONFERENCE_STATE_CREATING;
245     ASSERT_EQ(imsConference.JoinToConference(1), TELEPHONY_SUCCESS);
246     for (uint16_t i = 0; i <= CS_CONFERENCE_MAX_CALLS_CNT + 1; ++i) {
247         imsConference.subCallIdSet_.insert(i);
248     }
249     ASSERT_EQ(imsConference.CanCombineConference(), CALL_ERR_CONFERENCE_CALL_EXCEED_LIMIT);
250     imsConference.subCallIdSet_.clear();
251     imsConference.subCallIdSet_.insert(1);
252     ASSERT_EQ(imsConference.LeaveFromConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
253     ASSERT_EQ(imsConference.LeaveFromConference(1), TELEPHONY_SUCCESS);
254     imsConference.subCallIdSet_.clear();
255     imsConference.subCallIdSet_.insert(1);
256     ASSERT_EQ(imsConference.HoldConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
257     imsConference.state_ = CONFERENCE_STATE_HOLDING;
258     ASSERT_EQ(imsConference.HoldConference(-1), TELEPHONY_SUCCESS);
259     ASSERT_EQ(imsConference.HoldConference(1), TELEPHONY_SUCCESS);
260     ASSERT_EQ(imsConference.CanCombineConference(), TELEPHONY_SUCCESS);
261     imsConference.subCallIdSet_.insert(1);
262     imsConference.state_ = CONFERENCE_STATE_ACTIVE;
263     ASSERT_EQ(imsConference.CanSeparateConference(), TELEPHONY_SUCCESS);
264     ASSERT_EQ(imsConference.CanKickOutFromConference(), TELEPHONY_SUCCESS);
265     imsConference.subCallIdSet_.clear();
266     ASSERT_EQ(imsConference.CanSeparateConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
267     ASSERT_EQ(imsConference.CanKickOutFromConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
268 }
269 
270 /**
271  * @tc.number   Telephony_BluetoothCallService_001
272  * @tc.name     test error branch
273  * @tc.desc     Function test
274  */
275 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallService_001, Function | MediumTest | Level3)
276 {
277     BluetoothCallService bluetoothCallService;
278     ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.AnswerCall());
279     DialParaInfo dialParaInfo;
280     sptr<OHOS::Telephony::CallBase> callBase1 = new OTTCall(dialParaInfo);
281     bluetoothCallService.callObjectPtrList_.clear();
282     callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
283     callBase1->callId_ = -1;
284     bluetoothCallService.callObjectPtrList_.push_back(callBase1);
285     bluetoothCallService.AnswerCall();
286     bluetoothCallService.callControlManagerPtr_ = nullptr;
287     ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.AnswerCall());
288     ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.RejectCall());
289     ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.HangUpCall());
290     ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.HoldCall());
291     ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.UnHoldCall());
292     ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.SwitchCall());
293     bluetoothCallService.StartDtmf('c');
294     bluetoothCallService.callObjectPtrList_.clear();
295     callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
296     callBase1->callId_ = -1;
297     bluetoothCallService.callObjectPtrList_.push_back(callBase1);
298     ASSERT_NE(TELEPHONY_ERR_LOCAL_PTR_NULL, bluetoothCallService.StartDtmf('c'));
299     ASSERT_NE(TELEPHONY_ERR_LOCAL_PTR_NULL, bluetoothCallService.StopDtmf());
300     ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.CombineConference());
301     bluetoothCallService.callObjectPtrList_.clear();
302     callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
303     callBase1->callId_ = -1;
304     bluetoothCallService.callObjectPtrList_.push_back(callBase1);
305     ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.CombineConference());
306     ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.SeparateConference());
307     ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.KickOutFromConference());
308 }
309 
310 /**
311  * @tc.number   Telephony_BluetoothCallService_002
312  * @tc.name     test error branch
313  * @tc.desc     Function test
314  */
315 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallService_002, Function | MediumTest | Level3)
316 {
317     BluetoothCallService bluetoothCallService;
318     ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.AnswerCall());
319     DialParaInfo dialParaInfo;
320     sptr<OHOS::Telephony::CallBase> callBase1 = new OTTCall(dialParaInfo);
321     bluetoothCallService.callObjectPtrList_.clear();
322     callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
323     callBase1->callId_ = -1;
324     bluetoothCallService.callObjectPtrList_.push_back(callBase1);
325     bluetoothCallService.GetCurrentCallList(-1).size();
326     ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.CombineConference());
327     ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.SeparateConference());
328     ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.KickOutFromConference());
329 }
330 
331 /**
332  * @tc.number   Telephony_BluetoothCallStub_001
333  * @tc.name     test error nullptr branch
334  * @tc.desc     Function test
335  */
336 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallStub_001, Function | MediumTest | Level3)
337 {
338     auto bluetoothCallService = std::make_shared<BluetoothCallService>();
339     MessageParcel data1;
340     MessageParcel reply;
341     MessageOption option;
342     bluetoothCallService->OnRemoteRequest(static_cast<uint32_t>(
343         CallManagerCallAbilityInterfaceCode::UPDATE_CALL_STATE_INFO), data1, reply, option);
344     const uint8_t data = 1;
345     MessageParcel dataParcel;
346     dataParcel.WriteBuffer(&data, 1);
347     dataParcel.RewindRead(0);
348     int32_t result = bluetoothCallService->OnAnswerCall(dataParcel, reply);
349     ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
350     result = bluetoothCallService->OnRejectCall(dataParcel, reply);
351     ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
352     bluetoothCallService->OnHangUpCall(dataParcel, reply);
353     result = bluetoothCallService->OnGetBtCallState(dataParcel, reply);
354     ASSERT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
355     result = bluetoothCallService->OnHoldCall(dataParcel, reply);
356     ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
357     result = bluetoothCallService->OnUnHoldCall(dataParcel, reply);
358     ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
359     result = bluetoothCallService->OnSwitchCall(dataParcel, reply);
360     ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
361     result = bluetoothCallService->OnCombineConference(dataParcel, reply);
362     ASSERT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
363     result = bluetoothCallService->OnSeparateConference(dataParcel, reply);
364     ASSERT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
365     result = bluetoothCallService->OnKickOutFromConference(dataParcel, reply);
366     ASSERT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
367     result = bluetoothCallService->OnStartDtmf(dataParcel, reply);
368     ASSERT_EQ(result, TELEPHONY_SUCCESS);
369     result = bluetoothCallService->OnStopDtmf(dataParcel, reply);
370     ASSERT_EQ(result, TELEPHONY_SUCCESS);
371     result = bluetoothCallService->OnGetCurrentCallList(dataParcel, reply);
372     ASSERT_EQ(result, TELEPHONY_SUCCESS);
373 }
374 
375 /**
376  * @tc.number   Telephony_BluetoothConnection_001
377  * @tc.name     test error nullptr branch
378  * @tc.desc     Function test
379  */
380 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothConnection_001, Function | MediumTest | Level3)
381 {
382     auto bluetoothConnection = std::make_shared<BluetoothConnection>();
383     bluetoothConnection->IsAudioActivated();
384 #ifdef ABILITY_BLUETOOTH_SUPPORT
385     bluetoothConnection->ResetBtConnection();
386     bluetoothConnection->RegisterObserver();
387     std::string address = "123";
388     bluetoothConnection->RemoveBtDevice(address);
389     Bluetooth::BluetoothRemoteDevice device;
390     int32_t state = static_cast<int32_t>(Bluetooth::BTConnectState::CONNECTED);
391     int32_t cause = 1;
392     bluetoothConnection->OnConnectionStateChanged(device, state, cause);
393     state = static_cast<int32_t>(Bluetooth::BTConnectState::DISCONNECTED);
394     bluetoothConnection->OnConnectionStateChanged(device, state, cause);
395     EXPECT_FALSE(bluetoothConnection->IsAudioActivated());
396 #endif
397 }
398 
GetTestNumber()399 std::string GetTestNumber()
400 {
401     std::string number =
402         "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456";
403     number += number;
404     return number;
405 }
406 
407 /**
408  * @tc.number   Telephony_BluetoothCallPolicy_001
409  * @tc.name     test error branch
410  * @tc.desc     Function test
411  */
412 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallPolicy_001, Function | MediumTest | Level3)
413 {
414     BluetoothCallPolicy callPolicy;
415     DialParaInfo dialParaInfo;
416     sptr<OHOS::Telephony::CallBase> callBase1 = new OTTCall(dialParaInfo);
417     callBase1->callId_ = 0;
418     callPolicy.callObjectPtrList_.push_back(callBase1);
419     callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
420     int32_t policy = 0;
421     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.AnswerCallPolicy(policy));
422     callBase1->callState_ = TelCallState::CALL_STATUS_WAITING;
423     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.AnswerCallPolicy(policy));
424     callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
425     ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.AnswerCallPolicy(policy));
426     callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
427     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.RejectCallPolicy(policy));
428     callBase1->callState_ = TelCallState::CALL_STATUS_WAITING;
429     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.RejectCallPolicy(policy));
430     callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
431     ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.RejectCallPolicy(policy));
432     callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
433     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HoldCallPolicy(policy));
434     callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
435     ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.HoldCallPolicy(policy));
436     callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
437     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.UnHoldCallPolicy(policy));
438     callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
439     ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.UnHoldCallPolicy(policy));
440     callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
441     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
442     callBase1->callState_ = TelCallState::CALL_STATUS_WAITING;
443     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
444     callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
445     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
446     callBase1->callState_ = TelCallState::CALL_STATUS_ALERTING;
447     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
448     callBase1->callState_ = TelCallState::CALL_STATUS_DIALING;
449     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
450     callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
451     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
452     callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
453     ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
454     callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
455     ASSERT_EQ(CALL_ERR_ILLEGAL_CALL_OPERATION, callPolicy.SwitchCallPolicy(policy));
456     callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
457     ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.SwitchCallPolicy(policy));
458 }
459 
460 /**
461  * @tc.number   Telephony_BluetoothCallPolicy_002
462  * @tc.name     test error branch
463  * @tc.desc     Function test
464  */
465 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallPolicy_002, Function | MediumTest | Level3)
466 {
467     BluetoothCallPolicy callPolicy;
468     DialParaInfo dialParaInfo;
469     sptr<OHOS::Telephony::CallBase> callBase1 = new OTTCall(dialParaInfo);
470     callBase1->callId_ = 0;
471     callPolicy.callObjectPtrList_.push_back(callBase1);
472     int32_t policy = 0;
473     callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
474     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
475     callBase1->callState_ = TelCallState::CALL_STATUS_ALERTING;
476     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
477     callBase1->callState_ = TelCallState::CALL_STATUS_DIALING;
478     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
479     callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
480     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
481     callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
482     ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
483     callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
484     ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.CombineConferencePolicy(policy));
485     callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
486     ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.CombineConferencePolicy(policy));
487     callBase1->conferenceState_ = TelConferenceState::TEL_CONFERENCE_ACTIVE;
488     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.SeparateConferencePolicy(policy));
489     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.KickOutFromConferencePolicy(policy));
490     callBase1->conferenceState_ = TelConferenceState::TEL_CONFERENCE_HOLDING;
491     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.SeparateConferencePolicy(policy));
492     ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.KickOutFromConferencePolicy(policy));
493     callBase1->conferenceState_ = TelConferenceState::TEL_CONFERENCE_IDLE;
494     ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.SeparateConferencePolicy(policy));
495     ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.KickOutFromConferencePolicy(policy));
496 }
497 
498 /**
499  * @tc.number   Telephony_ImsCall_002
500  * @tc.name     test error branch
501  * @tc.desc     Function test
502  */
503 HWTEST_F(ZeroBranch4Test, Telephony_ImsCall_002, Function | MediumTest | Level3)
504 {
505     DialParaInfo dialParaInfo;
506     IMSCall call { dialParaInfo };
507     call.isInitialized_ = true;
508     ImsCallMode mode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
509     call.UpdateImsCallMode(mode);
510     call.SendUpdateCallMediaModeRequest(mode);
511     CallModeReportInfo callModeRequestInfo;
512     call.RecieveUpdateCallMediaModeRequest(callModeRequestInfo);
513     call.SendUpdateCallMediaModeResponse(mode);
514     CallModeReportInfo callModeResponseInfo;
515     call.ReceiveUpdateCallMediaModeResponse(callModeResponseInfo);
516     CallMediaModeInfo callMediaModeInfo;
517     call.ReportImsCallModeInfo(callMediaModeInfo);
518     call.SwitchVideoState(mode);
519     call.IsSupportVideoCall();
520     call.GetCallVideoState(mode);
521     std::string value = "123";
522     call.ControlCamera(value, 1, 1);
523     call.SetPausePicture(value);
524     uint64_t tempSurfaceId = std::stoull(value);
525     auto surface = SurfaceUtils::GetInstance()->GetSurface(tempSurfaceId);
526     if (surface == nullptr) {
527         value = "";
528     }
529     call.SetPreviewWindow(value, surface);
530     call.SetDisplayWindow(value, surface);
531     call.SetDeviceDirection(1);
532     call.CancelCallUpgrade();
533     call.RequestCameraCapabilities();
534     call.videoCallState_ = nullptr;
535     ASSERT_NE(TELEPHONY_ERR_LOCAL_PTR_NULL, call.UpdateImsCallMode(mode));
536     ASSERT_EQ(TELEPHONY_ERR_LOCAL_PTR_NULL, call.RecieveUpdateCallMediaModeRequest(callModeRequestInfo));
537     ASSERT_EQ(TELEPHONY_ERR_LOCAL_PTR_NULL, call.ReceiveUpdateCallMediaModeResponse(callModeResponseInfo));
538 }
539 
540 /**
541  * @tc.number   Telephony_CSCall_001
542  * @tc.name     test error branch
543  * @tc.desc     Function test
544  */
545 HWTEST_F(ZeroBranch4Test, Telephony_CSCall_001, Function | MediumTest | Level3)
546 {
547     DialParaInfo dialParaInfo;
548     CSCall call { dialParaInfo };
549     call.AnswerCall(0);
550     call.RejectCall();
551     call.HoldCall();
552     call.SwitchCall();
553     call.SetMute(0, 0);
554     call.CombineConference();
555     call.SeparateConference();
556     call.KickOutFromConference();
557     call.CanCombineConference();
558     call.CanSeparateConference();
559     call.LaunchConference();
560     call.HoldConference();
561     int32_t mainCallId = 1;
562     ASSERT_EQ(TELEPHONY_SUCCESS, call.GetMainCallId(mainCallId));
563     call.HandleCombineConferenceFailEvent();
564 }
565 
566 /**
567  * @tc.number   Telephony_CallRecordsManager_001
568  * @tc.name     test error branch
569  * @tc.desc     Function test
570  */
571 HWTEST_F(ZeroBranch4Test, Telephony_CallRecordsManager_001, Function | MediumTest | Level3)
572 {
573     CallRecordsManager callRecordsManager;
574     callRecordsManager.Init();
575 
576     sptr<CallBase> callObjectPtr = nullptr;
577     TelCallState priorState = TelCallState::CALL_STATUS_HOLDING;
578     TelCallState nextState = TelCallState::CALL_STATUS_HOLDING;
579     callRecordsManager.CallStateUpdated(callObjectPtr, priorState, nextState);
580     nextState = TelCallState::CALL_STATUS_DISCONNECTED;
581     callRecordsManager.CallStateUpdated(callObjectPtr, priorState, nextState);
582     DialParaInfo dialParaInfo;
583     callObjectPtr = new CSCall(dialParaInfo);
584     ASSERT_TRUE(callObjectPtr != nullptr);
585     callRecordsManager.CallStateUpdated(callObjectPtr, priorState, nextState);
586     CallAttributeInfo info;
587     info.callBeginTime = DEFAULT_TIME;
588     info.callEndTime = ONE_TIME;
589     callRecordsManager.AddOneCallRecord(info);
590     info.callBeginTime = ONE_TIME;
591     info.callEndTime = DEFAULT_TIME;
592     callRecordsManager.AddOneCallRecord(info);
593     info.callBeginTime = DEFAULT_TIME;
594     info.callEndTime = DEFAULT_TIME;
595     callRecordsManager.AddOneCallRecord(info);
596     info.callBeginTime = ONE_TIME;
597     info.callEndTime = ONE_TIME;
598     callRecordsManager.AddOneCallRecord(info);
599     info.ringBeginTime = DEFAULT_TIME;
600     info.ringEndTime = ONE_TIME;
601     callRecordsManager.AddOneCallRecord(info);
602     info.ringBeginTime = ONE_TIME;
603     info.ringEndTime = DEFAULT_TIME;
604     callRecordsManager.AddOneCallRecord(info);
605     info.ringBeginTime = DEFAULT_TIME;
606     info.ringEndTime = DEFAULT_TIME;
607     callRecordsManager.AddOneCallRecord(info);
608     info.ringBeginTime = ONE_TIME;
609     info.ringEndTime = ONE_TIME;
610     callRecordsManager.AddOneCallRecord(info);
611     callRecordsManager.RemoveMissedIncomingCallNotification();
612     int32_t videoState = static_cast<int32_t>(VideoStateType::TYPE_VIDEO);
613     callRecordsManager.GetCallFeatures(videoState);
614 }
615 
616 /**
617  * @tc.number   Telephony_CallControlManager_001
618  * @tc.name     test error branch
619  * @tc.desc     Function test
620  */
621 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_001, Function | MediumTest | Level3)
622 {
623     std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
624     int32_t videoState = 0;
625     ASSERT_NE(callControlManager->AnswerCall(INVALID_CALLID, videoState), TELEPHONY_SUCCESS);
626     videoState = 2;
627     ASSERT_NE(callControlManager->AnswerCall(VALID_CALLID, videoState), TELEPHONY_SUCCESS);
628     ASSERT_NE(callControlManager->RejectCall(VALID_CALLID, false, u""), TELEPHONY_SUCCESS);
629     ASSERT_NE(callControlManager->HangUpCall(VALID_CALLID), TELEPHONY_SUCCESS);
630     ASSERT_NE(callControlManager->HangUpCall(INVALID_CALLID), TELEPHONY_SUCCESS);
631     ASSERT_EQ(callControlManager->GetCallState(), TELEPHONY_SUCCESS);
632     ASSERT_NE(callControlManager->HoldCall(INVALID_CALLID), TELEPHONY_SUCCESS);
633     ASSERT_NE(callControlManager->UnHoldCall(INVALID_CALLID), TELEPHONY_SUCCESS);
634     ASSERT_NE(callControlManager->SwitchCall(INVALID_CALLID), TELEPHONY_SUCCESS);
635     ASSERT_FALSE(callControlManager->HasCall());
636     sptr<CallBase> callObjectPtr = nullptr;
637     TelCallState priorState = TelCallState::CALL_STATUS_HOLDING;
638     TelCallState nextState = TelCallState::CALL_STATUS_HOLDING;
639     ASSERT_FALSE(callControlManager->NotifyNewCallCreated(callObjectPtr));
640     callObjectPtr = nullptr;
641     ASSERT_EQ(TELEPHONY_ERR_LOCAL_PTR_NULL, callControlManager->AddCallLogAndNotification(callObjectPtr));
642     callObjectPtr = nullptr;
643     ASSERT_FALSE(callControlManager->NotifyCallStateUpdated(callObjectPtr, priorState, nextState));
644     DisconnectedDetails details;
645     ASSERT_FALSE(callControlManager->NotifyCallDestroyed(details));
646     ASSERT_FALSE(callControlManager->NotifyIncomingCallAnswered(callObjectPtr));
647     ASSERT_FALSE(callControlManager->NotifyIncomingCallRejected(callObjectPtr, false, ""));
648     ASSERT_NE(callControlManager->PostDialProceed(VALID_CALLID, true), TELEPHONY_SUCCESS);
649     CallEventInfo info;
650     ASSERT_FALSE(callControlManager->NotifyCallEventUpdated(info));
651     DialParaInfo dialParaInfo;
652     callObjectPtr = new CSCall(dialParaInfo);
653     ASSERT_TRUE(callControlManager->NotifyNewCallCreated(callObjectPtr));
654     callControlManager->AddCallLogAndNotification(callObjectPtr);
655     ASSERT_FALSE(callControlManager->NotifyCallStateUpdated(callObjectPtr, priorState, nextState));
656     ASSERT_FALSE(callControlManager->NotifyIncomingCallAnswered(callObjectPtr));
657     ASSERT_FALSE(callControlManager->NotifyIncomingCallRejected(callObjectPtr, false, ""));
658     callObjectPtr->SetCallCreateTime(time(nullptr));
659 
660     callControlManager->Init();
661     ASSERT_NE(callControlManager->RejectCall(VALID_CALLID, false, u""), TELEPHONY_SUCCESS);
662     ASSERT_NE(callControlManager->RejectCall(INVALID_CALLID, false, u""), TELEPHONY_SUCCESS);
663     ASSERT_NE(callControlManager->HangUpCall(VALID_CALLID), TELEPHONY_SUCCESS);
664     ASSERT_TRUE(callControlManager->NotifyNewCallCreated(callObjectPtr));
665     callControlManager->AddCallLogAndNotification(callObjectPtr);
666     ASSERT_TRUE(callControlManager->NotifyCallStateUpdated(callObjectPtr, priorState, nextState));
667     ASSERT_TRUE(callControlManager->NotifyIncomingCallAnswered(callObjectPtr));
668     ASSERT_TRUE(callControlManager->NotifyIncomingCallRejected(callObjectPtr, false, ""));
669     callControlManager->ConnectCallUiService(true);
670 }
671 
672 /**
673  * @tc.number   Telephony_CallControlManager_002
674  * @tc.name     test error branch
675  * @tc.desc     Function test
676  */
677 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_002, Function | MediumTest | Level3)
678 {
679     std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
680     ASSERT_NE(callControlManager->StartDtmf(INVALID_CALLID, 'a'), TELEPHONY_SUCCESS);
681     ASSERT_NE(callControlManager->StopDtmf(INVALID_CALLID), TELEPHONY_SUCCESS);
682     ASSERT_NE(callControlManager->GetCallWaiting(INVALID_CALLID), TELEPHONY_SUCCESS);
683     int32_t slotId = 1;
684     ASSERT_NE(callControlManager->GetCallWaiting(slotId), TELEPHONY_SUCCESS);
685     ASSERT_NE(callControlManager->SetCallWaiting(INVALID_CALLID, true), TELEPHONY_SUCCESS);
686     ASSERT_NE(callControlManager->SetCallWaiting(slotId, true), TELEPHONY_SUCCESS);
687     CallRestrictionType callRestrictionType = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
688     ASSERT_NE(callControlManager->GetCallRestriction(INVALID_CALLID, callRestrictionType), TELEPHONY_SUCCESS);
689     ASSERT_NE(callControlManager->GetCallRestriction(slotId, callRestrictionType), TELEPHONY_SUCCESS);
690     CallRestrictionInfo callRestrictionInfo;
691     ASSERT_NE(callControlManager->SetCallRestriction(INVALID_CALLID, callRestrictionInfo), TELEPHONY_SUCCESS);
692     ASSERT_NE(callControlManager->SetCallRestriction(slotId, callRestrictionInfo), TELEPHONY_SUCCESS);
693     CallTransferType callTransferType = CallTransferType::TRANSFER_TYPE_BUSY;
694     ASSERT_NE(callControlManager->GetCallTransferInfo(INVALID_CALLID, callTransferType), TELEPHONY_SUCCESS);
695     ASSERT_NE(callControlManager->GetCallTransferInfo(slotId, callTransferType), TELEPHONY_SUCCESS);
696     CallTransferInfo info;
697     ASSERT_NE(callControlManager->SetCallTransferInfo(INVALID_CALLID, info), TELEPHONY_SUCCESS);
698     ASSERT_NE(callControlManager->SetCallTransferInfo(slotId, info), TELEPHONY_SUCCESS);
699     bool result = true;
700     ASSERT_NE(callControlManager->CanSetCallTransferTime(INVALID_CALLID, result), TELEPHONY_SUCCESS);
701     ASSERT_NE(callControlManager->CanSetCallTransferTime(slotId, result), TELEPHONY_SUCCESS);
702     int32_t mode = 1;
703     ASSERT_NE(callControlManager->SetCallPreferenceMode(INVALID_CALLID, mode), TELEPHONY_SUCCESS);
704     ASSERT_NE(callControlManager->SetCallPreferenceMode(slotId, mode), TELEPHONY_SUCCESS);
705     ASSERT_NE(callControlManager->CombineConference(INVALID_CALLID), TELEPHONY_SUCCESS);
706     ASSERT_NE(callControlManager->SeparateConference(INVALID_CALLID), TELEPHONY_SUCCESS);
707     ASSERT_NE(callControlManager->KickOutFromConference(INVALID_CALLID), TELEPHONY_SUCCESS);
708     int32_t mainCallId = VALID_CALLID;
709     ASSERT_NE(callControlManager->GetMainCallId(INVALID_CALLID, mainCallId), TELEPHONY_SUCCESS);
710     std::vector<std::u16string> callIdList;
711     ASSERT_NE(callControlManager->GetSubCallIdList(INVALID_CALLID, callIdList), TELEPHONY_SUCCESS);
712     ASSERT_NE(callControlManager->GetCallIdListForConference(INVALID_CALLID, callIdList), TELEPHONY_SUCCESS);
713     ImsConfigItem item = ITEM_VIDEO_QUALITY;
714     ASSERT_NE(callControlManager->GetImsConfig(INVALID_CALLID, item), TELEPHONY_SUCCESS);
715     ASSERT_NE(callControlManager->GetImsConfig(slotId, item), TELEPHONY_SUCCESS);
716     std::u16string value = u"";
717     ASSERT_NE(callControlManager->SetImsConfig(INVALID_CALLID, item, value), TELEPHONY_SUCCESS);
718     ASSERT_NE(callControlManager->SetImsConfig(slotId, item, value), TELEPHONY_SUCCESS);
719     FeatureType featureType = TYPE_VOICE_OVER_LTE;
720     ASSERT_NE(callControlManager->GetImsFeatureValue(INVALID_CALLID, featureType), TELEPHONY_SUCCESS);
721     ASSERT_NE(callControlManager->GetImsFeatureValue(slotId, featureType), TELEPHONY_SUCCESS);
722     ASSERT_NE(callControlManager->SetImsFeatureValue(INVALID_CALLID, featureType, mode), TELEPHONY_SUCCESS);
723     ASSERT_NE(callControlManager->SetImsFeatureValue(slotId, featureType, mode), TELEPHONY_SUCCESS);
724     ASSERT_NE(callControlManager->DisableImsSwitch(INVALID_CALLID), TELEPHONY_SUCCESS);
725     ASSERT_NE(callControlManager->DisableImsSwitch(slotId), TELEPHONY_SUCCESS);
726 }
727 
728 /**
729  * @tc.number   Telephony_CallControlManager_003
730  * @tc.name     test error branch
731  * @tc.desc     Function test
732  */
733 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_003, Function | MediumTest | Level3)
734 {
735     std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
736     callControlManager->CallStateObserve();
737     callControlManager->Init();
738     callControlManager->CallStateObserve();
739     ASSERT_NE(callControlManager->GetCallWaiting(INVALID_CALLID), TELEPHONY_SUCCESS);
740     ASSERT_NE(callControlManager->GetCallWaiting(SIM1_SLOTID), TELEPHONY_SUCCESS);
741     ASSERT_NE(callControlManager->SetCallWaiting(INVALID_CALLID, true), TELEPHONY_SUCCESS);
742     ASSERT_NE(callControlManager->SetCallWaiting(SIM1_SLOTID, true), TELEPHONY_SUCCESS);
743     CallRestrictionType callRestrictionType = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING;
744     ASSERT_NE(callControlManager->GetCallRestriction(INVALID_CALLID, callRestrictionType), TELEPHONY_SUCCESS);
745     ASSERT_NE(callControlManager->GetCallRestriction(SIM1_SLOTID, callRestrictionType), TELEPHONY_SUCCESS);
746     CallRestrictionInfo callRestrictionInfo;
747     ASSERT_NE(callControlManager->SetCallRestriction(INVALID_CALLID, callRestrictionInfo), TELEPHONY_SUCCESS);
748     ASSERT_NE(callControlManager->SetCallRestriction(SIM1_SLOTID, callRestrictionInfo), TELEPHONY_SUCCESS);
749     CallTransferType callTransferType = CallTransferType::TRANSFER_TYPE_BUSY;
750     ASSERT_NE(callControlManager->GetCallTransferInfo(INVALID_CALLID, callTransferType), TELEPHONY_SUCCESS);
751     ASSERT_NE(callControlManager->GetCallTransferInfo(SIM1_SLOTID, callTransferType), TELEPHONY_SUCCESS);
752     CallTransferInfo callTransferInfo;
753     ASSERT_NE(callControlManager->SetCallTransferInfo(INVALID_CALLID, callTransferInfo), TELEPHONY_SUCCESS);
754     ASSERT_NE(callControlManager->SetCallTransferInfo(SIM1_SLOTID, callTransferInfo), TELEPHONY_SUCCESS);
755     bool result = true;
756     ASSERT_NE(callControlManager->CanSetCallTransferTime(INVALID_CALLID, result), TELEPHONY_SUCCESS);
757     ASSERT_NE(callControlManager->CanSetCallTransferTime(SIM1_SLOTID, result), TELEPHONY_SUCCESS);
758     int32_t mode = 1;
759     ASSERT_NE(callControlManager->SetCallPreferenceMode(INVALID_CALLID, mode), TELEPHONY_SUCCESS);
760     ASSERT_NE(callControlManager->SetCallPreferenceMode(SIM1_SLOTID, mode), TELEPHONY_SUCCESS);
761     ImsConfigItem item = ITEM_VIDEO_QUALITY;
762     ASSERT_NE(callControlManager->GetImsConfig(INVALID_CALLID, item), TELEPHONY_SUCCESS);
763     ASSERT_NE(callControlManager->GetImsConfig(SIM1_SLOTID, item), TELEPHONY_SUCCESS);
764     std::u16string value = u"";
765     ASSERT_NE(callControlManager->SetImsConfig(INVALID_CALLID, item, value), TELEPHONY_SUCCESS);
766     ASSERT_NE(callControlManager->SetImsConfig(SIM1_SLOTID, item, value), TELEPHONY_SUCCESS);
767     FeatureType featureType = TYPE_VOICE_OVER_LTE;
768     ASSERT_NE(callControlManager->GetImsFeatureValue(INVALID_CALLID, featureType), TELEPHONY_SUCCESS);
769     ASSERT_NE(callControlManager->GetImsFeatureValue(SIM1_SLOTID, featureType), TELEPHONY_SUCCESS);
770     ASSERT_NE(callControlManager->SetImsFeatureValue(INVALID_CALLID, featureType, mode), TELEPHONY_SUCCESS);
771     ASSERT_NE(callControlManager->SetImsFeatureValue(SIM1_SLOTID, featureType, mode), TELEPHONY_SUCCESS);
772     ASSERT_NE(callControlManager->DisableImsSwitch(INVALID_CALLID), TELEPHONY_SUCCESS);
773     ASSERT_NE(callControlManager->DisableImsSwitch(SIM1_SLOTID), TELEPHONY_SUCCESS);
774     bool enaled = false;
775     ASSERT_NE(callControlManager->IsImsSwitchEnabled(INVALID_CALLID, enaled), TELEPHONY_SUCCESS);
776     ASSERT_NE(callControlManager->IsImsSwitchEnabled(SIM1_SLOTID, enaled), TELEPHONY_SUCCESS);
777     std::vector<std::u16string> numberList = { u"123", u"124" };
778     ASSERT_NE(callControlManager->JoinConference(INVALID_CALLID, numberList), TELEPHONY_SUCCESS);
779     ASSERT_NE(callControlManager->JoinConference(SIM1_SLOTID, numberList), TELEPHONY_SUCCESS);
780 }
781 
782 /**
783  * @tc.number   Telephony_CallControlManager_004
784  * @tc.name     test error branch
785  * @tc.desc     Function test
786  */
787 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_004, Function | MediumTest | Level3)
788 {
789     std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
790     std::vector<std::u16string> numberList = { u"123", u"124" };
791     ASSERT_NE(callControlManager->JoinConference(INVALID_CALLID, numberList), TELEPHONY_SUCCESS);
792     ASSERT_NE(callControlManager->JoinConference(SIM1_SLOTID, numberList), TELEPHONY_SUCCESS);
793     ImsCallMode mode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
794     ASSERT_EQ(callControlManager->UpdateImsCallMode(INVALID_CALLID, mode), TELEPHONY_SUCCESS);
795     std::u16string str = u"";
796     ASSERT_NE(callControlManager->StartRtt(INVALID_CALLID, str), TELEPHONY_SUCCESS);
797     AudioDevice audioDevice = {
798         .deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO,
799         .address = { 0 },
800     };
801     callControlManager->SetAudioDevice(audioDevice);
802     audioDevice.deviceType = AudioDeviceType::DEVICE_SPEAKER;
803     callControlManager->SetAudioDevice(audioDevice);
804     bool enabled = false;
805     callControlManager->IsEmergencyPhoneNumber(str, SIM1_SLOTID, enabled);
806     callControlManager->IsEmergencyPhoneNumber(str, INVALID_SLOTID, enabled);
807     std::string number = "";
808     callControlManager->NumberLegalityCheck(number);
809     number = LONG_STR;
810     callControlManager->NumberLegalityCheck(number);
811     number = "1234567";
812     callControlManager->NumberLegalityCheck(number);
813     std::shared_ptr<CallBroadcastSubscriber> subscriberPtr = nullptr;
814     CallControlManager::SystemAbilityListener listen(subscriberPtr);
815     int32_t systemAbilityId = 1;
816     std::string deviceId = "123";
817     listen.OnAddSystemAbility(systemAbilityId, deviceId);
818     listen.OnRemoveSystemAbility(systemAbilityId, deviceId);
819     listen.OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
820     listen.OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
821     EventFwk::MatchingSkills matchingSkills;
822     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_STATE_CHANGED);
823     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
824     subscriberPtr = std::make_shared<CallBroadcastSubscriber>(subscriberInfo);
825     listen.OnAddSystemAbility(systemAbilityId, deviceId);
826     listen.OnRemoveSystemAbility(systemAbilityId, deviceId);
827     listen.OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
828     listen.OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
829     ASSERT_NE(callControlManager->StopRtt(INVALID_CALLID), TELEPHONY_SUCCESS);
830     ASSERT_NE(callControlManager->SetMuted(false), TELEPHONY_SUCCESS);
831     ASSERT_EQ(callControlManager->MuteRinger(), TELEPHONY_SUCCESS);
832     bool enaled = false;
833     int32_t slotId = 1;
834     ASSERT_NE(callControlManager->IsImsSwitchEnabled(INVALID_CALLID, enaled), TELEPHONY_SUCCESS);
835     ASSERT_NE(callControlManager->IsImsSwitchEnabled(slotId, enaled), TELEPHONY_SUCCESS);
836 }
837 
838 /**
839  * @tc.number   Telephony_CallControlManager_005
840  * @tc.name     test error branch
841  * @tc.desc     Function test
842  */
843 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_005, Function | MediumTest | Level3)
844 {
845     std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
846     std::u16string number = u"";
847     AppExecFwk::PacMap extras;
848     bool isEcc = false;
849     callControlManager->CanDial(number, extras, isEcc);
850     std::string accountNumber = "1234567";
851     callControlManager->PackageDialInformation(extras, accountNumber, isEcc);
852     int32_t videoState = 0;
853     callControlManager->CurrentIsSuperPrivacyMode(VALID_CALLID, videoState);
854     sptr<CallBase> callObjectPtr = nullptr;
855     callControlManager->AnswerHandlerForSatelliteOrVideoCall(callObjectPtr, videoState);
856     DialParaInfo dialParaInfo;
857     callObjectPtr = new CSCall(dialParaInfo);
858     callControlManager->AnswerHandlerForSatelliteOrVideoCall(callObjectPtr, videoState);
859     TelCallState callState = TelCallState::CALL_STATUS_ACTIVE;
860     callControlManager->CarrierAndVoipConflictProcess(VALID_CALLID, callState);
861     CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
862     int32_t slotId = 1;
863     const char oldPassword[kMaxNumberLen + 1] = "1111";
864     const char newPassword[kMaxNumberLen + 1] = "2222";
865     callControlManager->SetCallRestrictionPassword(slotId, fac, oldPassword, newPassword);
866     callControlManager->SeparateConference(VALID_CALLID);
867     callControlManager->KickOutFromConference(VALID_CALLID);
868     callControlManager->EnableImsSwitch(slotId);
869     int32_t state = 0;
870     callControlManager->SetVoNRState(slotId, state);
871     callControlManager->GetVoNRState(slotId, state);
872     callControlManager->IsEmergencyPhoneNumber(number, slotId, isEcc);
873     callControlManager->CloseUnFinishedUssd(slotId);
874     sptr<CallBase> callObjectPtr1 = nullptr;
875     callControlManager->AddBlockLogAndNotification(callObjectPtr1);
876     callControlManager->AddBlockLogAndNotification(callObjectPtr);
877     callControlManager->HangUpVoipCall();
878     callControlManager->SetVoIPCallState(3);
879     callControlManager->SetVoIPCallState(2);
880     ASSERT_EQ(callControlManager->SetVoIPCallState(0), TELEPHONY_SUCCESS);
881 }
882 
883 /**
884  * @tc.number   Telephony_CallStatusManager_001
885  * @tc.name     test error branch
886  * @tc.desc     Function test
887  */
888 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_001, Function | MediumTest | Level3)
889 {
890     std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
891     CallDetailInfo info;
892     std::string number = "123";
893     memcpy_s(&info.phoneNum, kMaxNumberLen, number.c_str(), number.length());
894     info.state = TelCallState::CALL_STATUS_ACTIVE;
895     ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
896     info.state = TelCallState::CALL_STATUS_HOLDING;
897     ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
898     info.state = TelCallState::CALL_STATUS_DIALING;
899     ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
900     info.state = TelCallState::CALL_STATUS_ALERTING;
901     ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
902     info.state = TelCallState::CALL_STATUS_INCOMING;
903     ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
904     info.state = TelCallState::CALL_STATUS_WAITING;
905     ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
906     info.state = TelCallState::CALL_STATUS_DISCONNECTED;
907     ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
908     info.state = TelCallState::CALL_STATUS_DISCONNECTING;
909     ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
910     info.state = TelCallState::CALL_STATUS_UNKNOWN;
911     ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
912     DisconnectedDetails details;
913     ASSERT_GT(callStatusManager->HandleDisconnectedCause(details), TELEPHONY_ERROR);
914     CellularCallEventInfo cellularCallEventInfo;
915     cellularCallEventInfo.eventType = static_cast<CellularCallEventType>(1);
916     ASSERT_GT(callStatusManager->HandleEventResultReportInfo(cellularCallEventInfo), TELEPHONY_ERROR);
917     cellularCallEventInfo.eventType = CellularCallEventType::EVENT_REQUEST_RESULT_TYPE;
918     cellularCallEventInfo.eventId = RequestResultEventId::RESULT_DIAL_NO_CARRIER;
919     ASSERT_GT(callStatusManager->HandleEventResultReportInfo(cellularCallEventInfo), TELEPHONY_ERROR);
920     OttCallEventInfo ottCallEventInfo;
921     (void)memset_s(&ottCallEventInfo, sizeof(OttCallEventInfo), 0, sizeof(OttCallEventInfo));
922     ottCallEventInfo.ottCallEventId = OttCallEventId::OTT_CALL_EVENT_FUNCTION_UNSUPPORTED;
923     (void)memcpy_s(ottCallEventInfo.bundleName, kMaxBundleNameLen + 1, LONG_STR, strlen(LONG_STR));
924     ASSERT_GT(callStatusManager->HandleOttEventReportInfo(ottCallEventInfo), TELEPHONY_ERROR);
925     (void)memset_s(&ottCallEventInfo, sizeof(OttCallEventInfo), 0, sizeof(OttCallEventInfo));
926     ottCallEventInfo.ottCallEventId = OttCallEventId::OTT_CALL_EVENT_FUNCTION_UNSUPPORTED;
927     (void)memcpy_s(ottCallEventInfo.bundleName, kMaxBundleNameLen + 1, TEST_STR, strlen(TEST_STR));
928     ASSERT_GT(callStatusManager->HandleOttEventReportInfo(ottCallEventInfo), TELEPHONY_ERROR);
929     info.voipCallInfo.voipCallId = "123456789";
930     info.callType = CallType::TYPE_VOIP;
931     info.state = TelCallState::CALL_STATUS_INCOMING;
932     ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
933     info.state = TelCallState::CALL_STATUS_ACTIVE;
934     ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
935     info.state = TelCallState::CALL_STATUS_DISCONNECTED;
936     ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
937 }
938 
939 /**
940  * @tc.number   Telephony_CallStatusManager_002
941  * @tc.name     test error branch
942  * @tc.desc     Function test
943  */
944 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_002, Function | MediumTest | Level3)
945 {
946     std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
947     CallDetailInfo callDetailInfo;
948     std::string number = "";
949     memcpy_s(&callDetailInfo.phoneNum, kMaxNumberLen, number.c_str(), number.length());
950     callDetailInfo.state = TelCallState::CALL_STATUS_INCOMING;
951     callDetailInfo.callType = CallType::TYPE_CS;
952     ASSERT_GT(callStatusManager->IncomingHandle(callDetailInfo), TELEPHONY_ERROR);
953     ASSERT_GT(callStatusManager->IncomingVoipCallHandle(callDetailInfo), TELEPHONY_ERROR);
954     callDetailInfo.state = TelCallState::CALL_STATUS_ACTIVE;
955     ASSERT_GT(callStatusManager->IncomingHandle(callDetailInfo), TELEPHONY_ERROR);
956     ASSERT_GT(callStatusManager->IncomingVoipCallHandle(callDetailInfo), TELEPHONY_ERROR);
957     ASSERT_GT(callStatusManager->IncomingFilterPolicy(callDetailInfo), TELEPHONY_ERROR);
958     sptr<CallBase> callObjectPtr = nullptr;
959     TelCallState nextState = TelCallState::CALL_STATUS_ACTIVE;
960     ASSERT_GT(callStatusManager->UpdateCallState(callObjectPtr, nextState), TELEPHONY_ERROR);
961     ASSERT_GT(callStatusManager->ToSpeakerPhone(callObjectPtr), TELEPHONY_ERROR);
962     DialParaInfo dialParaInfo;
963     dialParaInfo.callType = CallType::TYPE_CS;
964     dialParaInfo.callState = TelCallState::CALL_STATUS_INCOMING;
965     callObjectPtr = new CSCall(dialParaInfo);
966     ASSERT_GT(callStatusManager->UpdateCallState(callObjectPtr, nextState), TELEPHONY_ERROR);
967     nextState = TelCallState::CALL_STATUS_INCOMING;
968     ASSERT_GT(callStatusManager->UpdateCallState(callObjectPtr, nextState), TELEPHONY_ERROR);
969     callStatusManager->RefreshCallIfNecessary(callObjectPtr, callDetailInfo);
970     ASSERT_GT(callStatusManager->ToSpeakerPhone(callObjectPtr), TELEPHONY_ERROR);
971     callObjectPtr->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
972     ASSERT_GT(callStatusManager->ToSpeakerPhone(callObjectPtr), TELEPHONY_ERROR);
973     ASSERT_GT(callStatusManager->TurnOffMute(callObjectPtr), TELEPHONY_ERROR);
974     callObjectPtr->SetTelCallState(TelCallState::CALL_STATUS_ALERTING);
975     callStatusManager->SetOriginalCallTypeForActiveState(callObjectPtr);
976     callStatusManager->SetOriginalCallTypeForDisconnectState(callObjectPtr);
977     callObjectPtr->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
978     callStatusManager->SetOriginalCallTypeForActiveState(callObjectPtr);
979     int32_t activeCallNum = 0;
980     int32_t waitingCallNum = 0;
981     int32_t slotId = 0;
982     callStatusManager->AutoAnswer(activeCallNum, waitingCallNum);
983     bool canSwitchCallState = 1;
984     TelCallState priorState = TelCallState::CALL_STATUS_DISCONNECTING;
985     callStatusManager->AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, slotId, true);
986     callStatusManager->AutoUnHoldForDsda(canSwitchCallState, priorState, activeCallNum, slotId);
987     callStatusManager->AutoAnswerForVideoCall(activeCallNum);
988 }
989 } // namespace Telephony
990 } // namespace OHOS
991