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
CreateDataShareHelper(std::string uri)151 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(std::string uri)
152 {
153 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
154 if (saManager == nullptr) {
155 printf("Get system ability mgr failed.");
156 return nullptr;
157 }
158 auto remoteObj = saManager->GetSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
159 if (remoteObj == nullptr) {
160 printf("GetSystemAbility Service Failed.");
161 return nullptr;
162 }
163 return DataShare::DataShareHelper::Creator(remoteObj, uri);
164 }
165
CreateDataShareHelper(int systemAbilityId)166 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(int systemAbilityId)
167 {
168 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
169 if (saManager == nullptr) {
170 TELEPHONY_LOGE("GetSystemAbilityManager failed.");
171 return nullptr;
172 }
173 sptr<IRemoteObject> remote = saManager->GetSystemAbility(systemAbilityId);
174 if (remote == nullptr) {
175 TELEPHONY_LOGE("GetSystemAbility Service Failed.");
176 return nullptr;
177 }
178 const std::string SETTINGS_DATASHARE_URI =
179 "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
180 const std::string SETTINGS_DATASHARE_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility";
181 return DataShare::DataShareHelper::Creator(remote, SETTINGS_DATASHARE_URI, SETTINGS_DATASHARE_EXT_URI);
182 }
183
184 /**
185 * @tc.number Telephony_Ott_Conference_001
186 * @tc.name test error branch
187 * @tc.desc Function test
188 */
189 HWTEST_F(ZeroBranch4Test, Telephony_Ott_Conference_001, Function | MediumTest | Level3)
190 {
191 OttConference ottConference;
192 ottConference.state_ = CONFERENCE_STATE_IDLE;
193 ASSERT_EQ(ottConference.JoinToConference(1), CALL_ERR_ILLEGAL_CALL_OPERATION);
194 ottConference.state_ = CONFERENCE_STATE_CREATING;
195 ASSERT_EQ(ottConference.JoinToConference(1), TELEPHONY_SUCCESS);
196 for (uint16_t i = 0; i <= CS_CONFERENCE_MAX_CALLS_CNT + 1; ++i) {
197 ottConference.subCallIdSet_.insert(i);
198 }
199 ASSERT_EQ(ottConference.CanCombineConference(), CALL_ERR_CONFERENCE_CALL_EXCEED_LIMIT);
200 ottConference.subCallIdSet_.clear();
201 ottConference.subCallIdSet_.insert(1);
202 ASSERT_EQ(ottConference.LeaveFromConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
203 ASSERT_EQ(ottConference.LeaveFromConference(1), TELEPHONY_SUCCESS);
204 ottConference.subCallIdSet_.clear();
205 ottConference.subCallIdSet_.insert(1);
206 ASSERT_EQ(ottConference.HoldConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
207 ottConference.state_ = CONFERENCE_STATE_HOLDING;
208 ASSERT_EQ(ottConference.HoldConference(-1), TELEPHONY_SUCCESS);
209 ASSERT_EQ(ottConference.HoldConference(1), TELEPHONY_SUCCESS);
210 ASSERT_EQ(ottConference.CanCombineConference(), TELEPHONY_SUCCESS);
211 ottConference.subCallIdSet_.insert(1);
212 ottConference.state_ = CONFERENCE_STATE_ACTIVE;
213 ASSERT_EQ(ottConference.CanSeparateConference(), TELEPHONY_SUCCESS);
214 ASSERT_EQ(ottConference.CanKickOutFromConference(), TELEPHONY_SUCCESS);
215 ottConference.subCallIdSet_.clear();
216 ASSERT_EQ(ottConference.CanSeparateConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
217 ASSERT_EQ(ottConference.CanKickOutFromConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
218 }
219
220 /**
221 * @tc.number Telephony_Cs_Conference_001
222 * @tc.name test error branch
223 * @tc.desc Function test
224 */
225 HWTEST_F(ZeroBranch4Test, Telephony_Cs_Conference_001, Function | MediumTest | Level3)
226 {
227 CsConference csConference;
228 csConference.state_ = CONFERENCE_STATE_IDLE;
229 ASSERT_EQ(csConference.JoinToConference(1), CALL_ERR_ILLEGAL_CALL_OPERATION);
230 csConference.state_ = CONFERENCE_STATE_CREATING;
231 ASSERT_EQ(csConference.JoinToConference(1), TELEPHONY_SUCCESS);
232 for (uint16_t i = 0; i <= CS_CONFERENCE_MAX_CALLS_CNT + 1; ++i) {
233 csConference.subCallIdSet_.insert(i);
234 }
235 ASSERT_EQ(csConference.CanCombineConference(), CALL_ERR_CONFERENCE_CALL_EXCEED_LIMIT);
236 csConference.subCallIdSet_.clear();
237 csConference.subCallIdSet_.insert(1);
238 ASSERT_EQ(csConference.LeaveFromConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
239 ASSERT_EQ(csConference.LeaveFromConference(1), TELEPHONY_SUCCESS);
240 csConference.subCallIdSet_.clear();
241 csConference.subCallIdSet_.insert(1);
242 ASSERT_EQ(csConference.HoldConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
243 csConference.state_ = CONFERENCE_STATE_HOLDING;
244 ASSERT_EQ(csConference.HoldConference(-1), TELEPHONY_SUCCESS);
245 ASSERT_EQ(csConference.HoldConference(1), TELEPHONY_SUCCESS);
246 ASSERT_EQ(csConference.CanCombineConference(), TELEPHONY_SUCCESS);
247 csConference.subCallIdSet_.insert(1);
248 csConference.state_ = CONFERENCE_STATE_ACTIVE;
249 ASSERT_EQ(csConference.CanSeparateConference(), TELEPHONY_SUCCESS);
250 ASSERT_EQ(csConference.CanKickOutFromConference(), TELEPHONY_SUCCESS);
251 csConference.subCallIdSet_.clear();
252 ASSERT_EQ(csConference.CanSeparateConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
253 ASSERT_EQ(csConference.CanKickOutFromConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
254 }
255
256 /**
257 * @tc.number Telephony_Ims_Conference_001
258 * @tc.name test error branch
259 * @tc.desc Function test
260 */
261 HWTEST_F(ZeroBranch4Test, Telephony_Ims_Conference_001, Function | MediumTest | Level3)
262 {
263 ImsConference imsConference;
264 imsConference.state_ = CONFERENCE_STATE_IDLE;
265 ASSERT_EQ(imsConference.JoinToConference(1), CALL_ERR_ILLEGAL_CALL_OPERATION);
266 imsConference.state_ = CONFERENCE_STATE_CREATING;
267 ASSERT_EQ(imsConference.JoinToConference(1), TELEPHONY_SUCCESS);
268 for (uint16_t i = 0; i <= CS_CONFERENCE_MAX_CALLS_CNT + 1; ++i) {
269 imsConference.subCallIdSet_.insert(i);
270 }
271 ASSERT_EQ(imsConference.CanCombineConference(), CALL_ERR_CONFERENCE_CALL_EXCEED_LIMIT);
272 imsConference.subCallIdSet_.clear();
273 imsConference.subCallIdSet_.insert(1);
274 ASSERT_EQ(imsConference.LeaveFromConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
275 ASSERT_EQ(imsConference.LeaveFromConference(1), TELEPHONY_SUCCESS);
276 imsConference.subCallIdSet_.clear();
277 imsConference.subCallIdSet_.insert(1);
278 ASSERT_EQ(imsConference.HoldConference(-1), CALL_ERR_CONFERENCE_SEPERATE_FAILED);
279 imsConference.state_ = CONFERENCE_STATE_HOLDING;
280 ASSERT_EQ(imsConference.HoldConference(-1), TELEPHONY_SUCCESS);
281 ASSERT_EQ(imsConference.HoldConference(1), TELEPHONY_SUCCESS);
282 ASSERT_EQ(imsConference.CanCombineConference(), TELEPHONY_SUCCESS);
283 imsConference.subCallIdSet_.insert(1);
284 imsConference.state_ = CONFERENCE_STATE_ACTIVE;
285 ASSERT_EQ(imsConference.CanSeparateConference(), TELEPHONY_SUCCESS);
286 ASSERT_EQ(imsConference.CanKickOutFromConference(), TELEPHONY_SUCCESS);
287 imsConference.subCallIdSet_.clear();
288 ASSERT_EQ(imsConference.CanSeparateConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
289 ASSERT_EQ(imsConference.CanKickOutFromConference(), CALL_ERR_CONFERENCE_NOT_EXISTS);
290 }
291
292 /**
293 * @tc.number Telephony_BluetoothCallService_001
294 * @tc.name test error branch
295 * @tc.desc Function test
296 */
297 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallService_001, Function | MediumTest | Level3)
298 {
299 BluetoothCallService bluetoothCallService;
300 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.AnswerCall());
301 DialParaInfo dialParaInfo;
302 sptr<OHOS::Telephony::CallBase> callBase1 = new OTTCall(dialParaInfo);
303 bluetoothCallService.callObjectPtrList_.clear();
304 callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
305 callBase1->callId_ = -1;
306 bluetoothCallService.callObjectPtrList_.push_back(callBase1);
307 bluetoothCallService.AnswerCall();
308 bluetoothCallService.callControlManagerPtr_ = nullptr;
309 ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.AnswerCall());
310 ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.RejectCall());
311 ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.HangUpCall());
312 ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.HoldCall());
313 ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.UnHoldCall());
314 ASSERT_EQ(TELEPHONY_ERR_PERMISSION_ERR, bluetoothCallService.SwitchCall());
315 bluetoothCallService.StartDtmf('c');
316 bluetoothCallService.callObjectPtrList_.clear();
317 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
318 callBase1->callId_ = -1;
319 bluetoothCallService.callObjectPtrList_.push_back(callBase1);
320 ASSERT_NE(TELEPHONY_ERR_LOCAL_PTR_NULL, bluetoothCallService.StartDtmf('c'));
321 ASSERT_NE(TELEPHONY_ERR_LOCAL_PTR_NULL, bluetoothCallService.StopDtmf());
322 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.CombineConference());
323 bluetoothCallService.callObjectPtrList_.clear();
324 callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
325 callBase1->callId_ = -1;
326 bluetoothCallService.callObjectPtrList_.push_back(callBase1);
327 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.CombineConference());
328 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.SeparateConference());
329 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.KickOutFromConference());
330 }
331
332 /**
333 * @tc.number Telephony_BluetoothCallService_002
334 * @tc.name test error branch
335 * @tc.desc Function test
336 */
337 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallService_002, Function | MediumTest | Level3)
338 {
339 BluetoothCallService bluetoothCallService;
340 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.AnswerCall());
341 DialParaInfo dialParaInfo;
342 sptr<OHOS::Telephony::CallBase> callBase1 = new OTTCall(dialParaInfo);
343 bluetoothCallService.callObjectPtrList_.clear();
344 callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
345 callBase1->callId_ = -1;
346 bluetoothCallService.callObjectPtrList_.push_back(callBase1);
347 bluetoothCallService.GetCurrentCallList(-1).size();
348 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.CombineConference());
349 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.SeparateConference());
350 ASSERT_NE(TELEPHONY_ERR_SUCCESS, bluetoothCallService.KickOutFromConference());
351 }
352
353 /**
354 * @tc.number Telephony_BluetoothCallService_003
355 * @tc.name test error branch
356 * @tc.desc Function test
357 */
358 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallService_003, Function | MediumTest | Level3)
359 {
360 int32_t callId = 10020;
361 int32_t numActive = 1;
362 int32_t callState = (int32_t)TelCallState::CALL_STATUS_IDLE;
363 std::string number = "";
364 CallAttributeInfo callAttributeInfo;
365 callAttributeInfo.callId = callId;
366 CallObjectManager::AddOneVoipCallObject(callAttributeInfo);
367 BluetoothCallService bluetoothCallService;
368 bluetoothCallService.GetVoipCallState(numActive, callState, number);
369 EXPECT_EQ(numActive, 1);
370 CallObjectManager::UpdateOneVoipCallObjectByCallId(callId, TelCallState::CALL_STATUS_WAITING);
371 bluetoothCallService.GetVoipCallState(numActive, callState, number);
372 EXPECT_EQ(callState, (int32_t)TelCallState::CALL_STATUS_INCOMING);
373 CallObjectManager::UpdateOneVoipCallObjectByCallId(callId, TelCallState::CALL_STATUS_INCOMING);
374 bluetoothCallService.GetVoipCallState(numActive, callState, number);
375 EXPECT_EQ(callState, (int32_t)TelCallState::CALL_STATUS_INCOMING);
376 callState = (int32_t)TelCallState::CALL_STATUS_IDLE;
377 CallObjectManager::UpdateOneVoipCallObjectByCallId(callId, TelCallState::CALL_STATUS_ALERTING);
378 bluetoothCallService.GetVoipCallState(numActive, callState, number);
379 EXPECT_EQ(callState, (int32_t)TelCallState::CALL_STATUS_ALERTING);
380 numActive = 0;
381 CallObjectManager::UpdateOneVoipCallObjectByCallId(callId, TelCallState::CALL_STATUS_ACTIVE);
382 bluetoothCallService.GetVoipCallState(numActive, callState, number);
383 EXPECT_EQ(numActive, 1);
384 }
385
386 /**
387 * @tc.number Telephony_BluetoothCallStub_001
388 * @tc.name test error nullptr branch
389 * @tc.desc Function test
390 */
391 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallStub_001, Function | MediumTest | Level3)
392 {
393 auto bluetoothCallService = std::make_shared<BluetoothCallService>();
394 MessageParcel data1;
395 MessageParcel reply;
396 MessageOption option;
397 bluetoothCallService->OnRemoteRequest(static_cast<uint32_t>(
398 CallManagerCallAbilityInterfaceCode::UPDATE_CALL_STATE_INFO), data1, reply, option);
399 const uint8_t data = 1;
400 MessageParcel messageParcel;
401 messageParcel.WriteBuffer(&data, 1);
402 messageParcel.RewindRead(0);
403 int32_t result = bluetoothCallService->OnAnswerCall(messageParcel, reply);
404 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
405 result = bluetoothCallService->OnRejectCall(messageParcel, reply);
406 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
407 bluetoothCallService->OnHangUpCall(messageParcel, reply);
408 result = bluetoothCallService->OnGetBtCallState(messageParcel, reply);
409 ASSERT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
410 result = bluetoothCallService->OnHoldCall(messageParcel, reply);
411 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
412 result = bluetoothCallService->OnUnHoldCall(messageParcel, reply);
413 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
414 result = bluetoothCallService->OnSwitchCall(messageParcel, reply);
415 ASSERT_EQ(result, TELEPHONY_ERR_PERMISSION_ERR);
416 result = bluetoothCallService->OnCombineConference(messageParcel, reply);
417 ASSERT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
418 result = bluetoothCallService->OnSeparateConference(messageParcel, reply);
419 ASSERT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
420 result = bluetoothCallService->OnKickOutFromConference(messageParcel, reply);
421 ASSERT_NE(result, TELEPHONY_ERR_PERMISSION_ERR);
422 result = bluetoothCallService->OnStartDtmf(messageParcel, reply);
423 ASSERT_EQ(result, TELEPHONY_SUCCESS);
424 result = bluetoothCallService->OnStopDtmf(messageParcel, reply);
425 ASSERT_EQ(result, TELEPHONY_SUCCESS);
426 result = bluetoothCallService->OnGetCurrentCallList(messageParcel, reply);
427 ASSERT_EQ(result, TELEPHONY_SUCCESS);
428 }
429
430 /**
431 * @tc.number Telephony_BluetoothConnection_001
432 * @tc.name test error nullptr branch
433 * @tc.desc Function test
434 */
435 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothConnection_001, Function | MediumTest | Level3)
436 {
437 auto bluetoothConnection = std::make_shared<BluetoothConnection>();
438 bluetoothConnection->IsAudioActivated();
439 #ifdef ABILITY_BLUETOOTH_SUPPORT
440 bluetoothConnection->ResetBtConnection();
441 bluetoothConnection->RegisterObserver();
442 std::string address = "123";
443 bluetoothConnection->RemoveBtDevice(address);
444 Bluetooth::BluetoothRemoteDevice device;
445 int32_t state = static_cast<int32_t>(Bluetooth::BTConnectState::CONNECTED);
446 int32_t cause = 1;
447 bluetoothConnection->OnConnectionStateChanged(device, state, cause);
448 state = static_cast<int32_t>(Bluetooth::BTConnectState::DISCONNECTED);
449 bluetoothConnection->OnConnectionStateChanged(device, state, cause);
450 EXPECT_FALSE(bluetoothConnection->IsAudioActivated());
451 #endif
452 }
453
GetTestNumber()454 std::string GetTestNumber()
455 {
456 std::string number =
457 "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456";
458 number += number;
459 return number;
460 }
461
462 /**
463 * @tc.number Telephony_BluetoothCallPolicy_001
464 * @tc.name test error branch
465 * @tc.desc Function test
466 */
467 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallPolicy_001, Function | MediumTest | Level3)
468 {
469 BluetoothCallPolicy callPolicy;
470 DialParaInfo dialParaInfo;
471 sptr<OHOS::Telephony::CallBase> callBase1 = new OTTCall(dialParaInfo);
472 callBase1->callId_ = 0;
473 callPolicy.callObjectPtrList_.push_back(callBase1);
474 callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
475 int32_t policy = 0;
476 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.AnswerCallPolicy(policy));
477 callBase1->callState_ = TelCallState::CALL_STATUS_WAITING;
478 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.AnswerCallPolicy(policy));
479 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
480 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.AnswerCallPolicy(policy));
481 callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
482 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.RejectCallPolicy(policy));
483 callBase1->callState_ = TelCallState::CALL_STATUS_WAITING;
484 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.RejectCallPolicy(policy));
485 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
486 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.RejectCallPolicy(policy));
487 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
488 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HoldCallPolicy(policy));
489 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
490 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.HoldCallPolicy(policy));
491 callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
492 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.UnHoldCallPolicy(policy));
493 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
494 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.UnHoldCallPolicy(policy));
495 callBase1->callState_ = TelCallState::CALL_STATUS_INCOMING;
496 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
497 callBase1->callState_ = TelCallState::CALL_STATUS_WAITING;
498 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
499 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
500 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
501 callBase1->callState_ = TelCallState::CALL_STATUS_ALERTING;
502 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
503 callBase1->callState_ = TelCallState::CALL_STATUS_DIALING;
504 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
505 callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
506 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
507 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
508 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.HangUpPolicy(policy));
509 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
510 ASSERT_EQ(CALL_ERR_ILLEGAL_CALL_OPERATION, callPolicy.SwitchCallPolicy(policy));
511 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
512 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.SwitchCallPolicy(policy));
513 }
514
515 /**
516 * @tc.number Telephony_BluetoothCallPolicy_002
517 * @tc.name test error branch
518 * @tc.desc Function test
519 */
520 HWTEST_F(ZeroBranch4Test, Telephony_BluetoothCallPolicy_002, Function | MediumTest | Level3)
521 {
522 BluetoothCallPolicy callPolicy;
523 DialParaInfo dialParaInfo;
524 sptr<OHOS::Telephony::CallBase> callBase1 = new OTTCall(dialParaInfo);
525 callBase1->callId_ = 0;
526 callPolicy.callObjectPtrList_.push_back(callBase1);
527 int32_t policy = 0;
528 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
529 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
530 callBase1->callState_ = TelCallState::CALL_STATUS_ALERTING;
531 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
532 callBase1->callState_ = TelCallState::CALL_STATUS_DIALING;
533 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
534 callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
535 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
536 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
537 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.StartDtmfPolicy(policy));
538 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
539 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.CombineConferencePolicy(policy));
540 callBase1->callState_ = TelCallState::CALL_STATUS_UNKNOWN;
541 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.CombineConferencePolicy(policy));
542 callBase1->conferenceState_ = TelConferenceState::TEL_CONFERENCE_ACTIVE;
543 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.SeparateConferencePolicy(policy));
544 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.KickOutFromConferencePolicy(policy));
545 callBase1->conferenceState_ = TelConferenceState::TEL_CONFERENCE_HOLDING;
546 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.SeparateConferencePolicy(policy));
547 ASSERT_EQ(TELEPHONY_SUCCESS, callPolicy.KickOutFromConferencePolicy(policy));
548 callBase1->conferenceState_ = TelConferenceState::TEL_CONFERENCE_IDLE;
549 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.SeparateConferencePolicy(policy));
550 ASSERT_NE(TELEPHONY_SUCCESS, callPolicy.KickOutFromConferencePolicy(policy));
551 }
552
553 /**
554 * @tc.number Telephony_ImsCall_002
555 * @tc.name test error branch
556 * @tc.desc Function test
557 */
558 HWTEST_F(ZeroBranch4Test, Telephony_ImsCall_002, Function | MediumTest | Level3)
559 {
560 DialParaInfo dialParaInfo;
561 IMSCall call { dialParaInfo };
562 call.isInitialized_ = true;
563 ImsCallMode mode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
564 call.UpdateImsCallMode(mode);
565 call.SendUpdateCallMediaModeRequest(mode);
566 CallModeReportInfo callModeRequestInfo;
567 call.RecieveUpdateCallMediaModeRequest(callModeRequestInfo);
568 call.SendUpdateCallMediaModeResponse(mode);
569 CallModeReportInfo callModeResponseInfo;
570 call.ReceiveUpdateCallMediaModeResponse(callModeResponseInfo);
571 CallMediaModeInfo callMediaModeInfo;
572 call.ReportImsCallModeInfo(callMediaModeInfo);
573 call.SwitchVideoState(mode);
574 call.IsSupportVideoCall();
575 call.GetCallVideoState(mode);
576 std::string value = "123";
577 call.ControlCamera(value, 1, 1);
578 call.SetPausePicture(value);
579 uint64_t tempSurfaceId = std::stoull(value);
580 auto surface = SurfaceUtils::GetInstance()->GetSurface(tempSurfaceId);
581 if (surface == nullptr) {
582 value = "";
583 }
584 call.SetPreviewWindow(value, surface);
585 call.SetDisplayWindow(value, surface);
586 call.SetDeviceDirection(1);
587 call.CancelCallUpgrade();
588 call.RequestCameraCapabilities();
589 call.videoCallState_ = nullptr;
590 ASSERT_NE(TELEPHONY_ERR_LOCAL_PTR_NULL, call.UpdateImsCallMode(mode));
591 ASSERT_EQ(TELEPHONY_ERR_LOCAL_PTR_NULL, call.RecieveUpdateCallMediaModeRequest(callModeRequestInfo));
592 ASSERT_EQ(TELEPHONY_ERR_LOCAL_PTR_NULL, call.ReceiveUpdateCallMediaModeResponse(callModeResponseInfo));
593 }
594
595 /**
596 * @tc.number Telephony_CSCall_001
597 * @tc.name test error branch
598 * @tc.desc Function test
599 */
600 HWTEST_F(ZeroBranch4Test, Telephony_CSCall_001, Function | MediumTest | Level3)
601 {
602 DialParaInfo dialParaInfo;
603 CSCall call { dialParaInfo };
604 call.AnswerCall(0);
605 call.RejectCall();
606 call.HoldCall();
607 call.SwitchCall();
608 call.SetMute(0, 0);
609 call.CombineConference();
610 call.SeparateConference();
611 call.KickOutFromConference();
612 call.CanCombineConference();
613 call.CanSeparateConference();
614 call.LaunchConference();
615 call.HoldConference();
616 int32_t mainCallId = 1;
617 ASSERT_EQ(TELEPHONY_SUCCESS, call.GetMainCallId(mainCallId));
618 call.HandleCombineConferenceFailEvent();
619 }
620
621 /**
622 * @tc.number Telephony_CallRecordsManager_001
623 * @tc.name test error branch
624 * @tc.desc Function test
625 */
626 HWTEST_F(ZeroBranch4Test, Telephony_CallRecordsManager_001, Function | MediumTest | Level3)
627 {
628 CallRecordsManager callRecordsManager;
629 callRecordsManager.Init();
630
631 sptr<CallBase> callObjectPtr = nullptr;
632 TelCallState priorState = TelCallState::CALL_STATUS_HOLDING;
633 TelCallState nextState = TelCallState::CALL_STATUS_HOLDING;
634 callRecordsManager.CallStateUpdated(callObjectPtr, priorState, nextState);
635 nextState = TelCallState::CALL_STATUS_DISCONNECTED;
636 callRecordsManager.CallStateUpdated(callObjectPtr, priorState, nextState);
637 DialParaInfo dialParaInfo;
638 callObjectPtr = new CSCall(dialParaInfo);
639 ASSERT_TRUE(callObjectPtr != nullptr);
640 callRecordsManager.CallStateUpdated(callObjectPtr, priorState, nextState);
641 CallAttributeInfo info;
642 info.callBeginTime = DEFAULT_TIME;
643 info.callEndTime = ONE_TIME;
644 callRecordsManager.AddOneCallRecord(info);
645 info.callBeginTime = ONE_TIME;
646 info.callEndTime = DEFAULT_TIME;
647 callRecordsManager.AddOneCallRecord(info);
648 info.callBeginTime = DEFAULT_TIME;
649 info.callEndTime = DEFAULT_TIME;
650 callRecordsManager.AddOneCallRecord(info);
651 info.callBeginTime = ONE_TIME;
652 info.callEndTime = ONE_TIME;
653 callRecordsManager.AddOneCallRecord(info);
654 info.ringBeginTime = DEFAULT_TIME;
655 info.ringEndTime = ONE_TIME;
656 callRecordsManager.AddOneCallRecord(info);
657 info.ringBeginTime = ONE_TIME;
658 info.ringEndTime = DEFAULT_TIME;
659 callRecordsManager.AddOneCallRecord(info);
660 info.ringBeginTime = DEFAULT_TIME;
661 info.ringEndTime = DEFAULT_TIME;
662 callRecordsManager.AddOneCallRecord(info);
663 info.ringBeginTime = ONE_TIME;
664 info.ringEndTime = ONE_TIME;
665 callRecordsManager.AddOneCallRecord(info);
666 callRecordsManager.RemoveMissedIncomingCallNotification();
667 int32_t videoState = static_cast<int32_t>(VideoStateType::TYPE_VIDEO);
668 callRecordsManager.GetCallFeatures(videoState);
669 }
670
671 /**
672 * @tc.number Telephony_CallControlManager_001
673 * @tc.name test error branch
674 * @tc.desc Function test
675 */
676 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_001, Function | MediumTest | Level3)
677 {
678 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
679 int32_t videoState = 0;
680 ASSERT_NE(callControlManager->AnswerCall(INVALID_CALLID, videoState), TELEPHONY_SUCCESS);
681 videoState = 2;
682 ASSERT_NE(callControlManager->AnswerCall(VALID_CALLID, videoState), TELEPHONY_SUCCESS);
683 ASSERT_NE(callControlManager->RejectCall(VALID_CALLID, false, u""), TELEPHONY_SUCCESS);
684 ASSERT_NE(callControlManager->HangUpCall(VALID_CALLID), TELEPHONY_SUCCESS);
685 ASSERT_NE(callControlManager->HangUpCall(INVALID_CALLID), TELEPHONY_SUCCESS);
686 ASSERT_EQ(callControlManager->GetCallState(), TELEPHONY_SUCCESS);
687 ASSERT_NE(callControlManager->HoldCall(INVALID_CALLID), TELEPHONY_SUCCESS);
688 ASSERT_NE(callControlManager->UnHoldCall(INVALID_CALLID), TELEPHONY_SUCCESS);
689 ASSERT_NE(callControlManager->SwitchCall(INVALID_CALLID), TELEPHONY_SUCCESS);
690 ASSERT_FALSE(callControlManager->HasCall());
691 sptr<CallBase> callObjectPtr = nullptr;
692 TelCallState priorState = TelCallState::CALL_STATUS_HOLDING;
693 TelCallState nextState = TelCallState::CALL_STATUS_HOLDING;
694 ASSERT_FALSE(callControlManager->NotifyNewCallCreated(callObjectPtr));
695 callObjectPtr = nullptr;
696 ASSERT_EQ(TELEPHONY_ERR_LOCAL_PTR_NULL, callControlManager->AddCallLogAndNotification(callObjectPtr));
697 callObjectPtr = nullptr;
698 ASSERT_FALSE(callControlManager->NotifyCallStateUpdated(callObjectPtr, priorState, nextState));
699 DisconnectedDetails details;
700 ASSERT_FALSE(callControlManager->NotifyCallDestroyed(details));
701 ASSERT_FALSE(callControlManager->NotifyIncomingCallAnswered(callObjectPtr));
702 ASSERT_FALSE(callControlManager->NotifyIncomingCallRejected(callObjectPtr, false, ""));
703 ASSERT_NE(callControlManager->PostDialProceed(VALID_CALLID, true), TELEPHONY_SUCCESS);
704 CallEventInfo info;
705 ASSERT_FALSE(callControlManager->NotifyCallEventUpdated(info));
706 DialParaInfo dialParaInfo;
707 callObjectPtr = new CSCall(dialParaInfo);
708 ASSERT_TRUE(callControlManager->NotifyNewCallCreated(callObjectPtr));
709 callControlManager->AddCallLogAndNotification(callObjectPtr);
710 ASSERT_FALSE(callControlManager->NotifyCallStateUpdated(callObjectPtr, priorState, nextState));
711 ASSERT_FALSE(callControlManager->NotifyIncomingCallAnswered(callObjectPtr));
712 ASSERT_FALSE(callControlManager->NotifyIncomingCallRejected(callObjectPtr, false, ""));
713 callObjectPtr->SetCallCreateTime(time(nullptr));
714
715 callControlManager->Init();
716 ASSERT_NE(callControlManager->RejectCall(VALID_CALLID, false, u""), TELEPHONY_SUCCESS);
717 ASSERT_NE(callControlManager->RejectCall(INVALID_CALLID, false, u""), TELEPHONY_SUCCESS);
718 ASSERT_NE(callControlManager->HangUpCall(VALID_CALLID), TELEPHONY_SUCCESS);
719 ASSERT_TRUE(callControlManager->NotifyNewCallCreated(callObjectPtr));
720 callControlManager->AddCallLogAndNotification(callObjectPtr);
721 ASSERT_TRUE(callControlManager->NotifyCallStateUpdated(callObjectPtr, priorState, nextState));
722 ASSERT_TRUE(callControlManager->NotifyIncomingCallAnswered(callObjectPtr));
723 ASSERT_TRUE(callControlManager->NotifyIncomingCallRejected(callObjectPtr, false, ""));
724 callControlManager->ConnectCallUiService(true);
725 }
726
727 /**
728 * @tc.number Telephony_CallControlManager_002
729 * @tc.name test error branch
730 * @tc.desc Function test
731 */
732 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_002, Function | MediumTest | Level3)
733 {
734 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
735 ASSERT_NE(callControlManager->StartDtmf(INVALID_CALLID, 'a'), TELEPHONY_SUCCESS);
736 ASSERT_NE(callControlManager->StopDtmf(INVALID_CALLID), TELEPHONY_SUCCESS);
737 ASSERT_NE(callControlManager->GetCallWaiting(INVALID_CALLID), TELEPHONY_SUCCESS);
738 int32_t slotId = 1;
739 ASSERT_NE(callControlManager->GetCallWaiting(slotId), TELEPHONY_SUCCESS);
740 ASSERT_NE(callControlManager->SetCallWaiting(INVALID_CALLID, true), TELEPHONY_SUCCESS);
741 ASSERT_NE(callControlManager->SetCallWaiting(slotId, true), TELEPHONY_SUCCESS);
742 CallRestrictionType callRestrictionType = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
743 ASSERT_NE(callControlManager->GetCallRestriction(INVALID_CALLID, callRestrictionType), TELEPHONY_SUCCESS);
744 ASSERT_NE(callControlManager->GetCallRestriction(slotId, callRestrictionType), TELEPHONY_SUCCESS);
745 CallRestrictionInfo callRestrictionInfo;
746 ASSERT_NE(callControlManager->SetCallRestriction(INVALID_CALLID, callRestrictionInfo), TELEPHONY_SUCCESS);
747 ASSERT_NE(callControlManager->SetCallRestriction(slotId, callRestrictionInfo), TELEPHONY_SUCCESS);
748 CallTransferType callTransferType = CallTransferType::TRANSFER_TYPE_BUSY;
749 ASSERT_NE(callControlManager->GetCallTransferInfo(INVALID_CALLID, callTransferType), TELEPHONY_SUCCESS);
750 ASSERT_NE(callControlManager->GetCallTransferInfo(slotId, callTransferType), TELEPHONY_SUCCESS);
751 CallTransferInfo info;
752 ASSERT_NE(callControlManager->SetCallTransferInfo(INVALID_CALLID, info), TELEPHONY_SUCCESS);
753 ASSERT_NE(callControlManager->SetCallTransferInfo(slotId, info), TELEPHONY_SUCCESS);
754 bool result = true;
755 ASSERT_NE(callControlManager->CanSetCallTransferTime(INVALID_CALLID, result), TELEPHONY_SUCCESS);
756 ASSERT_NE(callControlManager->CanSetCallTransferTime(slotId, result), TELEPHONY_SUCCESS);
757 int32_t mode = 1;
758 ASSERT_NE(callControlManager->SetCallPreferenceMode(INVALID_CALLID, mode), TELEPHONY_SUCCESS);
759 ASSERT_NE(callControlManager->SetCallPreferenceMode(slotId, mode), TELEPHONY_SUCCESS);
760 ASSERT_NE(callControlManager->CombineConference(INVALID_CALLID), TELEPHONY_SUCCESS);
761 ASSERT_NE(callControlManager->SeparateConference(INVALID_CALLID), TELEPHONY_SUCCESS);
762 ASSERT_NE(callControlManager->KickOutFromConference(INVALID_CALLID), TELEPHONY_SUCCESS);
763 int32_t mainCallId = VALID_CALLID;
764 ASSERT_NE(callControlManager->GetMainCallId(INVALID_CALLID, mainCallId), TELEPHONY_SUCCESS);
765 std::vector<std::u16string> callIdList;
766 ASSERT_NE(callControlManager->GetSubCallIdList(INVALID_CALLID, callIdList), TELEPHONY_SUCCESS);
767 ASSERT_NE(callControlManager->GetCallIdListForConference(INVALID_CALLID, callIdList), TELEPHONY_SUCCESS);
768 ImsConfigItem item = ITEM_VIDEO_QUALITY;
769 ASSERT_NE(callControlManager->GetImsConfig(INVALID_CALLID, item), TELEPHONY_SUCCESS);
770 ASSERT_NE(callControlManager->GetImsConfig(slotId, item), TELEPHONY_SUCCESS);
771 std::u16string value = u"";
772 ASSERT_NE(callControlManager->SetImsConfig(INVALID_CALLID, item, value), TELEPHONY_SUCCESS);
773 ASSERT_NE(callControlManager->SetImsConfig(slotId, item, value), TELEPHONY_SUCCESS);
774 FeatureType featureType = TYPE_VOICE_OVER_LTE;
775 ASSERT_NE(callControlManager->GetImsFeatureValue(INVALID_CALLID, featureType), TELEPHONY_SUCCESS);
776 ASSERT_NE(callControlManager->GetImsFeatureValue(slotId, featureType), TELEPHONY_SUCCESS);
777 ASSERT_NE(callControlManager->SetImsFeatureValue(INVALID_CALLID, featureType, mode), TELEPHONY_SUCCESS);
778 ASSERT_NE(callControlManager->SetImsFeatureValue(slotId, featureType, mode), TELEPHONY_SUCCESS);
779 ASSERT_NE(callControlManager->DisableImsSwitch(INVALID_CALLID), TELEPHONY_SUCCESS);
780 ASSERT_NE(callControlManager->DisableImsSwitch(slotId), TELEPHONY_SUCCESS);
781 }
782
783 /**
784 * @tc.number Telephony_CallControlManager_003
785 * @tc.name test error branch
786 * @tc.desc Function test
787 */
788 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_003, Function | MediumTest | Level3)
789 {
790 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
791 callControlManager->UnInit();
792 callControlManager->CallStateObserve();
793 callControlManager->Init();
794 callControlManager->CallStateObserve();
795 ASSERT_NE(callControlManager->GetCallWaiting(INVALID_CALLID), TELEPHONY_SUCCESS);
796 ASSERT_NE(callControlManager->GetCallWaiting(SIM1_SLOTID), TELEPHONY_SUCCESS);
797 ASSERT_NE(callControlManager->SetCallWaiting(INVALID_CALLID, true), TELEPHONY_SUCCESS);
798 ASSERT_NE(callControlManager->SetCallWaiting(SIM1_SLOTID, true), TELEPHONY_SUCCESS);
799 CallRestrictionType callRestrictionType = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING;
800 ASSERT_NE(callControlManager->GetCallRestriction(INVALID_CALLID, callRestrictionType), TELEPHONY_SUCCESS);
801 ASSERT_NE(callControlManager->GetCallRestriction(SIM1_SLOTID, callRestrictionType), TELEPHONY_SUCCESS);
802 CallRestrictionInfo callRestrictionInfo;
803 ASSERT_NE(callControlManager->SetCallRestriction(INVALID_CALLID, callRestrictionInfo), TELEPHONY_SUCCESS);
804 ASSERT_NE(callControlManager->SetCallRestriction(SIM1_SLOTID, callRestrictionInfo), TELEPHONY_SUCCESS);
805 CallTransferType callTransferType = CallTransferType::TRANSFER_TYPE_BUSY;
806 ASSERT_NE(callControlManager->GetCallTransferInfo(INVALID_CALLID, callTransferType), TELEPHONY_SUCCESS);
807 ASSERT_NE(callControlManager->GetCallTransferInfo(SIM1_SLOTID, callTransferType), TELEPHONY_SUCCESS);
808 CallTransferInfo callTransferInfo;
809 ASSERT_NE(callControlManager->SetCallTransferInfo(INVALID_CALLID, callTransferInfo), TELEPHONY_SUCCESS);
810 ASSERT_NE(callControlManager->SetCallTransferInfo(SIM1_SLOTID, callTransferInfo), TELEPHONY_SUCCESS);
811 bool result = true;
812 ASSERT_NE(callControlManager->CanSetCallTransferTime(INVALID_CALLID, result), TELEPHONY_SUCCESS);
813 ASSERT_NE(callControlManager->CanSetCallTransferTime(SIM1_SLOTID, result), TELEPHONY_SUCCESS);
814 int32_t mode = 1;
815 ASSERT_NE(callControlManager->SetCallPreferenceMode(INVALID_CALLID, mode), TELEPHONY_SUCCESS);
816 ASSERT_NE(callControlManager->SetCallPreferenceMode(SIM1_SLOTID, mode), TELEPHONY_SUCCESS);
817 ImsConfigItem item = ITEM_VIDEO_QUALITY;
818 ASSERT_NE(callControlManager->GetImsConfig(INVALID_CALLID, item), TELEPHONY_SUCCESS);
819 ASSERT_NE(callControlManager->GetImsConfig(SIM1_SLOTID, item), TELEPHONY_SUCCESS);
820 std::u16string value = u"";
821 ASSERT_NE(callControlManager->SetImsConfig(INVALID_CALLID, item, value), TELEPHONY_SUCCESS);
822 ASSERT_NE(callControlManager->SetImsConfig(SIM1_SLOTID, item, value), TELEPHONY_SUCCESS);
823 FeatureType featureType = TYPE_VOICE_OVER_LTE;
824 ASSERT_NE(callControlManager->GetImsFeatureValue(INVALID_CALLID, featureType), TELEPHONY_SUCCESS);
825 ASSERT_NE(callControlManager->GetImsFeatureValue(SIM1_SLOTID, featureType), TELEPHONY_SUCCESS);
826 ASSERT_NE(callControlManager->SetImsFeatureValue(INVALID_CALLID, featureType, mode), TELEPHONY_SUCCESS);
827 ASSERT_NE(callControlManager->SetImsFeatureValue(SIM1_SLOTID, featureType, mode), TELEPHONY_SUCCESS);
828 ASSERT_NE(callControlManager->DisableImsSwitch(INVALID_CALLID), TELEPHONY_SUCCESS);
829 ASSERT_NE(callControlManager->DisableImsSwitch(SIM1_SLOTID), TELEPHONY_SUCCESS);
830 bool enaled = false;
831 ASSERT_NE(callControlManager->IsImsSwitchEnabled(INVALID_CALLID, enaled), TELEPHONY_SUCCESS);
832 ASSERT_NE(callControlManager->IsImsSwitchEnabled(SIM1_SLOTID, enaled), TELEPHONY_SUCCESS);
833 std::vector<std::u16string> numberList = { u"123", u"124" };
834 ASSERT_NE(callControlManager->JoinConference(INVALID_CALLID, numberList), TELEPHONY_SUCCESS);
835 ASSERT_NE(callControlManager->JoinConference(SIM1_SLOTID, numberList), TELEPHONY_SUCCESS);
836 }
837
838 /**
839 * @tc.number Telephony_CallControlManager_004
840 * @tc.name test error branch
841 * @tc.desc Function test
842 */
843 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_004, Function | MediumTest | Level3)
844 {
845 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
846 std::vector<std::u16string> numberList = { u"123", u"124" };
847 ASSERT_NE(callControlManager->JoinConference(INVALID_CALLID, numberList), TELEPHONY_SUCCESS);
848 ASSERT_NE(callControlManager->JoinConference(SIM1_SLOTID, numberList), TELEPHONY_SUCCESS);
849 ImsCallMode mode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
850 ASSERT_EQ(callControlManager->UpdateImsCallMode(INVALID_CALLID, mode), TELEPHONY_SUCCESS);
851 std::u16string str = u"";
852 ASSERT_NE(callControlManager->StartRtt(INVALID_CALLID, str), TELEPHONY_SUCCESS);
853 AudioDevice audioDevice = {
854 .deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO,
855 .address = { 0 },
856 };
857 callControlManager->SetAudioDevice(audioDevice);
858 audioDevice.deviceType = AudioDeviceType::DEVICE_SPEAKER;
859 callControlManager->SetAudioDevice(audioDevice);
860 bool enabled = false;
861 callControlManager->IsEmergencyPhoneNumber(str, SIM1_SLOTID, enabled);
862 callControlManager->IsEmergencyPhoneNumber(str, INVALID_SLOTID, enabled);
863 std::string number = "";
864 callControlManager->NumberLegalityCheck(number);
865 number = LONG_STR;
866 callControlManager->NumberLegalityCheck(number);
867 number = "1234567";
868 callControlManager->NumberLegalityCheck(number);
869 std::shared_ptr<CallBroadcastSubscriber> subscriberPtr = nullptr;
870 CallControlManager::SystemAbilityListener listen;
871 int32_t systemAbilityId = 1;
872 std::string deviceId = "123";
873 listen.OnAddSystemAbility(systemAbilityId, deviceId);
874 listen.OnRemoveSystemAbility(systemAbilityId, deviceId);
875 listen.OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
876 listen.OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
877 EventFwk::MatchingSkills matchingSkills;
878 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_STATE_CHANGED);
879 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
880 subscriberPtr = std::make_shared<CallBroadcastSubscriber>(subscriberInfo);
881 listen.OnAddSystemAbility(systemAbilityId, deviceId);
882 listen.OnRemoveSystemAbility(systemAbilityId, deviceId);
883 listen.OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
884 listen.OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
885 ASSERT_NE(callControlManager->StopRtt(INVALID_CALLID), TELEPHONY_SUCCESS);
886 ASSERT_NE(callControlManager->SetMuted(false), TELEPHONY_SUCCESS);
887 ASSERT_EQ(callControlManager->MuteRinger(), TELEPHONY_SUCCESS);
888 bool enaled = false;
889 int32_t slotId = 1;
890 ASSERT_NE(callControlManager->IsImsSwitchEnabled(INVALID_CALLID, enaled), TELEPHONY_SUCCESS);
891 ASSERT_NE(callControlManager->IsImsSwitchEnabled(slotId, enaled), TELEPHONY_SUCCESS);
892 }
893
894 /**
895 * @tc.number Telephony_CallControlManager_005
896 * @tc.name test error branch
897 * @tc.desc Function test
898 */
899 HWTEST_F(ZeroBranch4Test, Telephony_CallControlManager_005, Function | MediumTest | Level3)
900 {
901 std::shared_ptr<CallControlManager> callControlManager = std::make_shared<CallControlManager>();
902 std::u16string number = u"";
903 AppExecFwk::PacMap extras;
904 bool isEcc = false;
905 callControlManager->CanDial(number, extras, isEcc);
906 std::string accountNumber = "1234567";
907 callControlManager->PackageDialInformation(extras, accountNumber, isEcc);
908 int32_t videoState = 0;
909 callControlManager->CurrentIsSuperPrivacyMode(VALID_CALLID, videoState);
910 sptr<CallBase> callObjectPtr = nullptr;
911 callControlManager->AnswerHandlerForSatelliteOrVideoCall(callObjectPtr, videoState);
912 DialParaInfo dialParaInfo;
913 callObjectPtr = new CSCall(dialParaInfo);
914 callControlManager->AnswerHandlerForSatelliteOrVideoCall(callObjectPtr, videoState);
915 TelCallState callState = TelCallState::CALL_STATUS_ACTIVE;
916 callControlManager->CarrierAndVoipConflictProcess(VALID_CALLID, callState);
917 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
918 int32_t slotId = 1;
919 const char oldPassword[kMaxNumberLen + 1] = "1111";
920 const char newPassword[kMaxNumberLen + 1] = "2222";
921 callControlManager->SetCallRestrictionPassword(slotId, fac, oldPassword, newPassword);
922 callControlManager->SeparateConference(VALID_CALLID);
923 callControlManager->KickOutFromConference(VALID_CALLID);
924 callControlManager->EnableImsSwitch(slotId);
925 int32_t state = 0;
926 callControlManager->SetVoNRState(slotId, state);
927 callControlManager->GetVoNRState(slotId, state);
928 callControlManager->IsEmergencyPhoneNumber(number, slotId, isEcc);
929 callControlManager->CloseUnFinishedUssd(slotId);
930 sptr<CallBase> callObjectPtr1 = nullptr;
931 callControlManager->AddBlockLogAndNotification(callObjectPtr1);
932 callControlManager->AddBlockLogAndNotification(callObjectPtr);
933 callControlManager->HangUpVoipCall();
934 callControlManager->SetVoIPCallState(3);
935 callControlManager->SetVoIPCallState(2);
936 callControlManager->DisconnectAllCalls();
937 ASSERT_EQ(callControlManager->SetVoIPCallState(0), TELEPHONY_SUCCESS);
938 }
939
940 /**
941 * @tc.number Telephony_CallStatusManager_001
942 * @tc.name test error branch
943 * @tc.desc Function test
944 */
945 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_001, Function | MediumTest | Level3)
946 {
947 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
948 CallDetailInfo info;
949 std::string number = "123";
950 memcpy_s(&info.phoneNum, kMaxNumberLen, number.c_str(), number.length());
951 info.state = TelCallState::CALL_STATUS_ACTIVE;
952 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
953 info.state = TelCallState::CALL_STATUS_HOLDING;
954 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
955 info.state = TelCallState::CALL_STATUS_DIALING;
956 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
957 info.state = TelCallState::CALL_STATUS_ALERTING;
958 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
959 info.state = TelCallState::CALL_STATUS_INCOMING;
960 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
961 info.state = TelCallState::CALL_STATUS_WAITING;
962 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
963 info.state = TelCallState::CALL_STATUS_DISCONNECTED;
964 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
965 info.state = TelCallState::CALL_STATUS_DISCONNECTING;
966 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
967 info.state = TelCallState::CALL_STATUS_UNKNOWN;
968 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
969 DisconnectedDetails details;
970 ASSERT_GT(callStatusManager->HandleDisconnectedCause(details), TELEPHONY_ERROR);
971 CellularCallEventInfo cellularCallEventInfo;
972 cellularCallEventInfo.eventType = static_cast<CellularCallEventType>(1);
973 ASSERT_GT(callStatusManager->HandleEventResultReportInfo(cellularCallEventInfo), TELEPHONY_ERROR);
974 cellularCallEventInfo.eventType = CellularCallEventType::EVENT_REQUEST_RESULT_TYPE;
975 cellularCallEventInfo.eventId = RequestResultEventId::RESULT_DIAL_NO_CARRIER;
976 ASSERT_GT(callStatusManager->HandleEventResultReportInfo(cellularCallEventInfo), TELEPHONY_ERROR);
977 OttCallEventInfo ottCallEventInfo;
978 (void)memset_s(&ottCallEventInfo, sizeof(OttCallEventInfo), 0, sizeof(OttCallEventInfo));
979 ottCallEventInfo.ottCallEventId = OttCallEventId::OTT_CALL_EVENT_FUNCTION_UNSUPPORTED;
980 (void)memcpy_s(ottCallEventInfo.bundleName, kMaxBundleNameLen + 1, LONG_STR, strlen(LONG_STR));
981 ASSERT_GT(callStatusManager->HandleOttEventReportInfo(ottCallEventInfo), TELEPHONY_ERROR);
982 (void)memset_s(&ottCallEventInfo, sizeof(OttCallEventInfo), 0, sizeof(OttCallEventInfo));
983 ottCallEventInfo.ottCallEventId = OttCallEventId::OTT_CALL_EVENT_FUNCTION_UNSUPPORTED;
984 (void)memcpy_s(ottCallEventInfo.bundleName, kMaxBundleNameLen + 1, TEST_STR, strlen(TEST_STR));
985 ASSERT_GT(callStatusManager->HandleOttEventReportInfo(ottCallEventInfo), TELEPHONY_ERROR);
986 info.voipCallInfo.voipCallId = "123456789";
987 info.callType = CallType::TYPE_VOIP;
988 info.state = TelCallState::CALL_STATUS_INCOMING;
989 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
990 info.state = TelCallState::CALL_STATUS_ACTIVE;
991 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
992 info.state = TelCallState::CALL_STATUS_DISCONNECTED;
993 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
994 }
995
996 /**
997 * @tc.number Telephony_CallStatusManager_002
998 * @tc.name test error branch
999 * @tc.desc Function test
1000 */
1001 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_002, Function | MediumTest | Level3)
1002 {
1003 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1004 CallDetailInfo callDetailInfo;
1005 std::string number = "";
1006 memcpy_s(&callDetailInfo.phoneNum, kMaxNumberLen, number.c_str(), number.length());
1007 callDetailInfo.state = TelCallState::CALL_STATUS_INCOMING;
1008 callDetailInfo.callType = CallType::TYPE_CS;
1009 ASSERT_GT(callStatusManager->IncomingHandle(callDetailInfo), TELEPHONY_ERROR);
1010 ASSERT_GT(callStatusManager->IncomingVoipCallHandle(callDetailInfo), TELEPHONY_ERROR);
1011 callDetailInfo.state = TelCallState::CALL_STATUS_ACTIVE;
1012 ASSERT_GT(callStatusManager->IncomingHandle(callDetailInfo), TELEPHONY_ERROR);
1013 ASSERT_GT(callStatusManager->IncomingVoipCallHandle(callDetailInfo), TELEPHONY_ERROR);
1014 ASSERT_GT(callStatusManager->IncomingFilterPolicy(callDetailInfo), TELEPHONY_ERROR);
1015 sptr<CallBase> callObjectPtr = nullptr;
1016 TelCallState nextState = TelCallState::CALL_STATUS_ACTIVE;
1017 ASSERT_GT(callStatusManager->UpdateCallState(callObjectPtr, nextState), TELEPHONY_ERROR);
1018 ASSERT_GT(callStatusManager->ToSpeakerPhone(callObjectPtr), TELEPHONY_ERROR);
1019 DialParaInfo dialParaInfo;
1020 dialParaInfo.callType = CallType::TYPE_CS;
1021 dialParaInfo.callState = TelCallState::CALL_STATUS_INCOMING;
1022 callObjectPtr = new CSCall(dialParaInfo);
1023 ASSERT_GT(callStatusManager->UpdateCallState(callObjectPtr, nextState), TELEPHONY_ERROR);
1024 nextState = TelCallState::CALL_STATUS_INCOMING;
1025 ASSERT_GT(callStatusManager->UpdateCallState(callObjectPtr, nextState), TELEPHONY_ERROR);
1026 callStatusManager->RefreshCallIfNecessary(callObjectPtr, callDetailInfo);
1027 ASSERT_GT(callStatusManager->ToSpeakerPhone(callObjectPtr), TELEPHONY_ERROR);
1028 callObjectPtr->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
1029 ASSERT_GT(callStatusManager->ToSpeakerPhone(callObjectPtr), TELEPHONY_ERROR);
1030 ASSERT_GT(callStatusManager->TurnOffMute(callObjectPtr), TELEPHONY_ERROR);
1031 callObjectPtr->SetTelCallState(TelCallState::CALL_STATUS_ALERTING);
1032 callStatusManager->SetOriginalCallTypeForActiveState(callObjectPtr);
1033 callStatusManager->SetOriginalCallTypeForDisconnectState(callObjectPtr);
1034 callObjectPtr->SetTelCallState(TelCallState::CALL_STATUS_ACTIVE);
1035 callStatusManager->SetOriginalCallTypeForActiveState(callObjectPtr);
1036 int32_t activeCallNum = 0;
1037 int32_t waitingCallNum = 0;
1038 int32_t slotId = 0;
1039 callStatusManager->AutoAnswer(activeCallNum, waitingCallNum);
1040 bool canSwitchCallState = 1;
1041 TelCallState priorState = TelCallState::CALL_STATUS_DISCONNECTING;
1042 callStatusManager->AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, slotId, true);
1043 callStatusManager->AutoUnHoldForDsda(canSwitchCallState, priorState, activeCallNum, slotId);
1044 callStatusManager->AutoAnswerForVideoCall(activeCallNum);
1045 }
1046
1047 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_003, Function | MediumTest | Level3)
1048 {
1049 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1050 // scene-0: null input
1051 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(nullptr), false);
1052
1053 // init
1054 const std::string phoneNumber = "12345678911";
1055 time_t oldCallCreateTime = time(nullptr);
1056 if (oldCallCreateTime < 0) {
1057 oldCallCreateTime = 0;
1058 }
1059 int32_t incomingMaxDuration = 10 * 1000;
1060
1061 //old call
1062 DialParaInfo dialParaInfoOld;
1063 sptr<OHOS::Telephony::CallBase> oldCall = new BluetoothCall(dialParaInfoOld, "");
1064 oldCall->SetAccountNumber(phoneNumber);
1065 oldCall->SetCallId(1);
1066 oldCall->SetCallCreateTime(oldCallCreateTime);
1067 oldCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1068 oldCall->SetCallType(CallType::TYPE_BLUETOOTH);
1069 //new call
1070 DialParaInfo dialParaInfoNew;
1071 sptr<OHOS::Telephony::CallBase> newCall = new IMSCall(dialParaInfoNew);
1072 newCall->SetAccountNumber(phoneNumber);
1073 newCall->SetCallId(2);
1074 newCall->SetCallCreateTime(oldCallCreateTime + incomingMaxDuration - 1000);
1075 newCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1076 newCall->SetCallType(CallType::TYPE_IMS);
1077
1078 // scene-1: do not exist old call with the same phone number
1079 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(newCall), false);
1080 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1081
1082 // scene-2: invalid diff-CallID
1083 callStatusManager->AddOneCallObject(oldCall);
1084 newCall->SetCallId(9);
1085 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(newCall), false);
1086 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1087 }
1088
1089 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_004, Function | MediumTest | Level3)
1090 {
1091 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1092
1093 // init
1094 const std::string phoneNumber = "12345678911";
1095 time_t oldCallCreateTime = time(nullptr);
1096 if (oldCallCreateTime < 0) {
1097 oldCallCreateTime = 0;
1098 }
1099 int32_t incomingMaxDuration = 10 * 1000;
1100
1101 //old call
1102 DialParaInfo dialParaInfoOld;
1103 sptr<OHOS::Telephony::CallBase> oldCall = new BluetoothCall(dialParaInfoOld, "");
1104 oldCall->SetAccountNumber(phoneNumber);
1105 oldCall->SetCallId(1);
1106 oldCall->SetCallCreateTime(oldCallCreateTime);
1107 oldCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1108 oldCall->SetCallType(CallType::TYPE_BLUETOOTH);
1109 //new call
1110 DialParaInfo dialParaInfoNew;
1111 sptr<OHOS::Telephony::CallBase> newCall = new IMSCall(dialParaInfoNew);
1112 newCall->SetAccountNumber(phoneNumber);
1113 newCall->SetCallId(2);
1114 newCall->SetCallCreateTime(oldCallCreateTime + incomingMaxDuration + 1000);
1115 newCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1116 newCall->SetCallType(CallType::TYPE_IMS);
1117
1118 // scene-3: invalid diff-CreateTime
1119 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(newCall), false);
1120 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1121
1122 // scene-4: invalid old call status
1123 callStatusManager->DeleteOneCallObject(oldCall->GetCallID());
1124 oldCall->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
1125 callStatusManager->AddOneCallObject(oldCall);
1126 newCall->SetCallCreateTime(oldCallCreateTime + incomingMaxDuration - 1000);
1127 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(newCall), false);
1128 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1129 }
1130
1131 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_005, Function | MediumTest | Level3)
1132 {
1133 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1134
1135 // init
1136 const std::string phoneNumber = "12345678911";
1137 time_t oldCallCreateTime = time(nullptr);
1138 if (oldCallCreateTime < 0) {
1139 oldCallCreateTime = 0;
1140 }
1141 int32_t incomingMaxDuration = 10 * 1000;
1142
1143 // old call
1144 DialParaInfo dialParaInfoOld;
1145 sptr<OHOS::Telephony::CallBase> oldCall = new BluetoothCall(dialParaInfoOld, "");
1146 oldCall->SetAccountNumber(phoneNumber);
1147 oldCall->SetCallId(1);
1148 oldCall->SetCallCreateTime(oldCallCreateTime);
1149 oldCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1150 oldCall->SetCallType(CallType::TYPE_BLUETOOTH);
1151 // new call
1152 DialParaInfo dialParaInfoNew;
1153 sptr<OHOS::Telephony::CallBase> newCall = new IMSCall(dialParaInfoNew);
1154 newCall->SetAccountNumber(phoneNumber);
1155 newCall->SetCallId(2);
1156 newCall->SetCallCreateTime(oldCallCreateTime + incomingMaxDuration - 1000);
1157 newCall->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1158 newCall->SetCallType(CallType::TYPE_IMS);
1159 // scene-5: invalid call type
1160 callStatusManager->AddOneCallObject(oldCall);
1161 newCall->SetCallType(CallType::TYPE_CS);
1162 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(newCall), true);
1163 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1164 // scene-6: valid on-number-dual-call scene
1165 newCall->SetCallType(CallType::TYPE_IMS);
1166 ASSERT_EQ(callStatusManager->IsFromTheSameNumberAtTheSameTime(newCall), true);
1167 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1168 }
1169
1170 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_006, Function | MediumTest | Level3)
1171 {
1172 std::shared_ptr<DataShare::DataShareHelper> dataShareHelper =
1173 CreateDataShareHelper(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
1174 if (dataShareHelper != nullptr) {
1175 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1176 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1177
1178 OHOS::Uri uri("datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true");
1179 DataShare::DataShareValueObject keyObj("key_esim_card_type");
1180 DataShare::DataShareValueObject valueObj("2");
1181 DataShare::DataShareValuesBucket bucket;
1182 bucket.Put("KEYWORD", keyObj);
1183 bucket.Put("VALUE", valueObj);
1184 dataShareHelper->Insert(uri, bucket);
1185 dataShareHelper->Release();
1186 ASSERT_NO_THROW(callStatusManager->ModifyEsimType());
1187 }
1188 }
1189
1190 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_007, Function | MediumTest | Level3)
1191 {
1192 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1193 CallDetailInfo info;
1194 std::string number = "123456789";
1195 memcpy_s(&info.phoneNum, kMaxNumberLen, number.c_str(), number.length());
1196 info.voipCallInfo.voipCallId = "123456789";
1197 info.callType = CallType::TYPE_VOIP;
1198 info.state = TelCallState::CALL_STATUS_INCOMING;
1199 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1200 info.callType = CallType::TYPE_BLUETOOTH;
1201 info.index = 1;
1202 info.state = TelCallState::CALL_STATUS_INCOMING;
1203 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1204 info.state = TelCallState::CALL_STATUS_ACTIVE;
1205 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1206 info.state = TelCallState::CALL_STATUS_WAITING;
1207 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1208 info.state = TelCallState::CALL_STATUS_DISCONNECTED;
1209 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1210 info.state = TelCallState::CALL_STATUS_DIALING;
1211 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1212 info.state = TelCallState::CALL_STATUS_ALERTING;
1213 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1214 callStatusManager->HandleConnectingCallReportInfo(info);
1215 info.index = 0;
1216 ASSERT_GT(callStatusManager->HandleCallReportInfo(info), TELEPHONY_ERROR);
1217 sptr<CallBase> call = callStatusManager->GetOneCallObjectByVoipCallId(
1218 info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
1219 ASSERT_TRUE(call != nullptr);
1220 EXPECT_EQ(callStatusManager->AnsweredVoipCallHandle(info), TELEPHONY_ERROR);
1221 EXPECT_GT(callStatusManager->DisconnectingVoipCallHandle(info), TELEPHONY_ERROR);
1222 callStatusManager->DeleteOneCallObject(call);
1223 EXPECT_EQ(callStatusManager->AnsweredVoipCallHandle(info), TELEPHONY_ERROR);
1224 EXPECT_EQ(callStatusManager->DisconnectingVoipCallHandle(info), TELEPHONY_ERROR);
1225 EXPECT_FALSE(callStatusManager->IsContactPhoneNum(number));
1226 EXPECT_FALSE(callStatusManager->IsDistributeCallSourceStatus());
1227 EXPECT_GT(callStatusManager->UpdateCallStateAndHandleDsdsMode(info, call), TELEPHONY_ERROR);
1228 EXPECT_FALSE(callStatusManager->ShouldBlockIncomingCall(call, info));
1229 call = nullptr;
1230 EXPECT_EQ(callStatusManager->UpdateCallStateAndHandleDsdsMode(info, call), TELEPHONY_ERR_LOCAL_PTR_NULL);
1231 EXPECT_EQ(callStatusManager->HandleCallReportInfoEx(info), TELEPHONY_ERR_FAIL);
1232 VoipCallEventInfo voipCallInfo;
1233 callStatusManager->BtCallDialingHandleFirst(nullptr, info);
1234 std::vector<sptr<CallBase>> conferenceCallList;
1235 callStatusManager->SetConferenceCall(conferenceCallList);
1236 EXPECT_GT(callStatusManager->HandleVoipEventReportInfo(voipCallInfo), TELEPHONY_ERROR);
1237 }
1238
1239 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_008, Function | MediumTest | Level3)
1240 {
1241 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1242 CallDetailsInfo infos;
1243 infos.slotId = -1;
1244 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), CALL_ERR_INVALID_SLOT_ID);
1245 infos.slotId = 0;
1246 CallDetailInfo info;
1247 infos.callVec.push_back(info);
1248 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1249 callStatusManager->callDetailsInfo_[0].callVec.push_back(info);
1250 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1251 auto &info0 = infos.callVec[0];
1252 info0.state = TelCallState::CALL_STATUS_ACTIVE;
1253 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1254 info0.state = TelCallState::CALL_STATUS_UNKNOWN;
1255 info0.mpty = 1;
1256 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1257 info0.mpty = 0;
1258 info0.callType = CallType::TYPE_CS;
1259 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1260 info0.callType = CallType::TYPE_ERR_CALL;
1261 info0.callMode = VideoStateType::TYPE_VIDEO;
1262 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1263 info0.callMode = VideoStateType::TYPE_VOICE;
1264 info0.state = TelCallState::CALL_STATUS_ALERTING;
1265 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1266 auto &info1 = callStatusManager->callDetailsInfo_[0].callVec[0];
1267 info1.index = 1;
1268 EXPECT_EQ(callStatusManager->HandleCallsReportInfo(infos), TELEPHONY_SUCCESS);
1269 info.state = TelCallState::CALL_STATUS_DIALING;
1270 EXPECT_GT(callStatusManager->HandleVoipCallReportInfo(info), TELEPHONY_ERROR);
1271 info.state = TelCallState::CALL_STATUS_ANSWERED;
1272 EXPECT_EQ(callStatusManager->HandleVoipCallReportInfo(info), TELEPHONY_ERROR);
1273 info.state = TelCallState::CALL_STATUS_DISCONNECTING;
1274 EXPECT_EQ(callStatusManager->HandleVoipCallReportInfo(info), TELEPHONY_ERROR);
1275 }
1276
1277 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_009, Function | MediumTest | Level3)
1278 {
1279 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1280 CallObjectManager::callObjectPtrList_.clear();
1281 ContactInfo contactInfo;
1282 callStatusManager->QueryCallerInfo(contactInfo, "110");
1283 VoipCallEventInfo voipCallEventInfo;
1284 EXPECT_EQ(callStatusManager->HandleVoipEventReportInfo(voipCallEventInfo), TELEPHONY_ERR_LOCAL_PTR_NULL);
1285 CallDetailInfo info;
1286 callStatusManager->CallFilterCompleteResult(info);
1287 EXPECT_EQ(callStatusManager->UpdateDialingCallInfo(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1288 EXPECT_EQ(callStatusManager->IncomingVoipCallHandle(info), CALL_ERR_CALL_OBJECT_IS_NULL);
1289 EXPECT_EQ(callStatusManager->OutgoingVoipCallHandle(info), CALL_ERR_CALL_OBJECT_IS_NULL);
1290 bool isDistributedDeviceDialing = false;
1291 EXPECT_FALSE(callStatusManager->UpdateDialingHandle(info, isDistributedDeviceDialing));
1292 EXPECT_EQ(callStatusManager->ActiveHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1293 EXPECT_EQ(callStatusManager->ActiveVoipCallHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1294 EXPECT_EQ(callStatusManager->HoldingHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1295 EXPECT_EQ(callStatusManager->AlertHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1296 EXPECT_EQ(callStatusManager->DisconnectedVoipCallHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1297
1298 info.state = TelCallState::CALL_STATUS_ACTIVE;
1299 info.callType = CallType::TYPE_VOIP;
1300 sptr<CallBase> voipCall = callStatusManager->CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
1301 ASSERT_TRUE(voipCall != nullptr);
1302 callStatusManager->antiFraudSlotId_ = 0;
1303 callStatusManager->antiFraudIndex_ = 0;
1304 CallObjectManager::AddOneCallObject(voipCall);
1305 callStatusManager->SetupAntiFraudService(voipCall, info);
1306 callStatusManager->SetConferenceCall({voipCall});
1307 EXPECT_EQ(CallObjectManager::callObjectPtrList_.size(), 1);
1308 }
1309
1310 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_010, Function | MediumTest | Level3)
1311 {
1312 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1313 CallObjectManager::callObjectPtrList_.clear();
1314 CallDetailInfo info;
1315 info.state = TelCallState::CALL_STATUS_ACTIVE;
1316 info.callType = CallType::TYPE_SATELLITE;
1317 sptr<CallBase> satelliteCall = callStatusManager->CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
1318 ASSERT_TRUE(satelliteCall != nullptr);
1319 CallObjectManager::AddOneCallObject(satelliteCall);
1320 EXPECT_EQ(CallObjectManager::callObjectPtrList_.size(), 1);
1321 EXPECT_EQ(callStatusManager->UpdateDialingCallInfo(info), TELEPHONY_SUCCESS);
1322 EXPECT_NE(callStatusManager->HoldingHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1323 EXPECT_NE(callStatusManager->DisconnectingHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1324 EXPECT_NE(callStatusManager->DialingHandle(info), TELEPHONY_ERR_LOCAL_PTR_NULL);
1325 }
1326
1327 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_011, Function | MediumTest | Level3)
1328 {
1329 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1330 CallDetailInfo info;
1331 callStatusManager->callDetailsInfo_[0].callVec.push_back(info);
1332 callStatusManager->antiFraudSlotId_ = 0;
1333 callStatusManager->TriggerAntiFraud(static_cast<int32_t>(AntiFraudState::ANTIFRAUD_STATE_DEFAULT));
1334 callStatusManager->antiFraudIndex_ = -1;
1335 callStatusManager->antiFraudSlotId_ = 0;
1336 callStatusManager->TriggerAntiFraud(static_cast<int32_t>(AntiFraudState::ANTIFRAUD_STATE_RISK));
1337 EXPECT_EQ(callStatusManager->antiFraudSlotId_, -1);
1338 callStatusManager->antiFraudSlotId_ = 0;
1339 callStatusManager->TriggerAntiFraud(static_cast<int32_t>(AntiFraudState::ANTIFRAUD_STATE_FINISHED));
1340 EXPECT_EQ(callStatusManager->antiFraudSlotId_, -1);
1341 sleep(WAIT_TIME);
1342 }
1343
1344 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_013, Function | MediumTest | Level3)
1345 {
1346 std::shared_ptr<CallStatusManager> callStatusManager = std::make_shared<CallStatusManager>();
1347 CallDetailInfo info;
1348 bool isExistedOldCall = false;
1349 CallObjectManager::callObjectPtrList_.clear();
1350 EXPECT_EQ(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_SUCCESS);
1351 info.state = TelCallState::CALL_STATUS_ACTIVE;
1352 info.callType = CallType::TYPE_IMS;
1353 info.callMode = VideoStateType::TYPE_VOICE;
1354 callStatusManager->tmpCallDetailsInfo_[0].callVec.push_back(info);
1355 EXPECT_TRUE(callStatusManager->GetConferenceCallList(0).empty());
1356 auto &tmpInfo = callStatusManager->tmpCallDetailsInfo_[0].callVec[0];
1357 tmpInfo.mpty = 1;
1358 EXPECT_TRUE(callStatusManager->GetConferenceCallList(0).empty());
1359 sptr<CallBase> call = callStatusManager->CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
1360 ASSERT_TRUE(call != nullptr);
1361 DialParaInfo paraInfo;
1362 AppExecFwk::PacMap extras;
1363 EXPECT_TRUE(callStatusManager->CreateNewCallByCallTypeEx(paraInfo, info, CallDirection::CALL_DIRECTION_IN,
1364 extras) == nullptr);
1365 CallObjectManager::AddOneCallObject(call);
1366 callStatusManager->StartInComingCallMotionRecognition();
1367 EXPECT_FALSE(callStatusManager->GetConferenceCallList(0).empty());
1368 callStatusManager->StopCallMotionRecognition(TelCallState::CALL_STATUS_DISCONNECTED);
1369 EXPECT_GT(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_ERROR);
1370 info.callType = CallType::TYPE_CS;
1371 EXPECT_GT(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_ERROR);
1372 info.state = TelCallState::CALL_STATUS_HOLDING;
1373 EXPECT_GT(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_ERROR);
1374 info.callMode = VideoStateType::TYPE_VIDEO;
1375 EXPECT_GT(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_ERROR);
1376 info.callType = CallType::TYPE_IMS;
1377 info.state = TelCallState::CALL_STATUS_ACTIVE;
1378 EXPECT_GT(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_ERROR);
1379 info.callType = CallType::TYPE_CS;
1380 info.callMode = VideoStateType::TYPE_VOICE;
1381 EXPECT_GT(callStatusManager->RefreshOldCall(info, isExistedOldCall), TELEPHONY_ERROR);
1382 call->SetCallRunningState(CallRunningState::CALL_RUNNING_STATE_HOLD);
1383 callStatusManager->StartInComingCallMotionRecognition();
1384 callStatusManager->BtCallDialingHandleFirst(call, info);
1385 info.state = TelCallState::CALL_STATUS_ALERTING;
1386 callStatusManager->BtCallDialingHandleFirst(call, info);
1387 call->SetTelCallState(TelCallState::CALL_STATUS_ALERTING);
1388 callStatusManager->BtCallDialingHandleFirst(call, info);
1389 EXPECT_EQ(call->GetTelCallState(), TelCallState::CALL_STATUS_DIALING);
1390 callStatusManager->BtCallDialingHandle(call, info);
1391 EXPECT_EQ(call->phoneOrWatch_, static_cast<int32_t>(PhoneOrWatchDial::WATCH_DIAL));
1392 }
1393
1394 HWTEST_F(ZeroBranch4Test, Telephony_CallStatusManager_014, Function | MediumTest | Level3)
1395 {
1396 std::shared_ptr<CallStatusManager> manager = std::make_shared<CallStatusManager>();
1397 CallDetailInfo info;
1398 info.state = TelCallState::CALL_STATUS_ACTIVE;
1399 info.callType = CallType::TYPE_IMS;
1400 sptr<CallBase> call = manager->CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
1401 ASSERT_TRUE(call != nullptr);
1402 manager->antiFraudSlotId_ = 0;
1403 manager->antiFraudIndex_ = 0;
1404 call->SetSlotId(1);
1405 manager->StopAntiFraudDetect(call, info);
1406 manager->HandleCeliaCall(call);
1407 info.index = 1;
1408 call->SetCallIndex(1);
1409 manager->StopAntiFraudDetect(call, info);
1410 manager->HandleCeliaCall(call);
1411 call->SetSlotId(0);
1412 manager->StopAntiFraudDetect(call, info);
1413 manager->HandleCeliaCall(call);
1414 EXPECT_EQ(manager->antiFraudIndex_, 0);
1415
1416 NumberMarkInfo markInfo;
1417 markInfo.markType = MarkType::MARK_TYPE_FRAUD;
1418 call->SetNumberMarkInfo(markInfo);
1419 manager->SetupAntiFraudService(call, info);
1420 markInfo.markType = MarkType::MARK_TYPE_YELLOW_PAGE;
1421 call->SetNumberMarkInfo(markInfo);
1422 manager->SetupAntiFraudService(call, info);
1423 markInfo.markType = MarkType::MARK_TYPE_TAXI;
1424 call->SetNumberMarkInfo(markInfo);
1425 manager->SetupAntiFraudService(call, info);
1426 EXPECT_EQ(manager->antiFraudIndex_, 0);
1427 }
1428 } // namespace Telephony
1429 } // namespace OHOS
1430