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