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 "antifraud_service.h"
18 #include "bluetooth_call_client.h"
19 #include "bluetooth_call_manager.h"
20 #include "bluetooth_call_service.h"
21 #include "bluetooth_connection.h"
22 #include "iremote_broker.h"
23 #include "call_ability_callback.h"
24 #include "call_ability_connect_callback.h"
25 #include "call_ability_report_proxy.h"
26 #include "call_connect_ability.h"
27 #include "call_control_manager.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 "bluetooth_call.h"
79 #include "datashare_helper.h"
80
81 namespace OHOS {
82 namespace Telephony {
83 using namespace testing::ext;
84
85 namespace {
86 const int32_t INVALID_SLOTID = 2;
87 const int32_t SIM1_SLOTID = 0;
88 const int32_t DEFAULT_INDEX = 1;
89 const int16_t CAMERA_ROTATION_0 = 0;
90 const int16_t CAMERA_ROTATION_90 = 90;
91 const int16_t CAMERA_ROTATION_180 = 180;
92 const int16_t CAMERA_ROTATION_270 = 270;
93 const int32_t INVALID_MODE = 0;
94 const int32_t VALID_CALLID = 1;
95 const int32_t ERROR_CALLID = -1;
96 const int32_t ONE_TIME = 1;
97 const int32_t STEP_1 = 1;
98 const int32_t SOURCE_CALL = 2;
99 constexpr int16_t DEFAULT_TIME = 0;
100 constexpr const char *TEST_STR = "123";
101 constexpr const char *LONG_STR =
102 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
103 "111111111";
104 constexpr int WAIT_TIME = 3;
105 } // namespace
106
107 class DemoHandler : public AppExecFwk::EventHandler {
108 public:
DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> & eventRunner)109 explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &eventRunner) : AppExecFwk::EventHandler(eventRunner)
110 {}
~DemoHandler()111 virtual ~DemoHandler() {}
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)112 void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
113 };
114
115 class ZeroBranch4Test : public testing::Test {
116 public:
117 void SetUp();
118 void TearDown();
119 static void SetUpTestCase();
120 static void TearDownTestCase();
121 };
122
SetUp()123 void ZeroBranch4Test::SetUp() {}
124
TearDown()125 void ZeroBranch4Test::TearDown() {}
126
SetUpTestCase()127 void ZeroBranch4Test::SetUpTestCase()
128 {
129 constexpr int permissionNum = 1;
130 const char *perms[permissionNum] = {
131 "ohos.permission.GET_TELEPHONY_STATE"
132 };
133 NativeTokenInfoParams infoInstance = {
134 .dcapsNum = 0, // Indicates the capsbility list of the sa.
135 .permsNum = permissionNum,
136 .aclsNum = 0, // acls is the list of rights thar can be escalated.
137 .dcaps = nullptr,
138 .perms = perms,
139 .acls = nullptr,
140 .processName = "ZeroBranch4Test",
141 .aplStr = "system_basic",
142 };
143 uint64_t tokenId = GetAccessTokenId(&infoInstance);
144 SetSelfTokenID(tokenId);
145 auto result = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
146 EXPECT_EQ(result, Security::AccessToken::RET_SUCCESS);
147 }
148
TearDownTestCase()149 void ZeroBranch4Test::TearDownTestCase()
150 {
151 sleep(WAIT_TIME);
152 }
153
CreateDataShareHelper(std::string uri)154 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(std::string uri)
155 {
156 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
157 if (saManager == nullptr) {
158 printf("Get system ability mgr failed.");
159 return nullptr;
160 }
161 auto remoteObj = saManager->GetSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
162 if (remoteObj == nullptr) {
163 printf("GetSystemAbility Service Failed.");
164 return nullptr;
165 }
166 return DataShare::DataShareHelper::Creator(remoteObj, uri);
167 }
168
CreateDataShareHelper(int systemAbilityId)169 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(int systemAbilityId)
170 {
171 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
172 if (saManager == nullptr) {
173 TELEPHONY_LOGE("GetSystemAbilityManager failed.");
174 return nullptr;
175 }
176 sptr<IRemoteObject> remote = saManager->GetSystemAbility(systemAbilityId);
177 if (remote == nullptr) {
178 TELEPHONY_LOGE("GetSystemAbility Service Failed.");
179 return nullptr;
180 }
181 const std::string SETTINGS_DATASHARE_URI =
182 "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
183 const std::string SETTINGS_DATASHARE_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility";
184 return DataShare::DataShareHelper::Creator(remote, SETTINGS_DATASHARE_URI, SETTINGS_DATASHARE_EXT_URI);
185 }
186
187 /**
188 * @tc.number Telephony_Ott_Conference_001
189 * @tc.name test error branch
190 * @tc.desc Function test
191 */
192 HWTEST_F(ZeroBranch4Test, Telephony_Ott_Conference_001, TestSize.Level0)
193 {
194 OttConference ottConference;
195 ottConference.state_ = CONFERENCE_STATE_IDLE;
196 ASSERT_EQ(ottConference.JoinToConference(1), CALL_ERR_ILLEGAL_CALL_OPERATION);
197 ottConference.state_ = CONFERENCE_STATE_CREATING;
198 ASSERT_EQ(ottConference.JoinToConference(1), TELEPHONY_SUCCESS);
199 for (uint16_t i = 0; i <= CS_CONFERENCE_MAX_CALLS_CNT + 1; ++i) {
200 ottConference.subCallIdSet_.insert(i);
201 }
202 ASSERT_EQ(ottConference.CanCombineConference(), CALL_ERR_CONFERENCE_CALL_EXCEED_LIMIT);
203 ottConference.subCallIdSet_.clear();
204 ottConference.subCallIdSet_.insert(1);
205 ASSERT_EQ(ottConference.LeaveFromConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
206 ASSERT_EQ(ottConference.LeaveFromConference(1), TELEPHONY_SUCCESS);
207 ottConference.subCallIdSet_.clear();
208 ottConference.subCallIdSet_.insert(1);
209 ASSERT_EQ(ottConference.HoldConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
210 ottConference.state_ = CONFERENCE_STATE_HOLDING;
211 ASSERT_EQ(ottConference.HoldConference(-1), TELEPHONY_SUCCESS);
212 ASSERT_EQ(ottConference.HoldConference(1), TELEPHONY_SUCCESS);
213 ASSERT_EQ(ottConference.CanCombineConference(), TELEPHONY_SUCCESS);
214 ottConference.subCallIdSet_.insert(1);
215 ottConference.state_ = CONFERENCE_STATE_ACTIVE;
216 ASSERT_EQ(ottConference.CanSeparateConference(), TELEPHONY_SUCCESS);
217 ASSERT_EQ(ottConference.CanKickOutFromConference(), TELEPHONY_SUCCESS);
218 ottConference.subCallIdSet_.clear();
219 ASSERT_EQ(ottConference.CanSeparateConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
220 ASSERT_EQ(ottConference.CanKickOutFromConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
221 }
222
223 /**
224 * @tc.number Telephony_Cs_Conference_001
225 * @tc.name test error branch
226 * @tc.desc Function test
227 */
228 HWTEST_F(ZeroBranch4Test, Telephony_Cs_Conference_001, TestSize.Level0)
229 {
230 CsConference csConference;
231 csConference.state_ = CONFERENCE_STATE_IDLE;
232 ASSERT_EQ(csConference.JoinToConference(1), CALL_ERR_ILLEGAL_CALL_OPERATION);
233 csConference.state_ = CONFERENCE_STATE_CREATING;
234 ASSERT_EQ(csConference.JoinToConference(1), TELEPHONY_SUCCESS);
235 for (uint16_t i = 0; i <= CS_CONFERENCE_MAX_CALLS_CNT + 1; ++i) {
236 csConference.subCallIdSet_.insert(i);
237 }
238 ASSERT_EQ(csConference.CanCombineConference(), CALL_ERR_CONFERENCE_CALL_EXCEED_LIMIT);
239 csConference.subCallIdSet_.clear();
240 csConference.subCallIdSet_.insert(1);
241 ASSERT_EQ(csConference.LeaveFromConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
242 ASSERT_EQ(csConference.LeaveFromConference(1), TELEPHONY_SUCCESS);
243 csConference.subCallIdSet_.clear();
244 csConference.subCallIdSet_.insert(1);
245 ASSERT_EQ(csConference.HoldConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
246 csConference.state_ = CONFERENCE_STATE_HOLDING;
247 ASSERT_EQ(csConference.HoldConference(-1), TELEPHONY_SUCCESS);
248 ASSERT_EQ(csConference.HoldConference(1), TELEPHONY_SUCCESS);
249 ASSERT_EQ(csConference.CanCombineConference(), TELEPHONY_SUCCESS);
250 csConference.subCallIdSet_.insert(1);
251 csConference.state_ = CONFERENCE_STATE_ACTIVE;
252 ASSERT_EQ(csConference.CanSeparateConference(), TELEPHONY_SUCCESS);
253 ASSERT_EQ(csConference.CanKickOutFromConference(), TELEPHONY_SUCCESS);
254 csConference.subCallIdSet_.clear();
255 ASSERT_EQ(csConference.CanSeparateConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
256 ASSERT_EQ(csConference.CanKickOutFromConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
257 }
258
259 /**
260 * @tc.number Telephony_Ims_Conference_001
261 * @tc.name test error branch
262 * @tc.desc Function test
263 */
264 HWTEST_F(ZeroBranch4Test, Telephony_Ims_Conference_001, TestSize.Level0)
265 {
266 ImsConference imsConference;
267 imsConference.state_ = CONFERENCE_STATE_IDLE;
268 ASSERT_EQ(imsConference.JoinToConference(1), CALL_ERR_ILLEGAL_CALL_OPERATION);
269 imsConference.state_ = CONFERENCE_STATE_CREATING;
270 ASSERT_EQ(imsConference.JoinToConference(1), TELEPHONY_SUCCESS);
271 for (uint16_t i = 0; i <= CS_CONFERENCE_MAX_CALLS_CNT + 1; ++i) {
272 imsConference.subCallIdSet_.insert(i);
273 }
274 ASSERT_EQ(imsConference.CanCombineConference(), CALL_ERR_CONFERENCE_CALL_EXCEED_LIMIT);
275 imsConference.subCallIdSet_.clear();
276 imsConference.subCallIdSet_.insert(1);
277 ASSERT_EQ(imsConference.LeaveFromConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
278 ASSERT_EQ(imsConference.LeaveFromConference(1), TELEPHONY_SUCCESS);
279 imsConference.subCallIdSet_.clear();
280 imsConference.subCallIdSet_.insert(1);
281 ASSERT_EQ(imsConference.HoldConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
282 imsConference.state_ = CONFERENCE_STATE_HOLDING;
283 ASSERT_EQ(imsConference.HoldConference(-1), TELEPHONY_SUCCESS);
284 ASSERT_EQ(imsConference.HoldConference(1), TELEPHONY_SUCCESS);
285 ASSERT_EQ(imsConference.CanCombineConference(), TELEPHONY_SUCCESS);
286 imsConference.subCallIdSet_.insert(1);
287 imsConference.state_ = CONFERENCE_STATE_ACTIVE;
288 ASSERT_EQ(imsConference.CanSeparateConference(), TELEPHONY_SUCCESS);
289 ASSERT_EQ(imsConference.CanKickOutFromConference(), TELEPHONY_SUCCESS);
290 imsConference.subCallIdSet_.clear();
291 ASSERT_EQ(imsConference.CanSeparateConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
292 ASSERT_EQ(imsConference.CanKickOutFromConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
293 }
294
295 /**
296 * @tc.number Telephony_BluetoothCallService_001
297 * @tc.name test error branch
298 * @tc.desc Function test
299 */
300 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallService_001, TestSize.Level0)
301 {
302 BluetoothCallService bluetoothCallService;
303 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.AnswerCall());
304 DialParaInfo dialParaInfo;
305 sptr<OHOS::Telephony::CallBase> callBase1 = new OTTCall(dialParaInfo);
306 bluetoothCallService.callObjectPtrList_.clear();
307 callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
308 callBase1->callId_ = -1;
309 bluetoothCallService.callObjectPtrList_.push_back(callBase1);
310 bluetoothCallService.AnswerCall();
311 bluetoothCallService.callControlManagerPtr_ = nullptr;
312 ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.AnswerCall());
313 ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.RejectCall());
314 ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.HangUpCall());
315 ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.HoldCall());
316 ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.UnHoldCall());
317 ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.SwitchCall());
318 bluetoothCallService.StartDtmf('c');
319 bluetoothCallService.callObjectPtrList_.clear();
320 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
321 callBase1->callId_ = -1;
322 bluetoothCallService.callObjectPtrList_.push_back(callBase1);
323 ASSERT_NE(TELEPHONY_ERR_LOCAL_PTR_NULL, bluetoothCallService.StartDtmf('c'));
324 ASSERT_NE(TELEPHONY_ERR_LOCAL_PTR_NULL, bluetoothCallService.StopDtmf());
325 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.CombineConference());
326 bluetoothCallService.callObjectPtrList_.clear();
327 callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
328 callBase1->callId_ = -1;
329 bluetoothCallService.callObjectPtrList_.push_back(callBase1);
330 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.CombineConference());
331 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.SeparateConference());
332 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.KickOutFromConference());
333 }
334
335 /**
336 * @tc.number Telephony_BluetoothCallService_002
337 * @tc.name test error branch
338 * @tc.desc Function test
339 */
340 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallService_002, TestSize.Level1)
341 {
342 BluetoothCallService bluetoothCallService;
343 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.AnswerCall());
344 DialParaInfo dialParaInfo;
345 sptr<OHOS::Telephony::CallBase> callBase1 = new OTTCall(dialParaInfo);
346 bluetoothCallService.callObjectPtrList_.clear();
347 callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
348 callBase1->callId_ = -1;
349 bluetoothCallService.callObjectPtrList_.push_back(callBase1);
350 bluetoothCallService.GetCurrentCallList(-1).size();
351 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.CombineConference());
352 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.SeparateConference());
353 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.KickOutFromConference());
354 }
355
356 /**
357 * @tc.number Telephony_BluetoothCallService_003
358 * @tc.name test error branch
359 * @tc.desc Function test
360 */
361 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallService_003, TestSize.Level0)
362 {
363 int32_t callId = 10020;
364 int32_t numActive = 1;
365 int32_t callState = (int32_t)TelCallState::CALL_STATUS_IDLE;
366 std::string number = "";
367 CallAttributeInfo callAttributeInfo;
368 callAttributeInfo.callId = callId;
369 CallObjectManager::AddOneVoipCallObject(callAttributeInfo);
370 BluetoothCallService bluetoothCallService;
371 bluetoothCallService.GetVoipCallState(numActive, callState, number);
372 EXPECT_EQ(numActive, 1);
373 CallObjectManager::UpdateOneVoipCallObjectByCallId(callId, TelCallState::CALL_STATUS_WAITING);
374 bluetoothCallService.GetVoipCallState(numActive, callState, number);
375 EXPECT_EQ(callState, (int32_t)TelCallState::CALL_STATUS_INCOMING);
376 CallObjectManager::UpdateOneVoipCallObjectByCallId(callId, TelCallState::CALL_STATUS_INCOMING);
377 bluetoothCallService.GetVoipCallState(numActive, callState, number);
378 EXPECT_EQ(callState, (int32_t)TelCallState::CALL_STATUS_INCOMING);
379 callState = (int32_t)TelCallState::CALL_STATUS_IDLE;
380 CallObjectManager::UpdateOneVoipCallObjectByCallId(callId, TelCallState::CALL_STATUS_ALERTING);
381 bluetoothCallService.GetVoipCallState(numActive, callState, number);
382 EXPECT_EQ(callState, (int32_t)TelCallState::CALL_STATUS_ALERTING);
383 numActive = 0;
384 CallObjectManager::UpdateOneVoipCallObjectByCallId(callId, TelCallState::CALL_STATUS_ACTIVE);
385 bluetoothCallService.GetVoipCallState(numActive, callState, number);
386 EXPECT_EQ(numActive, 1);
387 }
388
389 /**
390 * @tc.number Telephony_BluetoothCallStub_001
391 * @tc.name test error nullptr branch
392 * @tc.desc Function test
393 */
394 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallStub_001, TestSize.Level0)
395 {
396 auto bluetoothCallService = std::make_shared<BluetoothCallService>();
397 MessageParcel data1;
398 MessageParcel reply;
399 MessageOption option;
400 bluetoothCallService->OnRemoteRequest(static_cast<uint32_t>(
401 CallManagerCallAbilityInterfaceCode::UPDATE_CALL_STATE_INFO), data1, reply, option);
402 const uint8_t data = 1;
403 MessageParcel messageParcel;
404 messageParcel.WriteBuffer(&data, 1);
405 messageParcel.RewindRead(0);
406 int32_t result = bluetoothCallService->OnAnswerCall(messageParcel, reply);
407 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
408 result = bluetoothCallService->OnRejectCall(messageParcel, reply);
409 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
410 bluetoothCallService->OnHangUpCall(messageParcel, reply);
411 result = bluetoothCallService->OnGetBtCallState(messageParcel, reply);
412 ASSERT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
413 result = bluetoothCallService->OnHoldCall(messageParcel, reply);
414 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
415 result = bluetoothCallService->OnUnHoldCall(messageParcel, reply);
416 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
417 result = bluetoothCallService->OnSwitchCall(messageParcel, reply);
418 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
419 result = bluetoothCallService->OnCombineConference(messageParcel, reply);
420 ASSERT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
421 result = bluetoothCallService->OnSeparateConference(messageParcel, reply);
422 ASSERT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
423 result = bluetoothCallService->OnKickOutFromConference(messageParcel, reply);
424 ASSERT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
425 result = bluetoothCallService->OnStartDtmf(messageParcel, reply);
426 ASSERT_EQ(result, TELEPHONY_SUCCESS);
427 result = bluetoothCallService->OnStopDtmf(messageParcel, reply);
428 ASSERT_EQ(result, TELEPHONY_SUCCESS);
429 result = bluetoothCallService->OnGetCurrentCallList(messageParcel, reply);
430 ASSERT_EQ(result, TELEPHONY_SUCCESS);
431 result = bluetoothCallService->OnAddAudioDeviceList(messageParcel, reply);
432 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
433 result = bluetoothCallService->OnRemoveAudioDeviceList(messageParcel, reply);
434 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
435 result = bluetoothCallService->OnResetNearlinkDeviceList(messageParcel, reply);
436 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
437 result = bluetoothCallService->OnResetBtHearingAidDeviceList(messageParcel, reply);
438 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
439 }
440
441 /**
442 * @tc.number Telephony_BluetoothConnection_001
443 * @tc.name test error nullptr branch
444 * @tc.desc Function test
445 */
446 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothConnection_001, TestSize.Level0)
447 {
448 auto bluetoothConnection = std::make_shared<BluetoothConnection>();
449 bluetoothConnection->IsAudioActivated();
450 #ifdef ABILITY_BLUETOOTH_SUPPORT
451 bluetoothConnection->ResetBtConnection();
452 bluetoothConnection->RegisterObserver();
453 std::string address = "123";
454 bluetoothConnection->RemoveBtDevice(address);
455 Bluetooth::BluetoothRemoteDevice device;
456 int32_t state = static_cast<int32_t>(Bluetooth::BTConnectState::CONNECTED);
457 int32_t cause = 1;
458 bluetoothConnection->OnConnectionStateChanged(device, state, cause);
459 state = static_cast<int32_t>(Bluetooth::BTConnectState::DISCONNECTED);
460 bluetoothConnection->OnConnectionStateChanged(device, state, cause);
461 EXPECT_FALSE(bluetoothConnection->IsAudioActivated());
462 #endif
463 }
464
GetTestNumber()465 std::string GetTestNumber()
466 {
467 std::string number =
468 "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456";
469 number += number;
470 return number;
471 }
472
473 /**
474 * @tc.number Telephony_BluetoothCallPolicy_001
475 * @tc.name test error branch
476 * @tc.desc Function test
477 */
478 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallPolicy_001, TestSize.Level0)
479 {
480 BluetoothCallPolicy callPolicy;
481 DialParaInfo dialParaInfo;
482 sptr<OHOS::Telephony::CallBase> callBase1 = new OTTCall(dialParaInfo);
483 callBase1->callId_ = 0;
484 callPolicy.callObjectPtrList_.push_back(callBase1);
485 callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
486 int32_t policy = 0;
487 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.AnswerCallPolicy(policy));
488 callBase1->callState_ = TelCallState::CALL_STATUS_WAITING;
489 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.AnswerCallPolicy(policy));
490 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
491 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.AnswerCallPolicy(policy));
492 callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
493 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.RejectCallPolicy(policy));
494 callBase1->callState_ = TelCallState::CALL_STATUS_WAITING;
495 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.RejectCallPolicy(policy));
496 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
497 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.RejectCallPolicy(policy));
498 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
499 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HoldCallPolicy(policy));
500 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
501 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.HoldCallPolicy(policy));
502 callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
503 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.UnHoldCallPolicy(policy));
504 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
505 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.UnHoldCallPolicy(policy));
506 callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
507 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
508 callBase1->callState_ = TelCallState::CALL_STATUS_WAITING;
509 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
510 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
511 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
512 callBase1->callState_ = TelCallState::CALL_STATUS_ALERTING;
513 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
514 callBase1->callState_ = TelCallState::CALL_STATUS_DIALING;
515 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
516 callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
517 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
518 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
519 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
520 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
521 ASSERT_EQ(CALL_ERR_ILLEGAL_CALL_OPERATION, callPolicy.SwitchCallPolicy(policy));
522 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
523 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.SwitchCallPolicy(policy));
524 }
525
526 /**
527 * @tc.number Telephony_BluetoothCallPolicy_002
528 * @tc.name test error branch
529 * @tc.desc Function test
530 */
531 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallPolicy_002, TestSize.Level0)
532 {
533 BluetoothCallPolicy callPolicy;
534 DialParaInfo dialParaInfo;
535 sptr<OHOS::Telephony::CallBase> callBase1 = new OTTCall(dialParaInfo);
536 callBase1->callId_ = 0;
537 callPolicy.callObjectPtrList_.push_back(callBase1);
538 int32_t policy = 0;
539 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
540 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
541 callBase1->callState_ = TelCallState::CALL_STATUS_ALERTING;
542 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
543 callBase1->callState_ = TelCallState::CALL_STATUS_DIALING;
544 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
545 callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
546 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
547 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
548 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
549 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
550 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.CombineConferencePolicy(policy));
551 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
552 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.CombineConferencePolicy(policy));
553 callBase1->conferenceState_ = TelConferenceState::TEL_CONFERENCE_ACTIVE;
554 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.SeparateConferencePolicy(policy));
555 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.KickOutFromConferencePolicy(policy));
556 callBase1->conferenceState_ = TelConferenceState::TEL_CONFERENCE_HOLDING;
557 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.SeparateConferencePolicy(policy));
558 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.KickOutFromConferencePolicy(policy));
559 callBase1->conferenceState_ = TelConferenceState::TEL_CONFERENCE_IDLE;
560 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.SeparateConferencePolicy(policy));
561 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.KickOutFromConferencePolicy(policy));
562 }
563
564
565 /**
566 * @tc.number Telephony_CSCall_001
567 * @tc.name test error branch
568 * @tc.desc Function test
569 */
570 HWTEST_F(ZeroBranch4Test, Telephony_CSCall_001, TestSize.Level0)
571 {
572 DialParaInfo dialParaInfo;
573 CSCall call { dialParaInfo };
574 call.AnswerCall(0);
575 call.RejectCall();
576 call.HoldCall();
577 call.SwitchCall();
578 call.SetMute(0, 0);
579 call.CombineConference();
580 call.SeparateConference();
581 call.KickOutFromConference();
582 call.CanCombineConference();
583 call.CanSeparateConference();
584 call.LaunchConference();
585 call.HoldConference();
586 int32_t mainCallId = 1;
587 ASSERT_EQ(TELEPHONY_SUCCESS, call.GetMainCallId(mainCallId));
588 call.HandleCombineConferenceFailEvent();
589 }
590
591 /**
592 * @tc.number Telephony_CallRecordsManager_001
593 * @tc.name test error branch
594 * @tc.desc Function test
595 */
596 HWTEST_F(ZeroBranch4Test, Telephony_CallRecordsManager_001, TestSize.Level0)
597 {
598 CallRecordsManager callRecordsManager;
599 callRecordsManager.Init();
600
601 sptr<CallBase> callObjectPtr = nullptr;
602 TelCallState priorState = TelCallState::CALL_STATUS_HOLDING;
603 TelCallState nextState = TelCallState::CALL_STATUS_HOLDING;
604 callRecordsManager.CallStateUpdated(callObjectPtr, priorState, nextState);
605 nextState = TelCallState::CALL_STATUS_DISCONNECTED;
606 callRecordsManager.CallStateUpdated(callObjectPtr, priorState, nextState);
607 DialParaInfo dialParaInfo;
608 callObjectPtr = new CSCall(dialParaInfo);
609 ASSERT_TRUE(callObjectPtr != nullptr);
610 callRecordsManager.CallStateUpdated(callObjectPtr, priorState, nextState);
611 CallAttributeInfo info;
612 info.callBeginTime = DEFAULT_TIME;
613 info.callEndTime = ONE_TIME;
614 callRecordsManager.AddOneCallRecord(info);
615 info.callBeginTime = ONE_TIME;
616 info.callEndTime = DEFAULT_TIME;
617 callRecordsManager.AddOneCallRecord(info);
618 info.callBeginTime = DEFAULT_TIME;
619 info.callEndTime = DEFAULT_TIME;
620 callRecordsManager.AddOneCallRecord(info);
621 info.callBeginTime = ONE_TIME;
622 info.callEndTime = ONE_TIME;
623 callRecordsManager.AddOneCallRecord(info);
624 info.ringBeginTime = DEFAULT_TIME;
625 info.ringEndTime = ONE_TIME;
626 callRecordsManager.AddOneCallRecord(info);
627 info.ringBeginTime = ONE_TIME;
628 info.ringEndTime = DEFAULT_TIME;
629 callRecordsManager.AddOneCallRecord(info);
630 info.ringBeginTime = DEFAULT_TIME;
631 info.ringEndTime = DEFAULT_TIME;
632 callRecordsManager.AddOneCallRecord(info);
633 info.ringBeginTime = ONE_TIME;
634 info.ringEndTime = ONE_TIME;
635 callRecordsManager.AddOneCallRecord(info);
636 callRecordsManager.RemoveMissedIncomingCallNotification();
637 int32_t videoState = static_cast<int32_t>(VideoStateType::TYPE_VIDEO);
638 callRecordsManager.GetCallFeatures(videoState);
639 nextState = TelCallState::CALL_STATUS_DISCONNECTED;
640 callRecordsManager.CallStateUpdated(callObjectPtr, priorState, nextState);
641 callObjectPtr->SetCallDirection(CallDirection::CALL_DIRECTION_IN);
642 callRecordsManager.CallStateUpdated(callObjectPtr, priorState, nextState);
643 callObjectPtr->SetAiAutoAnswer(true);
644 callRecordsManager.CallStateUpdated(callObjectPtr, priorState, nextState);
645 }
646
647 /**
648 * @tc.number Telephony_CallControlManager_001
649 * @tc.name test error branch
650 * @tc.desc Function test
651 */
652 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_001, TestSize.Level0)
653 {
654 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
655 int32_t videoState = 0;
656 ASSERT_NE(callControlManager->AnswerCall(INVALID_CALLID, videoState), TELEPHONY_SUCCESS);
657 videoState = 2;
658 ASSERT_NE(callControlManager->AnswerCall(VALID_CALLID, videoState), TELEPHONY_SUCCESS);
659 ASSERT_NE(callControlManager->RejectCall(VALID_CALLID, false, u""), TELEPHONY_SUCCESS);
660 ASSERT_NE(callControlManager->HangUpCall(VALID_CALLID), TELEPHONY_SUCCESS);
661 ASSERT_NE(callControlManager->HangUpCall(INVALID_CALLID), TELEPHONY_SUCCESS);
662 ASSERT_EQ(callControlManager->GetCallState(), TELEPHONY_SUCCESS);
663 ASSERT_NE(callControlManager->HoldCall(INVALID_CALLID), TELEPHONY_SUCCESS);
664 ASSERT_NE(callControlManager->UnHoldCall(INVALID_CALLID), TELEPHONY_SUCCESS);
665 ASSERT_NE(callControlManager->SwitchCall(INVALID_CALLID), TELEPHONY_SUCCESS);
666 ASSERT_FALSE(callControlManager->HasCall());
667 sptr<CallBase> callObjectPtr = nullptr;
668 TelCallState priorState = TelCallState::CALL_STATUS_HOLDING;
669 TelCallState nextState = TelCallState::CALL_STATUS_HOLDING;
670 ASSERT_FALSE(callControlManager->NotifyNewCallCreated(callObjectPtr));
671 callObjectPtr = nullptr;
672 ASSERT_EQ(TELEPHONY_ERR_LOCAL_PTR_NULL, callControlManager->AddCallLogAndNotification(callObjectPtr));
673 callObjectPtr = nullptr;
674 ASSERT_FALSE(callControlManager->NotifyCallStateUpdated(callObjectPtr, priorState, nextState));
675 DisconnectedDetails details;
676 ASSERT_FALSE(callControlManager->NotifyCallDestroyed(details));
677 ASSERT_FALSE(callControlManager->NotifyIncomingCallAnswered(callObjectPtr));
678 ASSERT_FALSE(callControlManager->NotifyIncomingCallRejected(callObjectPtr, false, ""));
679 ASSERT_NE(callControlManager->PostDialProceed(VALID_CALLID, true), TELEPHONY_SUCCESS);
680 CallEventInfo info;
681 ASSERT_FALSE(callControlManager->NotifyCallEventUpdated(info));
682 DialParaInfo dialParaInfo;
683 callObjectPtr = new CSCall(dialParaInfo);
684 ASSERT_TRUE(callControlManager->NotifyNewCallCreated(callObjectPtr));
685 callControlManager->AddCallLogAndNotification(callObjectPtr);
686 ASSERT_FALSE(callControlManager->NotifyCallStateUpdated(callObjectPtr, priorState, nextState));
687 ASSERT_FALSE(callControlManager->NotifyIncomingCallAnswered(callObjectPtr));
688 ASSERT_FALSE(callControlManager->NotifyIncomingCallRejected(callObjectPtr, false, ""));
689 callObjectPtr->SetCallCreateTime(time(nullptr));
690
691 callControlManager->Init();
692 ASSERT_NE(callControlManager->RejectCall(VALID_CALLID, false, u""), TELEPHONY_SUCCESS);
693 ASSERT_NE(callControlManager->RejectCall(INVALID_CALLID, false, u""), TELEPHONY_SUCCESS);
694 ASSERT_NE(callControlManager->HangUpCall(VALID_CALLID), TELEPHONY_SUCCESS);
695 ASSERT_TRUE(callControlManager->NotifyNewCallCreated(callObjectPtr));
696 callControlManager->AddCallLogAndNotification(callObjectPtr);
697 ASSERT_TRUE(callControlManager->NotifyCallStateUpdated(callObjectPtr, priorState, nextState));
698 ASSERT_TRUE(callControlManager->NotifyIncomingCallAnswered(callObjectPtr));
699 ASSERT_TRUE(callControlManager->NotifyIncomingCallRejected(callObjectPtr, false, ""));
700 callControlManager->ConnectCallUiService(true);
701 }
702
703 /**
704 * @tc.number Telephony_CallControlManager_002
705 * @tc.name test error branch
706 * @tc.desc Function test
707 */
708 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_002, TestSize.Level0)
709 {
710 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
711 ASSERT_NE(callControlManager->StartDtmf(INVALID_CALLID, 'a'), TELEPHONY_SUCCESS);
712 ASSERT_NE(callControlManager->StopDtmf(INVALID_CALLID), TELEPHONY_SUCCESS);
713 ASSERT_NE(callControlManager->GetCallWaiting(INVALID_CALLID), TELEPHONY_SUCCESS);
714 int32_t slotId = 1;
715 ASSERT_NE(callControlManager->GetCallWaiting(slotId), TELEPHONY_SUCCESS);
716 ASSERT_NE(callControlManager->SetCallWaiting(INVALID_CALLID, true), TELEPHONY_SUCCESS);
717 ASSERT_NE(callControlManager->SetCallWaiting(slotId, true), TELEPHONY_SUCCESS);
718 CallRestrictionType callRestrictionType = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
719 ASSERT_NE(callControlManager->GetCallRestriction(INVALID_CALLID, callRestrictionType), TELEPHONY_SUCCESS);
720 ASSERT_NE(callControlManager->GetCallRestriction(slotId, callRestrictionType), TELEPHONY_SUCCESS);
721 CallRestrictionInfo callRestrictionInfo;
722 ASSERT_NE(callControlManager->SetCallRestriction(INVALID_CALLID, callRestrictionInfo), TELEPHONY_SUCCESS);
723 ASSERT_NE(callControlManager->SetCallRestriction(slotId, callRestrictionInfo), TELEPHONY_SUCCESS);
724 CallTransferType callTransferType = CallTransferType::TRANSFER_TYPE_BUSY;
725 ASSERT_NE(callControlManager->GetCallTransferInfo(INVALID_CALLID, callTransferType), TELEPHONY_SUCCESS);
726 ASSERT_NE(callControlManager->GetCallTransferInfo(slotId, callTransferType), TELEPHONY_SUCCESS);
727 CallTransferInfo info;
728 ASSERT_NE(callControlManager->SetCallTransferInfo(INVALID_CALLID, info), TELEPHONY_SUCCESS);
729 ASSERT_NE(callControlManager->SetCallTransferInfo(slotId, info), TELEPHONY_SUCCESS);
730 bool result = true;
731 ASSERT_NE(callControlManager->CanSetCallTransferTime(INVALID_CALLID, result), TELEPHONY_SUCCESS);
732 ASSERT_NE(callControlManager->CanSetCallTransferTime(slotId, result), TELEPHONY_SUCCESS);
733 int32_t mode = 1;
734 ASSERT_NE(callControlManager->SetCallPreferenceMode(INVALID_CALLID, mode), TELEPHONY_SUCCESS);
735 ASSERT_NE(callControlManager->SetCallPreferenceMode(slotId, mode), TELEPHONY_SUCCESS);
736 ASSERT_NE(callControlManager->CombineConference(INVALID_CALLID), TELEPHONY_SUCCESS);
737 ASSERT_NE(callControlManager->SeparateConference(INVALID_CALLID), TELEPHONY_SUCCESS);
738 ASSERT_NE(callControlManager->KickOutFromConference(INVALID_CALLID), TELEPHONY_SUCCESS);
739 int32_t mainCallId = VALID_CALLID;
740 ASSERT_NE(callControlManager->GetMainCallId(INVALID_CALLID, mainCallId), TELEPHONY_SUCCESS);
741 std::vector<std::u16string> callIdList;
742 ASSERT_NE(callControlManager->GetSubCallIdList(INVALID_CALLID, callIdList), TELEPHONY_SUCCESS);
743 ASSERT_NE(callControlManager->GetCallIdListForConference(INVALID_CALLID, callIdList), TELEPHONY_SUCCESS);
744 ImsConfigItem item = ITEM_VIDEO_QUALITY;
745 ASSERT_NE(callControlManager->GetImsConfig(INVALID_CALLID, item), TELEPHONY_SUCCESS);
746 ASSERT_NE(callControlManager->GetImsConfig(slotId, item), TELEPHONY_SUCCESS);
747 std::u16string value = u"";
748 ASSERT_NE(callControlManager->SetImsConfig(INVALID_CALLID, item, value), TELEPHONY_SUCCESS);
749 ASSERT_NE(callControlManager->SetImsConfig(slotId, item, value), TELEPHONY_SUCCESS);
750 FeatureType featureType = TYPE_VOICE_OVER_LTE;
751 ASSERT_NE(callControlManager->GetImsFeatureValue(INVALID_CALLID, featureType), TELEPHONY_SUCCESS);
752 ASSERT_NE(callControlManager->GetImsFeatureValue(slotId, featureType), TELEPHONY_SUCCESS);
753 ASSERT_NE(callControlManager->SetImsFeatureValue(INVALID_CALLID, featureType, mode), TELEPHONY_SUCCESS);
754 ASSERT_NE(callControlManager->SetImsFeatureValue(slotId, featureType, mode), TELEPHONY_SUCCESS);
755 ASSERT_NE(callControlManager->DisableImsSwitch(INVALID_CALLID), TELEPHONY_SUCCESS);
756 ASSERT_NE(callControlManager->DisableImsSwitch(slotId), TELEPHONY_SUCCESS);
757 }
758
759 /**
760 * @tc.number Telephony_CallControlManager_003
761 * @tc.name test error branch
762 * @tc.desc Function test
763 */
764 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_003, TestSize.Level0)
765 {
766 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
767 callControlManager->UnInit();
768 callControlManager->CallStateObserve();
769 callControlManager->Init();
770 callControlManager->CallStateObserve();
771 ASSERT_NE(callControlManager->GetCallWaiting(INVALID_CALLID), TELEPHONY_SUCCESS);
772 ASSERT_NE(callControlManager->GetCallWaiting(SIM1_SLOTID), TELEPHONY_SUCCESS);
773 ASSERT_NE(callControlManager->SetCallWaiting(INVALID_CALLID, true), TELEPHONY_SUCCESS);
774 ASSERT_NE(callControlManager->SetCallWaiting(SIM1_SLOTID, true), TELEPHONY_SUCCESS);
775 CallRestrictionType callRestrictionType = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING;
776 ASSERT_NE(callControlManager->GetCallRestriction(INVALID_CALLID, callRestrictionType), TELEPHONY_SUCCESS);
777 ASSERT_NE(callControlManager->GetCallRestriction(SIM1_SLOTID, callRestrictionType), TELEPHONY_SUCCESS);
778 CallRestrictionInfo callRestrictionInfo;
779 ASSERT_NE(callControlManager->SetCallRestriction(INVALID_CALLID, callRestrictionInfo), TELEPHONY_SUCCESS);
780 ASSERT_NE(callControlManager->SetCallRestriction(SIM1_SLOTID, callRestrictionInfo), TELEPHONY_SUCCESS);
781 CallTransferType callTransferType = CallTransferType::TRANSFER_TYPE_BUSY;
782 ASSERT_NE(callControlManager->GetCallTransferInfo(INVALID_CALLID, callTransferType), TELEPHONY_SUCCESS);
783 ASSERT_NE(callControlManager->GetCallTransferInfo(SIM1_SLOTID, callTransferType), TELEPHONY_SUCCESS);
784 CallTransferInfo callTransferInfo;
785 ASSERT_NE(callControlManager->SetCallTransferInfo(INVALID_CALLID, callTransferInfo), TELEPHONY_SUCCESS);
786 ASSERT_NE(callControlManager->SetCallTransferInfo(SIM1_SLOTID, callTransferInfo), TELEPHONY_SUCCESS);
787 bool result = true;
788 ASSERT_NE(callControlManager->CanSetCallTransferTime(INVALID_CALLID, result), TELEPHONY_SUCCESS);
789 ASSERT_NE(callControlManager->CanSetCallTransferTime(SIM1_SLOTID, result), TELEPHONY_SUCCESS);
790 int32_t mode = 1;
791 ASSERT_NE(callControlManager->SetCallPreferenceMode(INVALID_CALLID, mode), TELEPHONY_SUCCESS);
792 ASSERT_NE(callControlManager->SetCallPreferenceMode(SIM1_SLOTID, mode), TELEPHONY_SUCCESS);
793 ImsConfigItem item = ITEM_VIDEO_QUALITY;
794 ASSERT_NE(callControlManager->GetImsConfig(INVALID_CALLID, item), TELEPHONY_SUCCESS);
795 ASSERT_NE(callControlManager->GetImsConfig(SIM1_SLOTID, item), TELEPHONY_SUCCESS);
796 std::u16string value = u"";
797 ASSERT_NE(callControlManager->SetImsConfig(INVALID_CALLID, item, value), TELEPHONY_SUCCESS);
798 ASSERT_NE(callControlManager->SetImsConfig(SIM1_SLOTID, item, value), TELEPHONY_SUCCESS);
799 FeatureType featureType = TYPE_VOICE_OVER_LTE;
800 ASSERT_NE(callControlManager->GetImsFeatureValue(INVALID_CALLID, featureType), TELEPHONY_SUCCESS);
801 ASSERT_NE(callControlManager->GetImsFeatureValue(SIM1_SLOTID, featureType), TELEPHONY_SUCCESS);
802 ASSERT_NE(callControlManager->SetImsFeatureValue(INVALID_CALLID, featureType, mode), TELEPHONY_SUCCESS);
803 ASSERT_NE(callControlManager->SetImsFeatureValue(SIM1_SLOTID, featureType, mode), TELEPHONY_SUCCESS);
804 ASSERT_NE(callControlManager->DisableImsSwitch(INVALID_CALLID), TELEPHONY_SUCCESS);
805 ASSERT_NE(callControlManager->DisableImsSwitch(SIM1_SLOTID), TELEPHONY_SUCCESS);
806 bool enaled = false;
807 ASSERT_NE(callControlManager->IsImsSwitchEnabled(INVALID_CALLID, enaled), TELEPHONY_SUCCESS);
808 ASSERT_NE(callControlManager->IsImsSwitchEnabled(SIM1_SLOTID, enaled), TELEPHONY_SUCCESS);
809 std::vector<std::u16string> numberList = { u"123", u"124" };
810 ASSERT_NE(callControlManager->JoinConference(INVALID_CALLID, numberList), TELEPHONY_SUCCESS);
811 ASSERT_NE(callControlManager->JoinConference(SIM1_SLOTID, numberList), TELEPHONY_SUCCESS);
812 }
813
814 /**
815 * @tc.number Telephony_CallControlManager_004
816 * @tc.name test error branch
817 * @tc.desc Function test
818 */
819 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_004, TestSize.Level0)
820 {
821 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
822 std::vector<std::u16string> numberList = { u"123", u"124" };
823 ASSERT_NE(callControlManager->JoinConference(INVALID_CALLID, numberList), TELEPHONY_SUCCESS);
824 ASSERT_NE(callControlManager->JoinConference(SIM1_SLOTID, numberList), TELEPHONY_SUCCESS);
825 ImsCallMode mode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
826 ASSERT_EQ(callControlManager->UpdateImsCallMode(INVALID_CALLID, mode), TELEPHONY_SUCCESS);
827 std::u16string str = u"";
828 ASSERT_NE(callControlManager->StartRtt(INVALID_CALLID, str), TELEPHONY_SUCCESS);
829 AudioDevice audioDevice = {
830 .deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO,
831 .address = { 0 },
832 };
833 callControlManager->SetAudioDevice(audioDevice);
834 audioDevice.deviceType = AudioDeviceType::DEVICE_SPEAKER;
835 callControlManager->SetAudioDevice(audioDevice);
836 bool enabled = false;
837 callControlManager->IsEmergencyPhoneNumber(str, SIM1_SLOTID, enabled);
838 callControlManager->IsEmergencyPhoneNumber(str, INVALID_SLOTID, enabled);
839 std::string number = "";
840 callControlManager->NumberLegalityCheck(number);
841 number = LONG_STR;
842 callControlManager->NumberLegalityCheck(number);
843 number = "1234567";
844 callControlManager->NumberLegalityCheck(number);
845 std::shared_ptr<CallBroadcastSubscriber> subscriberPtr = nullptr;
846 CallControlManager::SystemAbilityListener listen;
847 int32_t systemAbilityId = 1;
848 std::string deviceId = "123";
849 listen.OnAddSystemAbility(systemAbilityId, deviceId);
850 listen.OnRemoveSystemAbility(systemAbilityId, deviceId);
851 listen.OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
852 listen.OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
853 EventFwk::MatchingSkills matchingSkills;
854 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_STATE_CHANGED);
855 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
856 subscriberPtr = std::make_shared<CallBroadcastSubscriber>(subscriberInfo);
857 listen.OnAddSystemAbility(systemAbilityId, deviceId);
858 listen.OnRemoveSystemAbility(systemAbilityId, deviceId);
859 listen.OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
860 listen.OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
861 ASSERT_NE(callControlManager->StopRtt(INVALID_CALLID), TELEPHONY_SUCCESS);
862 ASSERT_NE(callControlManager->SetMuted(false), TELEPHONY_SUCCESS);
863 ASSERT_EQ(callControlManager->MuteRinger(), TELEPHONY_SUCCESS);
864 bool enaled = false;
865 int32_t slotId = 1;
866 ASSERT_NE(callControlManager->IsImsSwitchEnabled(INVALID_CALLID, enaled), TELEPHONY_SUCCESS);
867 ASSERT_NE(callControlManager->IsImsSwitchEnabled(slotId, enaled), TELEPHONY_SUCCESS);
868 }
869
870 /**
871 * @tc.number Telephony_CallControlManager_005
872 * @tc.name test error branch
873 * @tc.desc Function test
874 */
875 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_005, TestSize.Level0)
876 {
877 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
878 std::u16string number = u"";
879 AppExecFwk::PacMap extras;
880 bool isEcc = false;
881 callControlManager->CanDial(number, extras, isEcc);
882 std::string accountNumber = "1234567";
883 callControlManager->PackageDialInformation(extras, accountNumber, isEcc);
884 int32_t videoState = 0;
885 callControlManager->CurrentIsSuperPrivacyMode(VALID_CALLID, videoState);
886 sptr<CallBase> callObjectPtr = nullptr;
887 callControlManager->AnswerHandlerForSatelliteOrVideoCall(callObjectPtr, videoState);
888 DialParaInfo dialParaInfo;
889 callObjectPtr = new CSCall(dialParaInfo);
890 callControlManager->AnswerHandlerForSatelliteOrVideoCall(callObjectPtr, videoState);
891 TelCallState callState = TelCallState::CALL_STATUS_ACTIVE;
892 callControlManager->CarrierAndVoipConflictProcess(VALID_CALLID, callState);
893 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
894 int32_t slotId = 1;
895 const char oldPassword[kMaxNumberLen + 1] = "1111";
896 const char newPassword[kMaxNumberLen + 1] = "2222";
897 callControlManager->SetCallRestrictionPassword(slotId, fac, oldPassword, newPassword);
898 callControlManager->SeparateConference(VALID_CALLID);
899 callControlManager->KickOutFromConference(VALID_CALLID);
900 callControlManager->EnableImsSwitch(slotId);
901 int32_t state = 0;
902 callControlManager->SetVoNRState(slotId, state);
903 callControlManager->GetVoNRState(slotId, state);
904 callControlManager->IsEmergencyPhoneNumber(number, slotId, isEcc);
905 callControlManager->CloseUnFinishedUssd(slotId);
906 sptr<CallBase> callObjectPtr1 = nullptr;
907 callControlManager->AddBlockLogAndNotification(callObjectPtr1);
908 callControlManager->AddBlockLogAndNotification(callObjectPtr);
909 callControlManager->HangUpVoipCall();
910 callControlManager->SetVoIPCallState(3);
911 callControlManager->SetVoIPCallState(2);
912 callControlManager->DisconnectAllCalls();
913 callControlManager->SetVirtualCall(true);
914 ASSERT_EQ(callControlManager->SetVoIPCallState(0), TELEPHONY_SUCCESS);
915 }
916
917 /**
918 * @tc.number Telephony_CallControlManager_006
919 * @tc.name test CallControlManager
920 * @tc.desc Function test
921 */
922 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_006, Function | MediumTest | Level1)
923 {
924 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
925 callControlManager->ReportPhoneUEInSuperPrivacy("");
926 if (callControlManager->CallRequestHandlerPtr_ == nullptr) {
927 callControlManager->CallRequestHandlerPtr_ = std::make_unique<CallRequestHandler>();
928 callControlManager->CallRequestHandlerPtr_->callRequestProcessPtr_ = nullptr;
929 }
930 AppExecFwk::PacMap extras;
931 std::u16string longNum = u"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
932 "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
933 "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
934 EXPECT_NE(callControlManager->DialCall(longNum, extras), TELEPHONY_SUCCESS);
935 std::u16string normalNum = u"11111";
936 callControlManager->SetCallTypeExtras(extras);
937
938 extras.PutIntValue("dialType", static_cast<int32_t>(DialType::DIAL_CARRIER_TYPE));
939 callControlManager->SetCallTypeExtras(extras);
940 extras.PutIntValue("dialType", static_cast<int32_t>(DialType::DIAL_VOICE_MAIL_TYPE));
941 extras.PutIntValue("videoState", static_cast<int32_t>(VideoStateType::TYPE_VIDEO));
942 callControlManager->SetCallTypeExtras(extras);
943 EXPECT_NE(callControlManager->DialCall(normalNum, extras), TELEPHONY_SUCCESS);
944 extras.PutIntValue("dialType", static_cast<int32_t>(DialType::DIAL_BLUETOOTH_TYPE));
945 EXPECT_NE(callControlManager->DialCall(normalNum, extras), TELEPHONY_SUCCESS);
946 callControlManager->CallRequestHandlerPtr_ = nullptr;
947 EXPECT_NE(callControlManager->DialCall(normalNum, extras), TELEPHONY_SUCCESS);
948 }
949
950 /**
951 * @tc.number Telephony_CallControlManager_007
952 * @tc.name test CallControlManager
953 * @tc.desc Function test
954 */
955 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_007, Function | MediumTest | Level1)
956 {
957 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
958 if (callControlManager->CallRequestHandlerPtr_ == nullptr) {
959 callControlManager->CallRequestHandlerPtr_ = std::make_unique<CallRequestHandler>();
960 callControlManager->CallRequestHandlerPtr_->callRequestProcessPtr_ = nullptr;
961 }
962 EXPECT_EQ(callControlManager->CarrierAndVoipConflictProcess(-1, TelCallState::CALL_STATUS_ANSWERED),
963 TELEPHONY_ERR_LOCAL_PTR_NULL);
964 EXPECT_NE(callControlManager->GetCallState(), static_cast<int32_t>(CallStateToApp::CALL_STATE_UNKNOWN));
965 callControlManager->VoIPCallState_ = CallStateToApp::CALL_STATE_IDLE;
966 EXPECT_NE(callControlManager->GetCallState(), static_cast<int32_t>(CallStateToApp::CALL_STATE_UNKNOWN));
967 callControlManager->VoIPCallState_ = CallStateToApp::CALL_STATE_ANSWERED;
968 EXPECT_NE(callControlManager->GetCallState(), static_cast<int32_t>(CallStateToApp::CALL_STATE_UNKNOWN));
969 DialParaInfo info;
970 sptr<CallBase> call = new CSCall(info);
971 CallObjectManager::AddOneCallObject(call);
972 callControlManager->VoIPCallState_ = CallStateToApp::CALL_STATE_UNKNOWN;
973 EXPECT_NE(callControlManager->GetCallState(), static_cast<int32_t>(CallStateToApp::CALL_STATE_UNKNOWN));
974 callControlManager->VoIPCallState_ = CallStateToApp::CALL_STATE_RINGING;
975 EXPECT_NE(callControlManager->GetCallState(), static_cast<int32_t>(CallStateToApp::CALL_STATE_UNKNOWN));
976 callControlManager->VoIPCallState_ = CallStateToApp::CALL_STATE_OFFHOOK;
977 EXPECT_NE(callControlManager->GetCallState(), static_cast<int32_t>(CallStateToApp::CALL_STATE_UNKNOWN));
978 EXPECT_TRUE(callControlManager->HasCall());
979 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
980 call->SetCallType(CallType::TYPE_CS);
981 call->SetCrsType(0);
982 call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
983 callControlManager->VoIPCallState_ = CallStateToApp::CALL_STATE_IDLE;
984 EXPECT_NE(callControlManager->GetCallState(), static_cast<int32_t>(CallStateToApp::CALL_STATE_UNKNOWN));
985 EXPECT_NE(callControlManager->AnswerCall(-1, static_cast<int32_t>(VideoStateType::TYPE_VIDEO)), TELEPHONY_SUCCESS);
986 EXPECT_NE(callControlManager->AnswerCall(1, static_cast<int32_t>(VideoStateType::TYPE_VIDEO)), TELEPHONY_SUCCESS);
987 EXPECT_NE(callControlManager->AnswerCall(0, static_cast<int32_t>(VideoStateType::TYPE_VIDEO)), TELEPHONY_SUCCESS);
988 int32_t crsType = 2;
989 call->SetCrsType(crsType);
990 EXPECT_NE(callControlManager->AnswerCall(0, static_cast<int32_t>(VideoStateType::TYPE_VIDEO)), TELEPHONY_SUCCESS);
991 call->SetCallType(CallType::TYPE_VOIP);
992 EXPECT_NE(callControlManager->AnswerCall(0, static_cast<int32_t>(VideoStateType::TYPE_VOICE)), TELEPHONY_SUCCESS);
993 EXPECT_NE(callControlManager->AnswerCall(0, static_cast<int32_t>(VideoStateType::TYPE_SEND_ONLY)),
994 TELEPHONY_SUCCESS);
995 callControlManager->VoIPCallState_ = CallStateToApp::CALL_STATE_UNKNOWN;
996 EXPECT_NE(callControlManager->AnswerCall(0, static_cast<int32_t>(VideoStateType::TYPE_VOICE)), TELEPHONY_SUCCESS);
997 callControlManager->CallRequestHandlerPtr_ = nullptr;
998 EXPECT_EQ(callControlManager->HandlerAnswerCall(0, static_cast<int32_t>(VideoStateType::TYPE_VOICE)),
999 TELEPHONY_ERR_LOCAL_PTR_NULL);
1000 call->SetCallType(CallType::TYPE_CS);
1001 EXPECT_EQ(callControlManager->AnswerCall(0, static_cast<int32_t>(VideoStateType::TYPE_VOICE)), TELEPHONY_SUCCESS);
1002 call->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
1003 EXPECT_NE(callControlManager->SetMuted(false), CALL_ERR_AUDIO_SETTING_MUTE_FAILED);
1004 }
1005
1006 /**
1007 * @tc.number Telephony_CallControlManager_008
1008 * @tc.name test CallControlManager
1009 * @tc.desc Function test
1010 */
1011 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_008, Function | MediumTest | Level1)
1012 {
1013 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
1014 if (callControlManager->CallRequestHandlerPtr_ == nullptr) {
1015 callControlManager->CallRequestHandlerPtr_ = std::make_unique<CallRequestHandler>();
1016 callControlManager->CallRequestHandlerPtr_->callRequestProcessPtr_ = nullptr;
1017 }
1018 DialParaInfo info;
1019 sptr<CallBase> call = new CSCall(info);
1020 call->SetCallType(CallType::TYPE_CS);
1021 CallObjectManager::callObjectPtrList_.clear();
1022 CallObjectManager::AddOneCallObject(call);
1023 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
1024 call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1025 EXPECT_NE(callControlManager->HoldCall(0), TELEPHONY_SUCCESS);
1026 EXPECT_NE(callControlManager->HangUpCall(0), TELEPHONY_SUCCESS);
1027 EXPECT_NE(callControlManager->RejectCall(0, false, u""), TELEPHONY_SUCCESS);
1028 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_HOLD);
1029 EXPECT_NE(callControlManager->UnHoldCall(0), TELEPHONY_SUCCESS);
1030 callControlManager->CallRequestHandlerPtr_ = nullptr;
1031 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
1032 EXPECT_NE(callControlManager->HoldCall(0), TELEPHONY_SUCCESS);
1033 EXPECT_NE(callControlManager->HangUpCall(0), TELEPHONY_SUCCESS);
1034 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_HOLD);
1035 EXPECT_NE(callControlManager->UnHoldCall(0), TELEPHONY_SUCCESS);
1036 EXPECT_NE(callControlManager->StartDtmf(0, '1'), TELEPHONY_ERR_ARGUMENT_INVALID);
1037 sleep(1);
1038 EXPECT_NE(callControlManager->StopDtmf(0), TELEPHONY_ERR_ARGUMENT_INVALID);
1039 call->SetTelCallState(TelCallState::CALL_STATUS_IDLE);
1040 EXPECT_NE(callControlManager->StartDtmf(0, '1'), TELEPHONY_ERR_ARGUMENT_INVALID);
1041 EXPECT_NE(callControlManager->StopDtmf(0), TELEPHONY_ERR_ARGUMENT_INVALID);
1042 call->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
1043 EXPECT_NE(callControlManager->SetMuted(false), CALL_ERR_AUDIO_SETTING_MUTE_FAILED);
1044 sptr<CallBase> voipCall = (std::make_unique<VoIPCall>(info)).release();
1045 voipCall->SetCallType(CallType::TYPE_VOIP);
1046 CallObjectManager::AddOneCallObject(voipCall);
1047 call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1048 EXPECT_NE(callControlManager->HangUpCall(0), TELEPHONY_SUCCESS);
1049 EXPECT_NE(callControlManager->RejectCall(0, false, u""), TELEPHONY_SUCCESS);
1050 call->SetCallId(VOIP_CALL_MINIMUM);
1051 EXPECT_NE(callControlManager->HangUpCall(VOIP_CALL_MINIMUM), TELEPHONY_SUCCESS);
1052 EXPECT_NE(callControlManager->RejectCall(VOIP_CALL_MINIMUM, false, u""), TELEPHONY_SUCCESS);
1053 }
1054
1055 /**
1056 * @tc.number Telephony_CallControlManager_009
1057 * @tc.name test CallControlManager
1058 * @tc.desc Function test
1059 */
1060 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_009, Function | MediumTest | Level1)
1061 {
1062 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
1063 if (callControlManager->CallRequestHandlerPtr_ == nullptr) {
1064 callControlManager->CallRequestHandlerPtr_ = std::make_unique<CallRequestHandler>();
1065 callControlManager->CallRequestHandlerPtr_->callRequestProcessPtr_ = nullptr;
1066 }
1067 DialParaInfo info;
1068 sptr<CallBase> call = (std::make_unique<IMSCall>(info)).release();
1069 call->SetVideoStateType(VideoStateType::TYPE_VOICE);
1070 call->SetCallType(CallType::TYPE_IMS);
1071 callControlManager->AnswerHandlerForSatelliteOrVideoCall(call, static_cast<int32_t>(VideoStateType::TYPE_VOICE));
1072 callControlManager->AnswerHandlerForSatelliteOrVideoCall(call, static_cast<int32_t>(VideoStateType::TYPE_VIDEO));
1073 EXPECT_EQ(call->GetVideoStateType(), VideoStateType::TYPE_VIDEO);
1074 CallObjectManager::callObjectPtrList_.clear();
1075 CallObjectManager::AddOneCallObject(call);
1076 sptr<CallBase> satelliteCall = (std::make_unique<SatelliteCall>(info)).release();
1077 satelliteCall->SetCallType(CallType::TYPE_SATELLITE);
1078 satelliteCall->SetCallId(1);
1079 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_RINGING);
1080 callControlManager->AnswerHandlerForSatelliteOrVideoCall(satelliteCall,
1081 static_cast<int32_t>(VideoStateType::TYPE_VIDEO));
1082 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
1083 callControlManager->AnswerHandlerForSatelliteOrVideoCall(satelliteCall,
1084 static_cast<int32_t>(VideoStateType::TYPE_VIDEO));
1085 sptr<CallBase> voipCall = (std::make_unique<VoIPCall>(info)).release();
1086 voipCall->SetCallType(CallType::TYPE_VOIP);
1087 voipCall->SetCallId(2);
1088 sptr<CallBase> csCall = (std::make_unique<CSCall>(info)).release();
1089 csCall->SetCallId(3);
1090 csCall->SetCallType(CallType::TYPE_CS);
1091 CallObjectManager::AddOneCallObject(satelliteCall);
1092 CallObjectManager::AddOneCallObject(voipCall);
1093 CallObjectManager::AddOneCallObject(csCall);
1094 voipCall->SetTelCallState(TelCallState::CALL_STATUS_UNKNOWN);
1095 EXPECT_EQ(callControlManager->CarrierAndVoipConflictProcess(0, TelCallState::CALL_STATUS_ANSWERED),
1096 TELEPHONY_SUCCESS);
1097 EXPECT_EQ(callControlManager->CarrierAndVoipConflictProcess(1, TelCallState::CALL_STATUS_ANSWERED),
1098 TELEPHONY_SUCCESS);
1099 EXPECT_EQ(callControlManager->CarrierAndVoipConflictProcess(2, TelCallState::CALL_STATUS_ANSWERED),
1100 TELEPHONY_SUCCESS);
1101 EXPECT_EQ(callControlManager->CarrierAndVoipConflictProcess(3, TelCallState::CALL_STATUS_ANSWERED),
1102 TELEPHONY_SUCCESS);
1103 voipCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1104 EXPECT_GT(callControlManager->CarrierAndVoipConflictProcess(0, TelCallState::CALL_STATUS_ANSWERED),
1105 TELEPHONY_ERROR);
1106 voipCall->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
1107 EXPECT_GT(callControlManager->CarrierAndVoipConflictProcess(0, TelCallState::CALL_STATUS_ANSWERED),
1108 TELEPHONY_ERROR);
1109 EXPECT_GT(callControlManager->HangUpVoipCall(), TELEPHONY_ERROR);
1110 }
1111
1112 /**
1113 * @tc.number Telephony_CallControlManager_010
1114 * @tc.name test CallControlManager
1115 * @tc.desc Function test
1116 */
1117 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_010, Function | MediumTest | Level1)
1118 {
1119 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
1120 callControlManager->Init();
1121 DialParaInfo info;
1122 sptr<CallBase> call = (std::make_unique<IMSCall>(info)).release();
1123 call->SetCallType(CallType::TYPE_IMS);
1124 TelCallState priorState = TelCallState::CALL_STATUS_DIALING;
1125 TelCallState nextState = TelCallState::CALL_STATUS_HOLDING;
1126 EXPECT_TRUE(callControlManager->NotifyCallStateUpdated(call, priorState, nextState));
1127 nextState = TelCallState::CALL_STATUS_ALERTING;
1128 EXPECT_TRUE(callControlManager->NotifyCallStateUpdated(call, priorState, nextState));
1129 nextState = TelCallState::CALL_STATUS_ACTIVE;
1130 EXPECT_TRUE(callControlManager->NotifyCallStateUpdated(call, priorState, nextState));
1131 priorState = TelCallState::CALL_STATUS_INCOMING;
1132 EXPECT_TRUE(callControlManager->NotifyCallStateUpdated(call, priorState, nextState));
1133 nextState = TelCallState::CALL_STATUS_DISCONNECTED;
1134 EXPECT_TRUE(callControlManager->NotifyCallStateUpdated(call, priorState, nextState));
1135 priorState = TelCallState::CALL_STATUS_ACTIVE;
1136 EXPECT_TRUE(callControlManager->NotifyCallStateUpdated(call, priorState, nextState));
1137 nextState = TelCallState::CALL_STATUS_INCOMING;
1138 EXPECT_TRUE(callControlManager->NotifyCallStateUpdated(call, priorState, nextState));
1139 priorState = TelCallState::CALL_STATUS_DISCONNECTING;
1140 EXPECT_TRUE(callControlManager->NotifyCallStateUpdated(call, priorState, nextState));
1141 nextState = TelCallState::CALL_STATUS_DISCONNECTED;
1142 EXPECT_TRUE(callControlManager->NotifyCallStateUpdated(call, priorState, nextState));
1143 priorState = TelCallState::CALL_STATUS_WAITING;
1144 EXPECT_TRUE(callControlManager->NotifyCallStateUpdated(call, priorState, nextState));
1145 nextState = TelCallState::CALL_STATUS_ACTIVE;
1146 EXPECT_TRUE(callControlManager->NotifyCallStateUpdated(call, priorState, nextState));
1147 CallObjectManager::callObjectPtrList_.clear();
1148 CallObjectManager::AddOneCallObject(call);
1149 call->SetTelCallState(TelCallState::CALL_STATUS_IDLE);
1150 call->SetCallId(0);
1151 EXPECT_EQ(callControlManager->PostDialProceed(0, false), CALL_ERR_CALL_STATE_MISMATCH_OPERATION);
1152 call->SetTelCallState(TelCallState::CALL_STATUS_DISCONNECTED);
1153 EXPECT_EQ(callControlManager->PostDialProceed(0, false), CALL_ERR_CALL_STATE_MISMATCH_OPERATION);
1154 call->SetTelCallState(TelCallState::CALL_STATUS_DISCONNECTING);
1155 EXPECT_EQ(callControlManager->PostDialProceed(0, false), CALL_ERR_CALL_STATE_MISMATCH_OPERATION);
1156 call->SetTelCallState(TelCallState::CALL_STATUS_ANSWERED);
1157 EXPECT_NE(callControlManager->PostDialProceed(0, false), CALL_ERR_CALL_STATE_MISMATCH_OPERATION);
1158 call->SetTelCallState(TelCallState::CALL_STATUS_WAITING);
1159 EXPECT_NE(callControlManager->PostDialProceed(0, false), CALL_ERR_CALL_STATE_MISMATCH_OPERATION);
1160 call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1161 EXPECT_NE(callControlManager->PostDialProceed(0, false), CALL_ERR_CALL_STATE_MISMATCH_OPERATION);
1162 call->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
1163 EXPECT_NE(callControlManager->SetMuted(false), CALL_ERR_AUDIO_SETTING_MUTE_FAILED);
1164 callControlManager->DisconnectAllCalls();
1165 }
1166
1167 /**
1168 * @tc.number Telephony_CallControlManager_011
1169 * @tc.name test CallControlManager
1170 * @tc.desc Function test
1171 */
1172 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_011, Function | MediumTest | Level1)
1173 {
1174 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
1175 DialParaInfo info;
1176 sptr<CallBase> call = (std::make_unique<IMSCall>(info)).release();
1177 call->SetTelCallState(TelCallState::CALL_STATUS_IDLE);
1178 call->SetCallId(0);
1179 sptr<CallBase> call2 = (std::make_unique<IMSCall>(info)).release();
1180 call2->SetTelCallState(TelCallState::CALL_STATUS_HOLDING);
1181 call2->SetCallId(1);
1182 CallObjectManager::callObjectPtrList_.clear();
1183 CallObjectManager::AddOneCallObject(call);
1184 EXPECT_EQ(callControlManager->CombineConference(0), CALL_ERR_CALL_STATE_MISMATCH_OPERATION);
1185 call->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
1186 EXPECT_EQ(callControlManager->CombineConference(0), CALL_ERR_CALL_STATE_MISMATCH_OPERATION);
1187 CallObjectManager::AddOneCallObject(call2);
1188 EXPECT_NE(callControlManager->CombineConference(0), CALL_ERR_CALL_STATE_MISMATCH_OPERATION);
1189 EXPECT_NE(callControlManager->SeparateConference(0), TELEPHONY_ERR_ARGUMENT_INVALID);
1190 EXPECT_NE(callControlManager->KickOutFromConference(0), TELEPHONY_ERR_ARGUMENT_INVALID);
1191 int32_t mainCallId = 0;
1192 EXPECT_NE(callControlManager->GetMainCallId(0, mainCallId), TELEPHONY_ERR_ARGUMENT_INVALID);
1193 std::vector<std::u16string> callIdList;
1194 EXPECT_NE(callControlManager->GetSubCallIdList(0, callIdList), TELEPHONY_ERR_ARGUMENT_INVALID);
1195 EXPECT_NE(callControlManager->GetCallIdListForConference(0, callIdList), TELEPHONY_ERR_ARGUMENT_INVALID);
1196 }
1197
1198 /**
1199 * @tc.number Telephony_CallControlManager_012
1200 * @tc.name test CallControlManager
1201 * @tc.desc Function test
1202 */
1203 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_012, Function | MediumTest | Level1)
1204 {
1205 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
1206 EXPECT_EQ(callControlManager->GetCallWaiting(-1), CALL_ERR_INVALID_SLOT_ID);
1207 EXPECT_EQ(callControlManager->SetCallWaiting(-1, false), CALL_ERR_INVALID_SLOT_ID);
1208 EXPECT_EQ(callControlManager->GetCallRestriction(-1, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
1209 CALL_ERR_INVALID_SLOT_ID);
1210 CallRestrictionInfo restrictionInfo;
1211 EXPECT_EQ(callControlManager->SetCallRestriction(-1, restrictionInfo), CALL_ERR_INVALID_SLOT_ID);
1212 EXPECT_EQ(callControlManager->SetCallRestrictionPassword(-1, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING,
1213 "", ""), CALL_ERR_INVALID_SLOT_ID);
1214 EXPECT_EQ(callControlManager->GetCallTransferInfo(-1, CallTransferType::TRANSFER_TYPE_UNCONDITIONAL),
1215 CALL_ERR_INVALID_SLOT_ID);
1216 CallTransferInfo callTransferInfo;
1217 EXPECT_EQ(callControlManager->SetCallTransferInfo(-1, callTransferInfo), CALL_ERR_INVALID_SLOT_ID);
1218 bool result = false;
1219 EXPECT_EQ(callControlManager->CanSetCallTransferTime(-1, result), CALL_ERR_INVALID_SLOT_ID);
1220 EXPECT_EQ(callControlManager->SetCallPreferenceMode(-1, 0), CALL_ERR_INVALID_SLOT_ID);
1221 EXPECT_EQ(callControlManager->GetImsConfig(-1, ImsConfigItem::ITEM_VIDEO_QUALITY), CALL_ERR_INVALID_SLOT_ID);
1222 std::u16string value = u"";
1223 EXPECT_EQ(callControlManager->SetImsConfig(-1, ImsConfigItem::ITEM_VIDEO_QUALITY, value),
1224 CALL_ERR_INVALID_SLOT_ID);
1225 EXPECT_EQ(callControlManager->GetImsFeatureValue(-1, FeatureType::TYPE_VOICE_OVER_LTE), CALL_ERR_INVALID_SLOT_ID);
1226 EXPECT_EQ(callControlManager->SetImsFeatureValue(-1, FeatureType::TYPE_VOICE_OVER_LTE, 0),
1227 CALL_ERR_INVALID_SLOT_ID);
1228 EXPECT_EQ(callControlManager->EnableImsSwitch(-1), CALL_ERR_INVALID_SLOT_ID);
1229 EXPECT_EQ(callControlManager->DisableImsSwitch(-1), CALL_ERR_INVALID_SLOT_ID);
1230 EXPECT_EQ(callControlManager->IsImsSwitchEnabled(-1, result), CALL_ERR_INVALID_SLOT_ID);
1231 EXPECT_EQ(callControlManager->SetVoNRState(-1, 0), CALL_ERR_INVALID_SLOT_ID);
1232 int32_t state = 0;
1233 EXPECT_EQ(callControlManager->GetVoNRState(-1, state), CALL_ERR_INVALID_SLOT_ID);
1234 EXPECT_EQ(callControlManager->CloseUnFinishedUssd(-1), CALL_ERR_INVALID_SLOT_ID);
1235 CallControlManager::alarmSeted = true;
1236 callControlManager->ConnectCallUiService(true);
1237 CallControlManager::alarmSeted = true;
1238 callControlManager->ConnectCallUiService(false);
1239 CallControlManager::alarmSeted = true;
1240 callControlManager->ConnectCallUiService(true);
1241 EXPECT_NE(callControlManager->RemoveMissedIncomingCallNotification(), TELEPHONY_SUCCESS);
1242 }
1243
1244 /**
1245 * @tc.number Telephony_CallStatusManager_016
1246 * @tc.name test error branch
1247 * @tc.desc Function test
1248 */
1249 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_016, TestSize.Level0)
1250 {
1251 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1252 DialParaInfo info;
1253 CallObjectManager::callObjectPtrList_.clear();
1254 sptr<CallBase> imsCall = new IMSCall(info);
1255 imsCall->SetCallIndex(0);
1256 imsCall->SetSlotId(0);
1257 imsCall->SetCallType(CallType::TYPE_IMS);
1258 imsCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_CONNECTING);
1259 CallObjectManager::AddOneCallObject(imsCall);
1260 EXPECT_TRUE(CallObjectManager::HasCellularCallExist());
1261
1262 CallDetailInfo callDetailInfo;
1263 std::string number = "10086";
1264 memcpy_s(&callDetailInfo.phoneNum, kMaxNumberLen, number.c_str(), number.length());
1265 callDetailInfo.state = TelCallState::CALL_STATUS_INCOMING;
1266 callDetailInfo.callType = CallType::TYPE_IMS;
1267 callDetailInfo.callMode = VideoStateType::TYPE_VOICE;
1268 callDetailInfo.index = 2;
1269 callStatusManager->IncomingHandle(callDetailInfo);
1270 sptr<CallBase> incomingCall = callStatusManager->CreateNewCall(callDetailInfo, CallDirection::CALL_DIRECTION_OUT);
1271 CallObjectManager::AddOneCallObject(incomingCall);
1272 EXPECT_TRUE(CallObjectManager::HasCellularCallExist());
1273
1274 CallObjectManager::DeleteOneCallObject(incomingCall);
1275 EXPECT_FALSE(CallObjectManager::HasCellularCallExist());
1276 }
1277
1278 /**
1279 * @tc.number Telephony_CallStatusManager_001
1280 * @tc.name test error branch
1281 * @tc.desc Function test
1282 */
1283 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_001, TestSize.Level0)
1284 {
1285 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1286 CallDetailInfo info;
1287 std::string number = "123";
1288 memcpy_s(&info.phoneNum, kMaxNumberLen, number.c_str(), number.length());
1289 info.state = TelCallState::CALL_STATUS_ACTIVE;
1290 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1291 info.state = TelCallState::CALL_STATUS_HOLDING;
1292 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1293 info.state = TelCallState::CALL_STATUS_DIALING;
1294 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1295 info.state = TelCallState::CALL_STATUS_ALERTING;
1296 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1297 info.state = TelCallState::CALL_STATUS_INCOMING;
1298 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1299 info.state = TelCallState::CALL_STATUS_WAITING;
1300 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1301 info.state = TelCallState::CALL_STATUS_DISCONNECTED;
1302 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1303 info.state = TelCallState::CALL_STATUS_DISCONNECTING;
1304 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1305 info.state = TelCallState::CALL_STATUS_UNKNOWN;
1306 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1307 DisconnectedDetails details;
1308 ASSERT_GT(callStatusManager->HandleDisconnectedCause(details), TELEPHONY_ERROR);
1309 CellularCallEventInfo cellularCallEventInfo;
1310 cellularCallEventInfo.eventType = static_cast<CellularCallEventType>(1);
1311 ASSERT_GT(callStatusManager->HandleEventResultReportInfo(cellularCallEventInfo), TELEPHONY_ERROR);
1312 cellularCallEventInfo.eventType = CellularCallEventType::EVENT_REQUEST_RESULT_TYPE;
1313 cellularCallEventInfo.eventId = RequestResultEventId::RESULT_DIAL_NO_CARRIER;
1314 ASSERT_GT(callStatusManager->HandleEventResultReportInfo(cellularCallEventInfo), TELEPHONY_ERROR);
1315 OttCallEventInfo ottCallEventInfo;
1316 (void)memset_s(&ottCallEventInfo, sizeof(OttCallEventInfo), 0, sizeof(OttCallEventInfo));
1317 ottCallEventInfo.ottCallEventId = OttCallEventId::OTT_CALL_EVENT_FUNCTION_UNSUPPORTED;
1318 (void)memcpy_s(ottCallEventInfo.bundleName, kMaxBundleNameLen + 1, LONG_STR, strlen(LONG_STR));
1319 ASSERT_GT(callStatusManager->HandleOttEventReportInfo(ottCallEventInfo), TELEPHONY_ERROR);
1320 (void)memset_s(&ottCallEventInfo, sizeof(OttCallEventInfo), 0, sizeof(OttCallEventInfo));
1321 ottCallEventInfo.ottCallEventId = OttCallEventId::OTT_CALL_EVENT_FUNCTION_UNSUPPORTED;
1322 (void)memcpy_s(ottCallEventInfo.bundleName, kMaxBundleNameLen + 1, TEST_STR, strlen(TEST_STR));
1323 ASSERT_GT(callStatusManager->HandleOttEventReportInfo(ottCallEventInfo), TELEPHONY_ERROR);
1324 info.voipCallInfo.voipCallId = "123456789";
1325 info.callType = CallType::TYPE_VOIP;
1326 info.state = TelCallState::CALL_STATUS_INCOMING;
1327 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1328 info.state = TelCallState::CALL_STATUS_ACTIVE;
1329 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1330 info.state = TelCallState::CALL_STATUS_DISCONNECTED;
1331 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1332 }
1333
1334 /**
1335 * @tc.number Telephony_CallStatusManager_002
1336 * @tc.name test error branch
1337 * @tc.desc Function test
1338 */
1339 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_002, TestSize.Level0)
1340 {
1341 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1342 CallDetailInfo callDetailInfo;
1343 std::string number = "";
1344 memcpy_s(&callDetailInfo.phoneNum, kMaxNumberLen, number.c_str(), number.length());
1345 callDetailInfo.state = TelCallState::CALL_STATUS_INCOMING;
1346 callDetailInfo.callType = CallType::TYPE_CS;
1347 ASSERT_GT(callStatusManager->IncomingHandle(callDetailInfo), TELEPHONY_ERROR);
1348 ASSERT_GT(callStatusManager->IncomingVoipCallHandle(callDetailInfo), TELEPHONY_ERROR);
1349 callDetailInfo.state = TelCallState::CALL_STATUS_ACTIVE;
1350 ASSERT_GT(callStatusManager->IncomingHandle(callDetailInfo), TELEPHONY_ERROR);
1351 ASSERT_GT(callStatusManager->IncomingVoipCallHandle(callDetailInfo), TELEPHONY_ERROR);
1352 ASSERT_GT(callStatusManager->IncomingFilterPolicy(callDetailInfo), TELEPHONY_ERROR);
1353 sptr<CallBase> callObjectPtr = nullptr;
1354 TelCallState nextState = TelCallState::CALL_STATUS_ACTIVE;
1355 ASSERT_GT(callStatusManager->UpdateCallState(callObjectPtr, nextState), TELEPHONY_ERROR);
1356 ASSERT_GT(callStatusManager->ToSpeakerPhone(callObjectPtr), TELEPHONY_ERROR);
1357 DialParaInfo dialParaInfo;
1358 dialParaInfo.callType = CallType::TYPE_CS;
1359 dialParaInfo.callState = TelCallState::CALL_STATUS_INCOMING;
1360 callObjectPtr = new CSCall(dialParaInfo);
1361 ASSERT_GT(callStatusManager->UpdateCallState(callObjectPtr, nextState), TELEPHONY_ERROR);
1362 nextState = TelCallState::CALL_STATUS_INCOMING;
1363 ASSERT_GT(callStatusManager->UpdateCallState(callObjectPtr, nextState), TELEPHONY_ERROR);
1364 callStatusManager->RefreshCallIfNecessary(callObjectPtr, callDetailInfo);
1365 ASSERT_GT(callStatusManager->ToSpeakerPhone(callObjectPtr), TELEPHONY_ERROR);
1366 callObjectPtr->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
1367 ASSERT_GT(callStatusManager->ToSpeakerPhone(callObjectPtr), TELEPHONY_ERROR);
1368 ASSERT_GT(callStatusManager->TurnOffMute(callObjectPtr), TELEPHONY_ERROR);
1369 callObjectPtr->SetTelCallState(TelCallState::CALL_STATUS_ALERTING);
1370 callStatusManager->SetOriginalCallTypeForActiveState(callObjectPtr);
1371 callStatusManager->SetOriginalCallTypeForDisconnectState(callObjectPtr);
1372 callObjectPtr->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
1373 callStatusManager->SetOriginalCallTypeForActiveState(callObjectPtr);
1374 int32_t activeCallNum = 0;
1375 int32_t waitingCallNum = 0;
1376 int32_t slotId = 0;
1377 callStatusManager->AutoAnswer(activeCallNum, waitingCallNum);
1378 bool canSwitchCallState = 1;
1379 TelCallState priorState = TelCallState::CALL_STATUS_DISCONNECTING;
1380 callStatusManager->AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, slotId, true);
1381 callStatusManager->AutoUnHoldForDsda(canSwitchCallState, priorState, activeCallNum, slotId);
1382 callStatusManager->AutoAnswerForVideoCall(activeCallNum);
1383 }
1384
1385 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_003, TestSize.Level0)
1386 {
1387 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1388 // scene-0: null input
1389 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(nullptr), false);
1390
1391 // init
1392 const std::string phoneNumber = "12345678911";
1393 time_t oldCallCreateTime = time(nullptr);
1394 if (oldCallCreateTime < 0) {
1395 oldCallCreateTime = 0;
1396 }
1397 int32_t incomingMaxDuration = 10 * 1000;
1398
1399 //old call
1400 DialParaInfo dialParaInfoOld;
1401 sptr<OHOS::Telephony::CallBase> oldCall = new BluetoothCall(dialParaInfoOld, "");
1402 oldCall->SetAccountNumber(phoneNumber);
1403 oldCall->SetCallId(1);
1404 oldCall->SetCallCreateTime(oldCallCreateTime);
1405 oldCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1406 oldCall->SetCallType(CallType::TYPE_BLUETOOTH);
1407 //new call
1408 DialParaInfo dialParaInfoNew;
1409 sptr<OHOS::Telephony::CallBase> newCall = new IMSCall(dialParaInfoNew);
1410 newCall->SetAccountNumber(phoneNumber);
1411 newCall->SetCallId(2);
1412 newCall->SetCallCreateTime(oldCallCreateTime + incomingMaxDuration - 1000);
1413 newCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1414 newCall->SetCallType(CallType::TYPE_IMS);
1415
1416 // scene-1: do not exist old call with the same phone number
1417 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(newCall), false);
1418 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1419
1420 // scene-2: invalid diff-CallID
1421 callStatusManager->AddOneCallObject(oldCall);
1422 newCall->SetCallId(9);
1423 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(newCall), false);
1424 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1425 }
1426
1427 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_004, TestSize.Level0)
1428 {
1429 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1430
1431 // init
1432 const std::string phoneNumber = "12345678911";
1433 time_t oldCallCreateTime = time(nullptr);
1434 if (oldCallCreateTime < 0) {
1435 oldCallCreateTime = 0;
1436 }
1437 int32_t incomingMaxDuration = 10 * 1000;
1438
1439 //old call
1440 DialParaInfo dialParaInfoOld;
1441 sptr<OHOS::Telephony::CallBase> oldCall = new BluetoothCall(dialParaInfoOld, "");
1442 oldCall->SetAccountNumber(phoneNumber);
1443 oldCall->SetCallId(1);
1444 oldCall->SetCallCreateTime(oldCallCreateTime);
1445 oldCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1446 oldCall->SetCallType(CallType::TYPE_BLUETOOTH);
1447 //new call
1448 DialParaInfo dialParaInfoNew;
1449 sptr<OHOS::Telephony::CallBase> newCall = new IMSCall(dialParaInfoNew);
1450 newCall->SetAccountNumber(phoneNumber);
1451 newCall->SetCallId(2);
1452 newCall->SetCallCreateTime(oldCallCreateTime + incomingMaxDuration + 1000);
1453 newCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1454 newCall->SetCallType(CallType::TYPE_IMS);
1455
1456 // scene-3: invalid diff-CreateTime
1457 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(newCall), false);
1458 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1459
1460 // scene-4: invalid old call status
1461 callStatusManager->DeleteOneCallObject(oldCall->GetCallID());
1462 oldCall->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
1463 callStatusManager->AddOneCallObject(oldCall);
1464 newCall->SetCallCreateTime(oldCallCreateTime + incomingMaxDuration - 1000);
1465 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(newCall), false);
1466 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1467 }
1468
1469 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_005, TestSize.Level0)
1470 {
1471 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1472
1473 // init
1474 const std::string phoneNumber = "12345678911";
1475 time_t oldCallCreateTime = time(nullptr);
1476 if (oldCallCreateTime < 0) {
1477 oldCallCreateTime = 0;
1478 }
1479 int32_t incomingMaxDuration = 10 * 1000;
1480
1481 // old call
1482 DialParaInfo dialParaInfoOld;
1483 sptr<OHOS::Telephony::CallBase> oldCall = new BluetoothCall(dialParaInfoOld, "");
1484 oldCall->SetAccountNumber(phoneNumber);
1485 oldCall->SetCallId(1);
1486 oldCall->SetCallCreateTime(oldCallCreateTime);
1487 oldCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1488 oldCall->SetCallType(CallType::TYPE_BLUETOOTH);
1489 // new call
1490 DialParaInfo dialParaInfoNew;
1491 sptr<OHOS::Telephony::CallBase> newCall = new IMSCall(dialParaInfoNew);
1492 newCall->SetAccountNumber(phoneNumber);
1493 newCall->SetCallId(2);
1494 newCall->SetCallCreateTime(oldCallCreateTime + incomingMaxDuration - 1000);
1495 newCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1496 newCall->SetCallType(CallType::TYPE_IMS);
1497 // scene-5: invalid call type
1498 callStatusManager->AddOneCallObject(oldCall);
1499 newCall->SetCallType(CallType::TYPE_CS);
1500 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(newCall), true);
1501 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1502 // scene-6: valid on-number-dual-call scene
1503 newCall->SetCallType(CallType::TYPE_IMS);
1504 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(newCall), true);
1505 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1506 }
1507
1508 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_006, TestSize.Level0)
1509 {
1510 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper =
1511 CreateDataShareHelper(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
1512 if (dataShareHelper != nullptr) {
1513 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1514 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1515
1516 OHOS::Uri uri("datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true");
1517 DataShare::DataShareValueObject keyObj("key_esim_card_type");
1518 DataShare::DataShareValueObject valueObj("2");
1519 DataShare::DataShareValuesBucket bucket;
1520 bucket.Put("KEYWORD", keyObj);
1521 bucket.Put("VALUE", valueObj);
1522 dataShareHelper->Insert(uri, bucket);
1523 dataShareHelper->Release();
1524 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1525 }
1526 }
1527
1528 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_007, TestSize.Level0)
1529 {
1530 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1531 CallDetailInfo info;
1532 std::string number = "123456789";
1533 memcpy_s(&info.phoneNum, kMaxNumberLen, number.c_str(), number.length());
1534 info.voipCallInfo.voipCallId = "123456789";
1535 info.callType = CallType::TYPE_VOIP;
1536 info.state = TelCallState::CALL_STATUS_INCOMING;
1537 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1538 info.callType = CallType::TYPE_BLUETOOTH;
1539 info.index = 1;
1540 info.state = TelCallState::CALL_STATUS_INCOMING;
1541 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1542 info.state = TelCallState::CALL_STATUS_ACTIVE;
1543 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1544 info.state = TelCallState::CALL_STATUS_WAITING;
1545 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1546 info.state = TelCallState::CALL_STATUS_DISCONNECTED;
1547 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1548 info.state = TelCallState::CALL_STATUS_DIALING;
1549 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1550 info.state = TelCallState::CALL_STATUS_ALERTING;
1551 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1552 callStatusManager->HandleConnectingCallReportInfo(info);
1553 info.index = 0;
1554 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1555 sptr<CallBase> call = callStatusManager->GetOneCallObjectByVoipCallId(
1556 info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
1557 ASSERT_TRUE(call != nullptr);
1558 EXPECT_EQ(callStatusManager->AnsweredVoipCallHandle(info), TELEPHONY_ERROR);
1559 EXPECT_GT(callStatusManager->DisconnectingVoipCallHandle(info), TELEPHONY_ERROR);
1560 callStatusManager->DeleteOneCallObject(call);
1561 EXPECT_EQ(callStatusManager->AnsweredVoipCallHandle(info), TELEPHONY_ERROR);
1562 EXPECT_EQ(callStatusManager->DisconnectingVoipCallHandle(info), TELEPHONY_ERROR);
1563 EXPECT_FALSE(callStatusManager->IsContactPhoneNum(number));
1564 EXPECT_FALSE(callStatusManager->IsDistributeCallSourceStatus());
1565 EXPECT_GT(callStatusManager->UpdateCallStateAndHandleDsdsMode(info, call), TELEPHONY_ERROR);
1566 EXPECT_FALSE(callStatusManager->ShouldBlockIncomingCall(call, info));
1567 call = nullptr;
1568 EXPECT_EQ(callStatusManager->UpdateCallStateAndHandleDsdsMode(info, call), TELEPHONY_ERR_LOCAL_PTR_NULL);
1569 EXPECT_EQ(callStatusManager->HandleCallReportInfoEx(info), TELEPHONY_ERR_FAIL);
1570 VoipCallEventInfo voipCallInfo;
1571 callStatusManager->BtCallDialingHandleFirst(nullptr, info);
1572 std::vector<sptr<CallBase>> conferenceCallList;
1573 callStatusManager->SetConferenceCall(conferenceCallList);
1574 EXPECT_GT(callStatusManager->HandleVoipEventReportInfo(voipCallInfo), TELEPHONY_ERROR);
1575 }
1576
1577 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_008, TestSize.Level0)
1578 {
1579 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1580 CallDetailsInfo infos;
1581 infos.slotId = -1;
1582 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), CALL_ERR_INVALID_SLOT_ID);
1583 infos.slotId = 0;
1584 CallDetailInfo info;
1585 infos.callVec.push_back(info);
1586 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1587 callStatusManager->callDetailsInfo_[0].callVec.push_back(info);
1588 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1589 auto &info0 = infos.callVec[0];
1590 info0.state = TelCallState::CALL_STATUS_ACTIVE;
1591 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1592 info0.state = TelCallState::CALL_STATUS_UNKNOWN;
1593 info0.mpty = 1;
1594 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1595 info0.mpty = 0;
1596 info0.callType = CallType::TYPE_CS;
1597 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1598 info0.callType = CallType::TYPE_ERR_CALL;
1599 info0.callMode = VideoStateType::TYPE_VIDEO;
1600 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1601 info0.callMode = VideoStateType::TYPE_VOICE;
1602 info0.state = TelCallState::CALL_STATUS_ALERTING;
1603 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1604 auto &info1 = callStatusManager->callDetailsInfo_[0].callVec[0];
1605 info1.index = 1;
1606 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1607 info.state = TelCallState::CALL_STATUS_DIALING;
1608 EXPECT_GT(callStatusManager->HandleVoipCallReportInfo(info), TELEPHONY_ERROR);
1609 info.state = TelCallState::CALL_STATUS_ANSWERED;
1610 EXPECT_EQ(callStatusManager->HandleVoipCallReportInfo(info), TELEPHONY_ERROR);
1611 info.state = TelCallState::CALL_STATUS_DISCONNECTING;
1612 EXPECT_EQ(callStatusManager->HandleVoipCallReportInfo(info), TELEPHONY_ERROR);
1613 info.state = TelCallState::CALL_STATUS_UNKNOWN;
1614 EXPECT_GT(callStatusManager->HandleVoipCallReportInfo(info), TELEPHONY_ERROR);
1615 }
1616
1617 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_009, TestSize.Level0)
1618 {
1619 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1620 CallObjectManager::callObjectPtrList_.clear();
1621 ContactInfo contactInfo;
1622 callStatusManager->QueryCallerInfo(contactInfo, "110");
1623 VoipCallEventInfo voipCallEventInfo;
1624 EXPECT_EQ(callStatusManager->HandleVoipEventReportInfo(voipCallEventInfo), TELEPHONY_ERR_LOCAL_PTR_NULL);
1625 CallDetailInfo info;
1626 callStatusManager->CallFilterCompleteResult(info);
1627 EXPECT_EQ(callStatusManager->UpdateDialingCallInfo(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1628 EXPECT_EQ(callStatusManager->IncomingVoipCallHandle(info), CALL_ERR_CALL_OBJECT_IS_NULL);
1629 EXPECT_EQ(callStatusManager->OutgoingVoipCallHandle(info), CALL_ERR_CALL_OBJECT_IS_NULL);
1630 bool isDistributedDeviceDialing = false;
1631 EXPECT_FALSE(callStatusManager->UpdateDialingHandle(info, isDistributedDeviceDialing));
1632 EXPECT_EQ(callStatusManager->ActiveHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1633 EXPECT_EQ(callStatusManager->ActiveVoipCallHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1634 EXPECT_EQ(callStatusManager->HoldingHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1635 EXPECT_EQ(callStatusManager->AlertHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1636 EXPECT_EQ(callStatusManager->DisconnectedVoipCallHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1637
1638 info.state = TelCallState::CALL_STATUS_ACTIVE;
1639 info.callType = CallType::TYPE_VOIP;
1640 sptr<CallBase> voipCall = callStatusManager->CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
1641 ASSERT_TRUE(voipCall != nullptr);
1642 callStatusManager->antiFraudSlotId_ = 0;
1643 callStatusManager->antiFraudIndex_ = 0;
1644 CallObjectManager::AddOneCallObject(voipCall);
1645 callStatusManager->SetupAntiFraudService(voipCall, info);
1646 callStatusManager->StopAntiFraudDetect(voipCall, info);
1647 callStatusManager->HandleCeliaCall(voipCall);
1648 callStatusManager->SetConferenceCall({voipCall});
1649 EXPECT_EQ(CallObjectManager::callObjectPtrList_.size(), 1);
1650 voipCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_CREATE);
1651 EXPECT_EQ(callStatusManager->HandleVoipEventReportInfo(voipCallEventInfo), TELEPHONY_ERR_FAIL);
1652 voipCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
1653 callStatusManager->StartInComingCallMotionRecognition();
1654 EXPECT_EQ(callStatusManager->HandleVoipEventReportInfo(voipCallEventInfo), TELEPHONY_SUCCESS);
1655 voipCall->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_DIALING);
1656 callStatusManager->StartInComingCallMotionRecognition();
1657 voipCallEventInfo.voipCallEvent = VoipCallEvent::VOIP_CALL_EVENT_MUTED;
1658 EXPECT_EQ(callStatusManager->HandleVoipEventReportInfo(voipCallEventInfo), TELEPHONY_SUCCESS);
1659 voipCallEventInfo.voipCallEvent = VoipCallEvent::VOIP_CALL_EVENT_UNMUTED;
1660 EXPECT_EQ(callStatusManager->HandleVoipEventReportInfo(voipCallEventInfo), TELEPHONY_SUCCESS);
1661 EXPECT_EQ(callStatusManager->IncomingVoipCallHandle(info), TELEPHONY_SUCCESS);
1662 EXPECT_EQ(callStatusManager->OutgoingVoipCallHandle(info), TELEPHONY_SUCCESS);
1663 info.callMode = VideoStateType::TYPE_VIDEO;
1664 EXPECT_NE(callStatusManager->OutgoingVoipCallHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1665 }
1666
1667 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_010, TestSize.Level0)
1668 {
1669 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1670 CallObjectManager::callObjectPtrList_.clear();
1671 CallDetailInfo info;
1672 info.state = TelCallState::CALL_STATUS_ACTIVE;
1673 info.callType = CallType::TYPE_SATELLITE;
1674 sptr<CallBase> satelliteCall = callStatusManager->CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
1675 ASSERT_TRUE(satelliteCall != nullptr);
1676 CallObjectManager::AddOneCallObject(satelliteCall);
1677 EXPECT_EQ(CallObjectManager::callObjectPtrList_.size(), 1);
1678 EXPECT_EQ(callStatusManager->UpdateDialingCallInfo(info), TELEPHONY_SUCCESS);
1679 EXPECT_NE(callStatusManager->HoldingHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1680 EXPECT_NE(callStatusManager->DisconnectingHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1681 info.callType = CallType::TYPE_VOIP;
1682 EXPECT_NE(callStatusManager->DialingHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1683 }
1684
1685 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_011, TestSize.Level0)
1686 {
1687 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1688 callStatusManager->StopCallMotionRecognition(TelCallState::CALL_STATUS_ALERTING);
1689 std::string message = "call answered elsewhere";
1690 sptr<CallBase> call = nullptr;
1691 callStatusManager->SetOriginalCallTypeForActiveState(call);
1692 callStatusManager->SetOriginalCallTypeForDisconnectState(call);
1693 callStatusManager->SetVideoCallState(call, TelCallState::CALL_STATUS_DISCONNECTED);
1694 callStatusManager->SetBtCallDialByPhone(call, false);
1695 CallDetailInfo info;
1696 callStatusManager->CreateAndSaveNewCall(info, CallDirection::CALL_DIRECTION_IN);
1697 info.state = TelCallState::CALL_STATUS_ACTIVE;
1698 info.callType = CallType::TYPE_IMS;
1699 call = callStatusManager->CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
1700 ASSERT_TRUE(call != nullptr);
1701 info.callType = CallType::TYPE_ERR_CALL;
1702 EXPECT_NE(callStatusManager->RefreshCallIfNecessary(call, info), nullptr);
1703 info.callType = CallType::TYPE_CS;
1704 NumberMarkInfo numberMarkInfo;
1705 numberMarkInfo.markType = MarkType::MARK_TYPE_NONE;
1706 call->SetNumberLocation("default");
1707 EXPECT_NE(callStatusManager->RefreshCallIfNecessary(call, info), nullptr);
1708 call->SetNumberLocation("not_default");
1709 numberMarkInfo.markType = MarkType::MARK_TYPE_CRANK;
1710 call->SetNumberMarkInfo(numberMarkInfo);
1711 callStatusManager->HandleDialWhenHolding(0, call);
1712 call->SetCallType(CallType::TYPE_CS);
1713 callStatusManager->RefreshCallDisconnectReason(call,
1714 static_cast<int32_t>(RilDisconnectedReason::DISCONNECTED_REASON_CS_CALL_ANSWERED_ELSEWHER), message);
1715 callStatusManager->RefreshCallDisconnectReason(call,
1716 static_cast<int32_t>(RilDisconnectedReason::DISCONNECTED_REASON_ANSWERED_ELSEWHER), message);
1717 callStatusManager->RefreshCallDisconnectReason(call,
1718 static_cast<int32_t>(RilDisconnectedReason::DISCONNECTED_REASON_NORMAL), message);
1719 EXPECT_NE(callStatusManager->RefreshCallIfNecessary(call, info), nullptr);
1720 }
1721
1722 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_012, TestSize.Level0)
1723 {
1724 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1725 CallDetailInfo info;
1726 callStatusManager->callDetailsInfo_[0].callVec.push_back(info);
1727 callStatusManager->antiFraudSlotId_ = 0;
1728 callStatusManager->TriggerAntiFraud(static_cast<int32_t>(AntiFraudState::ANTIFRAUD_STATE_DEFAULT));
1729 callStatusManager->antiFraudIndex_ = -1;
1730 callStatusManager->antiFraudSlotId_ = 0;
1731 callStatusManager->TriggerAntiFraud(static_cast<int32_t>(AntiFraudState::ANTIFRAUD_STATE_RISK));
1732 EXPECT_EQ(callStatusManager->antiFraudSlotId_, -1);
1733 callStatusManager->antiFraudSlotId_ = 0;
1734 callStatusManager->TriggerAntiFraud(static_cast<int32_t>(AntiFraudState::ANTIFRAUD_STATE_FINISHED));
1735 EXPECT_EQ(callStatusManager->antiFraudSlotId_, -1);
1736 sleep(WAIT_TIME);
1737 }
1738
1739 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_013, TestSize.Level0)
1740 {
1741 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1742 CallDetailInfo info;
1743 bool isExistedOldCall = false;
1744 CallObjectManager::callObjectPtrList_.clear();
1745 EXPECT_EQ(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_SUCCESS);
1746 info.state = TelCallState::CALL_STATUS_ACTIVE;
1747 info.callType = CallType::TYPE_IMS;
1748 info.callMode = VideoStateType::TYPE_VOICE;
1749 callStatusManager->tmpCallDetailsInfo_[0].callVec.push_back(info);
1750 EXPECT_TRUE(callStatusManager->GetConferenceCallList(0).empty());
1751 auto &tmpInfo = callStatusManager->tmpCallDetailsInfo_[0].callVec[0];
1752 tmpInfo.mpty = 1;
1753 EXPECT_TRUE(callStatusManager->GetConferenceCallList(0).empty());
1754 sptr<CallBase> call = callStatusManager->CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
1755 ASSERT_TRUE(call != nullptr);
1756 DialParaInfo paraInfo;
1757 AppExecFwk::PacMap extras;
1758 EXPECT_TRUE(callStatusManager->CreateNewCallByCallTypeEx(paraInfo, info, CallDirection::CALL_DIRECTION_IN,
1759 extras) == nullptr);
1760 CallObjectManager::AddOneCallObject(call);
1761 callStatusManager->StartInComingCallMotionRecognition();
1762 EXPECT_FALSE(callStatusManager->GetConferenceCallList(0).empty());
1763 callStatusManager->StopCallMotionRecognition(TelCallState::CALL_STATUS_DISCONNECTED);
1764 EXPECT_GT(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_ERROR);
1765 info.callType = CallType::TYPE_CS;
1766 EXPECT_GT(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_ERROR);
1767 info.state = TelCallState::CALL_STATUS_HOLDING;
1768 EXPECT_GT(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_ERROR);
1769 info.callMode = VideoStateType::TYPE_VIDEO;
1770 EXPECT_GT(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_ERROR);
1771 info.callType = CallType::TYPE_IMS;
1772 info.state = TelCallState::CALL_STATUS_ACTIVE;
1773 EXPECT_GT(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_ERROR);
1774 info.callType = CallType::TYPE_CS;
1775 info.callMode = VideoStateType::TYPE_VOICE;
1776 EXPECT_GT(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_ERROR);
1777 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_HOLD);
1778 callStatusManager->StartInComingCallMotionRecognition();
1779 callStatusManager->BtCallDialingHandleFirst(call, info);
1780 info.state = TelCallState::CALL_STATUS_ALERTING;
1781 callStatusManager->BtCallDialingHandleFirst(call, info);
1782 call->SetTelCallState(TelCallState::CALL_STATUS_ALERTING);
1783 callStatusManager->BtCallDialingHandleFirst(call, info);
1784 EXPECT_EQ(call->GetTelCallState(), TelCallState::CALL_STATUS_DIALING);
1785 callStatusManager->BtCallDialingHandle(call, info);
1786 EXPECT_EQ(call->phoneOrWatch_, static_cast<int32_t>(PhoneOrWatchDial::WATCH_DIAL));
1787 }
1788
1789 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_014, TestSize.Level0)
1790 {
1791 std::shared_ptr<CallStatusManager> manager = std::make_shared<CallStatusManager>();
1792 CallDetailInfo info;
1793 info.state = TelCallState::CALL_STATUS_ACTIVE;
1794 info.callType = CallType::TYPE_IMS;
1795 sptr<CallBase> call = manager->CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
1796 ASSERT_TRUE(call != nullptr);
1797 manager->antiFraudSlotId_ = 0;
1798 manager->antiFraudIndex_ = 0;
1799 call->SetSlotId(1);
1800 manager->StopAntiFraudDetect(call, info);
1801 manager->HandleCeliaCall(call);
1802 info.index = 1;
1803 call->SetCallIndex(1);
1804 manager->StopAntiFraudDetect(call, info);
1805 manager->HandleCeliaCall(call);
1806 call->SetSlotId(0);
1807 manager->StopAntiFraudDetect(call, info);
1808 manager->HandleCeliaCall(call);
1809 EXPECT_EQ(manager->antiFraudIndex_, 0);
1810
1811 NumberMarkInfo markInfo;
1812 markInfo.markType = MarkType::MARK_TYPE_FRAUD;
1813 call->SetNumberMarkInfo(markInfo);
1814 manager->SetupAntiFraudService(call, info);
1815 markInfo.markType = MarkType::MARK_TYPE_YELLOW_PAGE;
1816 call->SetNumberMarkInfo(markInfo);
1817 manager->SetupAntiFraudService(call, info);
1818 markInfo.markType = MarkType::MARK_TYPE_ENTERPRISE;
1819 call->SetNumberMarkInfo(markInfo);
1820 manager->SetupAntiFraudService(call, info);
1821 markInfo.markType = MarkType::MARK_TYPE_TAXI;
1822 call->SetNumberMarkInfo(markInfo);
1823 manager->SetupAntiFraudService(call, info);
1824 EXPECT_EQ(manager->antiFraudIndex_, 0);
1825 }
1826
1827 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_015, TestSize.Level0)
1828 {
1829 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1830 CallDetailInfo callDetailInfo;
1831 callDetailInfo.state = TelCallState::CALL_STATUS_INCOMING;
1832 callDetailInfo.callType = CallType::TYPE_IMS;
1833 callDetailInfo.callMode = VideoStateType::TYPE_VOICE;
1834 std::string number = "";
1835 memcpy_s(&callDetailInfo.phoneNum, kMaxNumberLen, number.c_str(), number.length());
1836 sptr<CallBase> call = callStatusManager->CreateNewCall(callDetailInfo, CallDirection::CALL_DIRECTION_IN);
1837 callStatusManager->HandleVideoCallInAdvsecMode(call, callDetailInfo);
1838 EXPECT_EQ(call->IsForcedReportVoiceCall(), false);
1839
1840 call->SetVideoStateType(VideoStateType::TYPE_VIDEO);
1841 callStatusManager->HandleVideoCallInAdvsecMode(call, callDetailInfo);
1842 EXPECT_EQ(call->IsForcedReportVoiceCall(), true);
1843
1844 call->SetForcedReportVoiceCall(false);
1845 call->SetVideoStateType(VideoStateType::TYPE_VIDEO);
1846 call->SetCallType(CallType::TYPE_VOIP);
1847 callStatusManager->HandleVideoCallInAdvsecMode(call, callDetailInfo);
1848 EXPECT_EQ(call->IsForcedReportVoiceCall(), false);
1849
1850 call->SetCallType(CallType::TYPE_IMS);
1851 NumberMarkInfo markInfo;
1852 markInfo.markType = MarkType::MARK_TYPE_YELLOW_PAGE;
1853 call->SetNumberMarkInfo(markInfo);
1854 callStatusManager->HandleVideoCallInAdvsecMode(call, callDetailInfo);
1855 EXPECT_EQ(call->IsForcedReportVoiceCall(), false);
1856 }
1857 } // namespace Telephony
1858 } // namespace OHOS
1859