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