1 /*
2 * Copyright (C) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define private public
16 #define protected public
17 #include "bluetooth_call_client.h"
18 #include "bluetooth_call_manager.h"
19 #include "bluetooth_call_service.h"
20 #include "bluetooth_connection.h"
21 #include "iremote_broker.h"
22 #include "call_ability_callback.h"
23 #include "call_ability_connect_callback.h"
24 #include "call_ability_report_proxy.h"
25 #include "call_connect_ability.h"
26 #include "call_control_manager.h"
27 #include "call_manager_client.h"
28 #include "call_manager_hisysevent.h"
29 #include "call_number_utils.h"
30 #include "call_policy.h"
31 #include "call_records_manager.h"
32 #include "call_request_event_handler_helper.h"
33 #include "call_request_handler.h"
34 #include "call_request_process.h"
35 #include "call_setting_manager.h"
36 #include "call_state_report_proxy.h"
37 #include "call_status_manager.h"
38 #include "cellular_call_connection.h"
39 #include "common_event_manager.h"
40 #include "common_event_support.h"
41 #include "cs_call.h"
42 #include "cs_conference.h"
43 #include "distributed_call_manager.h"
44 #include "gtest/gtest.h"
45 #include "i_voip_call_manager_service.h"
46 #include "ims_call.h"
47 #include "ims_conference.h"
48 #include "incoming_call_notification.h"
49 #include "missed_call_notification.h"
50 #include "ott_call.h"
51 #include "ott_conference.h"
52 #include "reject_call_sms.h"
53 #include "report_call_info_handler.h"
54 #include "satellite_call.h"
55 #include "surface_utils.h"
56 #include "telephony_errors.h"
57 #include "telephony_hisysevent.h"
58 #include "telephony_log_wrapper.h"
59 #include "video_call_state.h"
60 #include "video_control_manager.h"
61 #include "voip_call_manager_proxy.h"
62 #include "voip_call.h"
63 #include "accesstoken_kit.h"
64 #include "token_setproc.h"
65 #include "nativetoken_kit.h"
66 #include "number_identity_data_base_helper.h"
67 #include "call_ability_callback_death_recipient.h"
68 #include "app_state_observer.h"
69 #include "call_ability_callback_proxy.h"
70 #include "super_privacy_manager_client.h"
71 #include "call_status_callback.h"
72 #include "satellite_call_control.h"
73 #include "proximity_sensor.h"
74 #include "status_bar.h"
75 #include "wired_headset.h"
76 #include "call_status_policy.h"
77 #include "native_call_manager_hisysevent.h"
78
79 namespace OHOS {
80 namespace Telephony {
81 using namespace testing::ext;
82
83 namespace {
84 const int32_t INVALID_SLOTID = 2;
85 const int32_t SIM1_SLOTID = 0;
86 const int32_t DEFAULT_INDEX = 1;
87 const int16_t CAMERA_ROTATION_0 = 0;
88 const int16_t CAMERA_ROTATION_90 = 90;
89 const int16_t CAMERA_ROTATION_180 = 180;
90 const int16_t CAMERA_ROTATION_270 = 270;
91 const int32_t INVALID_MODE = 0;
92 const int32_t VALID_CALLID = 1;
93 const int32_t ERROR_CALLID = -1;
94 const int32_t ONE_TIME = 1;
95 const int32_t STEP_1 = 1;
96 const int32_t SOURCE_CALL = 2;
97 constexpr int16_t DEFAULT_TIME = 0;
98 constexpr const char *TEST_STR = "123";
99 constexpr const char *LONG_STR =
100 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
101 "111111111";
102 } // namespace
103
104 class DemoHandler : public AppExecFwk::EventHandler {
105 public:
DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> & eventRunner)106 explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &eventRunner) : AppExecFwk::EventHandler(eventRunner)
107 {}
~DemoHandler()108 virtual ~DemoHandler() {}
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)109 void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
110 };
111
112 class ZeroBranch3Test : public testing::Test {
113 public:
114 void SetUp();
115 void TearDown();
116 static void SetUpTestCase();
117 static void TearDownTestCase();
118 };
119
SetUp()120 void ZeroBranch3Test::SetUp() {}
121
TearDown()122 void ZeroBranch3Test::TearDown() {}
123
SetUpTestCase()124 void ZeroBranch3Test::SetUpTestCase()
125 {
126 constexpr int permissionNum = 1;
127 const char *perms[permissionNum] = {
128 "ohos.permission.GET_TELEPHONY_STATE"
129 };
130 NativeTokenInfoParams infoInstance = {
131 .dcapsNum = 0, // Indicates the capsbility list of the sa.
132 .permsNum = permissionNum,
133 .aclsNum = 0, // acls is the list of rights thar can be escalated.
134 .dcaps = nullptr,
135 .perms = perms,
136 .acls = nullptr,
137 .processName = "ZeroBranch3Test",
138 .aplStr = "system_basic",
139 };
140 uint64_t tokenId = GetAccessTokenId(&infoInstance);
141 SetSelfTokenID(tokenId);
142 auto result = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
143 EXPECT_EQ(result, Security::AccessToken::RET_SUCCESS);
144 }
145
TearDownTestCase()146 void ZeroBranch3Test::TearDownTestCase() {}
147
CreateDataShareHelper(std::string uri)148 std::shared_ptr<DataShare::DataShareHelper> CreateDataShareHelper(std::string uri)
149 {
150 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
151 if (saManager == nullptr) {
152 printf("Get system ability mgr failed.");
153 return nullptr;
154 }
155 auto remoteObj = saManager->GetSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
156 if (remoteObj == nullptr) {
157 printf("GetSystemAbility Service Failed.");
158 return nullptr;
159 }
160 return DataShare::DataShareHelper::Creator(remoteObj, uri);
161 }
162
163 /**
164 * @tc.number Telephony_VideoCallState_001
165 * @tc.name test error branch
166 * @tc.desc Function test
167 */
168 HWTEST_F(ZeroBranch3Test, Telephony_VideoCallState_001, Function | MediumTest | Level1)
169 {
170 AudioOnlyState audioOnlyState = AudioOnlyState(nullptr);
171 ASSERT_NE(audioOnlyState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_SUCCESS);
172 ASSERT_EQ(audioOnlyState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_ONLY), TELEPHONY_ERR_SUCCESS);
173 ASSERT_EQ(
174 audioOnlyState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_RECEIVE_ONLY), TELEPHONY_ERR_SUCCESS);
175 ASSERT_NE(
176 audioOnlyState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_RECEIVE), TELEPHONY_ERR_SUCCESS);
177 ASSERT_NE(
178 audioOnlyState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_VIDEO_PAUSED), TELEPHONY_ERR_SUCCESS);
179 CallMediaModeInfo imsCallModeRequestInfo;
180 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
181 ASSERT_NE(audioOnlyState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
182 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_ONLY;
183 ASSERT_EQ(audioOnlyState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
184 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
185 ASSERT_EQ(audioOnlyState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
186 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_RECEIVE;
187 ASSERT_NE(audioOnlyState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
188 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_VIDEO_PAUSED;
189 ASSERT_NE(audioOnlyState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
190 ASSERT_NE(
191 audioOnlyState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_SUCCESS);
192 ASSERT_EQ(audioOnlyState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_SEND_ONLY), TELEPHONY_ERR_SUCCESS);
193 ASSERT_NE(
194 audioOnlyState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_RECEIVE_ONLY), TELEPHONY_ERR_SUCCESS);
195 ASSERT_NE(
196 audioOnlyState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_SEND_RECEIVE), TELEPHONY_ERR_SUCCESS);
197 ASSERT_NE(
198 audioOnlyState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_VIDEO_PAUSED), TELEPHONY_ERR_SUCCESS);
199 CallMediaModeInfo imsCallModeResponseInfo;
200 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
201 ASSERT_EQ(audioOnlyState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
202 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_SEND_ONLY;
203 ASSERT_EQ(audioOnlyState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
204 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
205 ASSERT_NE(audioOnlyState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
206 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_SEND_RECEIVE;
207 ASSERT_NE(audioOnlyState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
208 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_VIDEO_PAUSED;
209 ASSERT_EQ(audioOnlyState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
210 }
211
212 /**
213 * @tc.number Telephony_VideoCallState_002
214 * @tc.name test error branch
215 * @tc.desc Function test
216 */
217 HWTEST_F(ZeroBranch3Test, Telephony_VideoCallState_002, Function | MediumTest | Level1)
218 {
219 VideoSendState videoSendState = VideoSendState(nullptr);
220 ASSERT_NE(videoSendState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_SUCCESS);
221 ASSERT_NE(videoSendState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_ONLY), TELEPHONY_ERR_SUCCESS);
222 ASSERT_NE(
223 videoSendState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_RECEIVE_ONLY), TELEPHONY_ERR_SUCCESS);
224 ASSERT_NE(
225 videoSendState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_RECEIVE), TELEPHONY_ERR_SUCCESS);
226 ASSERT_NE(
227 videoSendState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_VIDEO_PAUSED), TELEPHONY_ERR_SUCCESS);
228 CallMediaModeInfo imsCallModeRequestInfo;
229 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
230 ASSERT_NE(videoSendState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
231 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_ONLY;
232 ASSERT_EQ(videoSendState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
233 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
234 ASSERT_NE(videoSendState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
235 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_RECEIVE;
236 ASSERT_EQ(videoSendState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
237 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_VIDEO_PAUSED;
238 ASSERT_NE(videoSendState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
239 ASSERT_EQ(
240 videoSendState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_SUCCESS);
241 ASSERT_EQ(videoSendState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_SEND_ONLY), TELEPHONY_ERR_SUCCESS);
242 ASSERT_EQ(
243 videoSendState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_RECEIVE_ONLY), TELEPHONY_ERR_SUCCESS);
244 ASSERT_EQ(
245 videoSendState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_SEND_RECEIVE), TELEPHONY_ERR_SUCCESS);
246 ASSERT_EQ(
247 videoSendState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_VIDEO_PAUSED), TELEPHONY_ERR_SUCCESS);
248 CallMediaModeInfo imsCallModeResponseInfo;
249 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
250 ASSERT_NE(videoSendState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
251 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_SEND_ONLY;
252 ASSERT_EQ(videoSendState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
253 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
254 ASSERT_EQ(videoSendState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
255 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_SEND_RECEIVE;
256 ASSERT_NE(videoSendState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
257 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_VIDEO_PAUSED;
258 ASSERT_NE(videoSendState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
259 }
260
261 /**
262 * @tc.number Telephony_VideoCallState_003
263 * @tc.name test error branch
264 * @tc.desc Function test
265 */
266 HWTEST_F(ZeroBranch3Test, Telephony_VideoCallState_003, Function | MediumTest | Level1)
267 {
268 VideoReceiveState videoReceiveState = VideoReceiveState(nullptr);
269 videoReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_AUDIO_ONLY);
270 videoReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_ONLY);
271 videoReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_RECEIVE_ONLY);
272 videoReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_VIDEO_PAUSED);
273 CallMediaModeInfo imsCallModeRequestInfo;
274 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
275 videoReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo);
276 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_ONLY;
277 videoReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo);
278 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
279 videoReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo);
280 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_RECEIVE;
281 videoReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo);
282 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_VIDEO_PAUSED;
283 videoReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo);
284 videoReceiveState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY);
285 videoReceiveState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_SEND_ONLY);
286 videoReceiveState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_RECEIVE_ONLY);
287 videoReceiveState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_SEND_RECEIVE);
288 videoReceiveState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_VIDEO_PAUSED);
289 CallMediaModeInfo imsCallModeResponseInfo;
290 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
291 videoReceiveState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo);
292 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_SEND_ONLY;
293 videoReceiveState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo);
294 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
295 videoReceiveState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo);
296 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_SEND_RECEIVE;
297 videoReceiveState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo);
298 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_VIDEO_PAUSED;
299 videoReceiveState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo);
300 videoReceiveState.SetVideoUpdateStatus(VideoUpdateStatus::STATUS_SEND_REQUEST);
301 EXPECT_EQ(videoReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_RECEIVE),
302 CALL_ERR_VIDEO_IN_PROGRESS);
303 }
304
305 /**
306 * @tc.number Telephony_VideoCallState_004
307 * @tc.name test error branch
308 * @tc.desc Function test
309 */
310 HWTEST_F(ZeroBranch3Test, Telephony_VideoCallState_004, Function | MediumTest | Level1)
311 {
312 VideoSendReceiveState videoSendReceiveState = VideoSendReceiveState(nullptr);
313 ASSERT_NE(videoSendReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_AUDIO_ONLY),
314 TELEPHONY_ERR_SUCCESS);
315 ASSERT_NE(
316 videoSendReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_ONLY), TELEPHONY_ERR_SUCCESS);
317 ASSERT_NE(videoSendReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_RECEIVE_ONLY),
318 TELEPHONY_ERR_SUCCESS);
319 ASSERT_NE(videoSendReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_RECEIVE),
320 TELEPHONY_ERR_SUCCESS);
321 ASSERT_NE(videoSendReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_VIDEO_PAUSED),
322 TELEPHONY_ERR_SUCCESS);
323 CallMediaModeInfo imsCallModeRequestInfo;
324 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
325 ASSERT_NE(videoSendReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
326 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_ONLY;
327 ASSERT_EQ(videoSendReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
328 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
329 ASSERT_EQ(videoSendReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
330 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_RECEIVE;
331 ASSERT_EQ(videoSendReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
332 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_VIDEO_PAUSED;
333 ASSERT_EQ(videoSendReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
334 ASSERT_EQ(videoSendReceiveState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY),
335 TELEPHONY_ERR_SUCCESS);
336 CallMediaModeInfo imsCallModeResponseInfo;
337 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
338 ASSERT_NE(
339 videoSendReceiveState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
340 }
341
342 /**
343 * @tc.number Telephony_VideoCallState_005
344 * @tc.name test error branch
345 * @tc.desc Function test
346 */
347 HWTEST_F(ZeroBranch3Test, Telephony_VideoCallState_005, Function | MediumTest | Level1)
348 {
349 VideoPauseState videoPauseState = VideoPauseState(nullptr);
350 ASSERT_NE(
351 videoPauseState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_SUCCESS);
352 ASSERT_NE(videoPauseState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_ONLY), TELEPHONY_ERR_SUCCESS);
353 ASSERT_NE(
354 videoPauseState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_RECEIVE_ONLY), TELEPHONY_ERR_SUCCESS);
355 ASSERT_NE(
356 videoPauseState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_RECEIVE), TELEPHONY_ERR_SUCCESS);
357 ASSERT_NE(
358 videoPauseState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_VIDEO_PAUSED), TELEPHONY_ERR_SUCCESS);
359 CallMediaModeInfo imsCallModeRequestInfo;
360 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
361 ASSERT_NE(videoPauseState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
362 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_ONLY;
363 ASSERT_EQ(videoPauseState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
364 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
365 ASSERT_EQ(videoPauseState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
366 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_RECEIVE;
367 ASSERT_NE(videoPauseState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
368 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_VIDEO_PAUSED;
369 ASSERT_NE(videoPauseState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
370 ASSERT_EQ(
371 videoPauseState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_SUCCESS);
372 CallMediaModeInfo imsCallModeResponseInfo;
373 ASSERT_EQ(videoPauseState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
374 // Test VideoCallState class cases
375 videoPauseState.IsCallSupportVideoCall();
376 videoPauseState.SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
377 videoPauseState.GetVideoUpdateStatus();
378 videoPauseState.SwitchCallVideoState(ImsCallMode::CALL_MODE_AUDIO_ONLY);
379 videoPauseState.DispatchUpdateVideoRequest(ImsCallMode::CALL_MODE_AUDIO_ONLY);
380 videoPauseState.DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY);
381 CallMediaModeInfo imsCallModeInfo;
382 videoPauseState.DispatchReportVideoCallInfo(imsCallModeInfo);
383 }
384
385 /**
386 * @tc.number Telephony_IncomingCallNotification_001
387 * @tc.name test error branch
388 * @tc.desc Function test
389 */
390 HWTEST_F(ZeroBranch3Test, Telephony_IncomingCallNotification_001, TestSize.Level0)
391 {
392 std::shared_ptr<IncomingCallNotification> incomingCallNotification = std::make_shared<IncomingCallNotification>();
393 sptr<CallBase> callObjectPtr = nullptr;
394 incomingCallNotification->NewCallCreated(callObjectPtr);
395 incomingCallNotification->CallStateUpdated(
396 callObjectPtr, TelCallState::CALL_STATUS_IDLE, TelCallState::CALL_STATUS_INCOMING);
397 incomingCallNotification->CallStateUpdated(
398 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
399 incomingCallNotification->IncomingCallActivated(callObjectPtr);
400 incomingCallNotification->IncomingCallHungUp(callObjectPtr, false, "");
401 DialParaInfo info;
402 info.number = TEST_STR;
403 callObjectPtr = new CSCall(info);
404 incomingCallNotification->NewCallCreated(callObjectPtr);
405 callObjectPtr->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
406 incomingCallNotification->NewCallCreated(callObjectPtr);
407 incomingCallNotification->NewCallCreated(callObjectPtr);
408 incomingCallNotification->CallStateUpdated(
409 callObjectPtr, TelCallState::CALL_STATUS_IDLE, TelCallState::CALL_STATUS_INCOMING);
410 incomingCallNotification->CallStateUpdated(
411 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
412 incomingCallNotification->IncomingCallActivated(callObjectPtr);
413 incomingCallNotification->IncomingCallHungUp(callObjectPtr, false, "");
414
415 DialParaInfo emptyNumberInfo;
416 sptr<CallBase> emptyNumberInfocall = new CSCall(emptyNumberInfo);
417 incomingCallNotification->CallStateUpdated(
418 emptyNumberInfocall, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
419 incomingCallNotification->IncomingCallActivated(emptyNumberInfocall);
420 incomingCallNotification->IncomingCallHungUp(callObjectPtr, true, "");
421
422 DisconnectedDetails details;
423 incomingCallNotification->CallDestroyed(details);
424 incomingCallNotification->PublishIncomingCallNotification(emptyNumberInfocall);
425 ASSERT_EQ(incomingCallNotification->CancelIncomingCallNotification(), TELEPHONY_SUCCESS);
426 ASSERT_FALSE(incomingCallNotification->IsFullScreen());
427 }
428
429 /**
430 * @tc.number Telephony_RejectCallSms_001
431 * @tc.name test error branch
432 * @tc.desc Function test
433 */
434 HWTEST_F(ZeroBranch3Test, Telephony_RejectCallSms_001, TestSize.Level0)
435 {
436 std::shared_ptr<RejectCallSms> rejectCallSms = std::make_shared<RejectCallSms>();
437 sptr<CallBase> callObjectPtr = nullptr;
438 rejectCallSms->IncomingCallHungUp(callObjectPtr, true, "");
439 rejectCallSms->IncomingCallHungUp(callObjectPtr, false, "");
440 DialParaInfo info;
441 info.number = TEST_STR;
442 callObjectPtr = new CSCall(info);
443 rejectCallSms->IncomingCallHungUp(callObjectPtr, true, "");
444 rejectCallSms->IncomingCallHungUp(callObjectPtr, false, "");
445 rejectCallSms->IncomingCallHungUp(callObjectPtr, false, TEST_STR);
446
447 std::u16string desAddr = u"123";
448 std::u16string text = u"";
449 rejectCallSms->SendMessage(INVALID_SLOTID, desAddr, text);
450 rejectCallSms->NewCallCreated(callObjectPtr);
451
452 DisconnectedDetails details;
453 rejectCallSms->CallDestroyed(details);
454 rejectCallSms->IncomingCallActivated(callObjectPtr);
455
456 rejectCallSms->CallStateUpdated(
457 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
458
459 bool convertRet = rejectCallSms->ConvertToUtf16(TEST_STR) == desAddr;
460 ASSERT_TRUE(convertRet);
461 }
462
463 /**
464 * @tc.number Telephony_MissedCallNotification_001
465 * @tc.name test error branch
466 * @tc.desc Function test
467 */
468 HWTEST_F(ZeroBranch3Test, Telephony_MissedCallNotification_001, TestSize.Level0)
469 {
470 std::shared_ptr<MissedCallNotification> missedCallNotification = std::make_shared<MissedCallNotification>();
471 sptr<CallBase> callObjectPtr = nullptr;
472
473 missedCallNotification->NewCallCreated(callObjectPtr);
474 missedCallNotification->CallStateUpdated(
475 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
476
477 missedCallNotification->IncomingCallActivated(callObjectPtr);
478 missedCallNotification->IncomingCallHungUp(callObjectPtr, true, "");
479
480 DisconnectedDetails details;
481 missedCallNotification->CallDestroyed(details);
482
483 DialParaInfo info;
484 info.number = TEST_STR;
485 callObjectPtr = new CSCall(info);
486 missedCallNotification->CallStateUpdated(
487 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
488 missedCallNotification->CallStateUpdated(
489 callObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED, TelCallState::CALL_STATUS_INCOMING);
490 callObjectPtr->SetAnswerType(CallAnswerType::CALL_ANSWER_MISSED);
491 missedCallNotification->CallStateUpdated(
492 callObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED, TelCallState::CALL_STATUS_INCOMING);
493 callObjectPtr->SetAnswerType(CallAnswerType::CALL_ANSWER_ACTIVED);
494 callObjectPtr->SetAiAutoAnswer(false);
495 missedCallNotification->CallStateUpdated(
496 callObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED, TelCallState::CALL_STATUS_INCOMING);
497 callObjectPtr->SetAiAutoAnswer(true);
498 missedCallNotification->CallStateUpdated(
499 callObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED, TelCallState::CALL_STATUS_INCOMING);
500 missedCallNotification->PublishMissedCallEvent(callObjectPtr);
501 std::map<std::string, int32_t> phoneNumAndUnReadCountMap;
502 phoneNumAndUnReadCountMap.insert(pair<string, int>("000", 1));
503 ASSERT_EQ(missedCallNotification->NotifyUnReadMissedCall(phoneNumAndUnReadCountMap), TELEPHONY_SUCCESS);
504 }
505
506 /**
507 * @tc.number Telephony_CallAbilityCallback_001
508 * @tc.name test error branch
509 * @tc.desc Function test
510 */
511 HWTEST_F(ZeroBranch3Test, Telephony_CallAbilityCallback_001, TestSize.Level0)
512 {
513 std::shared_ptr<CallAbilityCallback> callAbilityCallback = std::make_shared<CallAbilityCallback>();
514 ASSERT_EQ(callAbilityCallback->SetProcessCallback(nullptr), TELEPHONY_SUCCESS);
515 CallAttributeInfo callAttributeInfo;
516 ASSERT_EQ(callAbilityCallback->OnCallDetailsChange(callAttributeInfo), TELEPHONY_SUCCESS);
517 ASSERT_EQ(callAbilityCallback->OnMeeTimeDetailsChange(callAttributeInfo), TELEPHONY_SUCCESS);
518 CallEventInfo info;
519 ASSERT_EQ(callAbilityCallback->OnCallEventChange(info), TELEPHONY_SUCCESS);
520 DisconnectedDetails details;
521 ASSERT_EQ(callAbilityCallback->OnCallDisconnectedCause(details), TELEPHONY_SUCCESS);
522 AppExecFwk::PacMap resultInfo;
523 ASSERT_EQ(
524 callAbilityCallback->OnReportAsyncResults(CallResultReportId::GET_CALL_CLIP_ID, resultInfo), TELEPHONY_SUCCESS);
525 MmiCodeInfo mmiCodeInfo;
526 ASSERT_EQ(callAbilityCallback->OnReportMmiCodeResult(mmiCodeInfo), TELEPHONY_SUCCESS);
527 ASSERT_EQ(
528 callAbilityCallback->OnOttCallRequest(OttCallRequestId::OTT_REQUEST_ANSWER, resultInfo), TELEPHONY_SUCCESS);
529 CallMediaModeInfo imsCallModeInfo;
530 ASSERT_EQ(callAbilityCallback->OnReportImsCallModeChange(imsCallModeInfo), TELEPHONY_SUCCESS);
531 CallSessionEvent callSessionEventOptions;
532 ASSERT_EQ(callAbilityCallback->OnReportCallSessionEventChange(callSessionEventOptions), TELEPHONY_SUCCESS);
533 PeerDimensionsDetail peerDimensionsDetail;
534 ASSERT_EQ(callAbilityCallback->OnReportPeerDimensionsChange(peerDimensionsDetail), TELEPHONY_SUCCESS);
535 int64_t dataUsage = 0;
536 ASSERT_EQ(callAbilityCallback->OnReportCallDataUsageChange(dataUsage), TELEPHONY_SUCCESS);
537 CameraCapabilities cameraCapabilities;
538 ASSERT_EQ(callAbilityCallback->OnReportCameraCapabilities(cameraCapabilities), TELEPHONY_SUCCESS);
539 }
540
541 /**
542 * @tc.number Telephony_CallAbilityCallbackStub_001
543 * @tc.name test error branch
544 * @tc.desc Function test
545 */
546 HWTEST_F(ZeroBranch3Test, Telephony_CallAbilityCallbackStub_001, TestSize.Level0)
547 {
548 std::shared_ptr<CallAbilityCallback> callAbilityCallback = std::make_shared<CallAbilityCallback>();
549 MessageParcel data;
550 MessageParcel reply;
551 MessageOption option;
552 data.WriteInterfaceToken(CallAbilityCallbackStub::GetDescriptor());
553 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
554 CallManagerCallAbilityInterfaceCode::UPDATE_CALL_STATE_INFO), data, reply, option);
555 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::UPDATE_CALL_EVENT),
556 data, reply, option);
557 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
558 CallManagerCallAbilityInterfaceCode::UPDATE_CALL_DISCONNECTED_CAUSE), data, reply, option);
559 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
560 CallManagerCallAbilityInterfaceCode::UPDATE_CALL_ASYNC_RESULT_REQUEST), data, reply, option);
561 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
562 CallManagerCallAbilityInterfaceCode::REPORT_OTT_CALL_REQUEST),
563 data, reply, option);
564 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
565 CallManagerCallAbilityInterfaceCode::UPDATE_MMI_CODE_RESULT_REQUEST),
566 data, reply, option);
567 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
568 CallManagerCallAbilityInterfaceCode::UPDATE_AUDIO_DEVICE_CHANGE_RESULT_REQUEST),
569 data, reply, option);
570 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
571 CallManagerCallAbilityInterfaceCode::REPORT_POST_DIAL_DELAY),
572 data, reply, option);
573 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
574 CallManagerCallAbilityInterfaceCode::UPDATE_IMS_CALL_MODE_RECEIVE),
575 data, reply, option);
576 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
577 CallManagerCallAbilityInterfaceCode::CALL_SESSION_EVENT_CHANGE),
578 data, reply, option);
579 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
580 CallManagerCallAbilityInterfaceCode::PEERD_DIMENSIONS_CHANGE),
581 data, reply, option);
582 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
583 CallManagerCallAbilityInterfaceCode::CALL_DATA_USAGE_CHANGE), data, reply, option);
584 int32_t res = callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
585 CallManagerCallAbilityInterfaceCode::CAMERA_CAPABILITIES_CHANGE), data, reply, option);
586 ASSERT_NE(res, TELEPHONY_ERR_SUCCESS);
587 }
588
589 /**
590 * @tc.number Telephony_BluetoothCallClient_001
591 * @tc.name test error branch
592 * @tc.desc Function test
593 */
594 HWTEST_F(ZeroBranch3Test, Telephony_BluetoothCallClient_001, TestSize.Level1)
595 {
596 BluetoothCallClient &bluetoothCallClient = DelayedRefSingleton<BluetoothCallClient>::GetInstance();
597 bluetoothCallClient.UnInit();
598 ASSERT_NE(bluetoothCallClient.RegisterCallBack(nullptr), TELEPHONY_SUCCESS);
599 ASSERT_NE(bluetoothCallClient.UnRegisterCallBack(), TELEPHONY_SUCCESS);
600 std::u16string value = u"";
601 AppExecFwk::PacMap extras;
602 bool enabled;
603 bluetoothCallClient.IsNewCallAllowed(enabled);
604 bluetoothCallClient.IsInEmergencyCall(enabled);
605 bluetoothCallClient.SetMuted(false);
606 bluetoothCallClient.MuteRinger();
607 bluetoothCallClient.SetAudioDevice(AudioDeviceType::DEVICE_BLUETOOTH_SCO, "test");
608 bluetoothCallClient.GetCurrentCallList(-1).size();
609 ASSERT_NE(bluetoothCallClient.DialCall(value, extras), TELEPHONY_SUCCESS);
610 ASSERT_NE(bluetoothCallClient.AnswerCall(), TELEPHONY_SUCCESS);
611 ASSERT_NE(bluetoothCallClient.RejectCall(), TELEPHONY_SUCCESS);
612 ASSERT_NE(bluetoothCallClient.HangUpCall(), TELEPHONY_SUCCESS);
613 ASSERT_GE(bluetoothCallClient.GetCallState(), TELEPHONY_SUCCESS);
614 ASSERT_NE(bluetoothCallClient.HoldCall(), TELEPHONY_SUCCESS);
615 ASSERT_NE(bluetoothCallClient.UnHoldCall(), TELEPHONY_SUCCESS);
616 ASSERT_NE(bluetoothCallClient.SwitchCall(), TELEPHONY_SUCCESS);
617 ASSERT_NE(bluetoothCallClient.CombineConference(), TELEPHONY_SUCCESS);
618 ASSERT_NE(bluetoothCallClient.SeparateConference(), TELEPHONY_SUCCESS);
619 ASSERT_NE(bluetoothCallClient.KickOutFromConference(), TELEPHONY_SUCCESS);
620 ASSERT_NE(bluetoothCallClient.StartDtmf('a'), TELEPHONY_SUCCESS);
621 ASSERT_NE(bluetoothCallClient.StopDtmf(), TELEPHONY_SUCCESS);
622 ASSERT_NE(bluetoothCallClient.IsRinging(enabled), TELEPHONY_SUCCESS);
623 }
624
625 /**
626 * @tc.number Telephony_CallManagerClient_001
627 * @tc.name test error branch
628 * @tc.desc Function test
629 */
630 HWTEST_F(ZeroBranch3Test, Telephony_CallManagerClient_001, TestSize.Level0)
631 {
632 std::shared_ptr<CallManagerClient> callManagerClient = std::make_shared<CallManagerClient>();
633 callManagerClient->UnInit();
634 ASSERT_NE(callManagerClient->RegisterCallBack(nullptr), TELEPHONY_SUCCESS);
635 ASSERT_NE(callManagerClient->UnRegisterCallBack(), TELEPHONY_SUCCESS);
636 std::u16string value = u"";
637 AppExecFwk::PacMap extras;
638 callManagerClient->HoldCall(0);
639 callManagerClient->UnHoldCall(0);
640 callManagerClient->SwitchCall(0);
641 callManagerClient->CombineConference(0);
642 callManagerClient->SeparateConference(0);
643 callManagerClient->KickOutFromConference(0);
644 int32_t intValue;
645 callManagerClient->GetMainCallId(intValue, intValue);
646 std::vector<std::u16string> callIdList;
647 callManagerClient->GetSubCallIdList(0, callIdList);
648 callManagerClient->GetCallIdListForConference(0, callIdList);
649 callManagerClient->GetCallWaiting(0);
650 callManagerClient->SetCallWaiting(0, false);
651 callManagerClient->GetCallRestriction(0, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING);
652 CallRestrictionInfo callRestrictionInfo;
653 callManagerClient->SetCallRestriction(0, callRestrictionInfo);
654 callManagerClient->GetCallTransferInfo(0, CallTransferType::TRANSFER_TYPE_BUSY);
655 CallTransferInfo info;
656 callManagerClient->SetCallTransferInfo(0, info);
657 bool result;
658 callManagerClient->CanSetCallTransferTime(0, result);
659 callManagerClient->SetCallPreferenceMode(0, 0);
660 callManagerClient->StartDtmf(0, 'a');
661 callManagerClient->StopDtmf(0);
662 callManagerClient->IsRinging(result);
663 callManagerClient->HasCall();
664 callManagerClient->HasCall(false);
665 callManagerClient->HasCall(true);
666 callManagerClient->IsNewCallAllowed(result);
667 callManagerClient->IsInEmergencyCall(result);
668 callManagerClient->ObserverOnCallDetailsChange();
669 ASSERT_NE(callManagerClient->DialCall(value, extras), TELEPHONY_SUCCESS);
670 ASSERT_NE(callManagerClient->AnswerCall(0, 0), TELEPHONY_SUCCESS);
671 ASSERT_NE(callManagerClient->RejectCall(0, false, value), TELEPHONY_SUCCESS);
672 ASSERT_NE(callManagerClient->HangUpCall(0), TELEPHONY_SUCCESS);
673 ASSERT_GE(callManagerClient->GetCallState(), TELEPHONY_SUCCESS);
674 ASSERT_NE(callManagerClient->RemoveMissedIncomingCallNotification(), TELEPHONY_SUCCESS);
675 }
676
677 /**
678 * @tc.number Telephony_CallManagerClient_002
679 * @tc.name test error branch
680 * @tc.desc Function test
681 */
682 HWTEST_F(ZeroBranch3Test, Telephony_CallManagerClient_002, TestSize.Level0)
683 {
684 std::shared_ptr<CallManagerClient> callManagerClient = std::make_shared<CallManagerClient>();
685 std::u16string value = u"";
686 std::string value_ = "";
687 bool enabled;
688 int32_t callId = 1;
689 ASSERT_NE(callManagerClient->IsEmergencyPhoneNumber(value, 0, enabled), TELEPHONY_SUCCESS);
690 ASSERT_NE(callManagerClient->FormatPhoneNumber(value, value, value), TELEPHONY_SUCCESS);
691 ASSERT_NE(callManagerClient->FormatPhoneNumberToE164(value, value, value), TELEPHONY_SUCCESS);
692 ASSERT_NE(callManagerClient->SetMuted(false), TELEPHONY_SUCCESS);
693 ASSERT_NE(callManagerClient->MuteRinger(), TELEPHONY_SUCCESS);
694 AudioDevice audioDevice = {
695 .deviceType = AudioDeviceType::DEVICE_EARPIECE,
696 .address = { 0 },
697 };
698 callManagerClient->SetAudioDevice(audioDevice);
699 ASSERT_NE(callManagerClient->ControlCamera(callId, value), TELEPHONY_SUCCESS);
700 ASSERT_NE(callManagerClient->SetPreviewWindow(callId, value_), TELEPHONY_SUCCESS);
701 ASSERT_NE(callManagerClient->SetDisplayWindow(callId, value_), TELEPHONY_SUCCESS);
702 float zoomRatio = 1;
703 callManagerClient->GetImsConfig(0, ImsConfigItem::ITEM_IMS_SWITCH_STATUS);
704 callManagerClient->SetImsConfig(0, ImsConfigItem::ITEM_IMS_SWITCH_STATUS, value);
705 callManagerClient->GetImsFeatureValue(0, FeatureType::TYPE_SS_OVER_UT);
706 callManagerClient->SetImsFeatureValue(0, FeatureType::TYPE_SS_OVER_UT, 0);
707 callManagerClient->UpdateImsCallMode(0, ImsCallMode::CALL_MODE_AUDIO_ONLY);
708 callManagerClient->EnableImsSwitch(0);
709 callManagerClient->DisableImsSwitch(0);
710 callManagerClient->IsImsSwitchEnabled(0, enabled);
711 callManagerClient->StartRtt(0, value);
712 callManagerClient->StopRtt(0);
713 std::vector<std::u16string> numberList;
714 callManagerClient->JoinConference(0, numberList);
715 std::vector<OttCallDetailsInfo> ottVec;
716 callManagerClient->ReportOttCallDetailsInfo(ottVec);
717 OttCallEventInfo eventInfo;
718 callManagerClient->ReportOttCallEventInfo(eventInfo);
719 callManagerClient->ReportOttCallEventInfo(eventInfo);
720 ASSERT_GT(callManagerClient->SetCameraZoom(zoomRatio), TELEPHONY_ERROR);
721 ASSERT_GT(callManagerClient->SetPausePicture(callId, value), TELEPHONY_ERROR);
722 ASSERT_GT(callManagerClient->SetDeviceDirection(callId, 0), TELEPHONY_ERROR);
723 ASSERT_GT(callManagerClient->CancelCallUpgrade(callId), TELEPHONY_ERROR);
724 ASSERT_GT(callManagerClient->RequestCameraCapabilities(callId), TELEPHONY_ERROR);
725 int32_t slotId = 0;
726 std::string content = "1";
727 ASSERT_GT(callManagerClient->SendUssdResponse(slotId, content), TELEPHONY_ERROR);
728 std::vector<std::string> dialingList;
729 std::vector<std::string> incomingList;
730 ASSERT_GT(callManagerClient->SetCallPolicyInfo(false, dialingList, false, incomingList), TELEPHONY_ERROR);
731 }
732
733 /**
734 * @tc.number Telephony_CallManagerHisysevent_001
735 * @tc.name test error branch
736 * @tc.desc Function test
737 */
738 HWTEST_F(ZeroBranch3Test, Telephony_CallManagerHisysevent_001, TestSize.Level0)
739 {
740 std::shared_ptr<CallManagerHisysevent> callManagerHisysevent = std::make_shared<CallManagerHisysevent>();
741 std::string desc;
742 callManagerHisysevent->WriteCallStateBehaviorEvent(0, 0, 0);
743 callManagerHisysevent->WriteIncomingCallBehaviorEvent(0, 1, 0);
744 callManagerHisysevent->WriteIncomingCallBehaviorEvent(0, 1, 1);
745 callManagerHisysevent->WriteIncomingCallBehaviorEvent(0, 0, 0);
746 callManagerHisysevent->WriteIncomingCallBehaviorEvent(0, -1, -1);
747 callManagerHisysevent->WriteIncomingCallFaultEvent(0, 0, 0, static_cast<int32_t>(TELEPHONY_ERR_MEMCPY_FAIL), desc);
748 auto errCode = static_cast<int32_t>(TELEPHONY_ERR_VCARD_FILE_INVALID) + STEP_1;
749 callManagerHisysevent->WriteIncomingCallFaultEvent(0, 0, 0, errCode, desc);
750 callManagerHisysevent->WriteDialCallFaultEvent(0, 0, 0, static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID), desc);
751 callManagerHisysevent->WriteDialCallFaultEvent(0, 0, 0, errCode, desc);
752 callManagerHisysevent->WriteAnswerCallFaultEvent(0, 0, 0, static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID), desc);
753 callManagerHisysevent->WriteAnswerCallFaultEvent(0, 0, 0, errCode, desc);
754 callManagerHisysevent->WriteHangUpFaultEvent(0, 0, static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID), desc);
755 callManagerHisysevent->WriteHangUpFaultEvent(0, 0, errCode, desc);
756 CallErrorCode eventValue;
757 callManagerHisysevent->CallDataErrorCodeConversion(-1, eventValue);
758 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID), eventValue);
759 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_INVALID_SLOT_ID);
760 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_CALLID), eventValue);
761 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_INVALID_CALLID);
762 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_PHONE_NUMBER_EMPTY), eventValue);
763 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_PHONE_NUMBER_EMPTY);
764 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_NUMBER_OUT_OF_RANGE), eventValue);
765 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_NUMBER_OUT_OF_RANGE);
766 callManagerHisysevent->CallDataErrorCodeConversion(
767 static_cast<int32_t>(CALL_ERR_UNSUPPORTED_NETWORK_TYPE), eventValue);
768 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_UNSUPPORTED_NETWORK_TYPE);
769 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_DIAL_SCENE), eventValue);
770 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_INVALID_DIAL_SCENE);
771 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_VIDEO_STATE), eventValue);
772 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_INVALID_VIDEO_STATE);
773 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_UNKNOW_DIAL_TYPE), eventValue);
774 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_UNKNOW_DIAL_TYPE);
775 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_UNKNOW_CALL_TYPE), eventValue);
776 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_UNKNOW_CALL_TYPE);
777 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_CALL_OBJECT_IS_NULL), eventValue);
778 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_CALL_OBJECT_IS_NULL);
779 callManagerHisysevent->CallInterfaceErrorCodeConversion(-1, eventValue);
780 callManagerHisysevent->CallInterfaceErrorCodeConversion(static_cast<int32_t>(CALL_ERR_DIAL_IS_BUSY), eventValue);
781 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_DIAL_IS_BUSY);
782 callManagerHisysevent->CallInterfaceErrorCodeConversion(
783 static_cast<int32_t>(CALL_ERR_ILLEGAL_CALL_OPERATION), eventValue);
784 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_ILLEGAL_CALL_OPERATION);
785 callManagerHisysevent->CallInterfaceErrorCodeConversion(
786 static_cast<int32_t>(CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED), eventValue);
787 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_PHONE_CALLSTATE_NOTIFY_FAILED);
788 }
789
790 /**
791 * @tc.number Telephony_CallManagerHisysevent_002
792 * @tc.name test error branch
793 * @tc.desc Function test
794 */
795 HWTEST_F(ZeroBranch3Test, Telephony_CallManagerHisysevent_002, TestSize.Level0)
796 {
797 std::shared_ptr<CallManagerHisysevent> callManagerHisysevent = std::make_shared<CallManagerHisysevent>();
798 std::string errordesc;
799 callManagerHisysevent->GetErrorDescription(static_cast<int32_t>(CALL_ERR_PHONE_NUMBER_EMPTY), errordesc);
800 callManagerHisysevent->GetErrorDescription(static_cast<int32_t>(CALL_ERR_UNKNOW_DIAL_TYPE), errordesc);
801 callManagerHisysevent->GetErrorDescription(static_cast<int32_t>(TELEPHONY_ERR_LOCAL_PTR_NULL), errordesc);
802 callManagerHisysevent->GetErrorDescription(static_cast<int32_t>(CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE), errordesc);
803 callManagerHisysevent->SetDialStartTime();
804 callManagerHisysevent->SetIncomingStartTime();
805 callManagerHisysevent->SetAnswerStartTime();
806 callManagerHisysevent->JudgingDialTimeOut(0, 0, 0);
807 callManagerHisysevent->JudgingIncomingTimeOut(0, 0, 0);
808 callManagerHisysevent->JudgingAnswerTimeOut(0, 0, 0);
809 CallErrorCode eventValue;
810 callManagerHisysevent->CallInterfaceErrorCodeConversion(
811 static_cast<int32_t>(CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE), eventValue);
812 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_SYSTEM_EVENT_HANDLE_FAILURE);
813 callManagerHisysevent->CallInterfaceErrorCodeConversion(
814 static_cast<int32_t>(CALL_ERR_CALL_COUNTS_EXCEED_LIMIT), eventValue);
815 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_CALL_COUNTS_EXCEED_LIMIT);
816 callManagerHisysevent->CallInterfaceErrorCodeConversion(
817 static_cast<int32_t>(CALL_ERR_GET_RADIO_STATE_FAILED), eventValue);
818 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_GET_RADIO_STATE_FAILED);
819 callManagerHisysevent->TelephonyErrorCodeConversion(-1, eventValue);
820 callManagerHisysevent->TelephonyErrorCodeConversion(static_cast<int32_t>(TELEPHONY_ERR_LOCAL_PTR_NULL), eventValue);
821 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_CALL_LOCAL_PTR_NULL);
822 callManagerHisysevent->TelephonyErrorCodeConversion(
823 static_cast<int32_t>(TELEPHONY_ERR_ARGUMENT_INVALID), eventValue);
824 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_ARGUMENT_INVALID);
825 callManagerHisysevent->TelephonyErrorCodeConversion(
826 static_cast<int32_t>(TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL), eventValue);
827 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_IPC_CONNECT_STUB_FAIL);
828 callManagerHisysevent->TelephonyErrorCodeConversion(
829 static_cast<int32_t>(TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL), eventValue);
830 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_IPC_WRITE_DESCRIPTOR_TOKEN_FAIL);
831 callManagerHisysevent->TelephonyErrorCodeConversion(
832 static_cast<int32_t>(TELEPHONY_ERR_WRITE_DATA_FAIL), eventValue);
833 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_IPC_WRITE_DATA_FAIL);
834 callManagerHisysevent->TelephonyErrorCodeConversion(static_cast<int32_t>(TELEPHONY_ERR_PERMISSION_ERR), eventValue);
835 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_PERMISSION_ERR);
836 callManagerHisysevent->TelephonyErrorCodeConversion(static_cast<int32_t>(TELEPHONY_ERR_MEMSET_FAIL), eventValue);
837 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_MEMSET_FAIL);
838 callManagerHisysevent->TelephonyErrorCodeConversion(static_cast<int32_t>(TELEPHONY_ERR_MEMCPY_FAIL), eventValue);
839 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_MEMCPY_FAIL);
840 std::shared_ptr<NativeCallManagerHisysevent> nativeCallManagerHisysevent =
841 std::make_shared<NativeCallManagerHisysevent>();
842 nativeCallManagerHisysevent->WriteVoipCallEvent("001", "test", 0, 111, "testMsg", 1, 1, 1);
843 }
844
845
846 /**
847 * @tc.number Telephony_CallManagerHisysevent_003
848 * @tc.name test error branch
849 * @tc.desc Function test
850 */
851 HWTEST_F(ZeroBranch3Test, Telephony_CallManagerHisysevent_003, TestSize.Level0)
852 {
853 std::shared_ptr<CallManagerHisysevent> callManagerHisysevent = std::make_shared<CallManagerHisysevent>();
854 callManagerHisysevent->WriteVoipCallStatisticalEvent(0, "statisticalField");
855 DialParaInfo dialInfo;
856 int32_t appIndex = -1;
857 sptr<CallBase> call1 = new VoIPCall(dialInfo);
858 CallObjectManager::AddOneCallObject(call1);
859 sptr<VoIPCall> voipCall = reinterpret_cast<VoIPCall *>(call1.GetRefPtr());
860 callManagerHisysevent->WriteVoipCallStatisticalEvent("123", "abc", 100, "statisticalField");
861 callManagerHisysevent->WriteVoipCallStatisticalEvent(call1->GetCallID(), "statisticalField");
862 callManagerHisysevent->GetAppIndexByBundleName(voipCall->GetVoipBundleName(), voipCall->GetVoipUid(), appIndex);
863 EXPECT_EQ(appIndex, -1);
864 }
865 /**
866 * @tc.number Telephony_OTTCall_001
867 * @tc.name test error branch
868 * @tc.desc Function test
869 */
870 HWTEST_F(ZeroBranch3Test, Telephony_OTTCall_001, TestSize.Level0)
871 {
872 DialParaInfo info;
873 info.number = TEST_STR;
874 std::shared_ptr<OTTCall> ottCall = std::make_shared<OTTCall>(info);
875 CallAttributeInfo callAttributeInfo;
876 ottCall->GetCallAttributeInfo(callAttributeInfo);
877 ASSERT_EQ(ottCall->DialingProcess(), TELEPHONY_SUCCESS);
878 ASSERT_NE(ottCall->AnswerCall(static_cast<int32_t>(VideoStateType::TYPE_VOICE)), TELEPHONY_SUCCESS);
879 ASSERT_NE(ottCall->RejectCall(), TELEPHONY_SUCCESS);
880 ASSERT_NE(ottCall->HangUpCall(), TELEPHONY_SUCCESS);
881 ASSERT_NE(ottCall->HoldCall(), TELEPHONY_SUCCESS);
882 ASSERT_NE(ottCall->UnHoldCall(), TELEPHONY_SUCCESS);
883 ASSERT_NE(ottCall->SwitchCall(), TELEPHONY_SUCCESS);
884 ASSERT_FALSE(ottCall->GetEmergencyState());
885 ASSERT_NE(ottCall->StartDtmf('a'), TELEPHONY_SUCCESS);
886 ASSERT_NE(ottCall->StopDtmf(), TELEPHONY_SUCCESS);
887 ASSERT_NE(ottCall->GetSlotId(), TELEPHONY_SUCCESS);
888 ASSERT_NE(ottCall->CombineConference(), TELEPHONY_SUCCESS);
889 ASSERT_EQ(ottCall->CanCombineConference(), TELEPHONY_SUCCESS);
890 ASSERT_NE(ottCall->SeparateConference(), TELEPHONY_SUCCESS);
891 ASSERT_NE(ottCall->KickOutFromConference(), TELEPHONY_SUCCESS);
892 ASSERT_NE(ottCall->CanSeparateConference(), TELEPHONY_SUCCESS);
893 ASSERT_NE(ottCall->CanKickOutFromConference(), TELEPHONY_SUCCESS);
894 ASSERT_EQ(ottCall->LaunchConference(), TELEPHONY_SUCCESS);
895 ASSERT_EQ(ottCall->ExitConference(), TELEPHONY_SUCCESS);
896 ASSERT_NE(ottCall->HoldConference(), TELEPHONY_SUCCESS);
897 int32_t mainCallId = 1;
898 ASSERT_EQ(ottCall->GetMainCallId(mainCallId), TELEPHONY_SUCCESS);
899 std::vector<std::u16string> subCallIdList;
900 ASSERT_NE(ottCall->GetSubCallIdList(subCallIdList), TELEPHONY_SUCCESS);
901 std::vector<std::u16string> callIdList;
902 ASSERT_NE(ottCall->GetCallIdListForConference(callIdList), TELEPHONY_SUCCESS);
903 ASSERT_EQ(ottCall->IsSupportConferenceable(), TELEPHONY_SUCCESS);
904 ASSERT_NE(ottCall->SetMute(0, SIM1_SLOTID), TELEPHONY_SUCCESS);
905 OttCallRequestInfo requestInfo = {
906 .phoneNum = "",
907 .bundleName = "",
908 .videoState = VideoStateType::TYPE_VOICE,
909 };
910 ASSERT_EQ(ottCall->PackOttCallRequestInfo(requestInfo), TELEPHONY_SUCCESS);
911 ASSERT_NE(ottCall->PostDialProceed(true), TELEPHONY_SUCCESS);
912 }
913
914 /**
915 * @tc.number Telephony_OTTCall_002
916 * @tc.name test error branch
917 * @tc.desc Function test
918 */
919 HWTEST_F(ZeroBranch3Test, Telephony_OTTCall_002, TestSize.Level0)
920 {
921 DialParaInfo info;
922 info.number = TEST_STR;
923 std::shared_ptr<OTTCall> ottCall = std::make_shared<OTTCall>(info);
924 ottCall->HandleCombineConferenceFailEvent();
925 ASSERT_NE(ottCall->InitVideoCall(), TELEPHONY_SUCCESS);
926 ImsCallMode mode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
927 ASSERT_NE(ottCall->UpdateImsCallMode(mode), TELEPHONY_SUCCESS);
928 CallMediaModeInfo callMediaModeInfo;
929 ASSERT_NE(ottCall->ReportImsCallModeInfo(callMediaModeInfo), TELEPHONY_SUCCESS);
930 ASSERT_NE(ottCall->SendUpdateCallMediaModeRequest(mode), TELEPHONY_SUCCESS);
931 CallModeReportInfo callModeReportInfo;
932 ASSERT_NE(ottCall->RecieveUpdateCallMediaModeRequest(callModeReportInfo), TELEPHONY_SUCCESS);
933 ASSERT_NE(ottCall->SendUpdateCallMediaModeResponse(mode), TELEPHONY_SUCCESS);
934 ASSERT_NE(ottCall->ReceiveUpdateCallMediaModeResponse(callModeReportInfo), TELEPHONY_SUCCESS);
935 std::string value = "123";
936 ASSERT_NE(ottCall->ControlCamera(value, 1, 1), TELEPHONY_SUCCESS);
937 ASSERT_NE(ottCall->SetPausePicture(value), TELEPHONY_SUCCESS);
938 uint64_t tempSurfaceId = std::stoull(value);
939 auto surface = SurfaceUtils::GetInstance()->GetSurface(tempSurfaceId);
940 if (surface == nullptr) {
941 value = "";
942 }
943 ASSERT_NE(ottCall->SetPreviewWindow(value, surface), TELEPHONY_SUCCESS);
944 ASSERT_NE(ottCall->SetDisplayWindow(value, surface), TELEPHONY_SUCCESS);
945 ASSERT_NE(ottCall->SetDeviceDirection(1), TELEPHONY_SUCCESS);
946 ASSERT_NE(ottCall->CancelCallUpgrade(), TELEPHONY_SUCCESS);
947 ASSERT_NE(ottCall->RequestCameraCapabilities(), TELEPHONY_SUCCESS);
948 }
949 } // namespace Telephony
950 } // namespace OHOS
951