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 IS_CELIA_CALL = 1;
96 const int32_t SOURCE_CALL = 2;
97 const int32_t TELEPHONY_EXT_SA_ID = 4011;
98 const int32_t DISTRIBUTED_CALL_SOURCE_SA_ID = 9855;
99 constexpr int16_t DEFAULT_TIME = 0;
100 constexpr const char *TEST_STR = "123";
101 constexpr const char *LONG_STR =
102 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
103 "111111111";
104 constexpr const char *DEVICE_PROVISIONED_URI =
105 "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
106 } // namespace
107
108 class DemoHandler : public AppExecFwk::EventHandler {
109 public:
DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> & eventRunner)110 explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &eventRunner) : AppExecFwk::EventHandler(eventRunner)
111 {}
~DemoHandler()112 virtual ~DemoHandler() {}
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)113 void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
114 };
115
116 class ZeroBranch5Test : public testing::Test {
117 public:
118 void SetUp();
119 void TearDown();
120 static void SetUpTestCase();
121 static void TearDownTestCase();
122 };
123
SetUp()124 void ZeroBranch5Test::SetUp() {}
125
TearDown()126 void ZeroBranch5Test::TearDown() {}
127
SetUpTestCase()128 void ZeroBranch5Test::SetUpTestCase()
129 {
130 constexpr int permissionNum = 2;
131 const char *perms[permissionNum] = {
132 "ohos.permission.GET_TELEPHONY_STATE",
133 "ohos.permission.MANAGE_SETTINGS"
134 };
135 NativeTokenInfoParams infoInstance = {
136 .dcapsNum = 0, // Indicates the capsbility list of the sa.
137 .permsNum = permissionNum,
138 .aclsNum = 0, // acls is the list of rights thar can be escalated.
139 .dcaps = nullptr,
140 .perms = perms,
141 .acls = nullptr,
142 .processName = "ZeroBranch5Test",
143 .aplStr = "system_basic",
144 };
145 uint64_t tokenId = GetAccessTokenId(&infoInstance);
146 SetSelfTokenID(tokenId);
147 auto result = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
148 EXPECT_EQ(result, Security::AccessToken::RET_SUCCESS);
149 }
150
TearDownTestCase()151 void ZeroBranch5Test::TearDownTestCase() {}
152
CreateDataShareHelper(std::string uri)153 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(std::string uri)
154 {
155 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
156 if (saManager == nullptr) {
157 printf("Get system ability mgr failed.");
158 return nullptr;
159 }
160 auto remoteObj = saManager->GetSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
161 if (remoteObj == nullptr) {
162 printf("GetSystemAbility Service Failed.");
163 return nullptr;
164 }
165 return DataShare::DataShareHelper::Creator(remoteObj, uri);
166 }
167
168 /**
169 * @tc.number Telephony_CallStatusManager_005
170 * @tc.name test error branch
171 * @tc.desc Function test
172 */
173 HWTEST_F(ZeroBranch5Test, Telephony_CallStatusManager_005, TestSize.Level0)
174 {
175 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
176 ASSERT_TRUE(callStatusManager != nullptr);
177 callStatusManager->Init();
178 CallObjectManager::callObjectPtrList_.clear();
179 CallDetailInfo info;
180 info.state = TelCallState::CALL_STATUS_DIALING;
181 info.callType = CallType::TYPE_IMS;
182 info.index = 0;
183 std::string number = "10086";
184 memcpy_s(&info.phoneNum, kMaxNumberLen, number.c_str(), number.length());
185 EXPECT_NE(callStatusManager->HandleCallReportInfo(info), TELEPHONY_SUCCESS);
186 info.index = 1;
187 info.state = TelCallState::CALL_STATUS_ALERTING;
188 callStatusManager->HandleCallReportInfo(info);
189 info.state = TelCallState::CALL_STATUS_DISCONNECTED;
190 callStatusManager->HandleCallReportInfo(info);
191 }
192
193 /**
194 * @tc.number Telephony_CallStatusManager_006
195 * @tc.name test error branch
196 * @tc.desc Function test
197 */
198 HWTEST_F(ZeroBranch5Test, Telephony_CallStatusManager_006, TestSize.Level0)
199 {
200 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
201 ASSERT_TRUE(callStatusManager != nullptr);
202 callStatusManager->Init();
203 CallObjectManager::callObjectPtrList_.clear();
204 CallDetailInfo info;
205 info.state = TelCallState::CALL_STATUS_DIALING;
206 info.callType = CallType::TYPE_IMS;
207 info.index = 0;
208 std::string number = "10086";
209 memcpy_s(&info.phoneNum, kMaxNumberLen, number.c_str(), number.length());
210 EXPECT_NE(callStatusManager->HandleCallReportInfo(info), TELEPHONY_SUCCESS);
211 info.index = 1;
212 info.state = TelCallState::CALL_STATUS_ACTIVE;
213 callStatusManager->HandleCallReportInfo(info);
214 info.state = TelCallState::CALL_STATUS_DISCONNECTED;
215 callStatusManager->HandleCallReportInfo(info);
216 }
217
218 /**
219 * @tc.number Telephony_CallStatusManager_007
220 * @tc.name test error branch
221 * @tc.desc Function test
222 */
223 HWTEST_F(ZeroBranch5Test, Telephony_CallStatusManager_007, TestSize.Level0)
224 {
225 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
226 ASSERT_TRUE(callStatusManager != nullptr);
227 callStatusManager->Init();
228 CallObjectManager::callObjectPtrList_.clear();
229 CallDetailInfo info;
230 info.state = TelCallState::CALL_STATUS_DIALING;
231 info.callType = CallType::TYPE_IMS;
232 info.index = 0;
233 std::string number = "10086";
234 memcpy_s(&info.phoneNum, kMaxNumberLen, number.c_str(), number.length());
235 EXPECT_NE(callStatusManager->HandleCallReportInfo(info), TELEPHONY_SUCCESS);
236 info.index = 1;
237 info.state = TelCallState::CALL_STATUS_DISCONNECTED;
238 callStatusManager->HandleCallReportInfo(info);
239 }
240
241 /**
242 * @tc.number Telephony_IncomingCallWakeup_001
243 * @tc.name test error branch
244 * @tc.desc Function test
245 */
246 HWTEST_F(ZeroBranch5Test, Telephony_IncomingCallWakeup_001, TestSize.Level1)
247 {
248 auto incomingCallWakeup = std::make_shared<IncomingCallWakeup>();
249 sptr<CallBase> callObjectPtr = nullptr;
250 incomingCallWakeup->NewCallCreated(callObjectPtr);
251 EXPECT_TRUE(incomingCallWakeup != nullptr);
252 }
253
254 /**
255 * @tc.number Telephony_CallStateReportProxy_001
256 * @tc.name test error branch
257 * @tc.desc Function test
258 */
259 HWTEST_F(ZeroBranch5Test, Telephony_CallStateReportProxy_001, TestSize.Level0)
260 {
261 CallStateReportProxy callStateReportPtr;
262 sptr<CallBase> callObjectPtr = nullptr;
263 callStateReportPtr.CallStateUpdated(
264 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
265 DialParaInfo dialParaInfo;
266 dialParaInfo.callType = CallType::TYPE_CS;
267 dialParaInfo.callState = TelCallState::CALL_STATUS_INCOMING;
268 callObjectPtr = new CSCall(dialParaInfo);
269 ASSERT_TRUE(callObjectPtr != nullptr);
270 callStateReportPtr.CallStateUpdated(
271 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
272 callObjectPtr->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
273 callStateReportPtr.CallStateUpdated(
274 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
275 callStateReportPtr.UpdateCallState(callObjectPtr, TelCallState::CALL_STATUS_INCOMING);
276 callStateReportPtr.UpdateCallStateForSlotId(callObjectPtr, TelCallState::CALL_STATUS_INCOMING);
277 std::string number = "123456789012";
278 std::u16string phoneNumber = Str8ToStr16(number);
279 callStateReportPtr.ReportCallState(0, phoneNumber);
280 callStateReportPtr.ReportCallStateForCallId(0, 0, phoneNumber);
281 ASSERT_TRUE(!number.empty());
282 }
283
284 /**
285 * @tc.number Telephony_CallStateListener_001
286 * @tc.name test error branch
287 * @tc.desc Function test
288 */
289 HWTEST_F(ZeroBranch5Test, Telephony_CallStateListener_001, TestSize.Level0)
290 {
291 CallStateListener callStateListener;
292 sptr<CallBase> callObjectPtr = nullptr;
293 callStateListener.NewCallCreated(callObjectPtr);
294 callStateListener.CallStateUpdated(
295 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
296 callStateListener.IncomingCallHungUp(callObjectPtr, true, "");
297 callStateListener.IncomingCallActivated(callObjectPtr);
298 DialParaInfo dialParaInfo;
299 callObjectPtr = new CSCall(dialParaInfo);
300 callStateListener.NewCallCreated(callObjectPtr);
301 callStateListener.CallStateUpdated(
302 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
303 callStateListener.IncomingCallHungUp(callObjectPtr, true, "");
304 callStateListener.IncomingCallActivated(callObjectPtr);
305 std::shared_ptr<CallStateReportProxy> callStateReportPtr = nullptr;
306 ASSERT_FALSE(callStateListener.AddOneObserver(callStateReportPtr));
307 ASSERT_FALSE(callStateListener.RemoveOneObserver(callStateReportPtr));
308 callStateReportPtr = std::make_shared<CallStateReportProxy>();
309 ASSERT_TRUE(callStateListener.AddOneObserver(callStateReportPtr));
310 ASSERT_TRUE(callStateListener.AddOneObserver(callStateReportPtr));
311 }
312
313 /**
314 * @tc.number Telephony_ConferenceBase_001
315 * @tc.name test error branch
316 * @tc.desc Function test
317 */
318 HWTEST_F(ZeroBranch5Test, Telephony_ConferenceBase_001, TestSize.Level0)
319 {
320 std::shared_ptr<ConferenceBase> conference = std::make_shared<CsConference>();
321 std::vector<std::u16string> callIdList;
322 ASSERT_NE(conference->GetSubCallIdList(VALID_CALLID, callIdList), TELEPHONY_SUCCESS);
323 ASSERT_NE(conference->GetCallIdListForConference(VALID_CALLID, callIdList), TELEPHONY_SUCCESS);
324 ASSERT_NE(conference->JoinToConference(VALID_CALLID), TELEPHONY_SUCCESS);
325 ASSERT_NE(conference->LeaveFromConference(VALID_CALLID), TELEPHONY_SUCCESS);
326 ASSERT_NE(conference->HoldConference(VALID_CALLID), TELEPHONY_SUCCESS);
327 ASSERT_NE(conference->CanSeparateConference(), TELEPHONY_SUCCESS);
328 ASSERT_NE(conference->CanKickOutFromConference(), TELEPHONY_SUCCESS);
329 ASSERT_EQ(conference->SetMainCall(ERROR_CALLID), TELEPHONY_SUCCESS);
330 ASSERT_EQ(conference->SetMainCall(VALID_CALLID), TELEPHONY_SUCCESS);
331 ASSERT_NE(conference->CanSeparateConference(), TELEPHONY_SUCCESS);
332 ASSERT_NE(conference->CanKickOutFromConference(), TELEPHONY_SUCCESS);
333 conference->SetConferenceState(ConferenceState::CONFERENCE_STATE_CREATING);
334 ASSERT_EQ(conference->JoinToConference(VALID_CALLID), TELEPHONY_SUCCESS);
335 ASSERT_EQ(conference->GetSubCallIdList(VALID_CALLID, callIdList), TELEPHONY_SUCCESS);
336 ASSERT_EQ(conference->GetCallIdListForConference(VALID_CALLID, callIdList), TELEPHONY_SUCCESS);
337 ASSERT_EQ(conference->CanSeparateConference(), TELEPHONY_SUCCESS);
338 ASSERT_EQ(conference->CanKickOutFromConference(), TELEPHONY_SUCCESS);
339 ASSERT_EQ(conference->HoldConference(VALID_CALLID), TELEPHONY_SUCCESS);
340 ASSERT_EQ(conference->SetMainCall(VALID_CALLID), TELEPHONY_SUCCESS);
341 ASSERT_EQ(conference->JoinToConference(VALID_CALLID), TELEPHONY_SUCCESS);
342 ASSERT_EQ(conference->LeaveFromConference(VALID_CALLID), TELEPHONY_SUCCESS);
343 }
344
345 /**
346 * @tc.number Telephony_CallAbilityReportProxy_001
347 * @tc.name test error branch
348 * @tc.desc Function test
349 */
350 HWTEST_F(ZeroBranch5Test, Telephony_CallAbilityReportProxy_001, TestSize.Level0)
351 {
352 CallAbilityConnectCallback callAbilityConnectCallback;
353 callAbilityConnectCallback.ReConnectAbility();
354 if (CallObjectManager::HasCallExist()) {
355 callAbilityConnectCallback.ReConnectAbility();
356 }
357 CallConnectAbility callConnectCalluiAbility;
358 ASSERT_FALSE(callConnectCalluiAbility.WaitForConnectResult());
359 std::shared_ptr<CallAbilityReportProxy> callAbilityReportProxy = std::make_shared<CallAbilityReportProxy>();
360 sptr<ICallAbilityCallback> callAbilityCallbackPtr = nullptr;
361 std::string pidName = "123";
362 ASSERT_NE(callAbilityReportProxy->RegisterCallBack(callAbilityCallbackPtr, pidName), TELEPHONY_SUCCESS);
363 ASSERT_NE(callAbilityReportProxy->UnRegisterCallBack(pidName), TELEPHONY_SUCCESS);
364 sptr<IRemoteObject> object = nullptr;
365 ASSERT_NE(callAbilityReportProxy->UnRegisterCallBack(object), TELEPHONY_SUCCESS);
366 sptr<CallBase> callObjectPtr = nullptr;
367 callAbilityReportProxy->CallStateUpdated(
368 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
369 callAbilityCallbackPtr = new CallAbilityCallback();
370 ASSERT_EQ(callAbilityReportProxy->RegisterCallBack(callAbilityCallbackPtr, pidName), TELEPHONY_SUCCESS);
371 DisconnectedDetails disconnectedDetails;
372 callAbilityReportProxy->CallDestroyed(disconnectedDetails);
373 CallAttributeInfo callAttributeInfo;
374 callAbilityReportProxy->ReportCallStateInfo(callAttributeInfo);
375 callAbilityReportProxy->ReportCallStateInfo(callAttributeInfo, pidName);
376 CallEventInfo callEventInfo;
377 callAbilityReportProxy->CallEventUpdated(callEventInfo);
378 callAbilityReportProxy->ReportCallEvent(callEventInfo);
379 CallResultReportId reportId = CallResultReportId::GET_CALL_CLIP_ID;
380 AppExecFwk::PacMap resultInfo;
381 callAbilityReportProxy->ReportAsyncResults(reportId, resultInfo);
382 MmiCodeInfo mmiCodeInfo;
383 callAbilityReportProxy->ReportMmiCodeResult(mmiCodeInfo);
384 OttCallRequestId ottReportId = OttCallRequestId::OTT_REQUEST_ANSWER;
385 callAbilityReportProxy->OttCallRequest(ottReportId, resultInfo);
386 callAbilityReportProxy->ReportPostDialDelay(TEST_STR);
387 std::string ottBundleName = "com.ohos.callservice";
388 sptr<CallAbilityCallback> ottCallAbilityCallbackPtr = new CallAbilityCallback();
389 ASSERT_EQ(callAbilityReportProxy->RegisterCallBack(ottCallAbilityCallbackPtr, ottBundleName), TELEPHONY_SUCCESS);
390 callAbilityReportProxy->OttCallRequest(ottReportId, resultInfo);
391 ASSERT_EQ(callAbilityReportProxy->UnRegisterCallBack(ottBundleName), TELEPHONY_SUCCESS);
392 CallMediaModeInfo imsCallModeInfo;
393 callAbilityReportProxy->ReportImsCallModeChange(imsCallModeInfo);
394 CallSessionEvent callSessionEventOptions;
395 callAbilityReportProxy->ReportCallSessionEventChange(callSessionEventOptions);
396 PeerDimensionsDetail peerDimensionsDetail;
397 callAbilityReportProxy->ReportPeerDimensionsChange(peerDimensionsDetail);
398 }
399
400 /**
401 * @tc.number Telephony_CallAbilityReportProxy_002
402 * @tc.name test error branch
403 * @tc.desc Function test
404 */
405 HWTEST_F(ZeroBranch5Test, Telephony_CallAbilityReportProxy_002, TestSize.Level0)
406 {
407 CallAbilityConnectCallback callAbilityConnectCallback;
408 callAbilityConnectCallback.ReConnectAbility();
409 if (CallObjectManager::HasCallExist()) {
410 callAbilityConnectCallback.ReConnectAbility();
411 }
412 CallConnectAbility callConnectCalluiAbility;
413 callConnectCalluiAbility.WaitForConnectResult();
414 std::shared_ptr<CallAbilityReportProxy> callAbilityReportProxy = std::make_shared<CallAbilityReportProxy>();
415 ASSERT_NE(callAbilityReportProxy, nullptr);
416 int64_t dataUsage = 0;
417 std::string pidName = "123";
418 ASSERT_NE(callAbilityReportProxy->ReportCallDataUsageChange(dataUsage), TELEPHONY_SUCCESS);
419 CameraCapabilities cameraCapabilities;
420 ASSERT_NE(callAbilityReportProxy->ReportCameraCapabilities(cameraCapabilities), TELEPHONY_SUCCESS);
421 ASSERT_NE(callAbilityReportProxy->UnRegisterCallBack(pidName), TELEPHONY_SUCCESS);
422 }
423
424 /**
425 * @tc.number Telephony_CallAbilityReportProxy_003
426 * @tc.name test error branch
427 * @tc.desc Function test
428 */
429 HWTEST_F(ZeroBranch5Test, Telephony_CallAbilityReportProxy_003, TestSize.Level0)
430 {
431 CallAttributeInfo callAttributeInfo;
432 std::shared_ptr<CallAbilityReportProxy> callAbilityReportProxy = std::make_shared<CallAbilityReportProxy>();
433 EXPECT_EQ(callAbilityReportProxy->ReportMeeTimeStateInfo(callAttributeInfo), TELEPHONY_ERR_FAIL);
434 }
435
436 /**
437 * @tc.number Telephony_CallAbilityConnectCallback_001
438 * @tc.name test error branch
439 * @tc.desc Function test
440 */
441 HWTEST_F(ZeroBranch5Test, Telephony_CallAbilityConnectCallback_001, TestSize.Level0)
442 {
443 CallAbilityConnectCallback callAbilityConnectCallback;
444 callAbilityConnectCallback.ReConnectAbility();
445 if (CallObjectManager::HasCallExist()) {
446 callAbilityConnectCallback.ReConnectAbility();
447 }
448 std::string bundle = "111";
449 std::string ability = "222";
450 AppExecFwk::ElementName element("", bundle, ability);
451 int resultCode = 0;
452 callAbilityConnectCallback.OnAbilityConnectDone(element, nullptr, resultCode);
453 ASSERT_EQ(resultCode, 0);
454 callAbilityConnectCallback.OnAbilityDisconnectDone(element, resultCode);
455 ASSERT_EQ(resultCode, 0);
456 }
457
458 /**
459 * @tc.number Telephony_AutoAnswerState_001
460 * @tc.name test error branch
461 * @tc.desc Function test
462 */
463 HWTEST_F(ZeroBranch5Test, Telephony_AutoAnswerState_001, TestSize.Level0)
464 {
465 bool flag = true;
466 sptr<CallBase> callObjectPtr = nullptr;
467 DialParaInfo dialParaInfo;
468 dialParaInfo.callType = CallType::TYPE_IMS;
469 dialParaInfo.callState = TelCallState::CALL_STATUS_INCOMING;
470 callObjectPtr = new IMSCall(dialParaInfo);
471 ASSERT_TRUE(callObjectPtr != nullptr);
472 callObjectPtr->SetAutoAnswerState(flag);
473 ASSERT_EQ(callObjectPtr->GetAutoAnswerState(), true);
474 }
475
476 /**
477 * @tc.number Telephony_CanUnHoldState_001
478 * @tc.name test error branch
479 * @tc.desc Function test
480 */
481 HWTEST_F(ZeroBranch5Test, Telephony_CanUnHoldState_001, TestSize.Level0)
482 {
483 bool flag = true;
484 sptr<CallBase> callObjectPtr = nullptr;
485 DialParaInfo dialParaInfo;
486 dialParaInfo.callType = CallType::TYPE_IMS;
487 dialParaInfo.callState = TelCallState::CALL_STATUS_INCOMING;
488 callObjectPtr = new IMSCall(dialParaInfo);
489 ASSERT_TRUE(callObjectPtr != nullptr);
490 callObjectPtr->SetCanUnHoldState(flag);
491 ASSERT_EQ(callObjectPtr->GetCanUnHoldState(), true);
492 }
493
494 /**
495 * @tc.number Telephony_VoipCallManagerProxy_001
496 * @tc.name test error branch
497 * @tc.desc Function test
498 */
499 HWTEST_F(ZeroBranch5Test, Telephony_VoipCallManagerProxy_001, TestSize.Level0)
500 {
501 sptr<ISystemAbilityManager> managerPtr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
502 sptr<IVoipCallManagerService> voipCallManagerInterfacePtr = nullptr;
503 if (managerPtr != nullptr) {
504 sptr<IRemoteObject> iRemoteObjectPtr = managerPtr->GetSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
505 if (iRemoteObjectPtr != nullptr) {
506 voipCallManagerInterfacePtr = iface_cast<IVoipCallManagerService>(iRemoteObjectPtr);
507 }
508 }
509 AppExecFwk::PacMap mPacMap;
510 ErrorReason error = ErrorReason::VOIP_CALL_EXISTS;
511 if (voipCallManagerInterfacePtr != nullptr) {
512 std::vector<uint8_t> userProfile = { 0 };
513 int32_t ret1 = voipCallManagerInterfacePtr->ReportIncomingCall(mPacMap, userProfile, error);
514 int32_t ret2 = voipCallManagerInterfacePtr->ReportIncomingCallError(mPacMap);
515 voipCallManagerInterfacePtr->SendCallUiEventForWindow(mPacMap);
516 VoipCallState voipCallState = VoipCallState::VOIP_CALL_STATE_ACTIVE;
517 VoipCallType voipCallType = VoipCallType::VOIP_CALL_VOICE;
518 std::string callId = "123";
519 int32_t ret3 = voipCallManagerInterfacePtr->ReportCallStateChange(callId, voipCallState, voipCallType);
520 int32_t ret4 = voipCallManagerInterfacePtr->UnRegisterCallBack();
521 std::string bundleName = " ";
522 std::string processMode = "0";
523 int32_t uid = 0;
524 int32_t ret5 = voipCallManagerInterfacePtr->ReportVoipIncomingCall(callId, bundleName, processMode, uid);
525 int32_t ret6 = voipCallManagerInterfacePtr->ReportVoipCallExtensionId(callId, bundleName, " ", uid);
526 VoipCallEventInfo voipCallEventInfo;
527 voipCallEventInfo.voipCallId = "123";
528 int32_t ret7 = voipCallManagerInterfacePtr->Answer(voipCallEventInfo,
529 static_cast<int32_t>(VideoStateType::TYPE_VOICE));
530 int32_t ret8 = voipCallManagerInterfacePtr->HangUp(voipCallEventInfo);
531 int32_t ret9 = voipCallManagerInterfacePtr->Reject(voipCallEventInfo);
532 int32_t ret10 = voipCallManagerInterfacePtr->UnloadVoipSa();
533 sptr<ICallStatusCallback> statusCallback = (std::make_unique<CallStatusCallback>()).release();
534 int32_t ret11 = voipCallManagerInterfacePtr->RegisterCallManagerCallBack(statusCallback);
535 int32_t ret12 = voipCallManagerInterfacePtr->UnRegisterCallManagerCallBack();
536 EXPECT_NE(ret1, TELEPHONY_SUCCESS);
537 EXPECT_NE(ret2, TELEPHONY_SUCCESS);
538 EXPECT_NE(ret3, TELEPHONY_SUCCESS);
539 EXPECT_NE(ret4, TELEPHONY_SUCCESS);
540 EXPECT_NE(ret5, TELEPHONY_SUCCESS);
541 EXPECT_NE(ret6, TELEPHONY_SUCCESS);
542 EXPECT_NE(ret7, TELEPHONY_SUCCESS);
543 EXPECT_NE(ret8, TELEPHONY_SUCCESS);
544 EXPECT_NE(ret9, TELEPHONY_SUCCESS);
545 EXPECT_NE(ret10, TELEPHONY_SUCCESS);
546 EXPECT_NE(ret11, TELEPHONY_SUCCESS);
547 EXPECT_NE(ret12, TELEPHONY_SUCCESS);
548 }
549 }
550
551 /**
552 * @tc.number Telephony_CallRequestEventHandlerHelper_001
553 * @tc.name test error branch
554 * @tc.desc Function test
555 */
556 HWTEST_F(ZeroBranch5Test, Telephony_CallRequestEventHandlerHelper_001, TestSize.Level0)
557 {
558 bool flag = false;
559 DelayedSingleton<CallRequestEventHandlerHelper>::GetInstance()->RestoreDialingFlag(flag);
560 EXPECT_FALSE(DelayedSingleton<CallRequestEventHandlerHelper>::GetInstance()->IsDialingCallProcessing());
561 }
562
563 /**
564 * @tc.number Telephony_DistributedCallManager_001
565 * @tc.name test error branch
566 * @tc.desc Function test
567 */
568 HWTEST_F(ZeroBranch5Test, Telephony_DistributedCallManager_001, TestSize.Level0)
569 {
570 DistributedCallManager manager;
571 AudioDevice device;
572 std::string deviceId = "{ \"devIds\": \"101\" }";
573 device.deviceType = AudioDeviceType::DEVICE_EARPIECE;
574 std::string restr = manager.GetDevIdFromAudioDevice(device);
575 EXPECT_FALSE(manager.IsSelectVirtualModem());
576 EXPECT_TRUE(manager.SwitchOnDCallDeviceSync(device));
577 device.deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PHONE;
578 std::string devId = "";
579 std::vector<std::string> devices;
580 devices.push_back("TEST_STR");
581 manager.CreateDAudioDevice(devId, device);
582 manager.CreateDAudioDevice(TEST_STR, device);
583 manager.dcallProxy_ = std::make_shared<DistributedCallProxy>();
584 manager.CreateDAudioDevice(TEST_STR, device);
585 manager.AddDCallDevice(TEST_STR);
586 manager.RemoveDCallDevice(TEST_STR);
587 manager.onlineDCallDevices_.insert(std::make_pair(TEST_STR, device));
588 manager.AddDCallDevice(TEST_STR);
589 manager.RemoveDCallDevice(TEST_STR);
590 manager.GetConnectedDCallDeviceId();
591 manager.SwitchOffDCallDeviceSync();
592 manager.dCallDeviceSwitchedOn_.store(true);
593 manager.SwitchOffDCallDeviceSync();
594 manager.GetConnectedDCallDeviceId();
595 manager.GetConnectedDCallDevice(device);
596 manager.SetConnectedDCallDevice(device);
597 manager.ClearConnectedDCallDevice();
598 manager.IsSelectVirtualModem();
599 manager.SwitchOnDCallDeviceSync(device);
600 manager.OnDCallSystemAbilityAdded(TEST_STR);
601 manager.IsDistributedCarDeviceOnline();
602 manager.ReportDistributedDeviceInfoForSwitchOff();
603 manager.NotifyOnlineDCallDevices(devices);
604 manager.RemoveDCallDevice(TEST_STR);
605 device.deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PHONE;
606 ASSERT_EQ(memcpy_s(device.address, kMaxAddressLen + 1, deviceId.c_str(), deviceId.size()), EOK);
607 manager.GetDevIdFromAudioDevice(device);
608 deviceId = "{ \"devId\": \"101\" }";
609 ASSERT_EQ(memcpy_s(device.address, kMaxAddressLen + 1, deviceId.c_str(), deviceId.size()), EOK);
610 manager.GetDevIdFromAudioDevice(device);
611 EXPECT_TRUE(restr.empty());
612 }
613
614 /**
615 * @tc.number Telephony_DistributedCallManager_002
616 * @tc.name test normal branch
617 * @tc.desc Function test
618 */
619 HWTEST_F(ZeroBranch5Test, Telephony_DistributedCallManager_002, TestSize.Level0)
620 {
621 DistributedCallManager manager;
622 AudioDevice device;
623 std::string deviceId = "";
624 DialParaInfo dialParaInfo;
625 sptr<CallBase> call = new IMSCall(dialParaInfo);
626 manager.statusChangeListener_ = nullptr;
627 manager.Init();
628 manager.statusChangeListener_ = new (std::nothrow) DCallSystemAbilityListener();
629 manager.Init();
630 manager.AddDCallDevice(LONG_STR);
631 manager.RemoveDCallDevice(LONG_STR);
632 manager.ClearDCallDevices();
633 manager.GetConnectedDCallDeviceType();
634 manager.isCallActived_.store(false);
635 ASSERT_TRUE(manager.SwitchOnDCallDeviceSync(device));
636 manager.isCallActived_.store(true);
637 device.deviceType = AudioDeviceType::DEVICE_UNKNOWN;
638 ASSERT_FALSE(manager.SwitchOnDCallDeviceSync(device));
639
640 device.deviceType = AudioDeviceType::DEVICE_DISTRIBUTED_PHONE;
641 ASSERT_EQ(memcpy_s(device.address, kMaxAddressLen + 1, deviceId.c_str(), deviceId.size()), EOK);
642 ASSERT_FALSE(manager.SwitchOnDCallDeviceSync(device));
643
644 deviceId = "{ \"devId\": \"101\" }";
645 ASSERT_EQ(memcpy_s(device.address, kMaxAddressLen + 1, deviceId.c_str(), deviceId.size()), EOK);
646 manager.dcallProxy_ = nullptr;
647 manager.SwitchOnDCallDeviceSync(device);
648 manager.dcallProxy_ = std::make_shared<DistributedCallProxy>();
649 manager.SwitchOnDCallDeviceSync(device);
650 manager.SetCallState(false);
651 manager.DealDisconnectCall();
652 manager.onlineDCallDevices_["101"] = device;
653 ASSERT_TRUE(manager.IsDistributedCarDeviceOnline());
654 manager.onlineDCallDevices_.clear();
655 ASSERT_FALSE(manager.IsDistributedCarDeviceOnline());
656 CallObjectManager::callObjectPtrList_.clear();
657 ASSERT_FALSE(manager.isCeliaCall());
658 call->callType_ = CallType::TYPE_IMS;
659 call->callState_ = TelCallState::CALL_STATUS_WAITING;
660 call->celiaCallType_ = IS_CELIA_CALL;
661 CallObjectManager::callObjectPtrList_.push_back(call);
662 EXPECT_TRUE(manager.isCeliaCall());
663 manager.SwitchOnDCallDeviceAsync(device); // is celia call, return
664 CallObjectManager::callObjectPtrList_.clear();
665 call->celiaCallType_ = IS_CELIA_CALL + 1;
666 CallObjectManager::callObjectPtrList_.push_back(call);
667 EXPECT_FALSE(manager.isCeliaCall());
668 manager.SwitchOnDCallDeviceAsync(device); // not celia call
669 CallObjectManager::callObjectPtrList_.clear();
670 }
671
672 /**
673 * @tc.number Telephony_DistributedCallManager_003
674 * @tc.name test normal branch
675 * @tc.desc Function test
676 */
677 HWTEST_F(ZeroBranch5Test, Telephony_DistributedCallManager_003, TestSize.Level0)
678 {
679 AudioDevice device;
680 std::string deviceId = "";
681 DistributedCallManager manager;
682 auto listener = new (std::nothrow) DCallSystemAbilityListener();
683 manager.onlineDCallDevices_.clear();
684 ASSERT_FALSE(manager.IsSelectVirtualModem());
685 manager.onlineDCallDevices_["101"] = device;
686 manager.dcallProxy_ = nullptr;
687 ASSERT_FALSE(manager.IsSelectVirtualModem());
688 manager.dcallProxy_ = std::make_shared<DistributedCallProxy>();
689 manager.IsSelectVirtualModem();
690 manager.onlineDCallDevices_.clear();
691
692 manager.IsDCallDeviceSwitchedOn();
693 manager.OnDCallSystemAbilityRemoved(deviceId);
694 auto tempStatus = manager.dCallDeviceSwitchedOn_.load();
695 manager.dCallDeviceSwitchedOn_.store(false);
696 manager.OnDCallSystemAbilityRemoved(deviceId);
697 manager.dCallDeviceSwitchedOn_.store(true);
698 manager.OnDCallSystemAbilityRemoved(deviceId);
699 EXPECT_FALSE(manager.dCallDeviceSwitchedOn_);
700 manager.dCallDeviceSwitchedOn_.store(tempStatus);
701 listener->OnAddSystemAbility(-1, deviceId); // invalid sa id
702 listener->OnAddSystemAbility(TELEPHONY_EXT_SA_ID, deviceId);
703 listener->OnAddSystemAbility(DISTRIBUTED_CALL_SOURCE_SA_ID, deviceId);
704 listener->OnRemoveSystemAbility(-1, deviceId);
705 listener->OnRemoveSystemAbility(TELEPHONY_EXT_SA_ID, deviceId);
706 listener->OnRemoveSystemAbility(DISTRIBUTED_CALL_SOURCE_SA_ID, deviceId);
707 ASSERT_EQ(memcpy_s(device.address, kMaxAddressLen + 1, deviceId.c_str(), deviceId.size()), EOK);
708 manager.SetCallState(true);
709 manager.ReportDistributedDeviceInfo(device);
710 ASSERT_TRUE(manager.isCallActived_);
711 }
712
713 /**
714 * @tc.number Telephony_DistributedCallManager_004
715 * @tc.name test normal branch
716 * @tc.desc Function test
717 */
718 #ifdef ABILITY_BLUETOOTH_SUPPORT
719 HWTEST_F(ZeroBranch5Test, Telephony_DistributedCallManager_004, TestSize.Level0)
720 {
721 Bluetooth::BluetoothRemoteDevice device;
722 int32_t action = 1; // unwear bt headset
723 DCallHfpListener listener;
724 listener.OnHfpStackChanged(device, action); // not bt head set
725
726 DistributedCallManager manager;
727 manager.dcallHfpListener_ = nullptr;
728 EXPECT_EQ(manager.AddDCallDevice(TEST_STR), TELEPHONY_ERR_FAIL);
729 manager.OnDCallDeviceOffline(TEST_STR);
730 manager.dcallHfpListener_ = std::make_shared<DCallHfpListener>();
731 EXPECT_EQ(manager.AddDCallDevice(TEST_STR), TELEPHONY_ERR_FAIL);
732 manager.OnDCallDeviceOffline(TEST_STR);
733 }
734 #endif
735
736 /**
737 * @tc.number Telephony_DistributedCallProxy_001
738 * @tc.name test error branch
739 * @tc.desc Function test
740 */
741 HWTEST_F(ZeroBranch5Test, Telephony_DistributedCallProxy_001, TestSize.Level0)
742 {
743 std::unique_ptr<DistributedCallProxy> proxy = std::make_unique<DistributedCallProxy>();
744 std::shared_ptr<OHOS::DistributedHardware::IDCallDeviceCallback> callback = nullptr;
745 std::string name = "123";
746 proxy->GetDCallClient();
747 proxy->RegisterDeviceCallback(name, callback);
748 proxy->UnRegisterDeviceCallback(name);
749 int32_t res = proxy->Init();
750 proxy->GetDCallClient();
751 proxy->dcallClient_ = nullptr;
752 int32_t res1 = proxy->UnInit();
753 bool res2 = proxy->IsSelectVirtualModem();
754 int32_t res3 = proxy->SwitchDevice(TEST_STR, 1);
755 std::vector<std::string> devList;
756 int32_t res4 = proxy->GetOnlineDeviceList(devList);
757 OHOS::DistributedHardware::DCallDeviceInfo devInfo;
758 int32_t res5 = proxy->GetDCallDeviceInfo(TEST_STR, devInfo);
759 proxy->GetDCallClient();
760 proxy->IsSelectVirtualModem();
761 int32_t res6 = proxy->SwitchDevice(TEST_STR, 1);
762 int32_t res7 = proxy->GetOnlineDeviceList(devList);
763 proxy->GetDCallDeviceInfo(TEST_STR, devInfo);
764 int32_t res8 = proxy->UnInit();
765 proxy->GetDCallClient();
766 proxy->UnInit();
767 proxy->SwitchDevice(TEST_STR, 1);
768 proxy->GetDCallDeviceInfo(TEST_STR, devInfo);
769 proxy->RegisterDeviceCallback(name, callback);
770 proxy->UnRegisterDeviceCallback(name);
771 proxy->GetDCallDeviceInfo(TEST_STR, devInfo);
772 proxy->IsSelectVirtualModem();
773 EXPECT_NE(res, TELEPHONY_SUCCESS);
774 EXPECT_NE(res1, TELEPHONY_SUCCESS);
775 EXPECT_FALSE(res2);
776 EXPECT_NE(res3, TELEPHONY_SUCCESS);
777 EXPECT_NE(res4, TELEPHONY_SUCCESS);
778 EXPECT_NE(res5, TELEPHONY_SUCCESS);
779 EXPECT_NE(res6, TELEPHONY_SUCCESS);
780 EXPECT_NE(res7, TELEPHONY_SUCCESS);
781 EXPECT_NE(res8, TELEPHONY_SUCCESS);
782 }
783
784 /**
785 * @tc.number Telephony_BluetoothCallManager_001
786 * @tc.name test error branch
787 * @tc.desc Function test
788 */
789 HWTEST_F(ZeroBranch5Test, Telephony_BluetoothCallManager_001, TestSize.Level0)
790 {
791 int32_t state = 0;
792 int32_t numActive = CallObjectManager::GetCallNum(TelCallState::CALL_STATUS_ACTIVE);
793 int32_t numHeld = CallObjectManager::GetCallNum(TelCallState::CALL_STATUS_HOLDING);
794 int32_t numDial = CallObjectManager::GetCallNum(TelCallState::CALL_STATUS_DIALING);
795 int32_t callState = static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE);
796 std::string number = CallObjectManager::GetCallNumber(TelCallState::CALL_STATUS_HOLDING);
797 BluetoothCallManager bluetoothCallManager;
798 ASSERT_EQ(bluetoothCallManager.SendBtCallState(numActive, numHeld, callState, number), TELEPHONY_SUCCESS);
799 ASSERT_EQ(bluetoothCallManager.SendCallDetailsChange(1, 1), TELEPHONY_SUCCESS);
800 ASSERT_NE(bluetoothCallManager.IsBtAvailble(), true);
801 bluetoothCallManager.btConnection_ = nullptr;
802 EXPECT_FALSE(bluetoothCallManager.IsBtAvailble());
803 EXPECT_FALSE(bluetoothCallManager.SendBtCallState(numActive, numHeld, callState, number));
804 EXPECT_FALSE(bluetoothCallManager.SendCallDetailsChange(1, 1));
805 }
806
807 /**
808 * @tc.number Telephony_CallAbilityCallbackDeathRecipient_001
809 * @tc.name test error branch
810 * @tc.desc Function test
811 */
812 HWTEST_F(ZeroBranch5Test, Telephony_CallAbilityCallbackDeathRecipient_001, TestSize.Level0)
813 {
814 CallAbilityCallbackDeathRecipient recipient;
815 OHOS::wptr<OHOS::IRemoteObject> object;
816 recipient.OnRemoteDied(object);
817 ASSERT_EQ(object, nullptr);
818 }
819
820 /**
821 * @tc.number Telephony_ApplicationStateObserver_001
822 * @tc.name test error branch
823 * @tc.desc Function test
824 */
825 HWTEST_F(ZeroBranch5Test, Telephony_ApplicationStateObserver_001, TestSize.Level0)
826 {
827 ApplicationStateObserver applicationStateObserver;
828 AppExecFwk::ProcessData processData;
829 applicationStateObserver.OnProcessDied(processData);
830 ASSERT_NE(sizeof(processData), 0);
831 }
832
833 /**
834 * @tc.number Telephony_CallAbilityCallbackProxy_001
835 * @tc.name test error branch
836 * @tc.desc Function test
837 */
838 HWTEST_F(ZeroBranch5Test, Telephony_CallAbilityCallbackProxy_001, TestSize.Level0)
839 {
840 sptr<IRemoteObject> impl;
841 CallAbilityCallbackProxy callAbilityCallbackProxy(impl);
842 CallAttributeInfo callAttributeInfo;
843 callAbilityCallbackProxy.OnCallDetailsChange(callAttributeInfo);
844 callAbilityCallbackProxy.OnMeeTimeDetailsChange(callAttributeInfo);
845 CallEventInfo info;
846 callAbilityCallbackProxy.OnCallEventChange(info);
847 DisconnectedDetails details;
848 callAbilityCallbackProxy.OnCallDisconnectedCause(details);
849 AppExecFwk::PacMap resultInfo;
850
851 callAbilityCallbackProxy.OnReportAsyncResults(CallResultReportId::GET_CALL_CLIP_ID, resultInfo);
852 MmiCodeInfo mmiCodeInfo;
853 callAbilityCallbackProxy.OnReportMmiCodeResult(mmiCodeInfo);
854 callAbilityCallbackProxy.OnOttCallRequest(OttCallRequestId::OTT_REQUEST_ANSWER, resultInfo);
855 CallMediaModeInfo imsCallModeInfo;
856 callAbilityCallbackProxy.OnReportImsCallModeChange(imsCallModeInfo);
857 CallSessionEvent callSessionEventOptions;
858 callAbilityCallbackProxy.OnReportCallSessionEventChange(callSessionEventOptions);
859 PeerDimensionsDetail peerDimensionsDetail;
860 callAbilityCallbackProxy.OnReportPeerDimensionsChange(peerDimensionsDetail);
861 int64_t dataUsage = 0;
862 callAbilityCallbackProxy.OnReportCallDataUsageChange(dataUsage);
863 CameraCapabilities cameraCapabilities;
864 callAbilityCallbackProxy.OnReportCameraCapabilities(cameraCapabilities);
865
866 AudioDeviceInfo audioDeviceInfo;
867 callAbilityCallbackProxy.OnReportAudioDeviceChange(audioDeviceInfo);
868 const std::string str {"123"};
869 callAbilityCallbackProxy.OnReportPostDialDelay(str);
870 callAbilityCallbackProxy.OnPhoneStateChange(0, 0, 0, "");
871 ASSERT_TRUE(!str.empty());
872 }
873
874 /**
875 * @tc.number Telephony_OTTCallConnection_001
876 * @tc.name test error branch
877 * @tc.desc Function test
878 */
879 HWTEST_F(ZeroBranch5Test, Telephony_OTTCallConnection_001, TestSize.Level0)
880 {
881 OTTCallConnection ott;
882 OttCallRequestInfo requestInfo;
883 ott.Answer(requestInfo);
884 ott.HoldCall(requestInfo);
885 ott.HangUp(requestInfo);
886 ott.Reject(requestInfo);
887 ott.UnHoldCall(requestInfo);
888 ott.SwitchCall(requestInfo);
889 ott.CombineConference(requestInfo);
890 ott.SeparateConference(requestInfo);
891 ott.KickOutFromConference(requestInfo);
892 std::vector<std::string> numberList;
893 int32_t result = ott.InviteToConference(requestInfo, numberList);
894 ott.UpdateImsCallMode(requestInfo, ImsCallMode::CALL_MODE_AUDIO_ONLY);
895 AppExecFwk::PacMap info;
896 ott.PackCellularCallInfo(requestInfo, info);
897 ASSERT_NE(result, TELEPHONY_SUCCESS);
898 }
899
900 /**
901 * @tc.number Telephony_SuperPrivacyManagerClient_001
902 * @tc.name test error branch
903 * @tc.desc Function test
904 */
905 HWTEST_F(ZeroBranch5Test, Telephony_SuperPrivacyManagerClient_001, TestSize.Level0)
906 {
907 int32_t privacy = SuperPrivacyManagerClient::GetInstance().
908 SetSuperPrivacyMode(static_cast<int32_t>(CallSuperPrivacyModeType::OFF), SOURCE_CALL);
909 #ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
910 ASSERT_EQ(privacy, 22);
911 #else
912 ASSERT_EQ(privacy, 0);
913 #endif
914 }
915
916 /**
917 * @tc.number Telephony_CallStatusCallback_001
918 * @tc.name test error branch
919 * @tc.desc Function test
920 */
921 HWTEST_F(ZeroBranch5Test, Telephony_CallStatusCallback_001, TestSize.Level0)
922 {
923 auto callStatusCallback = std::make_shared<CallStatusCallback>();
924 CallReportInfo callReportInfo;
925 callStatusCallback->UpdateCallReportInfo(callReportInfo);
926 CallsReportInfo callsReportInfo;
927 callStatusCallback->UpdateCallsReportInfo(callsReportInfo);
928 DisconnectedDetails disconnectedDetails;
929 callStatusCallback->UpdateDisconnectedCause(disconnectedDetails);
930 CellularCallEventInfo cellularCallEventIndo;
931 callStatusCallback->UpdateEventResultInfo(cellularCallEventIndo);
932 RBTPlayInfo rbtpPlyaInfo = RBTPlayInfo::LOCAL_ALERTING;
933 callStatusCallback->UpdateRBTPlayInfo(rbtpPlyaInfo);
934 int32_t result = 0;
935 callStatusCallback->StartDtmfResult(result);
936 callStatusCallback->StopDtmfResult(result);
937 callStatusCallback->SendUssdResult(result);
938 callStatusCallback->GetImsCallDataResult(result);
939 CallWaitResponse callWaitResponse;
940 callStatusCallback->UpdateGetWaitingResult(callWaitResponse);
941 callStatusCallback->UpdateSetWaitingResult(result);
942 CallRestrictionResponse callRestrictionResponse;
943 callStatusCallback->UpdateGetRestrictionResult(callRestrictionResponse);
944 callStatusCallback->UpdateSetRestrictionResult(result);
945 callStatusCallback->UpdateSetRestrictionPasswordResult(result);
946 CallTransferResponse callTransferResponse;
947 callStatusCallback->UpdateGetTransferResult(callTransferResponse);
948 callStatusCallback->UpdateSetTransferResult(result);
949 ClipResponse clipResponse;
950 callStatusCallback->UpdateGetCallClipResult(clipResponse);
951 ClirResponse clirResponse;
952 callStatusCallback->UpdateGetCallClirResult(clirResponse);
953 callStatusCallback->UpdateSetCallClirResult(result);
954 callStatusCallback->StartRttResult(result);
955 callStatusCallback->StopRttResult(result);
956 GetImsConfigResponse getImsConfigResponse;
957 callStatusCallback->GetImsConfigResult(getImsConfigResponse);
958 callStatusCallback->SetImsConfigResult(result);
959 GetImsFeatureValueResponse getImsFeatureValueResopnse;
960 callStatusCallback->GetImsFeatureValueResult(getImsFeatureValueResopnse);
961 callStatusCallback->SetImsFeatureValueResult(result);
962 CallModeReportInfo callModeReportInfo;
963 callStatusCallback->ReceiveUpdateCallMediaModeRequest(callModeReportInfo);
964 callStatusCallback->ReceiveUpdateCallMediaModeResponse(callModeReportInfo);
965 callStatusCallback->InviteToConferenceResult(result);
966 MmiCodeInfo mmiCodeInfo;
967 callStatusCallback->SendMmiCodeResult(mmiCodeInfo);
968 int32_t res = callStatusCallback->CloseUnFinishedUssdResult(result);
969 ASSERT_NE(res, TELEPHONY_SUCCESS);
970 }
971
972 /**
973 * @tc.number Telephony_CallStatusCallback_002
974 * @tc.name test error branch
975 * @tc.desc Function test
976 */
977 HWTEST_F(ZeroBranch5Test, Telephony_CallStatusCallback_002, TestSize.Level0)
978 {
979 auto callStatusCallback = std::make_shared<CallStatusCallback>();
980 std::string c("a");
981 callStatusCallback->ReportPostDialChar(c);
982 std::string str("abc");
983 callStatusCallback->ReportPostDialDelay(str);
984 CallSessionReportInfo callSessionReportInfo;
985 callStatusCallback->HandleCallSessionEventChanged(callSessionReportInfo);
986 PeerDimensionsReportInfo peerDimensionReportInfo;
987 callStatusCallback->HandlePeerDimensionsChanged(peerDimensionReportInfo);
988 int64_t res = 0;
989 callStatusCallback->HandleCallDataUsageChanged(res);
990 CameraCapabilitiesReportInfo cameraCapabilities;
991 callStatusCallback->HandleCameraCapabilitiesChanged(cameraCapabilities);
992 VoipCallEventInfo voipCallEventInfo;
993 res = callStatusCallback->UpdateVoipEventInfo(voipCallEventInfo);
994 ASSERT_NE(res, TELEPHONY_SUCCESS);
995 }
996
997 /**
998 * @tc.number Telephony_CallStatusCallbackStub_001
999 * @tc.name test error branch
1000 * @tc.desc Function test
1001 */
1002 HWTEST_F(ZeroBranch5Test, Telephony_CallStatusCallbackStub_001, TestSize.Level0)
1003 {
1004 auto callStatusCallback = std::make_shared<CallStatusCallback>();
1005 MessageParcel data;
1006 MessageParcel reply;
1007 MessageOption option;
1008 data.WriteInterfaceToken(CallStatusCallbackStub::GetDescriptor());
1009 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_CALL_INFO),
1010 data, reply, option);
1011 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_CALLS_INFO),
1012 data, reply, option);
1013 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_DISCONNECTED_CAUSE),
1014 data, reply, option);
1015 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_EVENT_RESULT_INFO),
1016 data, reply, option);
1017 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_RBT_PLAY_INFO),
1018 data, reply, option);
1019 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_GET_WAITING),
1020 data, reply, option);
1021 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_SET_WAITING),
1022 data, reply, option);
1023 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_GET_RESTRICTION),
1024 data, reply, option);
1025 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_SET_RESTRICTION),
1026 data, reply, option);
1027 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_GET_TRANSFER),
1028 data, reply, option);
1029 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_SET_TRANSFER),
1030 data, reply, option);
1031 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_GET_CALL_CLIP),
1032 data, reply, option);
1033 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_GET_CALL_CLIR),
1034 data, reply, option);
1035 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_SET_CALL_CLIR),
1036 data, reply, option);
1037 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::GET_IMS_SWITCH_STATUS),
1038 data, reply, option);
1039 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::SET_IMS_SWITCH_STATUS),
1040 data, reply, option);
1041 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_STARTRTT_STATUS),
1042 data, reply, option);
1043 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_STOPRTT_STATUS),
1044 data, reply, option);
1045 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::GET_IMS_CONFIG),
1046 data, reply, option);
1047 int32_t res = callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::SET_IMS_CONFIG),
1048 data, reply, option);
1049 ASSERT_NE(res, TELEPHONY_SUCCESS);
1050 }
1051
1052 /**
1053 * @tc.number Telephony_CallStatusCallbackStub_002
1054 * @tc.name test error branch
1055 * @tc.desc Function test
1056 */
1057 HWTEST_F(ZeroBranch5Test, Telephony_CallStatusCallbackStub_002, TestSize.Level0)
1058 {
1059 auto callStatusCallback = std::make_shared<CallStatusCallback>();
1060 MessageParcel data;
1061 MessageParcel reply;
1062 MessageOption option;
1063 data.WriteInterfaceToken(CallStatusCallbackStub::GetDescriptor());
1064 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::GET_IMS_FEATURE_VALUE),
1065 data, reply, option);
1066 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::SET_IMS_FEATURE_VALUE),
1067 data, reply, option);
1068 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::GET_LTE_ENHANCE_MODE),
1069 data, reply, option);
1070 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::SET_LTE_ENHANCE_MODE),
1071 data, reply, option);
1072 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(
1073 CallStatusInterfaceCode::RECEIVE_UPDATE_MEDIA_MODE_RESPONSE), data, reply, option);
1074 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::INVITE_TO_CONFERENCE),
1075 data, reply, option);
1076 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::START_DTMF),
1077 data, reply, option);
1078 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::STOP_DTMF),
1079 data, reply, option);
1080 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::SEND_USSD),
1081 data, reply, option);
1082 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::GET_IMS_CALL_DATA),
1083 data, reply, option);
1084 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::MMI_CODE_INFO_RESPONSE),
1085 data, reply, option);
1086 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::CLOSE_UNFINISHED_USSD),
1087 data, reply, option);
1088 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_SET_RESTRICTION_PWD),
1089 data, reply, option);
1090 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::POST_DIAL_CHAR),
1091 data, reply, option);
1092 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::POST_DIAL_DELAY),
1093 data, reply, option);
1094 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::CALL_SESSION_EVENT),
1095 data, reply, option);
1096 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::PEER_DIMENSION_CHANGE),
1097 data, reply, option);
1098 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::CALL_DATA_USAGE),
1099 data, reply, option);
1100 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(CallStatusInterfaceCode::CAMERA_CAPBILITIES_CHANGE),
1101 data, reply, option);
1102 callStatusCallback->OnRemoteRequest(static_cast<uint32_t>(
1103 CallStatusInterfaceCode::RECEIVE_UPDATE_MEDIA_MODE_REQUEST), data, reply, option);
1104 int32_t res = callStatusCallback->OnRemoteRequest(
1105 static_cast<uint32_t>(CallStatusInterfaceCode::UPDATE_VOIP_EVENT_INFO), data, reply, option);
1106 ASSERT_NE(res, TELEPHONY_SUCCESS);
1107 }
1108
1109 /**
1110 * @tc.number Telephony_CallStatusCallbackStub_003
1111 * @tc.name test error branch
1112 * @tc.desc Function test
1113 */
1114 HWTEST_F(ZeroBranch5Test, Telephony_CallStatusCallbackStub_003, TestSize.Level0)
1115 {
1116 auto callStatusCallback = std::make_shared<CallStatusCallback>();
1117 MessageParcel data;
1118 MessageParcel reply;
1119 int32_t accountId = 0;
1120 int32_t defaultNumber = 0;
1121 std::string defaultString = "";
1122 std::vector<uint8_t> userProfile = {};
1123 char accountNum[kMaxNumberLen + 1] = { 0 };
1124 data.WriteInterfaceToken(CallStatusCallbackStub::GetDescriptor());
1125 data.WriteInt32(0);
1126 data.WriteCString(accountNum);
1127 data.WriteInt32(accountId);
1128 data.WriteInt32(static_cast<int32_t>(CallType::TYPE_VOIP));
1129 data.WriteInt32(static_cast<int32_t>(VideoStateType::TYPE_VOICE));
1130 data.WriteInt32(static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE));
1131 data.WriteInt32(defaultNumber);
1132 data.WriteInt32(defaultNumber);
1133 data.WriteInt32(defaultNumber);
1134 data.WriteInt32(defaultNumber);
1135 data.WriteString(defaultString);
1136 data.WriteString(defaultString);
1137 data.WriteString(defaultString);
1138 data.WriteString(defaultString);
1139 data.WriteString(defaultString);
1140 data.WriteUInt8Vector(userProfile);
1141 data.RewindRead(0);
1142 ASSERT_EQ(callStatusCallback->OnUpdateCallReportInfo(data, reply), TELEPHONY_SUCCESS);
1143 }
1144 } // namespace Telephony
1145 } // namespace OHOS
1146