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 <thread>
18 #include <chrono>
19 #include "bluetooth_call_client.h"
20 #include "bluetooth_call_manager.h"
21 #include "bluetooth_call_service.h"
22 #include "bluetooth_connection.h"
23 #include "iremote_broker.h"
24 #include "call_ability_callback.h"
25 #include "call_ability_connect_callback.h"
26 #include "call_ability_report_proxy.h"
27 #include "call_connect_ability.h"
28 #include "call_control_manager.h"
29 #include "call_manager_client.h"
30 #include "call_manager_hisysevent.h"
31 #include "call_number_utils.h"
32 #include "call_policy.h"
33 #include "call_records_manager.h"
34 #include "call_request_event_handler_helper.h"
35 #include "call_request_handler.h"
36 #include "call_request_process.h"
37 #include "call_setting_manager.h"
38 #include "call_state_report_proxy.h"
39 #include "call_status_manager.h"
40 #include "cellular_call_connection.h"
41 #include "common_event_manager.h"
42 #include "common_event_support.h"
43 #include "cs_call.h"
44 #include "cs_conference.h"
45 #include "distributed_call_manager.h"
46 #include "gtest/gtest.h"
47 #include "i_voip_call_manager_service.h"
48 #include "ims_call.h"
49 #include "ims_conference.h"
50 #include "incoming_call_notification.h"
51 #include "missed_call_notification.h"
52 #include "ott_call.h"
53 #include "ott_conference.h"
54 #include "reject_call_sms.h"
55 #include "report_call_info_handler.h"
56 #include "satellite_call.h"
57 #include "surface_utils.h"
58 #include "telephony_errors.h"
59 #include "telephony_hisysevent.h"
60 #include "telephony_log_wrapper.h"
61 #include "video_call_state.h"
62 #include "video_control_manager.h"
63 #include "voip_call_manager_proxy.h"
64 #include "voip_call.h"
65 #include "accesstoken_kit.h"
66 #include "token_setproc.h"
67 #include "nativetoken_kit.h"
68 #include "number_identity_data_base_helper.h"
69 #include "call_ability_callback_death_recipient.h"
70 #include "app_state_observer.h"
71 #include "call_ability_callback_proxy.h"
72 #include "super_privacy_manager_client.h"
73 #include "call_status_callback.h"
74 #include "satellite_call_control.h"
75 #include "proximity_sensor.h"
76 #include "status_bar.h"
77 #include "wired_headset.h"
78 #include "call_status_policy.h"
79 #include "call_superprivacy_control_manager.h"
80 #include "bluetooth_hfp_ag.h"
81 #include "call_manager_connect.h"
82 #include "call_manager_service.h"
83 #include "surface_utils.h"
84 #include "telephony_types.h"
85 #include "voip_call.h"
86 #include "telephony_permission.h"
87 #include "call_setting_manager.h"
88 #include "voip_call_connection.h"
89
90 namespace OHOS {
91 namespace Telephony {
92 using namespace testing::ext;
93
94 namespace {
95 const int32_t INVALID_SLOTID = 2;
96 const int32_t SIM1_SLOTID = 0;
97 const int32_t DEFAULT_INDEX = 1;
98 const int16_t CAMERA_ROTATION_0 = 0;
99 const int16_t CAMERA_ROTATION_90 = 90;
100 const int16_t CAMERA_ROTATION_180 = 180;
101 const int16_t CAMERA_ROTATION_270 = 270;
102 const int32_t INVALID_MODE = 0;
103 const int32_t VALID_CALLID = 1;
104 const int32_t ERROR_CALLID = -1;
105 const int32_t ONE_TIME = 1;
106 const int32_t STEP_1 = 1;
107 const int32_t SOURCE_CALL = 2;
108 const int32_t FIVE_SECOND = 5;
109 constexpr int16_t DEFAULT_TIME = 0;
110 constexpr const char *TEST_STR = "123";
111 constexpr const char *LONG_STR =
112 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
113 "111111111";
114 static constexpr const char *OHOS_PERMISSION_SET_TELEPHONY_STATE = "ohos.permission.SET_TELEPHONY_STATE";
115 static constexpr const char *OHOS_PERMISSION_PLACE_CALL = "ohos.permission.PLACE_CALL";
116 } // namespace
117
118 class DemoHandler : public AppExecFwk::EventHandler {
119 public:
DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> & eventRunner)120 explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &eventRunner) : AppExecFwk::EventHandler(eventRunner)
121 {}
~DemoHandler()122 virtual ~DemoHandler() {}
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)123 void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
124 };
125
126 class ZeroBranch8Test : public testing::Test {
127 public:
128 void SetUp();
129 void TearDown();
130 void InitDialInfo(int32_t accountId, int32_t videoState, int32_t dialScene, int32_t dialType);
131 static void SetUpTestCase();
132 static void TearDownTestCase();
133 public:
134 AppExecFwk::PacMap dialInfo_;
135 };
136
SetUp()137 void ZeroBranch8Test::SetUp() {}
138
TearDown()139 void ZeroBranch8Test::TearDown() {}
140
SetUpTestCase()141 void ZeroBranch8Test::SetUpTestCase()
142 {
143 constexpr int permissionNum = 1;
144 const char *perms[permissionNum] = {
145 "ohos.permission.GET_TELEPHONY_STATE"
146 };
147 NativeTokenInfoParams infoInstance = {
148 .dcapsNum = 0, // Indicates the capsbility list of the sa.
149 .permsNum = permissionNum,
150 .aclsNum = 0, // acls is the list of rights thar can be escalated.
151 .dcaps = nullptr,
152 .perms = perms,
153 .acls = nullptr,
154 .processName = "ZeroBranch8Test",
155 .aplStr = "system_basic",
156 };
157 uint64_t tokenId = GetAccessTokenId(&infoInstance);
158 SetSelfTokenID(tokenId);
159 auto result = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
160 EXPECT_EQ(result, Security::AccessToken::RET_SUCCESS);
161 }
162
TearDownTestCase()163 void ZeroBranch8Test::TearDownTestCase()
164 {
165 std::this_thread::sleep_for(std::chrono::seconds(FIVE_SECOND));
166 }
167
InitDialInfo(int32_t accountId,int32_t videoState,int32_t dialScene,int32_t dialType)168 void ZeroBranch8Test::InitDialInfo(int32_t accountId, int32_t videoState, int32_t dialScene, int32_t dialType)
169 {
170 dialInfo_.PutIntValue("accountId", accountId);
171 dialInfo_.PutIntValue("videoState", videoState);
172 dialInfo_.PutIntValue("dialScene", dialScene);
173 dialInfo_.PutIntValue("dialType", dialType);
174 }
175
176 HWTEST_F(ZeroBranch8Test, Telephony_CallManagerService_001, Function | MediumTest | Level1)
177 {
178 AccessToken token;
179 auto callManagerService = new CallManagerService();
180 callManagerService->state_ = CallManagerService::ServiceRunningState::STATE_RUNNING;
181 callManagerService->OnStart();
182 callManagerService->Init();
183 std::string deviceId("123");
184 int32_t systemAbilityId = 100;
185 std::u16string test = u"";
186 callManagerService->OnAddSystemAbility(systemAbilityId, deviceId);
187 EXPECT_NE(systemAbilityId, AUDIO_POLICY_SERVICE_ID);
188 int32_t slotId = 0;
189 EXPECT_EQ(callManagerService->CloseUnFinishedUssd(slotId), TELEPHONY_ERR_LOCAL_PTR_NULL);
190 EXPECT_EQ(callManagerService->SetVoIPCallState(0), TELEPHONY_ERR_LOCAL_PTR_NULL);
191 EXPECT_TRUE(TelephonyPermission::CheckCallerIsSystemApp());
192 EXPECT_TRUE(TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE));
193 std::string eventName = "ABC";
194 int32_t callId = 0;
195 EXPECT_EQ(callManagerService->SendCallUiEvent(callId, eventName), TELEPHONY_SUCCESS);
196 callManagerService->dealCeliaCallEvent(1);
197 std::string number = "123456";
198 EXPECT_EQ(callManagerService->MakeCall(number), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
199 EXPECT_TRUE(TelephonyPermission::CheckCallerIsSystemApp());
200 EXPECT_TRUE(TelephonyPermission::CheckPermission(OHOS_PERMISSION_SET_TELEPHONY_STATE));
201 if (TelephonyPermission::CheckCallerIsSystemApp() && TelephonyPermission::CheckPermission(
202 OHOS_PERMISSION_SET_TELEPHONY_STATE)) {
203 std::string content = "1";
204 EXPECT_EQ(callManagerService->SendUssdResponse(slotId, content), TELEPHONY_SUCCESS);
205 }
206 }
207
208 HWTEST_F(ZeroBranch8Test, Telephony_CallManagerService_002, Function | MediumTest | Level3)
209 {
210 AccessToken token;
211 std::u16string test = u"";
212 std::string testStr = "";
213 bool enabled;
214 auto callManagerService = new CallManagerService();
215 callManagerService->OnStart();
216 EXPECT_NE(callManagerService->callControlManagerPtr_, nullptr);
217 EXPECT_NE(callManagerService->DialCall(test, dialInfo_), TELEPHONY_ERR_PERMISSION_ERR);
218 EXPECT_NE(callManagerService->AnswerCall(0, 0), TELEPHONY_ERR_PERMISSION_ERR);
219 EXPECT_NE(callManagerService->RejectCall(0, false, test), TELEPHONY_ERR_PERMISSION_ERR);
220 EXPECT_NE(callManagerService->HangUpCall(0), TELEPHONY_ERR_PERMISSION_ERR);
221 EXPECT_NE(callManagerService->GetCallState(), TELEPHONY_ERR_LOCAL_PTR_NULL);
222 EXPECT_NE(callManagerService->HoldCall(0), TELEPHONY_ERR_PERMISSION_ERR);
223 EXPECT_NE(callManagerService->SwitchCall(0), TELEPHONY_ERR_PERMISSION_ERR);
224 EXPECT_FALSE(callManagerService->HasCall());
225 EXPECT_NE(callManagerService->IsNewCallAllowed(enabled), TELEPHONY_ERR_LOCAL_PTR_NULL);
226 EXPECT_NE(callManagerService->IsRinging(enabled), TELEPHONY_ERR_PERMISSION_ERR);
227 EXPECT_NE(callManagerService->IsInEmergencyCall(enabled), TELEPHONY_ERR_LOCAL_PTR_NULL);
228 EXPECT_NE(callManagerService->StartDtmf(0, 'a'), TELEPHONY_ERR_LOCAL_PTR_NULL);
229 EXPECT_NE(callManagerService->StopDtmf(0), TELEPHONY_ERR_LOCAL_PTR_NULL);
230 EXPECT_NE(callManagerService->callControlManagerPtr_, nullptr);
231 EXPECT_NE(callManagerService->GetCallWaiting(0), TELEPHONY_ERR_PERMISSION_ERR);
232 EXPECT_NE(callManagerService->SetCallWaiting(0, false), TELEPHONY_ERR_PERMISSION_ERR);
233 EXPECT_NE(callManagerService->GetCallRestriction(0, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
234 TELEPHONY_ERR_LOCAL_PTR_NULL);
235 CallRestrictionInfo callRestrictionInfo;
236 EXPECT_NE(callManagerService->SetCallRestriction(0, callRestrictionInfo), TELEPHONY_ERR_LOCAL_PTR_NULL);
237 EXPECT_NE(
238 callManagerService->SetCallRestrictionPassword(0, CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS, "11", "22"),
239 TELEPHONY_ERR_LOCAL_PTR_NULL);
240 EXPECT_NE(
241 callManagerService->GetCallTransferInfo(0, CallTransferType::TRANSFER_TYPE_UNCONDITIONAL),
242 TELEPHONY_ERR_LOCAL_PTR_NULL);
243 }
244
245 /**
246 * @tc.number Telephony_CallManagerService_003
247 * @tc.name test error nullptr branch with permission
248 * @tc.desc Function test
249 */
250 HWTEST_F(ZeroBranch8Test, Telephony_CallManagerService_003, Function | MediumTest | Level3)
251 {
252 AccessToken token;
253 float zoomRatio = 1;
254 std::u16string test = u"";
255 std::string testStr = "";
256 int32_t callId = 1;
257 int32_t value = 1;
258 bool enabled;
259 auto callManagerService = new CallManagerService();
260 callManagerService->OnStart();
261 EXPECT_NE(callManagerService->callControlManagerPtr_, nullptr);
262 EXPECT_TRUE(TelephonyPermission::CheckCallerIsSystemApp());
263 EXPECT_TRUE(TelephonyPermission::CheckPermission(OHOS_PERMISSION_PLACE_CALL));
264 EXPECT_NE(callManagerService->SetCameraZoom(zoomRatio), TELEPHONY_ERR_LOCAL_PTR_NULL);
265 EXPECT_NE(callManagerService->SetPausePicture(callId, test), TELEPHONY_ERR_LOCAL_PTR_NULL);
266 EXPECT_NE(callManagerService->SetDeviceDirection(callId, value), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
267 EXPECT_NE(callManagerService->CancelCallUpgrade(callId), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
268 EXPECT_NE(callManagerService->RequestCameraCapabilities(callId), TELEPHONY_ERR_PERMISSION_ERR);
269 EXPECT_NE(callManagerService->IsEmergencyPhoneNumber(test, 0, enabled), TELEPHONY_ERR_LOCAL_PTR_NULL);
270 EXPECT_NE(callManagerService->FormatPhoneNumber(test, test, test), TELEPHONY_ERR_LOCAL_PTR_NULL);
271 EXPECT_NE(callManagerService->FormatPhoneNumberToE164(test, test, test), TELEPHONY_ERR_LOCAL_PTR_NULL);
272 EXPECT_NE(callManagerService->GetMainCallId(value, value), TELEPHONY_ERR_PERMISSION_ERR);
273 std::vector<std::u16string> callIdList;
274 EXPECT_NE(callManagerService->GetSubCallIdList(0, callIdList), TELEPHONY_ERR_LOCAL_PTR_NULL);
275 EXPECT_NE(callManagerService->GetCallIdListForConference(0, callIdList), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
276 EXPECT_NE(callManagerService->GetImsConfig(0, ImsConfigItem::ITEM_VIDEO_QUALITY), TELEPHONY_ERR_LOCAL_PTR_NULL);
277 EXPECT_NE(callManagerService->SetImsConfig(0, ImsConfigItem::ITEM_VIDEO_QUALITY, test),
278 TELEPHONY_ERR_LOCAL_PTR_NULL);
279 EXPECT_NE(callManagerService->GetImsFeatureValue(0, FeatureType::TYPE_VOICE_OVER_LTE),
280 TELEPHONY_ERR_LOCAL_PTR_NULL);
281 EXPECT_NE(callManagerService->SetImsFeatureValue(0, FeatureType::TYPE_VOICE_OVER_LTE, 0),
282 TELEPHONY_ERR_LOCAL_PTR_NULL);
283 EXPECT_NE(callManagerService->UpdateImsCallMode(0, ImsCallMode::CALL_MODE_AUDIO_ONLY),
284 TELEPHONY_ERR_LOCAL_PTR_NULL);
285 EXPECT_NE(callManagerService->EnableImsSwitch(false), TELEPHONY_ERR_LOCAL_PTR_NULL);
286 EXPECT_NE(callManagerService->DisableImsSwitch(false), TELEPHONY_ERR_LOCAL_PTR_NULL);
287 EXPECT_NE(callManagerService->IsImsSwitchEnabled(0, enabled), TELEPHONY_ERR_LOCAL_PTR_NULL);
288 EXPECT_NE(callManagerService->SetVoNRState(0, value), TELEPHONY_ERR_LOCAL_PTR_NULL);
289 EXPECT_NE(callManagerService->GetVoNRState(0, value), TELEPHONY_ERR_LOCAL_PTR_NULL);
290 std::vector<std::u16string> numberList;
291 EXPECT_NE(callManagerService->JoinConference(false, numberList), TELEPHONY_ERR_LOCAL_PTR_NULL);
292 AudioDevice audioDevice = {
293 .deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO,
294 .address = { 0 },
295 };
296 EXPECT_NE(callManagerService->SetAudioDevice(audioDevice), TELEPHONY_ERR_LOCAL_PTR_NULL);
297 EXPECT_NE(callManagerService->ControlCamera(1, test), TELEPHONY_ERR_LOCAL_PTR_NULL);
298 EXPECT_NE(callManagerService->SetPreviewWindow(1, testStr, nullptr), TELEPHONY_ERR_LOCAL_PTR_NULL);
299 EXPECT_NE(callManagerService->SetDisplayWindow(1, testStr, nullptr), TELEPHONY_ERR_LOCAL_PTR_NULL);
300 }
301
302 /**
303 * @tc.number Telephony_CallManagerService_004
304 * @tc.name test error nullptr branch with permission
305 * @tc.desc Function test
306 */
307 HWTEST_F(ZeroBranch8Test, Telephony_CallManagerService_004, Function | MediumTest | Level3)
308 {
309 AccessFalseToken token;
310 std::u16string test = u"";
311 std::string testStr = "";
312 bool enabled;
313 auto callManagerService = new CallManagerService();
314 EXPECT_FALSE(TelephonyPermission::CheckCallerIsSystemApp());
315 EXPECT_EQ(callManagerService->DialCall(test, dialInfo_), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
316 EXPECT_EQ(callManagerService->AnswerCall(0, 0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
317 EXPECT_EQ(callManagerService->RejectCall(0, false, test), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
318 EXPECT_EQ(callManagerService->HangUpCall(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
319 EXPECT_EQ(callManagerService->HoldCall(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
320 EXPECT_EQ(callManagerService->UnHoldCall(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
321 EXPECT_EQ(callManagerService->SwitchCall(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
322 EXPECT_EQ(callManagerService->IsNewCallAllowed(enabled), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
323 EXPECT_EQ(callManagerService->IsRinging(enabled), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
324 EXPECT_EQ(callManagerService->IsInEmergencyCall(enabled), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
325 EXPECT_EQ(callManagerService->StartDtmf(0, 'a'), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
326 EXPECT_EQ(callManagerService->StopDtmf(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
327 EXPECT_EQ(callManagerService->GetCallWaiting(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
328 EXPECT_EQ(callManagerService->SetCallWaiting(0, false), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
329 EXPECT_EQ(callManagerService->GetCallRestriction(0, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
330 TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
331 CallRestrictionInfo callRestrictionInfo;
332 EXPECT_EQ(callManagerService->SetCallRestriction(0, callRestrictionInfo), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
333 EXPECT_EQ(
334 callManagerService->SetCallRestrictionPassword(0, CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS, "11", "22"),
335 TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
336 EXPECT_EQ(
337 callManagerService->GetCallTransferInfo(0, CallTransferType::TRANSFER_TYPE_UNCONDITIONAL),
338 TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
339 CallTransferInfo callTransferInfo;
340 EXPECT_EQ(callManagerService->SetCallTransferInfo(0, callTransferInfo), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
341 EXPECT_EQ(callManagerService->CanSetCallTransferTime(0, enabled), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
342 EXPECT_EQ(callManagerService->CombineConference(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
343 EXPECT_EQ(callManagerService->SeparateConference(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
344 EXPECT_EQ(callManagerService->KickOutFromConference(0), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
345 EXPECT_EQ(callManagerService->SetMuted(false), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
346 EXPECT_EQ(callManagerService->MuteRinger(), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
347 AudioDevice audioDevice = {
348 .deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO,
349 .address = { 0 },
350 };
351 EXPECT_EQ(callManagerService->SetAudioDevice(audioDevice), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
352 EXPECT_EQ(callManagerService->ControlCamera(1, test), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
353 EXPECT_EQ(callManagerService->SetPreviewWindow(1, testStr, nullptr), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
354 EXPECT_EQ(callManagerService->SetDisplayWindow(1, testStr, nullptr), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
355 }
356
357 /**
358 * @tc.number Telephony_CallManagerService_005
359 * @tc.name test error nullptr branch with permission
360 * @tc.desc Function test
361 */
362 HWTEST_F(ZeroBranch8Test, Telephony_CallManagerService_005, Function | MediumTest | Level3)
363 {
364 AccessFalseToken token;
365 float zoomRatio = 1;
366 std::u16string test = u"";
367 int32_t callId = 1;
368 int32_t value = 1;
369 bool enabled;
370 auto callManagerService = new CallManagerService();
371 EXPECT_FALSE(TelephonyPermission::CheckCallerIsSystemApp());
372 EXPECT_EQ(callManagerService->SetPausePicture(callId, test), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
373 EXPECT_EQ(callManagerService->SetDeviceDirection(callId, value), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
374 EXPECT_EQ(callManagerService->CancelCallUpgrade(callId), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
375 EXPECT_EQ(callManagerService->RequestCameraCapabilities(callId), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
376 EXPECT_EQ(callManagerService->GetMainCallId(value, value), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
377 std::vector<std::u16string> callIdList;
378 EXPECT_EQ(callManagerService->GetSubCallIdList(0, callIdList), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
379 EXPECT_EQ(callManagerService->GetCallIdListForConference(0, callIdList), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
380 EXPECT_EQ(callManagerService->UpdateImsCallMode(0, ImsCallMode::CALL_MODE_AUDIO_ONLY),
381 TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
382 EXPECT_EQ(callManagerService->EnableImsSwitch(false), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
383 EXPECT_EQ(callManagerService->DisableImsSwitch(false), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
384 EXPECT_EQ(callManagerService->IsImsSwitchEnabled(0, enabled), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
385 EXPECT_EQ(callManagerService->SetVoNRState(0, value), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
386 EXPECT_EQ(callManagerService->GetVoNRState(0, value), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
387 std::vector<std::u16string> numberList;
388 EXPECT_EQ(callManagerService->JoinConference(false, numberList), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
389 std::string number = "123456";
390 EXPECT_EQ(callManagerService->MakeCall(number), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
391 int32_t slotId = 0;
392 std::string content = "1";
393 EXPECT_EQ(callManagerService->SendUssdResponse(slotId, content), TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API);
394 }
395
396 HWTEST_F(ZeroBranch8Test, Telephony_BluetoothCallService_001, Function | MediumTest | Level3)
397 {
398 AccessToken token;
399 BluetoothCallService bluetoothCallService;
400 EXPECT_NE(bluetoothCallService.HangUpCall(), TELEPHONY_SUCCESS);
401 EXPECT_NE(bluetoothCallService.HoldCall(), TELEPHONY_SUCCESS);
402 EXPECT_NE(bluetoothCallService.UnHoldCall(), TELEPHONY_SUCCESS);
403 EXPECT_NE(bluetoothCallService.SwitchCall(), TELEPHONY_SUCCESS);
404 EXPECT_NE(bluetoothCallService.CombineConference(), TELEPHONY_SUCCESS);
405 EXPECT_NE(bluetoothCallService.SeparateConference(), TELEPHONY_SUCCESS);
406 EXPECT_NE(bluetoothCallService.KickOutFromConference(), TELEPHONY_SUCCESS);
407 }
408
409 HWTEST_F(ZeroBranch8Test, Telephony_BluetoothCallService_002, Function | MediumTest | Level3)
410 {
411 AccessToken token;
412 BluetoothCallService bluetoothCallService;
413 bluetoothCallService.callControlManagerPtr_ = DelayedSingleton<CallControlManager>::GetInstance();
414 EXPECT_NE(bluetoothCallService.SeparateConference(), TELEPHONY_ERR_LOCAL_PTR_NULL);
415 EXPECT_NE(bluetoothCallService.KickOutFromConference(), TELEPHONY_ERR_LOCAL_PTR_NULL);
416 }
417
418 HWTEST_F(ZeroBranch8Test, Telephony_CallSettingManager_001, Function | MediumTest | Level3)
419 {
420 std::shared_ptr<CallSettingManager> callSettingManager = std::make_shared<CallSettingManager>();
421 callSettingManager->cellularCallConnectionPtr_ = nullptr;
422 EXPECT_EQ(callSettingManager->GetCallRestriction(SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
423 TELEPHONY_ERR_LOCAL_PTR_NULL);
424 CallRestrictionInfo callRestrictionInfo = {
425 .password = "",
426 .fac = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING,
427 .mode = CallRestrictionMode::RESTRICTION_MODE_DEACTIVATION,
428 };
429 EXPECT_EQ(callSettingManager->SetCallRestriction(SIM1_SLOTID, callRestrictionInfo), TELEPHONY_ERR_LOCAL_PTR_NULL);
430 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING;
431 const char oldPassword[kMaxNumberLen + 1] = "1111";
432 const char newPassword[kMaxNumberLen + 1] = "2222";
433 EXPECT_EQ(callSettingManager->SetCallRestrictionPassword(INVALID_SLOTID, fac, oldPassword, newPassword),
434 CALL_ERR_INVALID_SLOT_ID);
435 EXPECT_EQ(callSettingManager->SetCallRestrictionPassword(SIM1_SLOTID, fac, oldPassword, newPassword),
436 TELEPHONY_ERR_LOCAL_PTR_NULL);
437 CallTransferType type = CallTransferType::TRANSFER_TYPE_UNCONDITIONAL;
438 EXPECT_EQ(callSettingManager->GetCallTransferInfo(INVALID_SLOTID, type), CALL_ERR_INVALID_SLOT_ID);
439 EXPECT_EQ(callSettingManager->GetCallTransferInfo(SIM1_SLOTID, type), TELEPHONY_ERR_LOCAL_PTR_NULL);
440 CallTransferInfo callTransferInfo = {
441 .transferNum = "",
442 .settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE,
443 .type = CallTransferType::TRANSFER_TYPE_BUSY,
444 .startHour = 1,
445 .startMinute = 1,
446 .endHour = 1,
447 .endMinute = 1,
448 };
449 EXPECT_EQ(callSettingManager->SetCallTransferInfo(SIM1_SLOTID, callTransferInfo), TELEPHONY_ERR_LOCAL_PTR_NULL);
450 bool result = false;
451 EXPECT_EQ(callSettingManager->CanSetCallTransferTime(SIM1_SLOTID, result), TELEPHONY_ERR_LOCAL_PTR_NULL);
452 int32_t featureValue = 0;
453 EXPECT_EQ(callSettingManager->SetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_VOICE_OVER_LTE, featureValue),
454 TELEPHONY_ERR_LOCAL_PTR_NULL);
455 EXPECT_EQ(callSettingManager->EnableImsSwitch(SIM1_SLOTID), TELEPHONY_ERR_LOCAL_PTR_NULL);
456 EXPECT_EQ(callSettingManager->DisableImsSwitch(SIM1_SLOTID), TELEPHONY_ERR_LOCAL_PTR_NULL);
457 bool enabled = false;
458 EXPECT_EQ(callSettingManager->IsImsSwitchEnabled(SIM1_SLOTID, enabled), TELEPHONY_ERR_LOCAL_PTR_NULL);
459 int32_t state = 0;
460 EXPECT_EQ(callSettingManager->SetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_LOCAL_PTR_NULL);
461 EXPECT_EQ(callSettingManager->GetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_LOCAL_PTR_NULL);
462 EXPECT_EQ(callSettingManager->CloseUnFinishedUssd(INVALID_SLOTID), CALL_ERR_INVALID_SLOT_ID);
463 EXPECT_EQ(callSettingManager->CloseUnFinishedUssd(SIM1_SLOTID), TELEPHONY_ERR_LOCAL_PTR_NULL);
464 }
465
466 HWTEST_F(ZeroBranch8Test, Telephony_CallSettingManager_002, Function | MediumTest | Level3)
467 {
468 std::shared_ptr<CallSettingManager> callSettingManager = std::make_shared<CallSettingManager>();
469 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING;
470 const char oldPassword[kMaxNumberLen + 1] = "1111";
471 const char newPassword[kMaxNumberLen + 1] = "2222";
472 EXPECT_NE(callSettingManager->SetCallRestrictionPassword(SIM1_SLOTID, fac, oldPassword, newPassword),
473 TELEPHONY_ERR_LOCAL_PTR_NULL);
474 int32_t state = 0;
475 EXPECT_NE(callSettingManager->SetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_LOCAL_PTR_NULL);
476 EXPECT_NE(callSettingManager->GetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_LOCAL_PTR_NULL);
477 }
478
479 HWTEST_F(ZeroBranch8Test, Telephony_CallRequestHandler_001, Function | MediumTest | Level1)
480 {
481 std::unique_ptr<CallRequestHandler> callRequestHandler = std::make_unique<CallRequestHandler>();
482 callRequestHandler->Init();
483 EXPECT_NE(callRequestHandler->DialCall(), TELEPHONY_ERR_LOCAL_PTR_NULL);
484 EXPECT_NE(callRequestHandler->AnswerCall(1, 1), TELEPHONY_ERR_LOCAL_PTR_NULL);
485 std::string content = "";
486 EXPECT_NE(callRequestHandler->RejectCall(1, true, content), TELEPHONY_ERR_LOCAL_PTR_NULL);
487 EXPECT_NE(callRequestHandler->HangUpCall(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
488 EXPECT_NE(callRequestHandler->HoldCall(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
489 EXPECT_NE(callRequestHandler->UnHoldCall(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
490 EXPECT_NE(callRequestHandler->SwitchCall(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
491 EXPECT_NE(callRequestHandler->CombineConference(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
492 EXPECT_NE(callRequestHandler->SeparateConference(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
493 EXPECT_NE(callRequestHandler->KickOutFromConference(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
494 std::u16string test = u"";
495 EXPECT_NE(callRequestHandler->StartRtt(1, test), TELEPHONY_ERR_LOCAL_PTR_NULL);
496 EXPECT_NE(callRequestHandler->StopRtt(1), TELEPHONY_ERR_LOCAL_PTR_NULL);
497 std::vector<std::string> emptyRecords = {};
498 EXPECT_NE(callRequestHandler->JoinConference(1, emptyRecords), TELEPHONY_ERR_LOCAL_PTR_NULL);
499 }
500
501 HWTEST_F(ZeroBranch8Test, Telephony_CallManagerClient_001, Function | MediumTest | Level1)
502 {
503 std::u16string test = u"";
504 int32_t callId = 1;
505 int32_t systemAbilityId = 1;
506 std::shared_ptr<CallManagerClient> callManagerClient = std::make_shared<CallManagerClient>();
507 callManagerClient->Init(systemAbilityId);
508 EXPECT_NE(callManagerClient->ObserverOnCallDetailsChange(), TELEPHONY_ERR_UNINIT);
509 std::string number = "12345678";
510 EXPECT_NE(callManagerClient->MakeCall(number), TELEPHONY_ERR_UNINIT);
511 EXPECT_NE(callManagerClient->UnRegisterVoipCallManagerCallback(), TELEPHONY_ERR_UNINIT);
512 bool result = false;
513 EXPECT_NE(callManagerClient->CanSetCallTransferTime(SIM1_SLOTID, result), TELEPHONY_ERR_UNINIT);
514 EXPECT_NE(callManagerClient->IsRinging(result), TELEPHONY_ERR_UNINIT);
515 EXPECT_NE(callManagerClient->IsNewCallAllowed(result), TELEPHONY_ERR_UNINIT);
516 float zoomRatio = 1.0;
517 EXPECT_NE(callManagerClient->SetCameraZoom(zoomRatio), TELEPHONY_ERR_UNINIT);
518 EXPECT_NE(callManagerClient->SetPausePicture(callId, test), TELEPHONY_ERR_UNINIT);
519 EXPECT_NE(callManagerClient->GetImsConfig(SIM1_SLOTID, ImsConfigItem::ITEM_IMS_SWITCH_STATUS),
520 TELEPHONY_ERR_UNINIT);
521 EXPECT_NE(callManagerClient->SetImsConfig(SIM1_SLOTID, ImsConfigItem::ITEM_IMS_SWITCH_STATUS, test),
522 TELEPHONY_ERR_UNINIT);
523 EXPECT_NE(callManagerClient->GetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_SS_OVER_UT), TELEPHONY_ERR_UNINIT);
524 int32_t value = 0;
525 EXPECT_NE(callManagerClient->SetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_SS_OVER_UT, value),
526 TELEPHONY_ERR_UNINIT);
527 EXPECT_NE(callManagerClient->UpdateImsCallMode(callId, ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_UNINIT);
528 EXPECT_NE(callManagerClient->StartRtt(callId, test), TELEPHONY_ERR_UNINIT);
529 EXPECT_NE(callManagerClient->StopRtt(callId), TELEPHONY_ERR_UNINIT);
530 EXPECT_NE(callManagerClient->CancelCallUpgrade(callId), TELEPHONY_ERR_UNINIT);
531 EXPECT_NE(callManagerClient->RequestCameraCapabilities(callId), TELEPHONY_ERR_UNINIT);
532 std::string eventName = "abc";
533 EXPECT_NE(callManagerClient->SendCallUiEvent(callId, eventName), TELEPHONY_ERR_UNINIT);
534 EXPECT_EQ(callManagerClient->RegisterBluetoothCallManagerCallbackPtr(eventName), nullptr);
535 int32_t slotId = 0;
536 std::string content = "1";
537 EXPECT_NE(callManagerClient->SendUssdResponse(slotId, content), TELEPHONY_ERR_UNINIT);
538 }
539
540 HWTEST_F(ZeroBranch8Test, Telephony_CallStatusCallback_001, Function | MediumTest | Level1)
541 {
542 auto callStatusCallback = std::make_shared<CallStatusCallback>();
543 CallReportInfo callReportInfo;
544 callReportInfo.callType = CallType::TYPE_VOIP;
545 EXPECT_EQ(callStatusCallback->UpdateCallReportInfo(callReportInfo), TELEPHONY_SUCCESS);
546 CallsReportInfo info;
547 callReportInfo.state = TelCallState::CALL_STATUS_INCOMING;
548 info.callVec.push_back(callReportInfo);
549 EXPECT_EQ(callStatusCallback->UpdateCallsReportInfo(info), TELEPHONY_SUCCESS);
550 }
551
552 HWTEST_F(ZeroBranch8Test, Telephony_VoipCallConnection_001, Function | MediumTest | Level1)
553 {
554 std::shared_ptr<VoipCallConnection> voipCallConnection = std::make_shared<VoipCallConnection>();
555 voipCallConnection->Init(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
556 EXPECT_NE(voipCallConnection->voipCallManagerInterfacePtr_, nullptr);
557 EXPECT_EQ(voipCallConnection->GetCallManagerProxy(), TELEPHONY_SUCCESS);
558 EXPECT_TRUE(voipCallConnection->connectCallManagerState_);
559 voipCallConnection->Init(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
560 VoipCallEventInfo voipCallEventInfo;
561 voipCallEventInfo.voipCallId = "123";
562 EXPECT_NE(voipCallConnection->AnswerCall(voipCallEventInfo, static_cast<int32_t>(VideoStateType::TYPE_VOICE)),
563 TELEPHONY_ERROR);
564 EXPECT_NE(voipCallConnection->RejectCall(voipCallEventInfo), TELEPHONY_ERROR);
565 EXPECT_NE(voipCallConnection->HangUpCall(voipCallEventInfo), TELEPHONY_ERROR);
566 sptr<ICallStatusCallback> callStatusCallback = nullptr;
567 EXPECT_NE(voipCallConnection->RegisterCallManagerCallBack(callStatusCallback), TELEPHONY_ERROR);
568 EXPECT_NE(voipCallConnection->UnRegisterCallManagerCallBack(), TELEPHONY_ERROR);
569 CallAudioEvent callAudioEvent = CallAudioEvent::AUDIO_EVENT_MUTED;
570 std::string voipCallId = "123";
571 EXPECT_NE(voipCallConnection->SendCallUiEvent(voipCallId, callAudioEvent), TELEPHONY_ERROR);
572 }
573 } // namespace Telephony
574 } // namespace OHOS
575