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