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 ASSERT_NE(
270 videoReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_SUCCESS);
271 ASSERT_EQ(
272 videoReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_ONLY), TELEPHONY_ERR_SUCCESS);
273 ASSERT_EQ(
274 videoReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_RECEIVE_ONLY), TELEPHONY_ERR_SUCCESS);
275 ASSERT_EQ(
276 videoReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_RECEIVE), TELEPHONY_ERR_SUCCESS);
277 ASSERT_NE(
278 videoReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_VIDEO_PAUSED), TELEPHONY_ERR_SUCCESS);
279 CallMediaModeInfo imsCallModeRequestInfo;
280 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
281 ASSERT_NE(videoReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
282 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_ONLY;
283 ASSERT_EQ(videoReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
284 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
285 ASSERT_EQ(videoReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
286 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_RECEIVE;
287 ASSERT_NE(videoReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
288 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_VIDEO_PAUSED;
289 ASSERT_NE(videoReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
290 ASSERT_NE(
291 videoReceiveState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_SUCCESS);
292 ASSERT_EQ(
293 videoReceiveState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_SEND_ONLY), TELEPHONY_ERR_SUCCESS);
294 ASSERT_EQ(
295 videoReceiveState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_RECEIVE_ONLY), TELEPHONY_ERR_SUCCESS);
296 ASSERT_NE(
297 videoReceiveState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_SEND_RECEIVE), TELEPHONY_ERR_SUCCESS);
298 ASSERT_NE(
299 videoReceiveState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_VIDEO_PAUSED), TELEPHONY_ERR_SUCCESS);
300 CallMediaModeInfo imsCallModeResponseInfo;
301 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
302 ASSERT_NE(videoReceiveState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
303 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_SEND_ONLY;
304 ASSERT_EQ(videoReceiveState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
305 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
306 ASSERT_EQ(videoReceiveState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
307 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_SEND_RECEIVE;
308 ASSERT_NE(videoReceiveState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
309 imsCallModeResponseInfo.callMode = ImsCallMode::CALL_MODE_VIDEO_PAUSED;
310 ASSERT_NE(videoReceiveState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
311 }
312
313 /**
314 * @tc.number Telephony_VideoCallState_004
315 * @tc.name test error branch
316 * @tc.desc Function test
317 */
318 HWTEST_F(ZeroBranch3Test, Telephony_VideoCallState_004, Function | MediumTest | Level1)
319 {
320 VideoSendReceiveState videoSendReceiveState = VideoSendReceiveState(nullptr);
321 ASSERT_NE(videoSendReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_AUDIO_ONLY),
322 TELEPHONY_ERR_SUCCESS);
323 ASSERT_NE(
324 videoSendReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_ONLY), TELEPHONY_ERR_SUCCESS);
325 ASSERT_NE(videoSendReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_RECEIVE_ONLY),
326 TELEPHONY_ERR_SUCCESS);
327 ASSERT_NE(videoSendReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_RECEIVE),
328 TELEPHONY_ERR_SUCCESS);
329 ASSERT_NE(videoSendReceiveState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_VIDEO_PAUSED),
330 TELEPHONY_ERR_SUCCESS);
331 CallMediaModeInfo imsCallModeRequestInfo;
332 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
333 ASSERT_NE(videoSendReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
334 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_ONLY;
335 ASSERT_EQ(videoSendReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
336 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
337 ASSERT_EQ(videoSendReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
338 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_RECEIVE;
339 ASSERT_EQ(videoSendReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
340 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_VIDEO_PAUSED;
341 ASSERT_EQ(videoSendReceiveState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
342 ASSERT_EQ(videoSendReceiveState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY),
343 TELEPHONY_ERR_SUCCESS);
344 CallMediaModeInfo imsCallModeResponseInfo;
345 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
346 ASSERT_NE(
347 videoSendReceiveState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
348 }
349
350 /**
351 * @tc.number Telephony_VideoCallState_005
352 * @tc.name test error branch
353 * @tc.desc Function test
354 */
355 HWTEST_F(ZeroBranch3Test, Telephony_VideoCallState_005, Function | MediumTest | Level1)
356 {
357 VideoPauseState videoPauseState = VideoPauseState(nullptr);
358 ASSERT_NE(
359 videoPauseState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_SUCCESS);
360 ASSERT_NE(videoPauseState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_ONLY), TELEPHONY_ERR_SUCCESS);
361 ASSERT_NE(
362 videoPauseState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_RECEIVE_ONLY), TELEPHONY_ERR_SUCCESS);
363 ASSERT_NE(
364 videoPauseState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_SEND_RECEIVE), TELEPHONY_ERR_SUCCESS);
365 ASSERT_NE(
366 videoPauseState.SendUpdateCallMediaModeRequest(ImsCallMode::CALL_MODE_VIDEO_PAUSED), TELEPHONY_ERR_SUCCESS);
367 CallMediaModeInfo imsCallModeRequestInfo;
368 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
369 ASSERT_NE(videoPauseState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
370 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_ONLY;
371 ASSERT_EQ(videoPauseState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
372 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_RECEIVE_ONLY;
373 ASSERT_EQ(videoPauseState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
374 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_SEND_RECEIVE;
375 ASSERT_NE(videoPauseState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
376 imsCallModeRequestInfo.callMode = ImsCallMode::CALL_MODE_VIDEO_PAUSED;
377 ASSERT_NE(videoPauseState.RecieveUpdateCallMediaModeRequest(imsCallModeRequestInfo), TELEPHONY_ERR_SUCCESS);
378 ASSERT_EQ(
379 videoPauseState.SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_ERR_SUCCESS);
380 CallMediaModeInfo imsCallModeResponseInfo;
381 ASSERT_EQ(videoPauseState.ReceiveUpdateCallMediaModeResponse(imsCallModeResponseInfo), TELEPHONY_ERR_SUCCESS);
382 // Test VideoCallState class cases
383 videoPauseState.IsCallSupportVideoCall();
384 videoPauseState.SetVideoUpdateStatus(VideoUpdateStatus::STATUS_NONE);
385 videoPauseState.GetVideoUpdateStatus();
386 videoPauseState.SwitchCallVideoState(ImsCallMode::CALL_MODE_AUDIO_ONLY);
387 videoPauseState.DispatchUpdateVideoRequest(ImsCallMode::CALL_MODE_AUDIO_ONLY);
388 videoPauseState.DispatchUpdateVideoResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY);
389 CallMediaModeInfo imsCallModeInfo;
390 videoPauseState.DispatchReportVideoCallInfo(imsCallModeInfo);
391 }
392
393 /**
394 * @tc.number Telephony_IncomingCallNotification_001
395 * @tc.name test error branch
396 * @tc.desc Function test
397 */
398 HWTEST_F(ZeroBranch3Test, Telephony_IncomingCallNotification_001, Function | MediumTest | Level3)
399 {
400 std::shared_ptr<IncomingCallNotification> incomingCallNotification = std::make_shared<IncomingCallNotification>();
401 sptr<CallBase> callObjectPtr = nullptr;
402 incomingCallNotification->NewCallCreated(callObjectPtr);
403 incomingCallNotification->CallStateUpdated(
404 callObjectPtr, TelCallState::CALL_STATUS_IDLE, TelCallState::CALL_STATUS_INCOMING);
405 incomingCallNotification->CallStateUpdated(
406 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
407 incomingCallNotification->IncomingCallActivated(callObjectPtr);
408 incomingCallNotification->IncomingCallHungUp(callObjectPtr, false, "");
409 DialParaInfo info;
410 info.number = TEST_STR;
411 callObjectPtr = new CSCall(info);
412 incomingCallNotification->NewCallCreated(callObjectPtr);
413 callObjectPtr->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
414 incomingCallNotification->NewCallCreated(callObjectPtr);
415 incomingCallNotification->NewCallCreated(callObjectPtr);
416 incomingCallNotification->CallStateUpdated(
417 callObjectPtr, TelCallState::CALL_STATUS_IDLE, TelCallState::CALL_STATUS_INCOMING);
418 incomingCallNotification->CallStateUpdated(
419 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
420 incomingCallNotification->IncomingCallActivated(callObjectPtr);
421 incomingCallNotification->IncomingCallHungUp(callObjectPtr, false, "");
422
423 DialParaInfo emptyNumberInfo;
424 sptr<CallBase> emptyNumberInfocall = new CSCall(emptyNumberInfo);
425 incomingCallNotification->CallStateUpdated(
426 emptyNumberInfocall, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
427 incomingCallNotification->IncomingCallActivated(emptyNumberInfocall);
428 incomingCallNotification->IncomingCallHungUp(callObjectPtr, true, "");
429
430 DisconnectedDetails details;
431 incomingCallNotification->CallDestroyed(details);
432 incomingCallNotification->PublishIncomingCallNotification(emptyNumberInfocall);
433 ASSERT_EQ(incomingCallNotification->CancelIncomingCallNotification(), TELEPHONY_SUCCESS);
434 ASSERT_FALSE(incomingCallNotification->IsFullScreen());
435 }
436
437 /**
438 * @tc.number Telephony_RejectCallSms_001
439 * @tc.name test error branch
440 * @tc.desc Function test
441 */
442 HWTEST_F(ZeroBranch3Test, Telephony_RejectCallSms_001, Function | MediumTest | Level3)
443 {
444 std::shared_ptr<RejectCallSms> rejectCallSms = std::make_shared<RejectCallSms>();
445 sptr<CallBase> callObjectPtr = nullptr;
446 rejectCallSms->IncomingCallHungUp(callObjectPtr, true, "");
447 rejectCallSms->IncomingCallHungUp(callObjectPtr, false, "");
448 DialParaInfo info;
449 info.number = TEST_STR;
450 callObjectPtr = new CSCall(info);
451 rejectCallSms->IncomingCallHungUp(callObjectPtr, true, "");
452 rejectCallSms->IncomingCallHungUp(callObjectPtr, false, "");
453 rejectCallSms->IncomingCallHungUp(callObjectPtr, false, TEST_STR);
454
455 std::u16string desAddr = u"123";
456 std::u16string text = u"";
457 rejectCallSms->SendMessage(INVALID_SLOTID, desAddr, text);
458 rejectCallSms->NewCallCreated(callObjectPtr);
459
460 DisconnectedDetails details;
461 rejectCallSms->CallDestroyed(details);
462 rejectCallSms->IncomingCallActivated(callObjectPtr);
463
464 rejectCallSms->CallStateUpdated(
465 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
466
467 bool convertRet = rejectCallSms->ConvertToUtf16(TEST_STR) == desAddr;
468 ASSERT_TRUE(convertRet);
469 }
470
471 /**
472 * @tc.number Telephony_MissedCallNotification_001
473 * @tc.name test error branch
474 * @tc.desc Function test
475 */
476 HWTEST_F(ZeroBranch3Test, Telephony_MissedCallNotification_001, Function | MediumTest | Level3)
477 {
478 std::shared_ptr<MissedCallNotification> missedCallNotification = std::make_shared<MissedCallNotification>();
479 sptr<CallBase> callObjectPtr = nullptr;
480
481 missedCallNotification->NewCallCreated(callObjectPtr);
482 missedCallNotification->CallStateUpdated(
483 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
484
485 missedCallNotification->IncomingCallActivated(callObjectPtr);
486 missedCallNotification->IncomingCallHungUp(callObjectPtr, true, "");
487
488 DisconnectedDetails details;
489 missedCallNotification->CallDestroyed(details);
490
491 DialParaInfo info;
492 info.number = TEST_STR;
493 callObjectPtr = new CSCall(info);
494 missedCallNotification->CallStateUpdated(
495 callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
496 missedCallNotification->CallStateUpdated(
497 callObjectPtr, TelCallState::CALL_STATUS_DISCONNECTED, TelCallState::CALL_STATUS_INCOMING);
498
499 missedCallNotification->PublishMissedCallEvent(callObjectPtr);
500 std::map<std::string, int32_t> phoneNumAndUnReadCountMap;
501 phoneNumAndUnReadCountMap.insert(pair<string, int>("000", 1));
502 ASSERT_EQ(missedCallNotification->NotifyUnReadMissedCall(phoneNumAndUnReadCountMap), TELEPHONY_SUCCESS);
503 }
504
505 /**
506 * @tc.number Telephony_CallSettingManager_001
507 * @tc.name test error branch
508 * @tc.desc Function test
509 */
510 HWTEST_F(ZeroBranch3Test, Telephony_CallSettingManager_001, Function | MediumTest | Level3)
511 {
512 std::shared_ptr<CallSettingManager> callSettingManager = std::make_shared<CallSettingManager>();
513 ASSERT_NE(callSettingManager->SetCallWaiting(SIM1_SLOTID, true), TELEPHONY_SUCCESS);
514 ASSERT_NE(callSettingManager->SetCallWaiting(INVALID_SLOTID, true), TELEPHONY_SUCCESS);
515 ASSERT_NE(callSettingManager->GetCallWaiting(SIM1_SLOTID), TELEPHONY_SUCCESS);
516 ASSERT_NE(callSettingManager->GetCallWaiting(INVALID_SLOTID), TELEPHONY_SUCCESS);
517 ASSERT_NE(callSettingManager->GetCallRestriction(SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
518 TELEPHONY_SUCCESS);
519 ASSERT_NE(callSettingManager->GetCallRestriction(INVALID_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS),
520 TELEPHONY_SUCCESS);
521
522 CallRestrictionInfo callRestrictionInfo = {
523 .password = "",
524 .fac = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING,
525 .mode = CallRestrictionMode::RESTRICTION_MODE_DEACTIVATION,
526 };
527 callSettingManager->SetCallRestriction(SIM1_SLOTID, callRestrictionInfo);
528 callSettingManager->SetCallRestriction(INVALID_SLOTID, callRestrictionInfo);
529
530 CallTransferInfo callTransferInfo = {
531 .transferNum = "",
532 .settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE,
533 .type = CallTransferType::TRANSFER_TYPE_BUSY,
534 .startHour = 1,
535 .startMinute = 1,
536 .endHour = 1,
537 .endMinute = 1,
538 };
539 ASSERT_NE(callSettingManager->SetCallTransferInfo(SIM1_SLOTID, callTransferInfo), TELEPHONY_SUCCESS);
540 ASSERT_NE(callSettingManager->SetCallTransferInfo(INVALID_SLOTID, callTransferInfo), TELEPHONY_SUCCESS);
541 bool result = false;
542 ASSERT_NE(callSettingManager->CanSetCallTransferTime(SIM1_SLOTID, result), TELEPHONY_SUCCESS);
543 ASSERT_NE(callSettingManager->SetCallPreferenceMode(SIM1_SLOTID, INVALID_MODE), TELEPHONY_SUCCESS);
544 ASSERT_NE(callSettingManager->SetCallPreferenceMode(SIM1_SLOTID, CS_VOICE_ONLY), TELEPHONY_SUCCESS);
545 ImsConfigItem item = ITEM_VIDEO_QUALITY;
546 ASSERT_NE(callSettingManager->GetImsConfig(SIM1_SLOTID, item), TELEPHONY_SUCCESS);
547 std::u16string value = u"";
548 ASSERT_NE(callSettingManager->SetImsConfig(SIM1_SLOTID, item, value), TELEPHONY_SUCCESS);
549 ASSERT_NE(callSettingManager->GetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_VOICE_OVER_LTE), TELEPHONY_SUCCESS);
550 int32_t featureValue = 0;
551 ASSERT_NE(callSettingManager->SetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_VOICE_OVER_LTE, featureValue),
552 TELEPHONY_SUCCESS);
553 ASSERT_NE(callSettingManager->EnableImsSwitch(SIM1_SLOTID), TELEPHONY_SUCCESS);
554 ASSERT_NE(callSettingManager->DisableImsSwitch(SIM1_SLOTID), TELEPHONY_SUCCESS);
555 bool enabled = false;
556 ASSERT_NE(callSettingManager->IsImsSwitchEnabled(SIM1_SLOTID, enabled), TELEPHONY_SUCCESS);
557 }
558
559 /**
560 * @tc.number Telephony_CallAbilityCallback_001
561 * @tc.name test error branch
562 * @tc.desc Function test
563 */
564 HWTEST_F(ZeroBranch3Test, Telephony_CallAbilityCallback_001, Function | MediumTest | Level3)
565 {
566 std::shared_ptr<CallAbilityCallback> callAbilityCallback = std::make_shared<CallAbilityCallback>();
567 ASSERT_EQ(callAbilityCallback->SetProcessCallback(nullptr), TELEPHONY_SUCCESS);
568 CallAttributeInfo callAttributeInfo;
569 ASSERT_EQ(callAbilityCallback->OnCallDetailsChange(callAttributeInfo), TELEPHONY_SUCCESS);
570 ASSERT_EQ(callAbilityCallback->OnMeeTimeDetailsChange(callAttributeInfo), TELEPHONY_SUCCESS);
571 CallEventInfo info;
572 ASSERT_EQ(callAbilityCallback->OnCallEventChange(info), TELEPHONY_SUCCESS);
573 DisconnectedDetails details;
574 ASSERT_EQ(callAbilityCallback->OnCallDisconnectedCause(details), TELEPHONY_SUCCESS);
575 AppExecFwk::PacMap resultInfo;
576 ASSERT_EQ(
577 callAbilityCallback->OnReportAsyncResults(CallResultReportId::GET_CALL_CLIP_ID, resultInfo), TELEPHONY_SUCCESS);
578 MmiCodeInfo mmiCodeInfo;
579 ASSERT_EQ(callAbilityCallback->OnReportMmiCodeResult(mmiCodeInfo), TELEPHONY_SUCCESS);
580 ASSERT_EQ(
581 callAbilityCallback->OnOttCallRequest(OttCallRequestId::OTT_REQUEST_ANSWER, resultInfo), TELEPHONY_SUCCESS);
582 CallMediaModeInfo imsCallModeInfo;
583 ASSERT_EQ(callAbilityCallback->OnReportImsCallModeChange(imsCallModeInfo), TELEPHONY_SUCCESS);
584 CallSessionEvent callSessionEventOptions;
585 ASSERT_EQ(callAbilityCallback->OnReportCallSessionEventChange(callSessionEventOptions), TELEPHONY_SUCCESS);
586 PeerDimensionsDetail peerDimensionsDetail;
587 ASSERT_EQ(callAbilityCallback->OnReportPeerDimensionsChange(peerDimensionsDetail), TELEPHONY_SUCCESS);
588 int64_t dataUsage = 0;
589 ASSERT_EQ(callAbilityCallback->OnReportCallDataUsageChange(dataUsage), TELEPHONY_SUCCESS);
590 CameraCapabilities cameraCapabilities;
591 ASSERT_EQ(callAbilityCallback->OnReportCameraCapabilities(cameraCapabilities), TELEPHONY_SUCCESS);
592 }
593
594 /**
595 * @tc.number Telephony_CallAbilityCallbackStub_001
596 * @tc.name test error branch
597 * @tc.desc Function test
598 */
599 HWTEST_F(ZeroBranch3Test, Telephony_CallAbilityCallbackStub_001, Function | MediumTest | Level3)
600 {
601 std::shared_ptr<CallAbilityCallback> callAbilityCallback = std::make_shared<CallAbilityCallback>();
602 MessageParcel data;
603 MessageParcel reply;
604 MessageOption option;
605 data.WriteInterfaceToken(CallAbilityCallbackStub::GetDescriptor());
606 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
607 CallManagerCallAbilityInterfaceCode::UPDATE_CALL_STATE_INFO), data, reply, option);
608 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(CallManagerCallAbilityInterfaceCode::UPDATE_CALL_EVENT),
609 data, reply, option);
610 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
611 CallManagerCallAbilityInterfaceCode::UPDATE_CALL_DISCONNECTED_CAUSE), data, reply, option);
612 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
613 CallManagerCallAbilityInterfaceCode::UPDATE_CALL_ASYNC_RESULT_REQUEST), data, reply, option);
614 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
615 CallManagerCallAbilityInterfaceCode::REPORT_OTT_CALL_REQUEST),
616 data, reply, option);
617 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
618 CallManagerCallAbilityInterfaceCode::UPDATE_MMI_CODE_RESULT_REQUEST),
619 data, reply, option);
620 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
621 CallManagerCallAbilityInterfaceCode::UPDATE_AUDIO_DEVICE_CHANGE_RESULT_REQUEST),
622 data, reply, option);
623 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
624 CallManagerCallAbilityInterfaceCode::REPORT_POST_DIAL_DELAY),
625 data, reply, option);
626 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
627 CallManagerCallAbilityInterfaceCode::UPDATE_IMS_CALL_MODE_RECEIVE),
628 data, reply, option);
629 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
630 CallManagerCallAbilityInterfaceCode::CALL_SESSION_EVENT_CHANGE),
631 data, reply, option);
632 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
633 CallManagerCallAbilityInterfaceCode::PEERD_DIMENSIONS_CHANGE),
634 data, reply, option);
635 callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
636 CallManagerCallAbilityInterfaceCode::CALL_DATA_USAGE_CHANGE), data, reply, option);
637 int32_t res = callAbilityCallback->OnRemoteRequest(static_cast<uint32_t>(
638 CallManagerCallAbilityInterfaceCode::CAMERA_CAPABILITIES_CHANGE), data, reply, option);
639 ASSERT_NE(res, TELEPHONY_ERR_SUCCESS);
640 }
641
642 /**
643 * @tc.number Telephony_BluetoothCallClient_001
644 * @tc.name test error branch
645 * @tc.desc Function test
646 */
647 HWTEST_F(ZeroBranch3Test, Telephony_BluetoothCallClient_001, Function | MediumTest | Level3)
648 {
649 BluetoothCallClient &bluetoothCallClient = DelayedRefSingleton<BluetoothCallClient>::GetInstance();
650 bluetoothCallClient.UnInit();
651 ASSERT_NE(bluetoothCallClient.RegisterCallBack(nullptr), TELEPHONY_SUCCESS);
652 ASSERT_NE(bluetoothCallClient.UnRegisterCallBack(), TELEPHONY_SUCCESS);
653 std::u16string value = u"";
654 AppExecFwk::PacMap extras;
655 bool enabled;
656 bluetoothCallClient.IsNewCallAllowed(enabled);
657 bluetoothCallClient.IsInEmergencyCall(enabled);
658 bluetoothCallClient.SetMuted(false);
659 bluetoothCallClient.MuteRinger();
660 bluetoothCallClient.SetAudioDevice(AudioDeviceType::DEVICE_BLUETOOTH_SCO, "test");
661 bluetoothCallClient.GetCurrentCallList(-1).size();
662 ASSERT_NE(bluetoothCallClient.DialCall(value, extras), TELEPHONY_SUCCESS);
663 ASSERT_NE(bluetoothCallClient.AnswerCall(), TELEPHONY_SUCCESS);
664 ASSERT_NE(bluetoothCallClient.RejectCall(), TELEPHONY_SUCCESS);
665 ASSERT_NE(bluetoothCallClient.HangUpCall(), TELEPHONY_SUCCESS);
666 ASSERT_GE(bluetoothCallClient.GetCallState(), TELEPHONY_SUCCESS);
667 ASSERT_NE(bluetoothCallClient.HoldCall(), TELEPHONY_SUCCESS);
668 ASSERT_NE(bluetoothCallClient.UnHoldCall(), TELEPHONY_SUCCESS);
669 ASSERT_NE(bluetoothCallClient.SwitchCall(), TELEPHONY_SUCCESS);
670 ASSERT_NE(bluetoothCallClient.CombineConference(), TELEPHONY_SUCCESS);
671 ASSERT_NE(bluetoothCallClient.SeparateConference(), TELEPHONY_SUCCESS);
672 ASSERT_NE(bluetoothCallClient.KickOutFromConference(), TELEPHONY_SUCCESS);
673 ASSERT_NE(bluetoothCallClient.StartDtmf('a'), TELEPHONY_SUCCESS);
674 ASSERT_NE(bluetoothCallClient.StopDtmf(), TELEPHONY_SUCCESS);
675 ASSERT_NE(bluetoothCallClient.IsRinging(enabled), TELEPHONY_SUCCESS);
676 }
677
678 /**
679 * @tc.number Telephony_CallManagerClient_001
680 * @tc.name test error branch
681 * @tc.desc Function test
682 */
683 HWTEST_F(ZeroBranch3Test, Telephony_CallManagerClient_001, Function | MediumTest | Level3)
684 {
685 std::shared_ptr<CallManagerClient> callManagerClient = std::make_shared<CallManagerClient>();
686 callManagerClient->UnInit();
687 ASSERT_NE(callManagerClient->RegisterCallBack(nullptr), TELEPHONY_SUCCESS);
688 ASSERT_NE(callManagerClient->UnRegisterCallBack(), TELEPHONY_SUCCESS);
689 std::u16string value = u"";
690 AppExecFwk::PacMap extras;
691 callManagerClient->HoldCall(0);
692 callManagerClient->UnHoldCall(0);
693 callManagerClient->SwitchCall(0);
694 callManagerClient->CombineConference(0);
695 callManagerClient->SeparateConference(0);
696 callManagerClient->KickOutFromConference(0);
697 int32_t intValue;
698 callManagerClient->GetMainCallId(intValue, intValue);
699 std::vector<std::u16string> callIdList;
700 callManagerClient->GetSubCallIdList(0, callIdList);
701 callManagerClient->GetCallIdListForConference(0, callIdList);
702 callManagerClient->GetCallWaiting(0);
703 callManagerClient->SetCallWaiting(0, false);
704 callManagerClient->GetCallRestriction(0, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING);
705 CallRestrictionInfo callRestrictionInfo;
706 callManagerClient->SetCallRestriction(0, callRestrictionInfo);
707 callManagerClient->GetCallTransferInfo(0, CallTransferType::TRANSFER_TYPE_BUSY);
708 CallTransferInfo info;
709 callManagerClient->SetCallTransferInfo(0, info);
710 bool result;
711 callManagerClient->CanSetCallTransferTime(0, result);
712 callManagerClient->SetCallPreferenceMode(0, 0);
713 callManagerClient->StartDtmf(0, 'a');
714 callManagerClient->StopDtmf(0);
715 callManagerClient->IsRinging(result);
716 callManagerClient->HasCall();
717 callManagerClient->IsNewCallAllowed(result);
718 callManagerClient->IsInEmergencyCall(result);
719 callManagerClient->ObserverOnCallDetailsChange();
720 ASSERT_NE(callManagerClient->DialCall(value, extras), TELEPHONY_SUCCESS);
721 ASSERT_NE(callManagerClient->AnswerCall(0, 0), TELEPHONY_SUCCESS);
722 ASSERT_NE(callManagerClient->RejectCall(0, false, value), TELEPHONY_SUCCESS);
723 ASSERT_NE(callManagerClient->HangUpCall(0), TELEPHONY_SUCCESS);
724 ASSERT_GE(callManagerClient->GetCallState(), TELEPHONY_SUCCESS);
725 ASSERT_NE(callManagerClient->RemoveMissedIncomingCallNotification(), TELEPHONY_SUCCESS);
726 }
727
728 /**
729 * @tc.number Telephony_CallManagerClient_002
730 * @tc.name test error branch
731 * @tc.desc Function test
732 */
733 HWTEST_F(ZeroBranch3Test, Telephony_CallManagerClient_002, Function | MediumTest | Level3)
734 {
735 std::shared_ptr<CallManagerClient> callManagerClient = std::make_shared<CallManagerClient>();
736 std::u16string value = u"";
737 std::string value_ = "";
738 bool enabled;
739 int32_t callId = 1;
740 ASSERT_NE(callManagerClient->IsEmergencyPhoneNumber(value, 0, enabled), TELEPHONY_SUCCESS);
741 ASSERT_NE(callManagerClient->FormatPhoneNumber(value, value, value), TELEPHONY_SUCCESS);
742 ASSERT_NE(callManagerClient->FormatPhoneNumberToE164(value, value, value), TELEPHONY_SUCCESS);
743 ASSERT_NE(callManagerClient->SetMuted(false), TELEPHONY_SUCCESS);
744 ASSERT_NE(callManagerClient->MuteRinger(), TELEPHONY_SUCCESS);
745 AudioDevice audioDevice = {
746 .deviceType = AudioDeviceType::DEVICE_EARPIECE,
747 .address = { 0 },
748 };
749 callManagerClient->SetAudioDevice(audioDevice);
750 ASSERT_NE(callManagerClient->ControlCamera(callId, value), TELEPHONY_SUCCESS);
751 ASSERT_NE(callManagerClient->SetPreviewWindow(callId, value_), TELEPHONY_SUCCESS);
752 ASSERT_NE(callManagerClient->SetDisplayWindow(callId, value_), TELEPHONY_SUCCESS);
753 float zoomRatio = 1;
754 callManagerClient->GetImsConfig(0, ImsConfigItem::ITEM_IMS_SWITCH_STATUS);
755 callManagerClient->SetImsConfig(0, ImsConfigItem::ITEM_IMS_SWITCH_STATUS, value);
756 callManagerClient->GetImsFeatureValue(0, FeatureType::TYPE_SS_OVER_UT);
757 callManagerClient->SetImsFeatureValue(0, FeatureType::TYPE_SS_OVER_UT, 0);
758 callManagerClient->UpdateImsCallMode(0, ImsCallMode::CALL_MODE_AUDIO_ONLY);
759 callManagerClient->EnableImsSwitch(0);
760 callManagerClient->DisableImsSwitch(0);
761 callManagerClient->IsImsSwitchEnabled(0, enabled);
762 callManagerClient->StartRtt(0, value);
763 callManagerClient->StopRtt(0);
764 std::vector<std::u16string> numberList;
765 callManagerClient->JoinConference(0, numberList);
766 std::vector<OttCallDetailsInfo> ottVec;
767 callManagerClient->ReportOttCallDetailsInfo(ottVec);
768 OttCallEventInfo eventInfo;
769 callManagerClient->ReportOttCallEventInfo(eventInfo);
770 callManagerClient->ReportOttCallEventInfo(eventInfo);
771 ASSERT_GT(callManagerClient->SetCameraZoom(zoomRatio), TELEPHONY_ERROR);
772 ASSERT_GT(callManagerClient->SetPausePicture(callId, value), TELEPHONY_ERROR);
773 ASSERT_GT(callManagerClient->SetDeviceDirection(callId, 0), TELEPHONY_ERROR);
774 ASSERT_GT(callManagerClient->CancelCallUpgrade(callId), TELEPHONY_ERROR);
775 ASSERT_GT(callManagerClient->RequestCameraCapabilities(callId), TELEPHONY_ERROR);
776 int32_t slotId = 0;
777 std::string content = "1";
778 ASSERT_GT(callManagerClient->SendUssdResponse(slotId, content), TELEPHONY_ERROR);
779 }
780
781 /**
782 * @tc.number Telephony_CallManagerHisysevent_001
783 * @tc.name test error branch
784 * @tc.desc Function test
785 */
786 HWTEST_F(ZeroBranch3Test, Telephony_CallManagerHisysevent_001, Function | MediumTest | Level3)
787 {
788 std::shared_ptr<CallManagerHisysevent> callManagerHisysevent = std::make_shared<CallManagerHisysevent>();
789 std::string desc;
790 callManagerHisysevent->WriteCallStateBehaviorEvent(0, 0, 0);
791 callManagerHisysevent->WriteIncomingCallBehaviorEvent(0, 1, 0);
792 callManagerHisysevent->WriteIncomingCallBehaviorEvent(0, 1, 1);
793 callManagerHisysevent->WriteIncomingCallBehaviorEvent(0, 0, 0);
794 callManagerHisysevent->WriteIncomingCallBehaviorEvent(0, -1, -1);
795 callManagerHisysevent->WriteIncomingCallFaultEvent(0, 0, 0, static_cast<int32_t>(TELEPHONY_ERR_MEMCPY_FAIL), desc);
796 auto errCode = static_cast<int32_t>(TELEPHONY_ERR_VCARD_FILE_INVALID) + STEP_1;
797 callManagerHisysevent->WriteIncomingCallFaultEvent(0, 0, 0, errCode, desc);
798 callManagerHisysevent->WriteDialCallFaultEvent(0, 0, 0, static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID), desc);
799 callManagerHisysevent->WriteDialCallFaultEvent(0, 0, 0, errCode, desc);
800 callManagerHisysevent->WriteAnswerCallFaultEvent(0, 0, 0, static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID), desc);
801 callManagerHisysevent->WriteAnswerCallFaultEvent(0, 0, 0, errCode, desc);
802 callManagerHisysevent->WriteHangUpFaultEvent(0, 0, static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID), desc);
803 callManagerHisysevent->WriteHangUpFaultEvent(0, 0, errCode, desc);
804 CallErrorCode eventValue;
805 callManagerHisysevent->CallDataErrorCodeConversion(-1, eventValue);
806 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID), eventValue);
807 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_INVALID_SLOT_ID);
808 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_CALLID), eventValue);
809 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_INVALID_CALLID);
810 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_PHONE_NUMBER_EMPTY), eventValue);
811 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_PHONE_NUMBER_EMPTY);
812 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_NUMBER_OUT_OF_RANGE), eventValue);
813 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_NUMBER_OUT_OF_RANGE);
814 callManagerHisysevent->CallDataErrorCodeConversion(
815 static_cast<int32_t>(CALL_ERR_UNSUPPORTED_NETWORK_TYPE), eventValue);
816 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_UNSUPPORTED_NETWORK_TYPE);
817 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_DIAL_SCENE), eventValue);
818 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_INVALID_DIAL_SCENE);
819 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_VIDEO_STATE), eventValue);
820 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_INVALID_VIDEO_STATE);
821 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_UNKNOW_DIAL_TYPE), eventValue);
822 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_UNKNOW_DIAL_TYPE);
823 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_UNKNOW_CALL_TYPE), eventValue);
824 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_UNKNOW_CALL_TYPE);
825 callManagerHisysevent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_CALL_OBJECT_IS_NULL), eventValue);
826 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_CALL_OBJECT_IS_NULL);
827 callManagerHisysevent->CallInterfaceErrorCodeConversion(-1, eventValue);
828 callManagerHisysevent->CallInterfaceErrorCodeConversion(static_cast<int32_t>(CALL_ERR_DIAL_IS_BUSY), eventValue);
829 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_DIAL_IS_BUSY);
830 callManagerHisysevent->CallInterfaceErrorCodeConversion(
831 static_cast<int32_t>(CALL_ERR_ILLEGAL_CALL_OPERATION), eventValue);
832 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_ILLEGAL_CALL_OPERATION);
833 callManagerHisysevent->CallInterfaceErrorCodeConversion(
834 static_cast<int32_t>(CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED), eventValue);
835 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_PHONE_CALLSTATE_NOTIFY_FAILED);
836 }
837
838 /**
839 * @tc.number Telephony_CallManagerHisysevent_002
840 * @tc.name test error branch
841 * @tc.desc Function test
842 */
843 HWTEST_F(ZeroBranch3Test, Telephony_CallManagerHisysevent_002, Function | MediumTest | Level3)
844 {
845 std::shared_ptr<CallManagerHisysevent> callManagerHisysevent = std::make_shared<CallManagerHisysevent>();
846 std::string errordesc;
847 callManagerHisysevent->GetErrorDescription(static_cast<int32_t>(CALL_ERR_PHONE_NUMBER_EMPTY), errordesc);
848 callManagerHisysevent->GetErrorDescription(static_cast<int32_t>(CALL_ERR_UNKNOW_DIAL_TYPE), errordesc);
849 callManagerHisysevent->GetErrorDescription(static_cast<int32_t>(TELEPHONY_ERR_LOCAL_PTR_NULL), errordesc);
850 callManagerHisysevent->GetErrorDescription(static_cast<int32_t>(CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE), errordesc);
851 callManagerHisysevent->SetDialStartTime();
852 callManagerHisysevent->SetIncomingStartTime();
853 callManagerHisysevent->SetAnswerStartTime();
854 callManagerHisysevent->JudgingDialTimeOut(0, 0, 0);
855 callManagerHisysevent->JudgingIncomingTimeOut(0, 0, 0);
856 callManagerHisysevent->JudgingAnswerTimeOut(0, 0, 0);
857 CallErrorCode eventValue;
858 callManagerHisysevent->CallInterfaceErrorCodeConversion(
859 static_cast<int32_t>(CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE), eventValue);
860 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_SYSTEM_EVENT_HANDLE_FAILURE);
861 callManagerHisysevent->CallInterfaceErrorCodeConversion(
862 static_cast<int32_t>(CALL_ERR_CALL_COUNTS_EXCEED_LIMIT), eventValue);
863 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_CALL_COUNTS_EXCEED_LIMIT);
864 callManagerHisysevent->CallInterfaceErrorCodeConversion(
865 static_cast<int32_t>(CALL_ERR_GET_RADIO_STATE_FAILED), eventValue);
866 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_GET_RADIO_STATE_FAILED);
867 callManagerHisysevent->TelephonyErrorCodeConversion(-1, eventValue);
868 callManagerHisysevent->TelephonyErrorCodeConversion(static_cast<int32_t>(TELEPHONY_ERR_LOCAL_PTR_NULL), eventValue);
869 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_CALL_LOCAL_PTR_NULL);
870 callManagerHisysevent->TelephonyErrorCodeConversion(
871 static_cast<int32_t>(TELEPHONY_ERR_ARGUMENT_INVALID), eventValue);
872 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_ARGUMENT_INVALID);
873 callManagerHisysevent->TelephonyErrorCodeConversion(
874 static_cast<int32_t>(TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL), eventValue);
875 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_IPC_CONNECT_STUB_FAIL);
876 callManagerHisysevent->TelephonyErrorCodeConversion(
877 static_cast<int32_t>(TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL), eventValue);
878 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_IPC_WRITE_DESCRIPTOR_TOKEN_FAIL);
879 callManagerHisysevent->TelephonyErrorCodeConversion(
880 static_cast<int32_t>(TELEPHONY_ERR_WRITE_DATA_FAIL), eventValue);
881 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_IPC_WRITE_DATA_FAIL);
882 callManagerHisysevent->TelephonyErrorCodeConversion(static_cast<int32_t>(TELEPHONY_ERR_PERMISSION_ERR), eventValue);
883 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_PERMISSION_ERR);
884 callManagerHisysevent->TelephonyErrorCodeConversion(static_cast<int32_t>(TELEPHONY_ERR_MEMSET_FAIL), eventValue);
885 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_MEMSET_FAIL);
886 callManagerHisysevent->TelephonyErrorCodeConversion(static_cast<int32_t>(TELEPHONY_ERR_MEMCPY_FAIL), eventValue);
887 ASSERT_EQ(eventValue, CallErrorCode::CALL_ERROR_MEMCPY_FAIL);
888 std::shared_ptr<NativeCallManagerHisysevent> nativeCallManagerHisysevent =
889 std::make_shared<NativeCallManagerHisysevent>();
890 nativeCallManagerHisysevent->WriteVoipCallEvent("001", "test", 0, 111, "testMsg", 1, 1, 1);
891 }
892
893 /**
894 * @tc.number Telephony_OTTCall_001
895 * @tc.name test error branch
896 * @tc.desc Function test
897 */
898 HWTEST_F(ZeroBranch3Test, Telephony_OTTCall_001, Function | MediumTest | Level3)
899 {
900 DialParaInfo info;
901 info.number = TEST_STR;
902 std::shared_ptr<OTTCall> ottCall = std::make_shared<OTTCall>(info);
903 CallAttributeInfo callAttributeInfo;
904 ottCall->GetCallAttributeInfo(callAttributeInfo);
905 ASSERT_EQ(ottCall->DialingProcess(), TELEPHONY_SUCCESS);
906 ASSERT_NE(ottCall->AnswerCall(static_cast<int32_t>(VideoStateType::TYPE_VOICE)), TELEPHONY_SUCCESS);
907 ASSERT_NE(ottCall->RejectCall(), TELEPHONY_SUCCESS);
908 ASSERT_NE(ottCall->HangUpCall(), TELEPHONY_SUCCESS);
909 ASSERT_NE(ottCall->HoldCall(), TELEPHONY_SUCCESS);
910 ASSERT_NE(ottCall->UnHoldCall(), TELEPHONY_SUCCESS);
911 ASSERT_NE(ottCall->SwitchCall(), TELEPHONY_SUCCESS);
912 ASSERT_FALSE(ottCall->GetEmergencyState());
913 ASSERT_NE(ottCall->StartDtmf('a'), TELEPHONY_SUCCESS);
914 ASSERT_NE(ottCall->StopDtmf(), TELEPHONY_SUCCESS);
915 ASSERT_NE(ottCall->GetSlotId(), TELEPHONY_SUCCESS);
916 ASSERT_NE(ottCall->CombineConference(), TELEPHONY_SUCCESS);
917 ASSERT_EQ(ottCall->CanCombineConference(), TELEPHONY_SUCCESS);
918 ASSERT_NE(ottCall->SeparateConference(), TELEPHONY_SUCCESS);
919 ASSERT_NE(ottCall->KickOutFromConference(), TELEPHONY_SUCCESS);
920 ASSERT_NE(ottCall->CanSeparateConference(), TELEPHONY_SUCCESS);
921 ASSERT_NE(ottCall->CanKickOutFromConference(), TELEPHONY_SUCCESS);
922 ASSERT_EQ(ottCall->LaunchConference(), TELEPHONY_SUCCESS);
923 ASSERT_EQ(ottCall->ExitConference(), TELEPHONY_SUCCESS);
924 ASSERT_NE(ottCall->HoldConference(), TELEPHONY_SUCCESS);
925 int32_t mainCallId = 1;
926 ASSERT_EQ(ottCall->GetMainCallId(mainCallId), TELEPHONY_SUCCESS);
927 std::vector<std::u16string> subCallIdList;
928 ASSERT_NE(ottCall->GetSubCallIdList(subCallIdList), TELEPHONY_SUCCESS);
929 std::vector<std::u16string> callIdList;
930 ASSERT_NE(ottCall->GetCallIdListForConference(callIdList), TELEPHONY_SUCCESS);
931 ASSERT_EQ(ottCall->IsSupportConferenceable(), TELEPHONY_SUCCESS);
932 ASSERT_NE(ottCall->SetMute(0, SIM1_SLOTID), TELEPHONY_SUCCESS);
933 OttCallRequestInfo requestInfo = {
934 .phoneNum = "",
935 .bundleName = "",
936 .videoState = VideoStateType::TYPE_VOICE,
937 };
938 ASSERT_EQ(ottCall->PackOttCallRequestInfo(requestInfo), TELEPHONY_SUCCESS);
939 ASSERT_NE(ottCall->PostDialProceed(true), TELEPHONY_SUCCESS);
940 }
941
942 /**
943 * @tc.number Telephony_OTTCall_002
944 * @tc.name test error branch
945 * @tc.desc Function test
946 */
947 HWTEST_F(ZeroBranch3Test, Telephony_OTTCall_002, Function | MediumTest | Level3)
948 {
949 DialParaInfo info;
950 info.number = TEST_STR;
951 std::shared_ptr<OTTCall> ottCall = std::make_shared<OTTCall>(info);
952 ottCall->HandleCombineConferenceFailEvent();
953 ASSERT_NE(ottCall->InitVideoCall(), TELEPHONY_SUCCESS);
954 ImsCallMode mode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
955 ASSERT_NE(ottCall->UpdateImsCallMode(mode), TELEPHONY_SUCCESS);
956 CallMediaModeInfo callMediaModeInfo;
957 ASSERT_NE(ottCall->ReportImsCallModeInfo(callMediaModeInfo), TELEPHONY_SUCCESS);
958 ASSERT_NE(ottCall->SendUpdateCallMediaModeRequest(mode), TELEPHONY_SUCCESS);
959 CallModeReportInfo callModeReportInfo;
960 ASSERT_NE(ottCall->RecieveUpdateCallMediaModeRequest(callModeReportInfo), TELEPHONY_SUCCESS);
961 ASSERT_NE(ottCall->SendUpdateCallMediaModeResponse(mode), TELEPHONY_SUCCESS);
962 ASSERT_NE(ottCall->ReceiveUpdateCallMediaModeResponse(callModeReportInfo), TELEPHONY_SUCCESS);
963 std::string value = "123";
964 ASSERT_NE(ottCall->ControlCamera(value, 1, 1), TELEPHONY_SUCCESS);
965 ASSERT_NE(ottCall->SetPausePicture(value), TELEPHONY_SUCCESS);
966 uint64_t tempSurfaceId = std::stoull(value);
967 auto surface = SurfaceUtils::GetInstance()->GetSurface(tempSurfaceId);
968 if (surface == nullptr) {
969 value = "";
970 }
971 ASSERT_NE(ottCall->SetPreviewWindow(value, surface), TELEPHONY_SUCCESS);
972 ASSERT_NE(ottCall->SetDisplayWindow(value, surface), TELEPHONY_SUCCESS);
973 ASSERT_NE(ottCall->SetDeviceDirection(1), TELEPHONY_SUCCESS);
974 ASSERT_NE(ottCall->CancelCallUpgrade(), TELEPHONY_SUCCESS);
975 ASSERT_NE(ottCall->RequestCameraCapabilities(), TELEPHONY_SUCCESS);
976 }
977 } // namespace Telephony
978 } // namespace OHOS
979