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 #include "edm_call_policy.h"
79
80 namespace OHOS {
81 namespace Telephony {
82 using namespace testing::ext;
83
84 namespace {
85 const int32_t INVALID_SLOTID = 2;
86 const int32_t SIM1_SLOTID = 0;
87 const int32_t DEFAULT_INDEX = 1;
88 const int16_t CAMERA_ROTATION_0 = 0;
89 const int16_t CAMERA_ROTATION_90 = 90;
90 const int16_t CAMERA_ROTATION_180 = 180;
91 const int16_t CAMERA_ROTATION_270 = 270;
92 const int32_t INVALID_MODE = 0;
93 const int32_t VALID_CALLID = 1;
94 const int32_t ERROR_CALLID = -1;
95 const int32_t ONE_TIME = 1;
96 const int32_t STEP_1 = 1;
97 const int32_t SOURCE_CALL = 2;
98 constexpr int16_t DEFAULT_TIME = 0;
99 constexpr const char *TEST_STR = "123";
100 constexpr const char *LONG_STR =
101 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
102 "111111111";
103 } // namespace
104
105 class DemoHandler : public AppExecFwk::EventHandler {
106 public:
DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> & eventRunner)107 explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &eventRunner) : AppExecFwk::EventHandler(eventRunner)
108 {}
~DemoHandler()109 virtual ~DemoHandler() {}
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)110 void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
111 };
112
113 class ZeroBranch2Test : public testing::Test {
114 public:
115 void SetUp();
116 void TearDown();
117 static void SetUpTestCase();
118 static void TearDownTestCase();
119 };
120
SetUp()121 void ZeroBranch2Test::SetUp() {}
122
TearDown()123 void ZeroBranch2Test::TearDown() {}
124
SetUpTestCase()125 void ZeroBranch2Test::SetUpTestCase()
126 {
127 constexpr int permissionNum = 1;
128 const char *perms[permissionNum] = {
129 "ohos.permission.GET_TELEPHONY_STATE"
130 };
131 NativeTokenInfoParams infoInstance = {
132 .dcapsNum = 0, // Indicates the capsbility list of the sa.
133 .permsNum = permissionNum,
134 .aclsNum = 0, // acls is the list of rights thar can be escalated.
135 .dcaps = nullptr,
136 .perms = perms,
137 .acls = nullptr,
138 .processName = "ZeroBranch2Test",
139 .aplStr = "system_basic",
140 };
141 uint64_t tokenId = GetAccessTokenId(&infoInstance);
142 SetSelfTokenID(tokenId);
143 auto result = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
144 EXPECT_EQ(result, Security::AccessToken::RET_SUCCESS);
145 }
146
TearDownTestCase()147 void ZeroBranch2Test::TearDownTestCase() {}
148
CreateDataShareHelper(std::string uri)149 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(std::string uri)
150 {
151 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
152 if (saManager == nullptr) {
153 printf("Get system ability mgr failed.");
154 return nullptr;
155 }
156 auto remoteObj = saManager->GetSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
157 if (remoteObj == nullptr) {
158 printf("GetSystemAbility Service Failed.");
159 return nullptr;
160 }
161 return DataShare::DataShareHelper::Creator(remoteObj, uri);
162 }
163
164 /**
165 * @tc.number Telephony_CallRequestHandler_001
166 * @tc.name test error branch
167 * @tc.desc Function test
168 */
169 HWTEST_F(ZeroBranch2Test, Telephony_CallRequestHandler_001, Function | MediumTest | Level1)
170 {
171 std::unique_ptr<CallRequestHandler> callRequestHandler = std::make_unique<CallRequestHandler>();
172 ASSERT_NE(callRequestHandler->DialCall(), TELEPHONY_ERR_SUCCESS);
173 ASSERT_NE(callRequestHandler->AnswerCall(1, 1), TELEPHONY_ERR_SUCCESS);
174 std::string content = "";
175 ASSERT_NE(callRequestHandler->RejectCall(1, true, content), TELEPHONY_ERR_SUCCESS);
176 ASSERT_NE(callRequestHandler->HangUpCall(1), TELEPHONY_ERR_SUCCESS);
177 ASSERT_NE(callRequestHandler->HoldCall(1), TELEPHONY_ERR_SUCCESS);
178 ASSERT_NE(callRequestHandler->UnHoldCall(1), TELEPHONY_ERR_SUCCESS);
179 ASSERT_NE(callRequestHandler->SwitchCall(1), TELEPHONY_ERR_SUCCESS);
180 ASSERT_NE(callRequestHandler->CombineConference(1), TELEPHONY_ERR_SUCCESS);
181 ASSERT_NE(callRequestHandler->SeparateConference(1), TELEPHONY_ERR_SUCCESS);
182 ASSERT_NE(callRequestHandler->KickOutFromConference(1), TELEPHONY_ERR_SUCCESS);
183 std::u16string test = u"";
184 ASSERT_NE(callRequestHandler->StartRtt(1, test), TELEPHONY_ERR_SUCCESS);
185 ASSERT_NE(callRequestHandler->StopRtt(1), TELEPHONY_ERR_SUCCESS);
186 std::vector<std::string> emptyRecords = {};
187 ASSERT_NE(callRequestHandler->JoinConference(1, emptyRecords), TELEPHONY_ERR_SUCCESS);
188 }
189
190 /**
191 * @tc.number Telephony_CallRequestProcess_001
192 * @tc.name test error branch
193 * @tc.desc Function test
194 */
195 HWTEST_F(ZeroBranch2Test, Telephony_CallRequestProcess_001, Function | MediumTest | Level1)
196 {
197 std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
198 callRequestProcess->DialRequest();
199 callRequestProcess->AnswerRequest(1, 1);
200 std::string content = "";
201 callRequestProcess->RejectRequest(1, true, content);
202 callRequestProcess->HangUpRequest(1);
203 callRequestProcess->HoldRequest(1);
204 callRequestProcess->UnHoldRequest(1);
205 callRequestProcess->SwitchRequest(1);
206 callRequestProcess->CombineConferenceRequest(1);
207 callRequestProcess->SeparateConferenceRequest(1);
208 callRequestProcess->KickOutFromConferenceRequest(1);
209 std::u16string test = u"";
210 callRequestProcess->StartRttRequest(1, test);
211 callRequestProcess->StopRttRequest(1);
212 std::vector<std::string> numberList = {};
213 callRequestProcess->JoinConference(1, numberList);
214 DialParaInfo mDialParaInfo;
215 callRequestProcess->UpdateCallReportInfo(mDialParaInfo, TelCallState::CALL_STATUS_INCOMING);
216 callRequestProcess->HandleDialFail();
217 callRequestProcess->GetOtherRingingCall(1);
218 callRequestProcess->CarrierDialProcess(mDialParaInfo);
219 callRequestProcess->IsDialCallForDsda(mDialParaInfo);
220 bool isEcc = false;
221 std::string phoneNumber = "123456789012";
222 callRequestProcess->HandleEccCallForDsda(phoneNumber, mDialParaInfo, isEcc);
223 callRequestProcess->VoiceMailDialProcess(mDialParaInfo);
224 callRequestProcess->OttDialProcess(mDialParaInfo);
225 CellularCallInfo mCellularCallInfo;
226 callRequestProcess->PackCellularCallInfo(mDialParaInfo, mCellularCallInfo);
227 std::vector<std::u16string> testList = {};
228 callRequestProcess->IsFdnNumber(testList, content);
229 callRequestProcess->IsDsdsMode3();
230 callRequestProcess->DisconnectOtherSubIdCall(1, 0, 0);
231 callRequestProcess->DisconnectOtherCallForVideoCall(1);
232 mDialParaInfo.number = "*#21#";
233 callRequestProcess->CarrierDialProcess(mDialParaInfo);
234 ASSERT_FALSE(callRequestProcess->IsDsdsMode5());
235 }
236
237 /**
238 * @tc.number Telephony_CallRequestProcess_002
239 * @tc.name test error branch
240 * @tc.desc Function test
241 */
242 HWTEST_F(ZeroBranch2Test, Telephony_CallRequestProcess_002, Function | MediumTest | Level1)
243 {
244 std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
245 callRequestProcess->HoldOrDisconnectedCall(VALID_CALLID, SIM1_SLOTID, 1);
246 DialParaInfo mDialParaInfo;
247 sptr<CallBase> call = new CSCall(mDialParaInfo);
248 call->SetCallId(VALID_CALLID);
249 call->SetCallType(CallType::TYPE_VOIP);
250 call->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
251 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
252 callRequestProcess->AddOneCallObject(call);
253 callRequestProcess->AnswerRequest(VALID_CALLID, static_cast<int>(CallType::TYPE_VOIP));
254 callRequestProcess->AnswerRequest(VALID_CALLID, static_cast<int>(CallType::TYPE_CS));
255 callRequestProcess->NeedAnswerVTAndEndActiveVO(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
256 callRequestProcess->NeedAnswerVTAndEndActiveVO(ERROR_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
257 callRequestProcess->NeedAnswerVOAndEndActiveVT(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VOICE));
258 callRequestProcess->NeedAnswerVOAndEndActiveVT(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
259 sptr<CallBase> voipCall = new VoIPCall(mDialParaInfo);
260 voipCall->SetCallId(VALID_CALLID);
261 voipCall->SetCallType(CallType::TYPE_VOIP);
262 voipCall->SetTelCallState(TelCallState::CALL_STATUS_HOLDING);
263 voipCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_HOLD);
264 callRequestProcess->AddOneCallObject(voipCall);
265 callRequestProcess->NeedAnswerVTAndEndActiveVO(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
266 callRequestProcess->NeedAnswerVTAndEndActiveVO(ERROR_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
267 callRequestProcess->NeedAnswerVOAndEndActiveVT(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VOICE));
268 callRequestProcess->NeedAnswerVOAndEndActiveVT(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
269 callRequestProcess->GetOtherRingingCall(VALID_CALLID);
270 callRequestProcess->GetOtherRingingCall(ERROR_CALLID);
271 callRequestProcess->HoldOrDisconnectedCall(VALID_CALLID, SIM1_SLOTID,
272 static_cast<int>(VideoStateType::TYPE_VIDEO));
273 callRequestProcess->HoldOrDisconnectedCall(VALID_CALLID, SIM1_SLOTID,
274 static_cast<int>(VideoStateType::TYPE_VOICE));
275 std::list<int32_t> list = {1, 2, -1, 0};
276 bool noOtherCall = false;
277 callRequestProcess->IsExistCallOtherSlot(list, SIM1_SLOTID, noOtherCall);
278 sptr<CallBase> dialCall = new IMSCall(mDialParaInfo);
279 dialCall->SetCallId(VALID_CALLID);
280 dialCall->SetCallType(CallType::TYPE_VOIP);
281 dialCall->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
282 dialCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_DIALING);
283 callRequestProcess->AddOneCallObject(dialCall);
284 sptr<CallBase> incomingCall = new CSCall(mDialParaInfo);
285 incomingCall->SetCallType(CallType::TYPE_CS);
286 bool flagForConference = false;
287 callRequestProcess->HandleCallWaitingNumZero(incomingCall, voipCall, SIM1_SLOTID, 2, flagForConference);
288 callRequestProcess->HandleCallWaitingNumZero(incomingCall, dialCall, SIM1_SLOTID, 2, flagForConference);
289 callRequestProcess->DisconnectOtherCallForVideoCall(VALID_CALLID);
290 ASSERT_FALSE(flagForConference);
291 }
292
293 /**
294 * @tc.number Telephony_CallRequestProcess_003
295 * @tc.name test error branch
296 * @tc.desc Function test
297 */
298 HWTEST_F(ZeroBranch2Test, Telephony_CallRequestProcess_003, Function | MediumTest | Level1)
299 {
300 std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
301 DialParaInfo mDialParaInfo;
302 sptr<CallBase> call = nullptr;
303 callRequestProcess->DeleteOneCallObject(call);
304 call = new CSCall(mDialParaInfo);
305 call->SetCallId(VALID_CALLID);
306 call->SetCallType(CallType::TYPE_VOIP);
307 call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
308 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
309 callRequestProcess->AddOneCallObject(call);
310 callRequestProcess->DisconnectOtherSubIdCall(VALID_CALLID, SIM1_SLOTID,
311 static_cast<int>(VideoStateType::TYPE_VIDEO));
312 sptr<CallBase> dialCall = new IMSCall(mDialParaInfo);
313 dialCall->SetCallId(2);
314 dialCall->SetCallType(CallType::TYPE_VOIP);
315 dialCall->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
316 dialCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_DIALING);
317 callRequestProcess->AddOneCallObject(dialCall);
318 callRequestProcess->DisconnectOtherSubIdCall(VALID_CALLID, SIM1_SLOTID,
319 static_cast<int>(VideoStateType::TYPE_VIDEO));
320 callRequestProcess->DisconnectOtherCallForVideoCall(VALID_CALLID);
321 callRequestProcess->DisconnectOtherCallForVideoCall(ERROR_CALLID);
322 std::string content = "";
323 callRequestProcess->RejectRequest(VALID_CALLID, true, content);
324 callRequestProcess->RejectRequest(2, true, content);
325 callRequestProcess->HoldRequest(VALID_CALLID);
326 callRequestProcess->HoldRequest(2);
327 callRequestProcess->CombineConferenceRequest(VALID_CALLID);
328 callRequestProcess->SeparateConferenceRequest(VALID_CALLID);
329 callRequestProcess->KickOutFromConferenceRequest(VALID_CALLID);
330 std::u16string msg = u"";
331 callRequestProcess->StartRttRequest(VALID_CALLID, msg);
332 callRequestProcess->StartRttRequest(2, msg);
333 callRequestProcess->StopRttRequest(VALID_CALLID);
334 callRequestProcess->StopRttRequest(2);
335 std::vector<std::string> numberList;
336 callRequestProcess->JoinConference(VALID_CALLID, numberList);
337 callRequestProcess->JoinConference(2, numberList);
338 callRequestProcess->isFirstDialCallAdded_ = true;
339 callRequestProcess->HandleDialFail();
340 callRequestProcess->DeleteOneCallObject(call);
341 callRequestProcess->DeleteOneCallObject(dialCall);
342 ASSERT_TRUE(callRequestProcess->isFirstDialCallAdded_);
343 }
344
345 /**
346 * @tc.number Telephony_CallRequestProcess_004
347 * @tc.name test error branch
348 * @tc.desc Function test
349 */
350 HWTEST_F(ZeroBranch2Test, Telephony_CallRequestProcess_004, Function | MediumTest | Level1)
351 {
352 std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
353 DialParaInfo info;
354 info.dialType = DialType::DIAL_CARRIER_TYPE;
355 EXPECT_GT(callRequestProcess->HandleDialRequest(info), TELEPHONY_ERROR);
356 info.dialType = DialType::DIAL_VOICE_MAIL_TYPE;
357 EXPECT_GT(callRequestProcess->HandleDialRequest(info), TELEPHONY_ERROR);
358 info.dialType = DialType::DIAL_OTT_TYPE;
359 EXPECT_GT(callRequestProcess->HandleDialRequest(info), TELEPHONY_ERROR);
360 info.dialType = DialType::DIAL_BLUETOOTH_TYPE;
361 EXPECT_GT(callRequestProcess->HandleDialRequest(info), TELEPHONY_ERROR);
362 sleep(1);
363 std::vector<std::u16string> fdnNumberList = { u"11111", u"22222" };
364 EXPECT_TRUE(callRequestProcess->IsFdnNumber(fdnNumberList, "22222"));
365 EXPECT_GT(callRequestProcess->BluetoothDialProcess(info), TELEPHONY_ERROR);
366 }
367
368 /**
369 * @tc.number Telephony_CallRequestProcess_005
370 * @tc.name test error branch
371 * @tc.desc Function test
372 */
373 HWTEST_F(ZeroBranch2Test, Telephony_CallRequestProcess_005, Function | MediumTest | Level1)
374 {
375 std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
376 callRequestProcess->isFirstDialCallAdded_ = false;
377 CallObjectManager::callObjectPtrList_.clear();
378 DialParaInfo info;
379 sptr<CallBase> imsCall = new IMSCall(info);
380 imsCall->SetCallType(CallType::TYPE_IMS);
381 imsCall->SetCallIndex(0);
382 imsCall->SetCallId(VALID_CALLID);
383 imsCall->SetSlotId(0);
384 imsCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_CONNECTING);
385 CallObjectManager::AddOneCallObject(imsCall);
386 callRequestProcess->HandleDialFail();
387 CallDetailInfo callDetailInfo;
388 callDetailInfo.callType = imsCall->GetCallType();
389 callDetailInfo.accountId = imsCall->GetSlotId();
390 callDetailInfo.state = TelCallState::CALL_STATUS_DISCONNECTED;
391 callDetailInfo.voiceDomain = static_cast<int32_t>(imsCall->GetCallType());
392 std::shared_ptr<CallStatusManager> callStatusManagerPtr = std::make_shared<CallStatusManager>();
393 callStatusManagerPtr->DisconnectedHandle(callDetailInfo);
394 EXPECT_FALSE(CallObjectManager::HasCellularCallExist());
395 }
396
397 /**
398 * @tc.number Telephony_CallRequestProcess_006
399 * @tc.name test error branch
400 * @tc.desc Function test
401 */
402 HWTEST_F(ZeroBranch2Test, Telephony_CallRequestProcess_006, Function | MediumTest | Level1)
403 {
404 std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
405 DialParaInfo info;
406 info.dialType = DialType::DIAL_BLUETOOTH_TYPE;
407 info.number = 112;
408 EXPECT_GT(callRequestProcess->BluetoothDialProcess(info), TELEPHONY_SUCCESS);
409 sptr<CallBase> imsCall = nullptr;
410 imsCall = new IMSCall(info);
411 CallObjectManager::callObjectPtrList_.push_back(imsCall);
412 DialParaInfo info2;
413 info2.dialType = DialType::DIAL_BLUETOOTH_TYPE;
414 info2.number = 123;
415 EXPECT_GT(callRequestProcess->BluetoothDialProcess(info2), CALL_ERR_CALL_COUNTS_EXCEED_LIMIT);
416 CallObjectManager::callObjectPtrList_.clear();
417 }
418
419 /**
420 * @tc.number Telephony_CallObjectManager_001
421 * @tc.name test error branch
422 * @tc.desc Function test
423 */
424 HWTEST_F(ZeroBranch2Test, Telephony_CallObjectManager_001, Function | MediumTest | Level1)
425 {
426 CallObjectManager::HasNewCall();
427 DialParaInfo mDialParaInfo;
428 sptr<CallBase> csCall = new CSCall(mDialParaInfo);
429 csCall->SetCallType(CallType::TYPE_CS);
430 csCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_DIALING);
431 CallObjectManager::AddOneCallObject(csCall);
432 CallObjectManager::HasNewCall();
433 csCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_CREATE);
434 CallObjectManager::HasNewCall();
435 csCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_CONNECTING);
436 CallObjectManager::HasNewCall();
437 CallObjectManager::HasRingingMaximum();
438 csCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
439 CallObjectManager::HasRingingMaximum();
440 CallObjectManager::HasDialingMaximum();
441 csCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
442 CallObjectManager::HasDialingMaximum();
443 std::string number = "";
444 CallObjectManager::IsCallExist(number);
445 number = "test";
446 bool res = CallObjectManager::IsCallExist(number);
447 CallObjectManager::HasVideoCall();
448 csCall->SetVideoStateType(VideoStateType::TYPE_VIDEO);
449 CallObjectManager::HasVideoCall();
450 csCall->SetCallType(CallType::TYPE_VOIP);
451 CallObjectManager::HasVideoCall();
452 CallObjectManager::GetCallInfoList(DEFAULT_INDEX);
453 csCall->SetCallType(CallType::TYPE_OTT);
454 CallObjectManager::GetCallInfoList(SIM1_SLOTID);
455 CallObjectManager::GetCallInfoList(DEFAULT_INDEX);
456 CallObjectManager::GetCallInfoList(DEFAULT_INDEX, false);
457 CallObjectManager::GetAllCallInfoList(false);
458 ASSERT_FALSE(res);
459 }
460
461 /**
462 * @tc.number Telephony_CallObjectManager_002
463 * @tc.name test error branch
464 * @tc.desc Function test
465 */
466 HWTEST_F(ZeroBranch2Test, Telephony_CallObjectManager_002, Function | MediumTest | Level1)
467 {
468 DialParaInfo mDialParaInfo;
469 sptr<CallBase> csCall = new CSCall(mDialParaInfo);
470 csCall->callId_ = 0;
471 csCall->callType_ = CallType::TYPE_VOIP;
472 csCall->callRunningState_ = CallRunningState::CALL_RUNNING_STATE_RINGING;
473 csCall->callState_ = TelCallState::CALL_STATUS_ACTIVE;
474 CallObjectManager::AddOneCallObject(csCall);
475 CallObjectManager::GetOneCallObject(0);
476 std::list<int32_t> list;
477 CallObjectManager::GetVoipCallList(list);
478 CallObjectManager::GetVoipCallNum();
479 CallObjectManager::GetAllCallList();
480 bool hasRingingCall = false;
481 CallObjectManager::HasRingingCall(hasRingingCall);
482 csCall->callRunningState_ = CallRunningState::CALL_RUNNING_STATE_HOLD;
483 CallObjectManager::HasHoldCall(hasRingingCall);
484 ASSERT_FALSE(CallObjectManager::IsCallExist(CallType::TYPE_VOIP, TelCallState::CALL_STATUS_ACTIVE));
485 std::list<int32_t> satelliteCallList;
486 EXPECT_EQ(CallObjectManager::GetSatelliteCallList(satelliteCallList), TELEPHONY_SUCCESS);
487 EXPECT_EQ(CallObjectManager::GetForegroundCall(false), nullptr);
488 EXPECT_EQ(CallObjectManager::GetForegroundCall(true), nullptr);
489 EXPECT_EQ(CallObjectManager::GetCallNumByRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE), 1);
490 EXPECT_EQ(CallObjectManager::GetCallNumByRunningState(CallRunningState::CALL_RUNNING_STATE_DIALING), 0);
491 EXPECT_EQ(CallObjectManager::GetForegroundLiveCallByCallId(0), nullptr);
492 EXPECT_FALSE(CallObjectManager::HasIncomingCallCrsType());
493 CallObjectManager::DeleteOneCallObject(0);
494 }
495
496 /**
497 * @tc.number Telephony_CallObjectManager_003
498 * @tc.name test error branch
499 * @tc.desc Function test
500 */
501 HWTEST_F(ZeroBranch2Test, Telephony_CallObjectManager_003, Function | MediumTest | Level1)
502 {
503 DialParaInfo dialInfo;
504 sptr<CallBase> call = new VoIPCall(dialInfo);
505 call->callId_ = 0;
506 call->callType_ = CallType::TYPE_VOIP;
507 call->callRunningState_ = CallRunningState::CALL_RUNNING_STATE_RINGING;
508 call->callState_ = TelCallState::CALL_STATUS_ACTIVE;
509 CallObjectManager::AddOneCallObject(call);
510 call->SetCallIndex(0);
511 call->SetSlotId(0);
512 EXPECT_TRUE(CallObjectManager::GetOneCallObjectByIndexAndSlotId(0, 0) == nullptr);
513 EXPECT_TRUE(CallObjectManager::GetOneCallObjectByIndexAndSlotId(0, 1) == nullptr);
514 EXPECT_TRUE(CallObjectManager::GetOneCallObjectByIndexAndSlotId(1, 0) == nullptr);
515 EXPECT_TRUE(CallObjectManager::GetOneCallObjectByIndexAndSlotId(1, 1) == nullptr);
516 EXPECT_TRUE(CallObjectManager::HasVoipCallExist());
517 int32_t callId = 0;
518 EXPECT_TRUE(CallObjectManager::IsCallExist(0));
519 EXPECT_FALSE(CallObjectManager::IsCallExist(1));
520 CallAttributeInfo info;
521 CallObjectManager::AddOneVoipCallObject(info);
522 CallObjectManager::GetActiveVoipCallInfo();
523 info.callState = TelCallState::CALL_STATUS_ACTIVE;
524 CallObjectManager::AddOneVoipCallObject(info);
525 CallAttributeInfo info2;
526 info2.callId = 1;
527 info2.callState = TelCallState::CALL_STATUS_ACTIVE;
528 CallObjectManager::AddOneVoipCallObject(info2);
529 CallObjectManager::GetActiveVoipCallInfo();
530 EXPECT_FALSE(CallObjectManager::IsVoipCallExist(TelCallState::CALL_STATUS_DIALING, callId));
531 EXPECT_TRUE(CallObjectManager::IsVoipCallExist(TelCallState::CALL_STATUS_ACTIVE, callId));
532 std::string phoneNum = "";
533 EXPECT_EQ(CallObjectManager::GetOneCallObject(phoneNum), nullptr);
534 bool enabled = false;
535 EXPECT_GT(CallObjectManager::IsNewCallAllowedCreate(enabled), TELEPHONY_ERROR);
536 CallObjectManager::DeleteOneCallObject(0);
537 }
538
539 /**
540 * @tc.number Telephony_CallObjectManager_004
541 * @tc.name test error branch
542 * @tc.desc Function test
543 */
544 HWTEST_F(ZeroBranch2Test, Telephony_CallObjectManager_004, Function | MediumTest | Level1)
545 {
546 DialParaInfo dialInfo;
547 sptr<CallBase> call = new CSCall(dialInfo);
548 call->callId_ = 1;
549 call->SetCallIndex(0);
550 call->SetSlotId(0);
551 call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
552 call->SetCallType(CallType::TYPE_CS);
553 CallObjectManager::AddOneCallObject(call);
554 EXPECT_TRUE(CallObjectManager::HasCellularCallExist());
555 call->SetTelCallState(TelCallState::CALL_STATUS_DISCONNECTED);
556 EXPECT_FALSE(CallObjectManager::HasCellularCallExist());
557 call->SetTelCallState(TelCallState::CALL_STATUS_DISCONNECTING);
558 EXPECT_FALSE(CallObjectManager::HasCellularCallExist());
559 EXPECT_TRUE(CallObjectManager::GetOneCallObjectByIndexAndSlotId(0, 0) != nullptr);
560 EXPECT_TRUE(CallObjectManager::GetOneCallObjectByIndexAndSlotId(0, 1) == nullptr);
561 EXPECT_TRUE(CallObjectManager::GetOneCallObjectByIndexAndSlotId(1, 0) == nullptr);
562 EXPECT_TRUE(CallObjectManager::GetOneCallObjectByIndexAndSlotId(1, 1) == nullptr);
563 bool enabled = false;
564 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_CREATE);
565 EXPECT_GT(CallObjectManager::IsNewCallAllowedCreate(enabled), TELEPHONY_ERROR);
566 EXPECT_GT(CallObjectManager::HasRingingCall(enabled), TELEPHONY_ERROR);
567 EXPECT_GT(CallObjectManager::HasHoldCall(enabled), TELEPHONY_ERROR);
568 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_CONNECTING);
569 EXPECT_GT(CallObjectManager::IsNewCallAllowedCreate(enabled), TELEPHONY_ERROR);
570 EXPECT_GT(CallObjectManager::HasRingingCall(enabled), TELEPHONY_ERROR);
571 EXPECT_GT(CallObjectManager::HasHoldCall(enabled), TELEPHONY_ERROR);
572 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_DIALING);
573 EXPECT_GT(CallObjectManager::IsNewCallAllowedCreate(enabled), TELEPHONY_ERROR);
574 EXPECT_GT(CallObjectManager::HasRingingCall(enabled), TELEPHONY_ERROR);
575 EXPECT_GT(CallObjectManager::HasHoldCall(enabled), TELEPHONY_ERROR);
576 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
577 EXPECT_GT(CallObjectManager::IsNewCallAllowedCreate(enabled), TELEPHONY_ERROR);
578 EXPECT_GT(CallObjectManager::HasRingingCall(enabled), TELEPHONY_ERROR);
579 EXPECT_GT(CallObjectManager::HasHoldCall(enabled), TELEPHONY_ERROR);
580 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ENDED);
581 EXPECT_GT(CallObjectManager::IsNewCallAllowedCreate(enabled), TELEPHONY_ERROR);
582 EXPECT_GT(CallObjectManager::HasRingingCall(enabled), TELEPHONY_ERROR);
583 EXPECT_GT(CallObjectManager::HasHoldCall(enabled), TELEPHONY_ERROR);
584 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_HOLD);
585 EXPECT_GT(CallObjectManager::HasRingingCall(enabled), TELEPHONY_ERROR);
586 EXPECT_GT(CallObjectManager::HasHoldCall(enabled), TELEPHONY_ERROR);
587 CallObjectManager::DeleteOneCallObject(1);
588 }
589
590 /**
591 * @tc.number Telephony_CallNumberUtils_001
592 * @tc.name test error branch
593 * @tc.desc Function test
594 */
595 HWTEST_F(ZeroBranch2Test, Telephony_CallNumberUtils_001, Function | MediumTest | Level1)
596 {
597 std::string emptyStr = "";
598 std::string phoneNumber = "123456789012";
599 std::string countryCode = "gr";
600 std::string formatNumber = "";
601 NumberMarkInfo numberMarkInfo;
602 ASSERT_NE(DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumber(emptyStr, emptyStr, formatNumber),
603 TELEPHONY_ERR_SUCCESS);
604 EXPECT_EQ(DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumber(phoneNumber, emptyStr, formatNumber),
605 TELEPHONY_ERR_SUCCESS);
606 EXPECT_EQ(
607 DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumber(phoneNumber, countryCode, formatNumber),
608 TELEPHONY_ERR_SUCCESS);
609 ASSERT_GE(
610 DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumberToE164(emptyStr, emptyStr, formatNumber),
611 TELEPHONY_ERR_SUCCESS);
612 EXPECT_EQ(
613 DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumberToE164(phoneNumber, emptyStr, formatNumber),
614 TELEPHONY_ERR_SUCCESS);
615 EXPECT_EQ(DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumberToE164(
616 phoneNumber, countryCode, formatNumber), TELEPHONY_ERR_SUCCESS);
617 ASSERT_NE(DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumberToNational(
618 emptyStr, emptyStr, formatNumber), TELEPHONY_ERR_SUCCESS);
619 ASSERT_NE(DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumberToInternational(
620 emptyStr, emptyStr, formatNumber), TELEPHONY_ERR_SUCCESS);
621 ASSERT_FALSE(DelayedSingleton<CallNumberUtils>::GetInstance()->IsValidSlotId(INVALID_SLOTID));
622 ASSERT_TRUE(DelayedSingleton<CallNumberUtils>::GetInstance()->IsValidSlotId(0));
623 EXPECT_NE(DelayedSingleton<CallNumberUtils>::GetInstance()->QueryYellowPageAndMarkInfo(
624 numberMarkInfo, phoneNumber), TELEPHONY_ERR_LOCAL_PTR_NULL);
625 }
626
627 /**
628 * @tc.number Telephony_CallNumberUtils_002
629 * @tc.name test error branch
630 * @tc.desc Function test
631 */
632 HWTEST_F(ZeroBranch2Test, Telephony_CallNumberUtils_002, Function | MediumTest | Level1)
633 {
634 std::string emptyStr = "";
635 std::string phoneNumber = "123456789012";
636 std::string numberLocation = "";
637 EXPECT_NE(DelayedSingleton<CallNumberUtils>::GetInstance()->QueryNumberLocationInfo(numberLocation, emptyStr),
638 TELEPHONY_ERR_SUCCESS);
639 std::shared_ptr<NumberIdentityDataBaseHelper> callDataPtr =
640 DelayedSingleton<NumberIdentityDataBaseHelper>::GetInstance();
641 printf("NUMBER_IDENTITY_URI: %s\n", callDataPtr->NUMBER_IDENTITY_URI);
642 auto helper = CreateDataShareHelper(callDataPtr->NUMBER_IDENTITY_URI);
643 if (helper != nullptr) {
644 helper->Release();
645 EXPECT_EQ(DelayedSingleton<CallNumberUtils>::GetInstance()->
646 QueryNumberLocationInfo(numberLocation, phoneNumber), TELEPHONY_ERR_SUCCESS);
647 } else {
648 printf("helper is null");
649 EXPECT_NE(DelayedSingleton<CallNumberUtils>::GetInstance()->
650 QueryNumberLocationInfo(numberLocation, phoneNumber), TELEPHONY_ERR_SUCCESS);
651 }
652 }
653
654 /**
655 * @tc.number Telephony_CellularCallConnection_001
656 * @tc.name test error branch
657 * @tc.desc Function test
658 */
659 HWTEST_F(ZeroBranch2Test, Telephony_CellularCallConnection_001, Function | MediumTest | Level1)
660 {
661 std::shared_ptr<CellularCallConnection> cellularCallConnection =
662 DelayedSingleton<CellularCallConnection>::GetInstance();
663 CellularCallInfo mCellularCallInfo;
664 ASSERT_NE(cellularCallConnection->Dial(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
665 ASSERT_NE(cellularCallConnection->HangUp(
666 mCellularCallInfo, CallSupplementType::TYPE_DEFAULT), TELEPHONY_ERR_SUCCESS);
667 ASSERT_NE(cellularCallConnection->Reject(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
668 ASSERT_NE(cellularCallConnection->Answer(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
669 ASSERT_NE(cellularCallConnection->HoldCall(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
670 ASSERT_NE(cellularCallConnection->UnHoldCall(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
671 ASSERT_NE(cellularCallConnection->SwitchCall(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
672 bool enabled = false;
673 ASSERT_NE(cellularCallConnection->IsEmergencyPhoneNumber("", 0, enabled), TELEPHONY_ERR_SUCCESS);
674 ASSERT_NE(cellularCallConnection->CombineConference(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
675 ASSERT_NE(cellularCallConnection->SeparateConference(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
676 ASSERT_NE(cellularCallConnection->KickOutFromConference(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
677 ASSERT_NE(cellularCallConnection->StartDtmf('a', mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
678 ASSERT_NE(cellularCallConnection->StopDtmf(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
679 ASSERT_NE(cellularCallConnection->GetCallTransferInfo(
680 CallTransferType::TRANSFER_TYPE_BUSY, 0), TELEPHONY_ERR_SUCCESS);
681 ASSERT_NE(cellularCallConnection->SetCallWaiting(true, 0), TELEPHONY_ERR_SUCCESS);
682 ASSERT_NE(cellularCallConnection->GetCallWaiting(0), TELEPHONY_ERR_SUCCESS);
683 CallRestrictionInfo mCallRestrictionInfo;
684 ASSERT_NE(cellularCallConnection->SetCallRestriction(mCallRestrictionInfo, 0), TELEPHONY_ERR_SUCCESS);
685 ASSERT_NE(cellularCallConnection->GetCallRestriction(
686 CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING, 0), TELEPHONY_ERR_SUCCESS);
687 ASSERT_NE(cellularCallConnection->SetCallPreferenceMode(0, 1), TELEPHONY_ERR_SUCCESS);
688 }
689
690 /**
691 * @tc.number Telephony_CellularCallConnection_002
692 * @tc.name test error branch
693 * @tc.desc Function test
694 */
695 HWTEST_F(ZeroBranch2Test, Telephony_CellularCallConnection_002, Function | MediumTest | Level1)
696 {
697 CallTransferInfo mCallTransferInfo;
698 std::shared_ptr<CellularCallConnection> cellularCallConnection =
699 DelayedSingleton<CellularCallConnection>::GetInstance();
700 ASSERT_NE(cellularCallConnection->SetCallTransferInfo(mCallTransferInfo, 0), TELEPHONY_ERR_SUCCESS);
701 bool result;
702 ASSERT_NE(cellularCallConnection->CanSetCallTransferTime(0, result), TELEPHONY_ERR_SUCCESS);
703 ASSERT_NE(cellularCallConnection->GetImsSwitchStatus(0, result), TELEPHONY_ERR_SUCCESS);
704 ASSERT_NE(cellularCallConnection->SetImsConfig(ImsConfigItem::ITEM_VIDEO_QUALITY, "", 0), TELEPHONY_ERR_SUCCESS);
705 ASSERT_NE(cellularCallConnection->SetImsConfig(ImsConfigItem::ITEM_VIDEO_QUALITY, 1, 0), TELEPHONY_ERR_SUCCESS);
706 ASSERT_NE(cellularCallConnection->GetImsConfig(ImsConfigItem::ITEM_VIDEO_QUALITY, 0), TELEPHONY_ERR_SUCCESS);
707 ASSERT_NE(
708 cellularCallConnection->SetImsFeatureValue(FeatureType::TYPE_VOICE_OVER_LTE, 1, 0), TELEPHONY_ERR_SUCCESS);
709 ASSERT_NE(cellularCallConnection->GetImsFeatureValue(FeatureType::TYPE_VOICE_OVER_LTE, 0), TELEPHONY_ERR_SUCCESS);
710 std::vector<std::string> numberList = {};
711 ASSERT_NE(cellularCallConnection->InviteToConference(numberList, 0), TELEPHONY_ERR_SUCCESS);
712 ASSERT_NE(cellularCallConnection->SetMute(0, 0), TELEPHONY_ERR_SUCCESS);
713 ASSERT_NE(cellularCallConnection->SendDtmf('a', ""), TELEPHONY_ERR_SUCCESS);
714 ASSERT_NE(
715 cellularCallConnection->SendDtmfString("", "", PhoneNetType::PHONE_TYPE_GSM, 1, 0), TELEPHONY_ERR_SUCCESS);
716 ASSERT_NE(cellularCallConnection->RegisterCallBack(nullptr), TELEPHONY_ERR_SUCCESS);
717 ASSERT_NE(cellularCallConnection->SetImsSwitchStatus(0, true), TELEPHONY_ERR_SUCCESS);
718 ASSERT_NE(cellularCallConnection->ConnectService(), TELEPHONY_ERR_SUCCESS);
719 cellularCallConnection->ClearAllCalls();
720 std::string testStr = "";
721 ASSERT_NE(cellularCallConnection->ControlCamera(SIM1_SLOTID, DEFAULT_INDEX, testStr, 1, 1), TELEPHONY_ERR_SUCCESS);
722 ASSERT_NE(
723 cellularCallConnection->SetPreviewWindow(SIM1_SLOTID, DEFAULT_INDEX, testStr, nullptr), TELEPHONY_ERR_SUCCESS);
724 ASSERT_NE(
725 cellularCallConnection->SetDisplayWindow(SIM1_SLOTID, DEFAULT_INDEX, testStr, nullptr), TELEPHONY_ERR_SUCCESS);
726 float zoomRatio = 1;
727 ASSERT_NE(cellularCallConnection->SetCameraZoom(zoomRatio), TELEPHONY_ERR_SUCCESS);
728 ASSERT_NE(cellularCallConnection->SetPausePicture(SIM1_SLOTID, DEFAULT_INDEX, testStr), TELEPHONY_ERR_SUCCESS);
729 ASSERT_NE(cellularCallConnection->SetDeviceDirection(SIM1_SLOTID, DEFAULT_INDEX, 1), TELEPHONY_ERR_SUCCESS);
730 ASSERT_NE(cellularCallConnection->CancelCallUpgrade(SIM1_SLOTID, DEFAULT_INDEX), TELEPHONY_ERR_SUCCESS);
731 ASSERT_NE(cellularCallConnection->RequestCameraCapabilities(SIM1_SLOTID, DEFAULT_INDEX), TELEPHONY_ERR_SUCCESS);
732 int32_t slotId = 0;
733 std::string content = "1";
734 ASSERT_EQ(cellularCallConnection->SendUssdResponse(slotId, content), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
735 }
736
737 /**
738 * @tc.number Telephony_CellularCallConnection_003
739 * @tc.name test error branch
740 * @tc.desc Function test
741 */
742 HWTEST_F(ZeroBranch2Test, Telephony_CellularCallConnection_003, Function | MediumTest | Level1)
743 {
744 CellularCallInfo mCellularCallInfo;
745 std::shared_ptr<CellularCallConnection> cellularCallConnection =
746 DelayedSingleton<CellularCallConnection>::GetInstance();
747 std::u16string test = u"";
748 ASSERT_NE(cellularCallConnection->StartRtt(mCellularCallInfo, test), TELEPHONY_ERR_SUCCESS);
749 ASSERT_NE(cellularCallConnection->StopRtt(mCellularCallInfo), TELEPHONY_ERR_SUCCESS);
750 ASSERT_NE(cellularCallConnection->SendUpdateCallMediaModeRequest(
751 mCellularCallInfo, ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_SUCCESS);
752 ASSERT_NE(cellularCallConnection->RegisterCallBackFun(), TELEPHONY_ERR_SUCCESS);
753 ASSERT_NE(cellularCallConnection->ReConnectService(), TELEPHONY_ERR_SUCCESS);
754 ASSERT_NE(cellularCallConnection->PostDialProceed(mCellularCallInfo, true), TELEPHONY_ERR_SUCCESS);
755 }
756
757 /**
758 * @tc.number Telephony_CellularCallConnection_004
759 * @tc.name test error branch
760 * @tc.desc Function test
761 */
762 HWTEST_F(ZeroBranch2Test, Telephony_CellularCallConnection_004, Function | MediumTest | Level1)
763 {
764 CellularCallInfo mCellularCallInfo;
765 std::shared_ptr<CellularCallConnection> cellularCallConnection =
766 DelayedSingleton<CellularCallConnection>::GetInstance();
767 std::u16string test = u"";
768 int32_t state = 0;
769 cellularCallConnection->SetVoNRState(SIM1_SLOTID, state);
770 cellularCallConnection->GetVoNRState(SIM1_SLOTID, state);
771 int res = cellularCallConnection->CloseUnFinishedUssd(SIM1_SLOTID);
772 CellularCallConnection::SystemAbilityListener listen;
773 int32_t systemAbilityId = 1;
774 std::string deviceId = "123";
775 listen.OnAddSystemAbility(systemAbilityId, deviceId);
776 listen.OnRemoveSystemAbility(systemAbilityId, deviceId);
777 ASSERT_NE(res, TELEPHONY_ERR_SUCCESS);
778 }
779
780 /**
781 * @tc.number Telephony_CallPolicy_001
782 * @tc.name test error branch
783 * @tc.desc Function test
784 */
785 HWTEST_F(ZeroBranch2Test, Telephony_CallPolicy_001, Function | MediumTest | Level1)
786 {
787 CallPolicy mCallPolicy;
788 std::u16string testEmptyStr = u"";
789 AppExecFwk::PacMap mPacMap;
790 mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true);
791 mPacMap.PutIntValue("dialType", static_cast<int32_t>(DialType::DIAL_CARRIER_TYPE));
792 ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
793 mPacMap.PutIntValue("dialType", static_cast<int32_t>(DialType::DIAL_VOICE_MAIL_TYPE));
794 ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
795 mPacMap.PutIntValue("callType", static_cast<int32_t>(CallType::TYPE_CS));
796 ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
797 mPacMap.PutIntValue("dialScene", static_cast<int32_t>(DialScene::CALL_NORMAL));
798 ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
799 ASSERT_NE(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, false), TELEPHONY_ERR_SUCCESS);
800 mPacMap.PutIntValue("dialScene", static_cast<int32_t>(DialScene::CALL_PRIVILEGED));
801 ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
802 ASSERT_NE(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, false), TELEPHONY_ERR_SUCCESS);
803 mPacMap.PutIntValue("dialScene", static_cast<int32_t>(DialScene::CALL_EMERGENCY));
804 mPacMap.PutIntValue("videoState", static_cast<int32_t>(VideoStateType::TYPE_VOICE));
805 ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
806 ASSERT_NE(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, false), TELEPHONY_ERR_SUCCESS);
807 system::SetParameter("persist.edm.telephony_call_disable", "true");
808 ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_POLICY_DISABLED);
809 system::SetParameter("persist.edm.telephony_call_disable", "false");
810 mPacMap.PutIntValue("dialType", static_cast<int32_t>(DialType::DIAL_VOICE_MAIL_TYPE));
811 ASSERT_EQ(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, true), TELEPHONY_ERR_SUCCESS);
812 ASSERT_NE(mCallPolicy.DialPolicy(testEmptyStr, mPacMap, false), TELEPHONY_ERR_SUCCESS);
813 ASSERT_NE(mCallPolicy.AnswerCallPolicy(0, INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
814 ASSERT_NE(mCallPolicy.AnswerCallPolicy(0, 0), TELEPHONY_ERR_SUCCESS);
815 ASSERT_NE(mCallPolicy.RejectCallPolicy(0), TELEPHONY_ERR_SUCCESS);
816 ASSERT_GE(mCallPolicy.HoldCallPolicy(0), TELEPHONY_ERR_SUCCESS);
817 ASSERT_NE(mCallPolicy.UnHoldCallPolicy(0), TELEPHONY_ERR_SUCCESS);
818 ASSERT_NE(mCallPolicy.HangUpPolicy(0), TELEPHONY_ERR_SUCCESS);
819 ASSERT_NE(mCallPolicy.SwitchCallPolicy(0), TELEPHONY_ERR_SUCCESS);
820 ASSERT_GE(mCallPolicy.VideoCallPolicy(0), TELEPHONY_ERR_SUCCESS);
821 ASSERT_NE(mCallPolicy.StartRttPolicy(0), TELEPHONY_ERR_SUCCESS);
822 ASSERT_NE(mCallPolicy.StopRttPolicy(0), TELEPHONY_ERR_SUCCESS);
823 ASSERT_NE(mCallPolicy.IsValidSlotId(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
824 ASSERT_FALSE(mCallPolicy.IsSupportVideoCall(mPacMap));
825 ASSERT_GE(mCallPolicy.CanDialMulityCall(mPacMap, false), TELEPHONY_ERR_SUCCESS);
826 }
827
828 /**
829 * @tc.number Telephony_CallPolicy_002
830 * @tc.name test error branch
831 * @tc.desc Function test
832 */
833 HWTEST_F(ZeroBranch2Test, Telephony_CallPolicy_002, Function | MediumTest | Level1)
834 {
835 CallPolicy mCallPolicy;
836 ASSERT_EQ(mCallPolicy.IsValidSlotId(0), TELEPHONY_ERR_SUCCESS);
837 ASSERT_NE(mCallPolicy.EnableVoLtePolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
838 ASSERT_EQ(mCallPolicy.EnableVoLtePolicy(0), TELEPHONY_ERR_SUCCESS);
839 ASSERT_NE(mCallPolicy.DisableVoLtePolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
840 ASSERT_EQ(mCallPolicy.DisableVoLtePolicy(0), TELEPHONY_ERR_SUCCESS);
841 ASSERT_NE(mCallPolicy.IsVoLteEnabledPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
842 ASSERT_EQ(mCallPolicy.IsVoLteEnabledPolicy(0), TELEPHONY_ERR_SUCCESS);
843 ASSERT_NE(mCallPolicy.GetCallWaitingPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
844 ASSERT_EQ(mCallPolicy.GetCallWaitingPolicy(0), TELEPHONY_ERR_SUCCESS);
845 ASSERT_NE(mCallPolicy.SetCallWaitingPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
846 ASSERT_EQ(mCallPolicy.SetCallWaitingPolicy(0), TELEPHONY_ERR_SUCCESS);
847 ASSERT_NE(mCallPolicy.GetCallRestrictionPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
848 ASSERT_EQ(mCallPolicy.GetCallRestrictionPolicy(0), TELEPHONY_ERR_SUCCESS);
849 ASSERT_NE(mCallPolicy.SetCallRestrictionPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
850 ASSERT_EQ(mCallPolicy.SetCallRestrictionPolicy(0), TELEPHONY_ERR_SUCCESS);
851 ASSERT_NE(mCallPolicy.GetCallTransferInfoPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
852 ASSERT_EQ(mCallPolicy.GetCallTransferInfoPolicy(0), TELEPHONY_ERR_SUCCESS);
853 ASSERT_NE(mCallPolicy.SetCallTransferInfoPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
854 ASSERT_EQ(mCallPolicy.SetCallTransferInfoPolicy(0), TELEPHONY_ERR_SUCCESS);
855 ASSERT_NE(mCallPolicy.SetCallPreferenceModePolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
856 ASSERT_EQ(mCallPolicy.SetCallPreferenceModePolicy(0), TELEPHONY_ERR_SUCCESS);
857 ASSERT_NE(mCallPolicy.GetImsConfigPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
858 ASSERT_EQ(mCallPolicy.GetImsConfigPolicy(0), TELEPHONY_ERR_SUCCESS);
859 ASSERT_NE(mCallPolicy.SetImsConfigPolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
860 ASSERT_EQ(mCallPolicy.SetImsConfigPolicy(0), TELEPHONY_ERR_SUCCESS);
861 ASSERT_NE(mCallPolicy.GetImsFeatureValuePolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
862 ASSERT_EQ(mCallPolicy.GetImsFeatureValuePolicy(0), TELEPHONY_ERR_SUCCESS);
863 ASSERT_NE(mCallPolicy.SetImsFeatureValuePolicy(INVALID_SLOTID), TELEPHONY_ERR_SUCCESS);
864 ASSERT_EQ(mCallPolicy.SetImsFeatureValuePolicy(0), TELEPHONY_ERR_SUCCESS);
865 std::vector<std::string> numberList = {};
866 ASSERT_NE(mCallPolicy.InviteToConferencePolicy(0, numberList), TELEPHONY_ERR_SUCCESS);
867 }
868
869 /**
870 * @tc.number Telephony_CallPolicy_003
871 * @tc.name test error branch
872 * @tc.desc Function test
873 */
874 HWTEST_F(ZeroBranch2Test, Telephony_CallPolicy_003, Function | MediumTest | Level1)
875 {
876 CallPolicy callPolicy;
877 AppExecFwk::PacMap videoExtras;
878 videoExtras.PutIntValue("videoState", static_cast<int>(VideoStateType::TYPE_VIDEO));
879 callPolicy.CanDialMulityCall(videoExtras, false);
880 AppExecFwk::PacMap voiceExtras;
881 voiceExtras.PutIntValue("videoState", static_cast<int>(VideoStateType::TYPE_VOICE));
882 callPolicy.CanDialMulityCall(voiceExtras, false);
883 DialParaInfo info;
884 sptr<CallBase> call = new CSCall(info);
885 call->SetCallType(CallType::TYPE_CS);
886 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
887 callPolicy.AddOneCallObject(call);
888 callPolicy.IsVoiceCallValid(VideoStateType::TYPE_VIDEO);
889 callPolicy.IsVoiceCallValid(VideoStateType::TYPE_VOICE);
890 call->SetVideoStateType(VideoStateType::TYPE_VIDEO);
891 callPolicy.IsVoiceCallValid(VideoStateType::TYPE_VOICE);
892 call->SetCallType(CallType::TYPE_VOIP);
893 callPolicy.IsVoiceCallValid(VideoStateType::TYPE_VOICE);
894 call->SetVideoStateType(VideoStateType::TYPE_VOICE);
895 call->SetCallType(CallType::TYPE_CS);
896 callPolicy.IsVoiceCallValid(VideoStateType::TYPE_VOICE);
897 callPolicy.IsValidCallType(CallType::TYPE_CS);
898 callPolicy.IsValidCallType(CallType::TYPE_IMS);
899 callPolicy.IsValidCallType(CallType::TYPE_OTT);
900 callPolicy.IsValidCallType(CallType::TYPE_SATELLITE);
901 callPolicy.IsValidCallType(CallType::TYPE_VOIP);
902 callPolicy.CanDialMulityCall(videoExtras, false);
903 callPolicy.CanDialMulityCall(voiceExtras, false);
904 call->SetVideoStateType(VideoStateType::TYPE_VIDEO);
905 callPolicy.CanDialMulityCall(videoExtras, false);
906 callPolicy.CanDialMulityCall(voiceExtras, false);
907 call->SetCallId(VALID_CALLID);
908 call->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
909 callPolicy.RejectCallPolicy(VALID_CALLID);
910 callPolicy.AnswerCallPolicy(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VOICE));
911 callPolicy.AnswerCallPolicy(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
912 call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
913 callPolicy.RejectCallPolicy(VALID_CALLID);
914 callPolicy.AnswerCallPolicy(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VOICE));
915 callPolicy.AnswerCallPolicy(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
916 call->SetTelCallState(TelCallState::CALL_STATUS_WAITING);
917 callPolicy.RejectCallPolicy(VALID_CALLID);
918 callPolicy.AnswerCallPolicy(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VOICE));
919 callPolicy.AnswerCallPolicy(VALID_CALLID, static_cast<int>(VideoStateType::TYPE_VIDEO));
920 ASSERT_GE(callPolicy.RejectCallPolicy(VALID_CALLID), TELEPHONY_ERR_SUCCESS);
921 }
922
923 /**
924 * @tc.number Telephony_CallPolicy_004
925 * @tc.name test error branch
926 * @tc.desc Function test
927 */
928 HWTEST_F(ZeroBranch2Test, Telephony_CallPolicy_004, Function | MediumTest | Level1)
929 {
930 CallPolicy callPolicy;
931 DialParaInfo info;
932 sptr<CallBase> call = new CSCall(info);
933 call->SetCallType(CallType::TYPE_CS);
934 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
935 call->SetCallId(VALID_CALLID);
936 callPolicy.AddOneCallObject(call);
937 callPolicy.HoldCallPolicy(VALID_CALLID);
938 callPolicy.UnHoldCallPolicy(VALID_CALLID);
939 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_HOLD);
940 callPolicy.HoldCallPolicy(VALID_CALLID);
941 callPolicy.UnHoldCallPolicy(VALID_CALLID);
942 call->SetTelCallState(TelCallState::CALL_STATUS_IDLE);
943 callPolicy.HangUpPolicy(VALID_CALLID);
944 call->SetTelCallState(TelCallState::CALL_STATUS_DISCONNECTING);
945 callPolicy.HangUpPolicy(VALID_CALLID);
946 call->SetTelCallState(TelCallState::CALL_STATUS_DISCONNECTED);
947 callPolicy.HangUpPolicy(VALID_CALLID);
948 callPolicy.SwitchCallPolicy(VALID_CALLID);
949 sptr<CallBase> imsCall = new IMSCall(info);
950 imsCall->SetCallType(CallType::TYPE_IMS);
951 imsCall->SetCallId(2);
952 callPolicy.AddOneCallObject(imsCall);
953 imsCall->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
954 ASSERT_EQ(callPolicy.SwitchCallPolicy(VALID_CALLID), CALL_ERR_ILLEGAL_CALL_OPERATION);
955 imsCall->SetTelCallState(TelCallState::CALL_STATUS_ALERTING);
956 ASSERT_EQ(callPolicy.SwitchCallPolicy(VALID_CALLID), CALL_ERR_ILLEGAL_CALL_OPERATION);
957 call->SetTelCallState(TelCallState::CALL_STATUS_HOLDING);
958 ASSERT_EQ(callPolicy.SwitchCallPolicy(VALID_CALLID), CALL_ERR_ILLEGAL_CALL_OPERATION);
959 imsCall->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
960 ASSERT_EQ(callPolicy.SwitchCallPolicy(VALID_CALLID), TELEPHONY_ERR_SUCCESS);
961 callPolicy.VideoCallPolicy(VALID_CALLID);
962 callPolicy.StartRttPolicy(VALID_CALLID);
963 callPolicy.StartRttPolicy(2);
964 callPolicy.StopRttPolicy(VALID_CALLID);
965 callPolicy.StopRttPolicy(2);
966 call->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
967 callPolicy.StartRttPolicy(VALID_CALLID);
968 callPolicy.StopRttPolicy(VALID_CALLID);
969 std::vector<std::string> numberList;
970 callPolicy.InviteToConferencePolicy(VALID_CALLID, numberList);
971 numberList.push_back("");
972 numberList.push_back("123");
973 numberList.push_back(
974 "19119080646435437102938190283912471651865851478647016881846814376871464810514786470168818468143768714648");
975 ASSERT_GE(callPolicy.InviteToConferencePolicy(VALID_CALLID, numberList), TELEPHONY_ERR_SUCCESS);
976 }
977
978 /**
979 * @tc.number Telephony_CallPolicy_005
980 * @tc.name test error branch
981 * @tc.desc Function test
982 */
983 HWTEST_F(ZeroBranch2Test, Telephony_CallPolicy_005, Function | MediumTest | Level1)
984 {
985 CallPolicy callPolicy;
986 ASSERT_EQ(callPolicy.IsValidSlotId(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
987 ASSERT_EQ(callPolicy.EnableVoLtePolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
988 ASSERT_EQ(callPolicy.DisableVoLtePolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
989 ASSERT_EQ(callPolicy.IsVoLteEnabledPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
990 ASSERT_EQ(callPolicy.VoNRStatePolicy(INVALID_SLOTID, -1), CALL_ERR_INVALID_SLOT_ID);
991 ASSERT_EQ(callPolicy.GetCallWaitingPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
992 ASSERT_EQ(callPolicy.SetCallWaitingPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
993 ASSERT_EQ(callPolicy.GetCallRestrictionPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
994 ASSERT_EQ(callPolicy.SetCallRestrictionPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
995 ASSERT_EQ(callPolicy.GetCallTransferInfoPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
996 ASSERT_EQ(callPolicy.SetCallTransferInfoPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
997 ASSERT_EQ(callPolicy.SetCallPreferenceModePolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
998 ASSERT_EQ(callPolicy.GetImsConfigPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
999 ASSERT_EQ(callPolicy.SetImsConfigPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
1000 ASSERT_EQ(callPolicy.GetImsFeatureValuePolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
1001 ASSERT_EQ(callPolicy.SetImsFeatureValuePolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
1002 ASSERT_EQ(callPolicy.CloseUnFinishedUssdPolicy(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
1003 }
1004
1005 /**
1006 * @tc.number Telephony_CallPolicy_006
1007 * @tc.name test error branch
1008 * @tc.desc Function test
1009 */
1010 HWTEST_F(ZeroBranch2Test, Telephony_CallPolicy_006, Function | MediumTest | Level1)
1011 {
1012 CallPolicy callPolicy;
1013 bool isEcc = false;
1014 int32_t slotId = 0;
1015 std::string number = "111111";
1016 callPolicy.HasNormalCall(isEcc, slotId, CallType::TYPE_IMS);
1017 bool isAirplaneModeOn = false;
1018 callPolicy.GetAirplaneMode(isAirplaneModeOn);
1019 ASSERT_EQ(isAirplaneModeOn, false);
1020 std::vector<std::string> dialingList;
1021 std::vector<std::string> incomingList;
1022 ASSERT_EQ(callPolicy.IsDialingEnable(number), true);
1023 ASSERT_EQ(callPolicy.IsIncomingEnable(number), true);
1024 dialingList.push_back(number);
1025 incomingList.push_back(number);
1026 ASSERT_EQ(callPolicy.SetEdmPolicy(false, dialingList, false, incomingList), TELEPHONY_ERR_SUCCESS);
1027 ASSERT_EQ(callPolicy.IsDialingEnable(number), false);
1028 ASSERT_EQ(callPolicy.IsIncomingEnable(number), false);
1029 }
1030
1031 /**
1032 * @tc.number Telephony_ReportCallInfoHandler_001
1033 * @tc.name test error branch
1034 * @tc.desc Function test
1035 */
1036 HWTEST_F(ZeroBranch2Test, Telephony_ReportCallInfoHandler_001, Function | MediumTest | Level1)
1037 {
1038 CallDetailInfo mCallDetailInfo;
1039 DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateCallReportInfo(mCallDetailInfo);
1040 CallDetailsInfo mCallDetailsInfo;
1041 ASSERT_NE(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateCallsReportInfo(mCallDetailsInfo),
1042 TELEPHONY_ERR_SUCCESS);
1043 DisconnectedDetails mDisconnectedDetails;
1044 ASSERT_NE(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateDisconnectedCause(mDisconnectedDetails),
1045 TELEPHONY_ERR_SUCCESS);
1046 CellularCallEventInfo mCellularCallEventInfo;
1047 ASSERT_NE(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateEventResultInfo(mCellularCallEventInfo),
1048 TELEPHONY_ERR_SUCCESS);
1049 OttCallEventInfo mOttCallEventInfo;
1050 ASSERT_NE(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateOttEventInfo(mOttCallEventInfo),
1051 TELEPHONY_ERR_SUCCESS);
1052 DelayedSingleton<ReportCallInfoHandler>::GetInstance()->Init();
1053 ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateCallReportInfo(mCallDetailInfo),
1054 TELEPHONY_ERR_SUCCESS);
1055 ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateCallsReportInfo(mCallDetailsInfo),
1056 TELEPHONY_ERR_SUCCESS);
1057 ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateDisconnectedCause(mDisconnectedDetails),
1058 TELEPHONY_ERR_SUCCESS);
1059 ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateEventResultInfo(mCellularCallEventInfo),
1060 TELEPHONY_ERR_SUCCESS);
1061 ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->UpdateOttEventInfo(mOttCallEventInfo),
1062 TELEPHONY_ERR_SUCCESS);
1063 CallModeReportInfo mCallModeRequestInfo;
1064 ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->ReceiveImsCallModeRequest(mCallModeRequestInfo),
1065 TELEPHONY_ERR_SUCCESS);
1066 CallModeReportInfo mCallModeResponseInfo;
1067 ASSERT_EQ(DelayedSingleton<ReportCallInfoHandler>::GetInstance()->ReceiveImsCallModeResponse(mCallModeResponseInfo),
1068 TELEPHONY_ERR_SUCCESS);
1069 }
1070
1071 /**
1072 * @tc.number Telephony_VideoControlManager_001
1073 * @tc.name test error branch
1074 * @tc.desc Function test
1075 */
1076 HWTEST_F(ZeroBranch2Test, Telephony_VideoControlManager_001, Function | MediumTest | Level1)
1077 {
1078 std::u16string testEmptyStr = u"";
1079 std::u16string testStr = u"123";
1080 std::string testEmptyStr_ = "";
1081 std::string testStr_ = "123";
1082 int32_t callId = 1;
1083 uint64_t tempSurfaceId = std::stoull(testStr_);
1084 auto surface = SurfaceUtils::GetInstance()->GetSurface(tempSurfaceId);
1085 if (surface == nullptr) {
1086 testStr_ = "";
1087 }
1088 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->ControlCamera(callId, testEmptyStr, 1, 1),
1089 TELEPHONY_ERR_SUCCESS);
1090 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->ControlCamera(callId, testStr, 1, 1),
1091 TELEPHONY_ERR_SUCCESS);
1092 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetPreviewWindow(callId, testEmptyStr_, nullptr),
1093 TELEPHONY_ERR_SUCCESS);
1094 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetPreviewWindow(callId, testStr_, surface),
1095 TELEPHONY_ERR_SUCCESS);
1096 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDisplayWindow(callId, testEmptyStr_, nullptr),
1097 TELEPHONY_ERR_SUCCESS);
1098 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDisplayWindow(callId, testStr_, surface),
1099 TELEPHONY_ERR_SUCCESS);
1100 float zoomRatio = 11;
1101 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetCameraZoom(zoomRatio), TELEPHONY_ERR_SUCCESS);
1102 zoomRatio = 0.01;
1103 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetCameraZoom(zoomRatio), TELEPHONY_ERR_SUCCESS);
1104 zoomRatio = 1;
1105 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetCameraZoom(zoomRatio), TELEPHONY_ERR_SUCCESS);
1106 ASSERT_NE(
1107 DelayedSingleton<VideoControlManager>::GetInstance()->SetPausePicture(callId, testStr), TELEPHONY_ERR_SUCCESS);
1108 int32_t rotation = CAMERA_ROTATION_0;
1109 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDeviceDirection(callId, rotation),
1110 TELEPHONY_ERR_SUCCESS);
1111 rotation = CAMERA_ROTATION_90;
1112 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDeviceDirection(callId, rotation),
1113 TELEPHONY_ERR_SUCCESS);
1114 rotation = CAMERA_ROTATION_180;
1115 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDeviceDirection(callId, rotation),
1116 TELEPHONY_ERR_SUCCESS);
1117 rotation = CAMERA_ROTATION_270;
1118 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDeviceDirection(callId, rotation),
1119 TELEPHONY_ERR_SUCCESS);
1120 rotation = 1;
1121 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->SetDeviceDirection(callId, rotation),
1122 TELEPHONY_ERR_SUCCESS);
1123 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->CancelCallUpgrade(callId), TELEPHONY_ERR_SUCCESS);
1124 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->RequestCameraCapabilities(callId),
1125 TELEPHONY_ERR_SUCCESS);
1126 }
1127
1128 /**
1129 * @tc.number Telephony_VideoControlManager_002
1130 * @tc.name test error branch
1131 * @tc.desc Function test
1132 */
1133 HWTEST_F(ZeroBranch2Test, Telephony_VideoControlManager_002, Function | MediumTest | Level1)
1134 {
1135 int32_t callId = 1;
1136 std::u16string testStr = u"123";
1137 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->OpenCamera(callId, testStr, 0, 0),
1138 TELEPHONY_ERR_SUCCESS);
1139 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->CloseCamera(callId, testStr, 0, 0),
1140 TELEPHONY_ERR_SUCCESS);
1141 ImsCallMode mode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
1142 CallMediaModeInfo imsCallModeInfo;
1143 ASSERT_NE(DelayedSingleton<VideoControlManager>::GetInstance()->ReportImsCallModeInfo(imsCallModeInfo),
1144 TELEPHONY_ERR_SUCCESS);
1145 ASSERT_NE(
1146 DelayedSingleton<VideoControlManager>::GetInstance()->UpdateImsCallMode(callId, mode), TELEPHONY_ERR_SUCCESS);
1147 ASSERT_FALSE(DelayedSingleton<VideoControlManager>::GetInstance()->ContainCameraID(""));
1148 VideoWindow mVideoWindow;
1149 mVideoWindow.width = -1;
1150 mVideoWindow.height = 1;
1151 ASSERT_FALSE(DelayedSingleton<VideoControlManager>::GetInstance()->CheckWindow(mVideoWindow));
1152 mVideoWindow.width = 1;
1153 mVideoWindow.height = -1;
1154 ASSERT_FALSE(DelayedSingleton<VideoControlManager>::GetInstance()->CheckWindow(mVideoWindow));
1155 mVideoWindow.width = -1;
1156 mVideoWindow.height = -1;
1157 ASSERT_FALSE(DelayedSingleton<VideoControlManager>::GetInstance()->CheckWindow(mVideoWindow));
1158 mVideoWindow.width = 1;
1159 mVideoWindow.height = 1;
1160 mVideoWindow.z = 2;
1161 ASSERT_FALSE(DelayedSingleton<VideoControlManager>::GetInstance()->CheckWindow(mVideoWindow));
1162 mVideoWindow.z = 0;
1163 ASSERT_TRUE(DelayedSingleton<VideoControlManager>::GetInstance()->CheckWindow(mVideoWindow));
1164 mVideoWindow.z = 1;
1165 ASSERT_TRUE(DelayedSingleton<VideoControlManager>::GetInstance()->CheckWindow(mVideoWindow));
1166 }
1167
1168 /**
1169 * @tc.number Telephony_CallDialog_001
1170 * @tc.name test error branch
1171 * @tc.desc Function test
1172 */
1173 HWTEST_F(ZeroBranch2Test, Telephony_CallDialog_001, Function | MediumTest | Level1)
1174 {
1175 auto callDialog = DelayedSingleton<CallDialog>::GetInstance();
1176 ASSERT_NE(callDialog, nullptr);
1177 callDialog->DialogProcessMMICodeExtension();
1178 std::string diallogReason = "SATELLITE";
1179 int32_t slotId = 0;
1180 ASSERT_TRUE(callDialog->DialogConnectExtension(diallogReason, slotId));
1181 ASSERT_TRUE(callDialog->DialogConnectExtension(diallogReason));
1182 std::u16string number = u"13333333333";
1183 int32_t videoState = 0;
1184 int32_t dialType = 0;
1185 int32_t dialScene = 0;
1186 int32_t callType = 1;
1187 bool isVideo = false;
1188 ASSERT_TRUE(callDialog->DialogConnectPrivpacyModeExtension(
1189 diallogReason, number, slotId, videoState, dialType, dialScene, callType, isVideo));
1190 ASSERT_TRUE(callDialog->DialogConnectAnswerPrivpacyModeExtension(diallogReason, slotId, videoState, isVideo));
1191 callDialog->DialogCallingPrivacyModeExtension(Rosen::FoldStatus::FOLDED);
1192 callDialog->DialogCallingPrivacyModeExtension(Rosen::FoldStatus::EXPAND);
1193 }
1194
1195 /**
1196 * @tc.number Telephony_CallNumberUtils_003
1197 * @tc.name test error branch
1198 * @tc.desc Function test
1199 */
1200 HWTEST_F(ZeroBranch2Test, Telephony_CallNumberUtils_003, Function | MediumTest | Level1)
1201 {
1202 auto cellularCallConnection = DelayedSingleton<CellularCallConnection>::GetInstance();
1203 EXPECT_NE(cellularCallConnection, nullptr);
1204 std::string dialStr = "";
1205 ASSERT_FALSE(cellularCallConnection->IsMmiCode(0, dialStr));
1206 DialParaInfo dialInfo;
1207 sptr<CallBase> call = new IMSCall(dialInfo);
1208 call->callId_ = 1;
1209 call->SetCallIndex(0);
1210 call->SetSlotId(0);
1211 call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1212 call->SetCallType(CallType::TYPE_IMS);
1213 CallObjectManager::AddOneCallObject(call);
1214 dialStr = "333";
1215 ASSERT_FALSE(cellularCallConnection->IsMmiCode(0, dialStr));
1216 dialStr = "33";
1217 ASSERT_TRUE(cellularCallConnection->IsMmiCode(0, dialStr));
1218 CallObjectManager::DeleteOneCallObject(call);
1219 dialStr = "333";
1220 ASSERT_FALSE(cellularCallConnection->IsMmiCode(0, dialStr));
1221 dialStr = "12";
1222 ASSERT_FALSE(cellularCallConnection->IsMmiCode(0, dialStr));
1223 dialStr = "1*";
1224 ASSERT_TRUE(cellularCallConnection->IsMmiCode(0, dialStr));
1225 dialStr = "*1";
1226 ASSERT_TRUE(cellularCallConnection->IsMmiCode(0, dialStr));
1227 dialStr = "**";
1228 ASSERT_TRUE(cellularCallConnection->IsMmiCode(0, dialStr));
1229 dialStr = "33";
1230 ASSERT_TRUE(cellularCallConnection->IsMmiCode(0, dialStr));
1231 dialStr = "*21*10086#";
1232 ASSERT_TRUE(cellularCallConnection->IsMmiCode(0, dialStr));
1233 dialStr = "10086";
1234 ASSERT_FALSE(cellularCallConnection->IsMmiCode(0, dialStr));
1235 dialStr = "*30#10086";
1236 ASSERT_FALSE(cellularCallConnection->IsMmiCode(0, dialStr));
1237 dialStr = "*33##123#";
1238 ASSERT_FALSE(cellularCallConnection->IsMmiCode(0, dialStr));
1239 dialStr = "*10086#";
1240 ASSERT_TRUE(cellularCallConnection->IsMmiCode(0, dialStr));
1241 dialStr = "#10086#";
1242 ASSERT_TRUE(cellularCallConnection->IsMmiCode(0, dialStr));
1243 }
1244
1245 /**
1246 * @tc.number Telephony_EdmCallPolicy_001
1247 * @tc.name test error branch
1248 * @tc.desc Function test
1249 */
1250 HWTEST_F(ZeroBranch2Test, Telephony_EdmCallPolicy_001, Function | MediumTest | Level1)
1251 {
1252 std::vector<std::string> dialingList;
1253 std::vector<std::string> incomingList;
1254 std::string number = "11111111";
1255 bool isModifyParameter = false;
1256 std::shared_ptr<EdmCallPolicy> edmCallPolicy = std::make_shared<EdmCallPolicy>();
1257 edmCallPolicy->SetCallPolicy(false, dialingList, false, incomingList);
1258 EXPECT_EQ(edmCallPolicy->IsDialingEnable(number), true);
1259 dialingList.push_back(number);
1260 edmCallPolicy->SetCallPolicy(false, dialingList, false, incomingList);
1261 EXPECT_EQ(edmCallPolicy->IsDialingEnable(number), false);
1262 edmCallPolicy->SetCallPolicy(true, dialingList, false, incomingList);
1263 EXPECT_EQ(edmCallPolicy->IsDialingEnable(number), true);
1264 dialingList.insert(dialingList.end(), 1000, "22222222");
1265 EXPECT_EQ(edmCallPolicy->SetCallPolicy(false, dialingList, false, incomingList), TELEPHONY_ERR_ARGUMENT_INVALID);
1266 dialingList.clear();
1267 edmCallPolicy->SetCallPolicy(true, dialingList, false, incomingList);
1268 EXPECT_EQ(edmCallPolicy->IsDialingEnable(number), true);
1269 }
1270
1271 /**
1272 * @tc.number Telephony_EdmCallPolicy_002
1273 * @tc.name test error branch
1274 * @tc.desc Function test
1275 */
1276 HWTEST_F(ZeroBranch2Test, Telephony_EdmCallPolicy_002, Function | MediumTest | Level1)
1277 {
1278 std::vector<std::string> dialingList;
1279 std::vector<std::string> incomingList;
1280 std::string number = "11111111";
1281 bool isModifyParameter = false;
1282 std::shared_ptr<EdmCallPolicy> edmCallPolicy = std::make_shared<EdmCallPolicy>();
1283 edmCallPolicy->SetCallPolicy(false, dialingList, false, incomingList);
1284 EXPECT_EQ(edmCallPolicy->IsIncomingEnable(number), true);
1285 incomingList.push_back(number);
1286 edmCallPolicy->SetCallPolicy(false, dialingList, false, incomingList);
1287 EXPECT_EQ(edmCallPolicy->IsIncomingEnable(number), false);
1288 edmCallPolicy->SetCallPolicy(false, dialingList, true, incomingList);
1289 EXPECT_EQ(edmCallPolicy->IsIncomingEnable(number), true);
1290 incomingList.insert(incomingList.end(), 1000, "22222222");
1291 EXPECT_EQ(edmCallPolicy->SetCallPolicy(false, dialingList, false, incomingList), TELEPHONY_ERR_ARGUMENT_INVALID);
1292 incomingList.clear();
1293 edmCallPolicy->SetCallPolicy(false, dialingList, true, incomingList);
1294 EXPECT_EQ(edmCallPolicy->IsIncomingEnable(number), true);
1295 }
1296 } // namespace Telephony
1297 } // namespace OHOS
1298