1 /*
2 * Copyright (C) 2021-2022 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
16 #include "call_manager_special_mock.h"
17 #include <thread>
18 #include <chrono>
19 #include "call_manager_connect.h"
20 #include "call_voice_assistant_manager.h"
21 #include "spam_call_adapter.h"
22 #include "bluetooth_call_client.h"
23 #include "bluetooth_call_manager.h"
24 #include "bluetooth_call_service.h"
25 #include "bluetooth_connection.h"
26 #include "iremote_broker.h"
27 #include "call_ability_connect_callback.h"
28 #include "call_ability_report_proxy.h"
29 #include "call_connect_ability.h"
30 #include "call_control_manager.h"
31 #include "call_manager_client.h"
32 #include "call_manager_hisysevent.h"
33 #include "call_number_utils.h"
34 #include "call_policy.h"
35 #include "call_records_manager.h"
36 #include "call_request_event_handler_helper.h"
37 #include "call_request_handler.h"
38 #include "call_request_process.h"
39 #include "call_setting_manager.h"
40 #include "call_state_report_proxy.h"
41 #include "call_status_manager.h"
42 #include "cellular_call_connection.h"
43 #include "common_event_manager.h"
44 #include "common_event_support.h"
45 #include "cs_call.h"
46 #include "cs_conference.h"
47 #include "distributed_call_manager.h"
48 #include "gtest/gtest.h"
49 #include "i_voip_call_manager_service.h"
50 #include "ims_call.h"
51 #include "ims_conference.h"
52 #include "incoming_call_notification.h"
53 #include "missed_call_notification.h"
54 #include "ott_call.h"
55 #include "ott_conference.h"
56 #include "reject_call_sms.h"
57 #include "report_call_info_handler.h"
58 #include "satellite_call.h"
59 #include "surface_utils.h"
60 #include "telephony_errors.h"
61 #include "telephony_hisysevent.h"
62 #include "telephony_log_wrapper.h"
63 #include "video_call_state.h"
64 #include "video_control_manager.h"
65 #include "voip_call_manager_proxy.h"
66 #include "voip_call.h"
67 #include "accesstoken_kit.h"
68 #include "token_setproc.h"
69 #include "nativetoken_kit.h"
70 #include "number_identity_data_base_helper.h"
71 #include "call_ability_callback_death_recipient.h"
72 #include "app_state_observer.h"
73 #include "call_ability_callback_proxy.h"
74 #include "super_privacy_manager_client.h"
75 #include "call_status_callback.h"
76 #include "satellite_call_control.h"
77 #include "proximity_sensor.h"
78 #include "status_bar.h"
79 #include "wired_headset.h"
80 #include "call_status_policy.h"
81 #include "call_superprivacy_control_manager.h"
82 #include "bluetooth_hfp_ag.h"
83 #include "call_manager_service.h"
84 #include "telephony_types.h"
85 #include "telephony_permission.h"
86 #include "voip_call_connection.h"
87 #include "number_identity_service.h"
88 #include "bluetooth_call.h"
89 #include "bluetooth_call_connection.h"
90 #include "bluetooth_call_state.h"
91 #include "call_broadcast_subscriber.h"
92 #include "call_incoming_filter_manager.h"
93 #include "call_object_manager.h"
94 #include "call_wired_headset.h"
95 #include "fold_status_manager.h"
96 #include "audio_control_manager.h"
97 #include "call_state_processor.h"
98
99 namespace OHOS {
100 namespace Telephony {
101 using namespace testing::ext;
102 const int PERMS_NUM = 6;
103
104 class SpecialBranch0Test : public testing::Test {
105 public:
106 static void SetUpTestCase();
107 static void TearDownTestCase();
108 void SetUp();
109 void TearDown();
110 };
111
SetUpTestCase()112 void SpecialBranch0Test::SetUpTestCase()
113 {
114 const char *perms[PERMS_NUM] = {
115 "ohos.permission.PLACE_CALL",
116 "ohos.permission.ANSWER_CALL",
117 "ohos.permission.SET_TELEPHONY_STATE",
118 "ohos.permission.GET_TELEPHONY_STATE",
119 "ohos.permission.READ_CALL_LOG",
120 "ohos.permission.WRITE_CALL_LOG",
121 };
122 NativeTokenInfoParams infoInstance = {
123 .dcapsNum = 0,
124 .permsNum = PERMS_NUM,
125 .aclsNum = 0,
126 .dcaps = nullptr,
127 .perms = perms,
128 .acls = nullptr,
129 .processName = "SpecialBranch0Test",
130 .aplStr = "system_basic",
131 };
132 uint64_t tokenId = GetAccessTokenId(&infoInstance);
133 SetSelfTokenID(tokenId);
134 auto result = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
135 EXPECT_EQ(result, Security::AccessToken::RET_SUCCESS);
136 }
137
TearDownTestCase()138 void SpecialBranch0Test::TearDownTestCase()
139 {
140 }
141
SetUp()142 void SpecialBranch0Test::SetUp()
143 {
144 }
145
TearDown()146 void SpecialBranch0Test::TearDown()
147 {
148 sleep(1);
149 }
150
151 /**
152 * @tc.number Telephony_NumberIdentityServiceHelper_002
153 * @tc.name test branch
154 * @tc.desc Function test
155 */
156 HWTEST_F(SpecialBranch0Test, Telephony_NumberIdentityServiceHelper_002, TestSize.Level0)
157 {
158 auto &help = DelayedRefSingleton<NumberIdentityServiceHelper>::GetInstance();
__anon29ab4de80102(sptr<IRemoteObject> remote) 159 ConnectedCallback onConnected = [&help](sptr<IRemoteObject> remote) {
160 TELEPHONY_LOGI("NumberIdentityService async notify end.");
161 if (help.working_) {
162 TELEPHONY_LOGI("NumberIdentityService notify task is working, skip this notify.");
163 }
164 };
__anon29ab4de80202() 165 DisconnectedCallback onDisconnected = [&help]() {
166 TELEPHONY_LOGI("NumberIdentityService notify task disconnected.");
167 if (help.working_) {
168 TELEPHONY_LOGI("NumberIdentityService notify task is working, skip this notify.");
169 }
170 };
171 int ret = help.Connect(onConnected, onDisconnected);
172 EXPECT_NE(ret, 0);
173 }
174
175 /**
176 * @tc.number Telephony_NumberIdentityServiceHelper_003
177 * @tc.name test branch
178 * @tc.desc Function test
179 */
180 HWTEST_F(SpecialBranch0Test, Telephony_NumberIdentityServiceHelper_003, TestSize.Level0)
181 {
182 auto &help = DelayedRefSingleton<NumberIdentityServiceHelper>().GetInstance();
183 help.working_ = true;
184 help.NotifyNumberMarkDataUpdate();
185 ASSERT_TRUE(help.connection_ != nullptr);
186 }
187
188 /**
189 * @tc.number Telephony_NumberIdentityConnection_001
190 * @tc.name test branch
191 * @tc.desc Function test
192 */
193 HWTEST_F(SpecialBranch0Test, Telephony_NumberIdentityConnection_001, TestSize.Level0)
194 {
195 sptr<NumberIdentityConnection> connection = new (std::nothrow) NumberIdentityConnection(
__anon29ab4de80302(const sptr<IRemoteObject> &remoteObject) 196 [](const sptr<IRemoteObject> &remoteObject) {}, []() {});
197 connection->disconnectedCallback_ = nullptr;
198 AppExecFwk::ElementName element;
199 sptr<OHOS::IRemoteObject> failRemoteObj = new MockRemoteObject(-1);
200 connection->OnAbilityConnectDone(element, failRemoteObj, -1);
201
202 auto proxy = std::make_shared<NumberIdentityServiceProxy>(failRemoteObj);
203 proxy->NotifyNumberMarkDataUpdate();
204
205 auto &help = DelayedRefSingleton<NumberIdentityServiceHelper>().GetInstance();
206 help.working_ = false;
207 proxy->NotifyNumberMarkDataUpdate();
208
209 help.connection_ = nullptr;
210 help.Disconnect();
211 ASSERT_TRUE(connection != nullptr);
212 }
213
214 /**
215 * @tc.number Telephony_CallManagerHisysevent_001
216 * @tc.name test branch
217 * @tc.desc Function test
218 */
219 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerHisysevent_001, TestSize.Level0)
220 {
221 std::shared_ptr<CallManagerHisysevent> callManagerHisysevent = std::make_shared<CallManagerHisysevent>();
222 std::string errorDesc;
223 callManagerHisysevent->GetErrorDescription(static_cast<int32_t>(CALL_ERR_PHONE_NUMBER_EMPTY), errorDesc);
224 callManagerHisysevent->GetErrorDescription(static_cast<int32_t>(CALL_ERR_UNKNOW_DIAL_TYPE), errorDesc);
225 callManagerHisysevent->GetErrorDescription(static_cast<int32_t>(TELEPHONY_ERR_LOCAL_PTR_NULL), errorDesc);
226 callManagerHisysevent->GetErrorDescription(static_cast<int32_t>(CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE), errorDesc);
227 callManagerHisysevent->GetErrorDescription(-1, errorDesc);
228 ASSERT_TRUE(callManagerHisysevent != nullptr);
229 }
230
231 /**
232 * @tc.number Telephony_CallSettingManager_001
233 * @tc.name test branch
234 * @tc.desc Function test
235 */
236 HWTEST_F(SpecialBranch0Test, Telephony_CallSettingManager_001, TestSize.Level1)
237 {
238 std::shared_ptr<CallSettingManager> callSettingManager = std::make_shared<CallSettingManager>();
239 ASSERT_TRUE(callSettingManager != nullptr);
240 callSettingManager->cellularCallConnectionPtr_ = nullptr;
241 callSettingManager->GetCallWaiting(0);
242 callSettingManager->SetCallWaiting(0, false);
243 int32_t ret = callSettingManager->GetImsFeatureValue(0, FeatureType::TYPE_VOICE_OVER_LTE);
244 EXPECT_NE(ret, 0);
245 }
246
247 /**
248 * @tc.number Telephony_CallVoiceAssistantManager_001
249 * @tc.name test branch
250 * @tc.desc Function test
251 */
252 HWTEST_F(SpecialBranch0Test, Telephony_CallVoiceAssistantManager_001, TestSize.Level0)
253 {
254 std::shared_ptr<CallVoiceAssistantManager> voicePtr = CallVoiceAssistantManager::GetInstance();
255 voicePtr->mInstance_ = nullptr;
256 voicePtr->GetInstance();
257 ASSERT_TRUE(voicePtr->GetInstance() != nullptr);
258 }
259
260 /**
261 * @tc.number Telephony_CallVoiceAssistantManager_002
262 * @tc.name test branch
263 * @tc.desc Function test
264 */
265 HWTEST_F(SpecialBranch0Test, Telephony_CallVoiceAssistantManager_002, TestSize.Level0)
266 {
267 std::shared_ptr<CallVoiceAssistantManager> voicePtr = CallVoiceAssistantManager::GetInstance();
268 ASSERT_FALSE(voicePtr->IsSwitchOn("1"));
269 }
270
271 /**
272 * @tc.number Telephony_CallVoiceAssistantManager_003
273 * @tc.name test branch
274 * @tc.desc Function test
275 */
276 HWTEST_F(SpecialBranch0Test, Telephony_CallVoiceAssistantManager_003, TestSize.Level0)
277 {
278 std::shared_ptr<CallVoiceAssistantManager> voicePtr = CallVoiceAssistantManager::GetInstance();
279 voicePtr->PublishCommonEvent(false, "a");
280 ASSERT_TRUE(voicePtr->GetInstance() != nullptr);
281 }
282
283 /**
284 * @tc.number Telephony_CallVoiceAssistantManager_004
285 * @tc.name test branch
286 * @tc.desc Function test
287 */
288 HWTEST_F(SpecialBranch0Test, Telephony_CallVoiceAssistantManager_004, TestSize.Level0)
289 {
290 std::shared_ptr<CallVoiceAssistantManager> voicePtr = CallVoiceAssistantManager::GetInstance();
291 voicePtr->SendRequest(nullptr, false);
292 auto info = std::make_shared<IncomingContactInformation>();
293 info->isQueryComplete = false;
294 voicePtr->SendRequest(info, false);
295 ASSERT_TRUE(voicePtr->GetInstance() != nullptr);
296 }
297
298 /**
299 * @tc.number Telephony_CallVoiceAssistantManager_005
300 * @tc.name test branch
301 * @tc.desc Function test
302 */
303 HWTEST_F(SpecialBranch0Test, Telephony_CallVoiceAssistantManager_005, TestSize.Level0)
304 {
305 auto voicePtr = std::make_shared<VoiceAssistantConnectCallback>(1);
306 AppExecFwk::ElementName element;
307 voicePtr->OnAbilityConnectDone(element, nullptr, 0);
308 sptr<IRemoteObject> remoteObject = sptr<VoiceAssistantConnectCallback>::MakeSptr(1);
309 voicePtr->OnAbilityConnectDone(element, remoteObject, -1);
310 ASSERT_TRUE(voicePtr != nullptr);
311 }
312
313 /**
314 * @tc.number Telephony_CallVoiceAssistantManager_006
315 * @tc.name test branch
316 * @tc.desc Function test
317 */
318 HWTEST_F(SpecialBranch0Test, Telephony_CallVoiceAssistantManager_006, TestSize.Level0)
319 {
320 std::shared_ptr<CallVoiceAssistantManager> voicePtr = CallVoiceAssistantManager::GetInstance();
321 std::u16string ret = voicePtr->GetSendString(nullptr);
322 ASSERT_TRUE(ret.empty());
323 }
324
325 /**
326 * @tc.number Telephony_CallVoiceAssistantManager_007
327 * @tc.name test branch
328 * @tc.desc Function test
329 */
330 HWTEST_F(SpecialBranch0Test, Telephony_CallVoiceAssistantManager_007, TestSize.Level0)
331 {
332 std::shared_ptr<CallVoiceAssistantManager> voicePtr = CallVoiceAssistantManager::GetInstance();
333 voicePtr->SetIsControlSwitchOn(true);
334 std::shared_ptr<VoiceAssistantSwitchObserver> observer = std::make_shared<VoiceAssistantSwitchObserver>();
335 observer->OnChange();
336 ASSERT_TRUE(voicePtr->GetInstance() != nullptr);
337 }
338
339 /**
340 * @tc.number Telephony_CallVoiceAssistantManager_009
341 * @tc.name test branch
342 * @tc.desc Function test
343 */
344 HWTEST_F(SpecialBranch0Test, Telephony_CallVoiceAssistantManager_009, TestSize.Level0)
345 {
346 std::shared_ptr<CallVoiceAssistantManager> voicePtr = CallVoiceAssistantManager::GetInstance();
347 voicePtr->nowCallId = 0;
348 voicePtr->nowAccountId = 0;
349 voicePtr->nowVoipCallState = static_cast<int32_t>(CallStateToApp::CALL_STATE_OFFHOOK);
350 voicePtr->CallStatusIncoming(1, 1);
351 voicePtr->nowVoipCallState = static_cast<int32_t>(CallStateToApp::CALL_STATE_ANSWERED);
352 voicePtr->CallStatusIncoming(1, 1);
353 ASSERT_TRUE(voicePtr->GetInstance() != nullptr);
354 }
355
356 /**
357 * @tc.number Telephony_CallVoiceAssistantManager_010
358 * @tc.name test branch
359 * @tc.desc Function test
360 */
361 HWTEST_F(SpecialBranch0Test, Telephony_CallVoiceAssistantManager_010, TestSize.Level0)
362 {
363 std::shared_ptr<CallVoiceAssistantManager> voicePtr = CallVoiceAssistantManager::GetInstance();
364 voicePtr->accountIds[1] = std::make_shared<IncomingContactInformation>();
365 voicePtr->nowCallId = 0;
366 voicePtr->nowAccountId = 0;
367 voicePtr->CallStatusDialing(1, 1);
368 ASSERT_TRUE(voicePtr->GetInstance() != nullptr);
369 }
370
371 /**
372 * @tc.number Telephony_CallVoiceAssistantManager_011
373 * @tc.name test branch
374 * @tc.desc Function test
375 */
376 HWTEST_F(SpecialBranch0Test, Telephony_CallVoiceAssistantManager_011, TestSize.Level0)
377 {
378 std::shared_ptr<CallVoiceAssistantManager> voicePtr = CallVoiceAssistantManager::GetInstance();
379 auto info = std::make_shared<IncomingContactInformation>();
380 info->call_status = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
381 voicePtr->accountIds[1] = info;
382 voicePtr->nowCallId = 0;
383 voicePtr->nowAccountId = 0;
384 voicePtr->CallStatusDisconnected(1, 1);
385
386 info->call_status = static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING);
387 voicePtr->CallStatusDisconnected(1, 1);
388 ASSERT_TRUE(voicePtr->GetInstance() != nullptr);
389 }
390
391 /**
392 * @tc.number Telephony_CallVoiceAssistantManager_012
393 * @tc.name test branch
394 * @tc.desc Function test
395 */
396 HWTEST_F(SpecialBranch0Test, Telephony_CallVoiceAssistantManager_012, TestSize.Level0)
397 {
398 std::shared_ptr<CallVoiceAssistantManager> voicePtr = CallVoiceAssistantManager::GetInstance();
399 auto info = std::make_shared<IncomingContactInformation>();
400 info->call_status = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
401 voicePtr->accountIds[1] = info;
402 voicePtr->nowCallId = 0;
403 voicePtr->nowAccountId = 0;
404 int32_t ret = voicePtr->CheckTelCallState(TelCallState::CALL_STATUS_WAITING);
405 EXPECT_NE(ret, 0);
406 }
407
408 /**
409 * @tc.number Telephony_CallVoiceAssistantManager_014
410 * @tc.name test branch
411 * @tc.desc Function test
412 */
413 HWTEST_F(SpecialBranch0Test, Telephony_CallVoiceAssistantManager_014, TestSize.Level0)
414 {
415 std::shared_ptr<CallVoiceAssistantManager> voicePtr = CallVoiceAssistantManager::GetInstance();
416 voicePtr->UpdateReplyData("a\"\"b");
417 ASSERT_TRUE(voicePtr->GetInstance() != nullptr);
418 }
419
420 /**
421 * @tc.number Telephony_SpamCallAdapter_001
422 * @tc.name test branch
423 * @tc.desc Function test
424 */
425 HWTEST_F(SpecialBranch0Test, Telephony_SpamCallAdapter_001, TestSize.Level0)
426 {
427 std::shared_ptr<SpamCallAdapter> spamCallAdapter = std::make_shared<SpamCallAdapter>();
428 bool isBlock = false;
429 NumberMarkInfo info;
430 int32_t blockReason = 0;
431 std::string detectDetails;
432 spamCallAdapter->GetParseResult(isBlock, info, blockReason, detectDetails);
433 EXPECT_EQ(blockReason, 0);
434 }
435
436 /**
437 * @tc.number Telephony_SpamCallAdapter_002
438 * @tc.name test branch
439 * @tc.desc Function test
440 */
441 HWTEST_F(SpecialBranch0Test, Telephony_SpamCallAdapter_002, TestSize.Level0)
442 {
443 std::shared_ptr<SpamCallAdapter> spamCallAdapter = std::make_shared<SpamCallAdapter>();
444 std::string phone = spamCallAdapter->GetDetectPhoneNum();
445 ASSERT_TRUE(phone.empty());
446 }
447
448 /**
449 * @tc.number Telephony_SpamCallAdapter_003
450 * @tc.name test branch
451 * @tc.desc Function test
452 */
453 HWTEST_F(SpecialBranch0Test, Telephony_SpamCallAdapter_003, TestSize.Level0)
454 {
455 std::shared_ptr<SpamCallAdapter> spamCallAdapter = std::make_shared<SpamCallAdapter>();
456 spamCallAdapter->timeWaitHelper_ = nullptr;
457 ASSERT_FALSE(spamCallAdapter->WaitForDetectResult());
458 }
459
460 /**
461 * @tc.number Telephony_CallManagerServiceStub_001
462 * @tc.name test branch
463 * @tc.desc Function test
464 */
465 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerServiceStub_001, TestSize.Level1)
466 {
467 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
468 ASSERT_TRUE(callManagerService != nullptr);
469 MessageParcel data;
470 MessageParcel reply;
471 MessageOption option;
472 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
473 data.RewindRead(0);
474 int32_t ret = callManagerService->OnRemoteRequest(
475 static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_BLUETOOTH_REGISTER_CALLBACKPTR), data, reply, option);
476 EXPECT_EQ(ret, 0);
477 }
478
479 /**
480 * @tc.number Telephony_CallManagerServiceStub_002
481 * @tc.name test branch
482 * @tc.desc Function test
483 */
484 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerServiceStub_002, TestSize.Level0)
485 {
486 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
487 ASSERT_TRUE(callManagerService != nullptr);
488 MessageParcel data;
489 MessageParcel reply;
490 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
491 data.RewindRead(0);
492 int32_t ret = callManagerService->OnRegisterCallBack(data, reply);
493 EXPECT_NE(ret, 0);
494 }
495
496 /**
497 * @tc.number Telephony_CallManagerServiceStub_003
498 * @tc.name test branch
499 * @tc.desc Function test
500 */
501 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerServiceStub_003, TestSize.Level0)
502 {
503 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
504 ASSERT_TRUE(callManagerService != nullptr);
505 MessageParcel data;
506 MessageParcel reply;
507 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
508 data.RewindRead(0);
509 int32_t ret = callManagerService->OnUnRegisterCallBack(data, reply);
510 EXPECT_NE(ret, 0);
511 }
512
513 /**
514 * @tc.number Telephony_CallManagerServiceStub_004
515 * @tc.name test branch
516 * @tc.desc Function test
517 */
518 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerServiceStub_004, TestSize.Level1)
519 {
520 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
521 ASSERT_TRUE(callManagerService != nullptr);
522 MessageParcel data;
523 MessageParcel reply;
524 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
525 data.RewindRead(0);
526 int32_t ret = callManagerService->OnObserverOnCallDetailsChange(data, reply);
527 EXPECT_EQ(ret, 0);
528 }
529
530 /**
531 * @tc.number Telephony_CallManagerServiceStub_005
532 * @tc.name test branch
533 * @tc.desc Function test
534 */
535 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerServiceStub_005, TestSize.Level0)
536 {
537 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
538 ASSERT_TRUE(callManagerService != nullptr);
539 MessageParcel data;
540 MessageParcel reply;
541 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
542 data.RewindRead(0);
543 int32_t ret = callManagerService->OnMakeCall(data, reply);
544 EXPECT_NE(ret, 0);
545 }
546
547 /**
548 * @tc.number Telephony_CallManagerServiceStub_006
549 * @tc.name test branch
550 * @tc.desc Function test
551 */
552 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerServiceStub_006, TestSize.Level0)
553 {
554 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
555 ASSERT_TRUE(callManagerService != nullptr);
556 MessageParcel data;
557 MessageParcel reply;
558 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
559 data.RewindRead(0);
560 int32_t ret = callManagerService->OnSetPreviewWindow(data, reply);
561 EXPECT_EQ(ret, 0);
562 }
563
564 /**
565 * @tc.number Telephony_CallManagerServiceStub_007
566 * @tc.name test branch
567 * @tc.desc Function test
568 */
569 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerServiceStub_007, TestSize.Level0)
570 {
571 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
572 ASSERT_TRUE(callManagerService != nullptr);
573 MessageParcel data;
574 MessageParcel reply;
575 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
576 data.RewindRead(0);
577 int32_t ret = callManagerService->OnSetDisplayWindow(data, reply);
578 EXPECT_EQ(ret, 0);
579 }
580
581 /**
582 * @tc.number Telephony_CallManagerServiceStub_008
583 * @tc.name test branch
584 * @tc.desc Function test
585 */
586 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerServiceStub_008, TestSize.Level0)
587 {
588 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
589 ASSERT_TRUE(callManagerService != nullptr);
590 MessageParcel data;
591 MessageParcel reply;
592 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
593 data.RewindRead(0);
594 int32_t temp = 1;
595 data.WriteRawData((const void *)&temp, sizeof(int32_t));
596 int32_t ret = callManagerService->OnReportOttCallDetailsInfo(data, reply);
597 EXPECT_NE(ret, 0);
598 }
599
600 /**
601 * @tc.number Telephony_CallManagerServiceStub_009
602 * @tc.name test branch
603 * @tc.desc Function test
604 */
605 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerServiceStub_009, TestSize.Level0)
606 {
607 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
608 callManagerService->CancelTimer(1);
609 ASSERT_TRUE(callManagerService != nullptr);
610 }
611
612 /**
613 * @tc.number Telephony_CallManagerServiceStub_010
614 * @tc.name test branch
615 * @tc.desc Function test
616 */
617 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerServiceStub_010, TestSize.Level1)
618 {
619 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
620 ASSERT_TRUE(callManagerService != nullptr);
621 MessageParcel data;
622 MessageParcel reply;
623 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
624 data.RewindRead(0);
625 int32_t temp = 1;
626 data.WriteRawData((const void *)&temp, sizeof(int32_t));
627 int32_t ret = callManagerService->OnRegisterBluetoothCallManagerCallbackPtr(data, reply);
628 EXPECT_EQ(ret, 0);
629 }
630
631 /**
632 * @tc.number Telephony_CallManagerService_001
633 * @tc.name test branch
634 * @tc.desc Function test
635 */
636 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_001, TestSize.Level0)
637 {
638 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
639 callManagerService->OnAddSystemAbility(3009, "");
640 callManagerService->OnAddSystemAbility(4802, "");
641 ASSERT_TRUE(callManagerService != nullptr);
642 }
643
644 /**
645 * @tc.number Telephony_CallManagerService_002
646 * @tc.name test branch
647 * @tc.desc Function test
648 */
649 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_002, TestSize.Level0)
650 {
651 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
652 callManagerService->UnInit();
653 ASSERT_TRUE(callManagerService != nullptr);
654 }
655
656 /**
657 * @tc.number Telephony_CallManagerService_005
658 * @tc.name test branch
659 * @tc.desc Function test
660 */
661 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_005, TestSize.Level0)
662 {
663 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
664 ASSERT_TRUE(callManagerService != nullptr);
665 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
666 int32_t ret = callManagerService->PostDialProceed(1, false);
667 EXPECT_NE(ret, 0);
668 }
669
670 /**
671 * @tc.number Telephony_CallManagerService_006
672 * @tc.name test branch
673 * @tc.desc Function test
674 */
675 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_006, TestSize.Level0)
676 {
677 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
678 ASSERT_TRUE(callManagerService != nullptr);
679 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
680 CallTransferInfo info;
681 int32_t ret = callManagerService->SetCallTransferInfo(0, info);
682 EXPECT_NE(ret, 0);
683 }
684
685 /**
686 * @tc.number Telephony_CallManagerService_007
687 * @tc.name test branch
688 * @tc.desc Function test
689 */
690 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_007, TestSize.Level0)
691 {
692 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
693 ASSERT_TRUE(callManagerService != nullptr);
694 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
695 std::u16string msg;
696 int32_t ret = callManagerService->StartRtt(0, msg);
697 EXPECT_NE(ret, 0);
698 }
699
700 /**
701 * @tc.number Telephony_CallManagerService_008
702 * @tc.name test branch
703 * @tc.desc Function test
704 */
705 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_008, TestSize.Level0)
706 {
707 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
708 ASSERT_TRUE(callManagerService != nullptr);
709 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
710 int32_t ret = callManagerService->StopRtt(0);
711 EXPECT_NE(ret, 0);
712 }
713
714 /**
715 * @tc.number Telephony_CallManagerService_009
716 * @tc.name test branch
717 * @tc.desc Function test
718 */
719 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_009, TestSize.Level0)
720 {
721 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
722 ASSERT_TRUE(callManagerService != nullptr);
723 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
724 int32_t ret = callManagerService->KickOutFromConference(0);
725 EXPECT_NE(ret, 0);
726 }
727
728 /**
729 * @tc.number Telephony_CallManagerService_010
730 * @tc.name test branch
731 * @tc.desc Function test
732 */
733 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_010, TestSize.Level0)
734 {
735 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
736 ASSERT_TRUE(callManagerService != nullptr);
737 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
738 int32_t ret = callManagerService->SetMuted(false);
739 EXPECT_NE(ret, 0);
740 }
741
742 /**
743 * @tc.number Telephony_CallManagerService_011
744 * @tc.name test branch
745 * @tc.desc Function test
746 */
747 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_011, TestSize.Level1)
748 {
749 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
750 ASSERT_TRUE(callManagerService != nullptr);
751 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
752 int32_t ret = callManagerService->MuteRinger();
753 EXPECT_EQ(ret, 0);
754 }
755
756 /**
757 * @tc.number Telephony_CallManagerService_012
758 * @tc.name test branch
759 * @tc.desc Function test
760 */
761 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_012, TestSize.Level0)
762 {
763 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
764 ASSERT_TRUE(callManagerService != nullptr);
765 callManagerService->callControlManagerPtr_ = nullptr;
766 int32_t ret = callManagerService->CloseUnFinishedUssd(0);
767 EXPECT_NE(ret, 0);
768 }
769
770 /**
771 * @tc.number Telephony_CallManagerService_013
772 * @tc.name test branch
773 * @tc.desc Function test
774 */
775 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_013, TestSize.Level1)
776 {
777 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
778 ASSERT_TRUE(callManagerService != nullptr);
779 callManagerService->supportSpecialCode_[0] = "123";
780 int32_t ret = callManagerService->InputDialerSpecialCode("123");
781 EXPECT_EQ(ret, 0);
782 }
783
784 /**
785 * @tc.number Telephony_CallManagerService_014
786 * @tc.name test branch
787 * @tc.desc Function test
788 */
789 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_014, TestSize.Level0)
790 {
791 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
792 ASSERT_TRUE(callManagerService != nullptr);
793 callManagerService->callControlManagerPtr_ = nullptr;
794 int32_t ret = callManagerService->SetVoIPCallState(0);
795 EXPECT_NE(ret, 0);
796 }
797
798 /**
799 * @tc.number Telephony_CallManagerService_015
800 * @tc.name test branch
801 * @tc.desc Function test
802 */
803 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_015, TestSize.Level1)
804 {
805 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
806 ASSERT_TRUE(callManagerService != nullptr);
807 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
808 int32_t ret = callManagerService->SetVoIPCallState(0);
809 EXPECT_EQ(ret, 0);
810 }
811
812 /**
813 * @tc.number Telephony_CallManagerService_016
814 * @tc.name test branch
815 * @tc.desc Function test
816 */
817 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_016, TestSize.Level0)
818 {
819 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
820 ASSERT_TRUE(callManagerService != nullptr);
821 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
822 int32_t callId = 0;
823 int32_t state = 0;
824 std::string phoneNumber;
825 int32_t ret = callManagerService->GetVoIPCallInfo(callId, state, phoneNumber);
826 EXPECT_EQ(ret, 0);
827 }
828
829 /**
830 * @tc.number Telephony_CallManagerService_017
831 * @tc.name test branch
832 * @tc.desc Function test
833 */
834 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_017, TestSize.Level0)
835 {
836 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
837 ASSERT_TRUE(callManagerService != nullptr);
838 sptr<OHOS::IRemoteObject> failRemoteObj = new MockRemoteObject(-1);
839 callManagerService->proxyObjectPtrMap_[1] = failRemoteObj;
840 sptr<IRemoteObject> ret = callManagerService->GetProxyObjectPtr(static_cast<CallManagerProxyType>(1));
841 EXPECT_NE(ret, nullptr);
842 }
843
844 /**
845 * @tc.number Telephony_CallManagerService_018
846 * @tc.name test branch
847 * @tc.desc Function test
848 */
849 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_018, TestSize.Level0)
850 {
851 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
852 ASSERT_TRUE(callManagerService != nullptr);
853 DialParaInfo dialParaInfo;
854 dialParaInfo.callId = 1;
855 sptr<CallBase> callObjectPtr = new CSCall(dialParaInfo);
856 CallObjectManager::AddOneCallObject(callObjectPtr);
857 int32_t ret = callManagerService->dealCeliaCallEvent(1);
858 EXPECT_EQ(ret, 0);
859 }
860
861 /**
862 * @tc.number Telephony_CallManagerService_019
863 * @tc.name test branch
864 * @tc.desc Function test
865 */
866 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_019, TestSize.Level1)
867 {
868 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
869 ASSERT_TRUE(callManagerService != nullptr);
870 CallObjectManager::callObjectPtrList_.clear();
871 DialParaInfo info;
872 sptr<CallBase> call = new IMSCall(info);
873 call->SetCallId(0);
874 CallObjectManager::AddOneCallObject(call);
875 std::string eventName = "DISPLAY_SPECIFIED_CALL_PAGE_BY_CALL_ID";
876 callManagerService->SendCallUiEvent(1, eventName);
877 eventName = "EVENT_CELIA_AUTO_ANSWER_CALL_ON";
878 callManagerService->SendCallUiEvent(1, eventName);
879 eventName = "EVENT_CELIA_AUTO_ANSWER_CALL_OFF";
880 callManagerService->SendCallUiEvent(1, eventName);
881
882 CallObjectManager::callObjectPtrList_.clear();
883 call->SetCallId(1);
884 CallObjectManager::AddOneCallObject(call);
885 eventName = "DISPLAY_SPECIFIED_CALL_PAGE_BY_CALL_ID";
886 callManagerService->SendCallUiEvent(1, eventName);
887 eventName = "EVENT_CELIA_AUTO_ANSWER_CALL_ON";
888 callManagerService->SendCallUiEvent(1, eventName);
889 ASSERT_TRUE(call->IsAiAutoAnswer());
890 eventName = "EVENT_CELIA_AUTO_ANSWER_CALL_OFF";
891 callManagerService->SendCallUiEvent(1, eventName);
892 ASSERT_FALSE(call->IsAiAutoAnswer());
893 eventName = "EVENT_BLUETOOTH_SCO_STATE_OFF";
894 callManagerService->SendCallUiEvent(1, eventName);
895 eventName = "EVENT_BLUETOOTH_SCO_STATE_ON";
896 callManagerService->SendCallUiEvent(1, eventName);
897 eventName = "EVENT_NOT_SUPPORT_BLUETOOTH_CALL";
898 callManagerService->SendCallUiEvent(1, eventName);
899 eventName = "EVENT_VOIP_CALL_SUCCESS";
900 callManagerService->SendCallUiEvent(1, eventName);
901 eventName = "EVENT_VOIP_CALL_FAILED";
902 callManagerService->SendCallUiEvent(1, eventName);
903 call->SetCallType(CallType::TYPE_VOIP);
904 callManagerService->HandleVoIPCallEvent(1, eventName);
905 callManagerService->HandleVoIPCallEvent(2, eventName);
906 eventName = "123";
907 int32_t ret = callManagerService->SendCallUiEvent(1, eventName);
908 EXPECT_EQ(ret, 0);
909 }
910
911 /**
912 * @tc.number Telephony_CallManagerService_021
913 * @tc.name test branch
914 * @tc.desc Function test
915 */
916 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_021, TestSize.Level0)
917 {
918 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
919 ASSERT_TRUE(callManagerService != nullptr);
920 callManagerService->callControlManagerPtr_ = nullptr;
921 int32_t ret = callManagerService->RemoveMissedIncomingCallNotification();
922 EXPECT_NE(ret, 0);
923 }
924
925 /**
926 * @tc.number Telephony_CallManagerService_022
927 * @tc.name test branch
928 * @tc.desc Function test
929 */
930 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_022, TestSize.Level0)
931 {
932 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
933 ASSERT_TRUE(callManagerService != nullptr);
934 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
935 int32_t ret = callManagerService->UnHoldCall(0);
936 EXPECT_NE(ret, 0);
937 }
938
939 /**
940 * @tc.number Telephony_CallManagerService_023
941 * @tc.name test branch
942 * @tc.desc Function test
943 */
944 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_023, TestSize.Level0)
945 {
946 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
947 ASSERT_TRUE(callManagerService != nullptr);
948 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
949 bool result;
950 int32_t ret = callManagerService->CanSetCallTransferTime(0, result);
951 EXPECT_NE(ret, 0);
952 }
953
954 /**
955 * @tc.number Telephony_CallManagerService_024
956 * @tc.name test branch
957 * @tc.desc Function test
958 */
959 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_024, TestSize.Level0)
960 {
961 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
962 ASSERT_TRUE(callManagerService != nullptr);
963 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
964 int32_t mode = 0;
965 int32_t ret = callManagerService->SetCallPreferenceMode(0, mode);
966 EXPECT_NE(ret, 0);
967 }
968
969 /**
970 * @tc.number Telephony_CallManagerService_025
971 * @tc.name test branch
972 * @tc.desc Function test
973 */
974 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_025, TestSize.Level0)
975 {
976 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
977 ASSERT_TRUE(callManagerService != nullptr);
978 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
979 int32_t ret = callManagerService->SeparateConference(0);
980 EXPECT_NE(ret, 0);
981 }
982
983 /**
984 * @tc.number Telephony_CallManagerService_026
985 * @tc.name test branch
986 * @tc.desc Function test
987 */
988 HWTEST_F(SpecialBranch0Test, Telephony_CallManagerService_026, TestSize.Level0)
989 {
990 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
991 ASSERT_TRUE(callManagerService != nullptr);
992 callManagerService->callControlManagerPtr_ = std::make_shared<CallControlManager>();
993 AudioDevice audioDevice;
994 int32_t ret = callManagerService->SetAudioDevice(audioDevice);
995 EXPECT_NE(ret, 0);
996 }
997 } // namespace Telephony
998 } // namespace OHOS
999