1 /*
2 * Copyright (C) 2021-2022 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
16 #define private public
17 #define protected public
18 #include "call_manager_gtest.h"
19
20 #include <gtest/gtest.h>
21 #include <cstring>
22 #include <string>
23
24 #include "bluetooth_hfp_ag.h"
25 #include "call_manager_connect.h"
26 #include "call_manager_service.h"
27 #include "surface_utils.h"
28 #include "telephony_types.h"
29 #include "voip_call.h"
30
31 using namespace OHOS::Bluetooth;
32 namespace OHOS {
33 namespace Telephony {
34 using namespace testing::ext;
35 constexpr int16_t SIM2_SLOTID = 1;
36 constexpr int16_t SIM1_SLOTID_NO_CARD = 0;
37 constexpr int16_t RETURN_VALUE_IS_ZERO = 0;
38 constexpr int16_t INVALID_NEGATIVE_ID = -100;
39 constexpr int16_t INVALID_POSITIVE_ID = 100;
40 constexpr int INVALID_DIAL_TYPE = 3;
41 constexpr int WAIT_TIME = 3;
42 constexpr int16_t CAMERA_ROTATION_90 = 90;
43 constexpr int16_t CAMERA_ROTATION_ERROR = 50;
44 constexpr int16_t SLEEP_1000_MS = 1000;
45 constexpr int BASE_TIME_MS = 1000;
46 constexpr int SLEEP_TIME_MS = 50;
47 constexpr int MAX_LIMIT_TIME = 18000;
48 constexpr int16_t SIM1_SLOTID = 0;
49 const std::string PHONE_NUMBER = "0000000000";
50
51 std::unordered_map<int32_t, std::unordered_set<int32_t>> g_callStateMap;
52 int32_t g_newCallId = -1;
53 std::mutex CallInfoManager::mutex_;
54 int16_t CallInfoManager::newCallState_;
55 CallAttributeInfo CallInfoManager::updateCallInfo_;
56 std::unordered_set<int32_t> CallInfoManager::callIdSet_;
57
CallDetailsChange(const CallAttributeInfo & info)58 int32_t CallInfoManager::CallDetailsChange(const CallAttributeInfo &info)
59 {
60 TELEPHONY_LOGI("CallDetailsChange Start");
61 std::lock_guard<std::mutex> lock(mutex_);
62 updateCallInfo_ = info;
63 if (callIdSet_.find(updateCallInfo_.callId) == callIdSet_.end()) {
64 TELEPHONY_LOGI("CallDetailsChange new call");
65 callIdSet_.insert(updateCallInfo_.callId);
66 g_newCallId = updateCallInfo_.callId;
67 newCallState_ = (int32_t)updateCallInfo_.callState;
68 std::unordered_set<int32_t> newSet;
69 newSet.clear();
70 g_callStateMap.insert(std::pair<int32_t, std::unordered_set<int32_t>>(g_newCallId, newSet));
71 }
72 g_callStateMap[updateCallInfo_.callId].insert((int32_t)updateCallInfo_.callState);
73 return TELEPHONY_SUCCESS;
74 }
75
HasActiveStatus()76 bool CallInfoManager::HasActiveStatus()
77 {
78 TELEPHONY_LOGI("Waiting for activation !");
79 int sumUseTime = 0;
80 int slipMs = SLEEP_TIME_MS;
81 do {
82 if (!(HasState(g_newCallId, static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE)))) {
83 usleep(slipMs * BASE_TIME_MS);
84 sumUseTime += slipMs;
85 } else {
86 TELEPHONY_LOGI("===========wait %d ms callStatus:%d==============", sumUseTime, newCallState_);
87 return true;
88 }
89 } while (sumUseTime < MAX_LIMIT_TIME);
90 TELEPHONY_LOGI("===========wait %d ms callStatus:%d=====not active=========", sumUseTime, newCallState_);
91 return false;
92 }
93
HasState(int callId,int32_t callState)94 bool CallInfoManager::HasState(int callId, int32_t callState)
95 {
96 if (g_callStateMap.find(callId) == g_callStateMap.end()) {
97 return false;
98 }
99 if (g_callStateMap[callId].find(callState) == g_callStateMap[callId].end()) {
100 return false;
101 }
102 return true;
103 }
104
CallEventChange(const CallEventInfo & info)105 int32_t CallInfoManager::CallEventChange(const CallEventInfo &info)
106 {
107 return TELEPHONY_SUCCESS;
108 }
109
Init()110 void CallInfoManager::Init()
111 {
112 g_newCallId = -1;
113 updateCallInfo_.speakerphoneOn = -1;
114 updateCallInfo_.startTime = -1;
115 updateCallInfo_.isEcc = -1;
116 updateCallInfo_.accountId = -1;
117 updateCallInfo_.callType = CallType::TYPE_CS;
118 updateCallInfo_.callId = -1;
119 updateCallInfo_.callState = TelCallState::CALL_STATUS_IDLE;
120 updateCallInfo_.videoState = VideoStateType::TYPE_VOICE;
121 }
122
LockCallId(bool eq,int32_t targetId,int32_t slipMs,int32_t timeoutMs)123 void CallInfoManager::LockCallId(bool eq, int32_t targetId, int32_t slipMs, int32_t timeoutMs)
124 {
125 int32_t useTimeMs = 0;
126 std::cout << "wait for a few seconds......" << std::endl;
127 while ((updateCallInfo_.callId != targetId) && (useTimeMs < timeoutMs)) {
128 usleep(slipMs * SLEEP_1000_MS);
129 useTimeMs += slipMs;
130 }
131 std::cout << "\n===========wait " << useTimeMs << " ms target:" << updateCallInfo_.callId << std::endl;
132 if (eq) {
133 EXPECT_EQ(updateCallInfo_.callId, targetId);
134 } else {
135 EXPECT_NE(updateCallInfo_.callId, targetId);
136 }
137 }
138
LockCallState(bool eq,int32_t targetState,int32_t slipMs,int32_t timeoutMs)139 void CallInfoManager::LockCallState(bool eq, int32_t targetState, int32_t slipMs, int32_t timeoutMs)
140 {
141 if (CallManagerGtest::clientPtr_->GetCallState() == targetState) {
142 return;
143 }
144 int32_t usedTimeMs = 0;
145 std::cout << "wait for a few seconds......" << std::endl;
146 while ((CallManagerGtest::clientPtr_->GetCallState() != targetState) && (usedTimeMs < timeoutMs)) {
147 usleep(slipMs * SLEEP_1000_MS);
148 usedTimeMs += slipMs;
149 }
150 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
151 std::cout << "waited " << usedTimeMs << " seconds" << std::endl;
152 std::cout << "target call state:" << targetState << std::endl;
153 EXPECT_EQ(callState, targetState);
154 }
155
HangUpCall()156 void CallManagerGtest::HangUpCall()
157 {
158 clientPtr_->HangUpCall(INVALID_CALLID);
159 }
160
161 class ClientErrorBranchTest : public testing::Test {
162 public:
SetUpTestCase()163 static void SetUpTestCase() {};
TearDownTestCase()164 static void TearDownTestCase() {};
SetUp()165 void SetUp() {};
TearDown()166 void TearDown() {};
167 };
168
169 /**
170 * @tc.number Telephony_CallManagerService_001
171 * @tc.name test error nullptr branch with permission
172 * @tc.desc Function test
173 */
174 HWTEST_F(CallManagerGtest, Telephony_CallManagerService_001, Function | MediumTest | Level3)
175 {
176 AccessToken token;
177 std::u16string test = u"";
178 std::string test_ = "";
179 bool enabled;
180 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
181 ASSERT_NE(callManagerService->DialCall(test, dialInfo_), TELEPHONY_SUCCESS);
182 ASSERT_NE(callManagerService->AnswerCall(0, 0), TELEPHONY_SUCCESS);
183 ASSERT_NE(callManagerService->RejectCall(0, false, test), TELEPHONY_SUCCESS);
184 ASSERT_NE(callManagerService->HangUpCall(0), TELEPHONY_SUCCESS);
185 ASSERT_NE(callManagerService->GetCallState(), TELEPHONY_SUCCESS);
186 ASSERT_NE(callManagerService->HoldCall(0), TELEPHONY_SUCCESS);
187 ASSERT_NE(callManagerService->UnHoldCall(0), TELEPHONY_SUCCESS);
188 ASSERT_NE(callManagerService->SwitchCall(0), TELEPHONY_SUCCESS);
189 ASSERT_NE(callManagerService->IsNewCallAllowed(enabled), TELEPHONY_SUCCESS);
190 ASSERT_NE(callManagerService->IsRinging(enabled), TELEPHONY_SUCCESS);
191 ASSERT_NE(callManagerService->IsInEmergencyCall(enabled), TELEPHONY_SUCCESS);
192 ASSERT_NE(callManagerService->StartDtmf(0, 'a'), TELEPHONY_SUCCESS);
193 ASSERT_NE(callManagerService->StopDtmf(0), TELEPHONY_SUCCESS);
194 ASSERT_NE(callManagerService->GetCallWaiting(0), TELEPHONY_SUCCESS);
195 ASSERT_NE(callManagerService->SetCallWaiting(0, false), TELEPHONY_SUCCESS);
196 ASSERT_NE(callManagerService->GetCallRestriction(0, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
197 TELEPHONY_SUCCESS);
198 CallRestrictionInfo callRestrictionInfo;
199 ASSERT_NE(callManagerService->SetCallRestriction(0, callRestrictionInfo), TELEPHONY_SUCCESS);
200 ASSERT_NE(
201 callManagerService->SetCallRestrictionPassword(0, CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS, "11", "22"),
202 TELEPHONY_SUCCESS);
203 ASSERT_NE(
204 callManagerService->GetCallTransferInfo(0, CallTransferType::TRANSFER_TYPE_UNCONDITIONAL), TELEPHONY_SUCCESS);
205 CallTransferInfo callTransferInfo;
206 ASSERT_NE(callManagerService->SetCallTransferInfo(0, callTransferInfo), TELEPHONY_SUCCESS);
207 ASSERT_NE(callManagerService->CanSetCallTransferTime(0, enabled), TELEPHONY_SUCCESS);
208 ASSERT_NE(callManagerService->SetCallPreferenceMode(0, 0), TELEPHONY_SUCCESS);
209 ASSERT_NE(callManagerService->StartRtt(0, test), TELEPHONY_SUCCESS);
210 ASSERT_NE(callManagerService->StopRtt(0), TELEPHONY_SUCCESS);
211 ASSERT_NE(callManagerService->CombineConference(0), TELEPHONY_SUCCESS);
212 ASSERT_NE(callManagerService->SeparateConference(0), TELEPHONY_SUCCESS);
213 ASSERT_NE(callManagerService->KickOutFromConference(0), TELEPHONY_SUCCESS);
214 ASSERT_NE(callManagerService->SetMuted(false), TELEPHONY_SUCCESS);
215 ASSERT_NE(callManagerService->MuteRinger(), TELEPHONY_SUCCESS);
216 AudioDevice audioDevice = {
217 .deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO,
218 .address = { 0 },
219 };
220 ASSERT_NE(callManagerService->SetAudioDevice(audioDevice), TELEPHONY_SUCCESS);
221 ASSERT_NE(callManagerService->ControlCamera(1, test), TELEPHONY_SUCCESS);
222 ASSERT_NE(callManagerService->SetPreviewWindow(1, test_, nullptr), TELEPHONY_SUCCESS);
223 ASSERT_NE(callManagerService->SetDisplayWindow(1, test_, nullptr), TELEPHONY_SUCCESS);
224 }
225
226 /**
227 * @tc.number Telephony_CallManagerService_002
228 * @tc.name test error nullptr branch with permission
229 * @tc.desc Function test
230 */
231 HWTEST_F(CallManagerGtest, Telephony_CallManagerService_002, Function | MediumTest | Level3)
232 {
233 AccessToken token;
234 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
235 float zoomRatio = 1;
236 std::u16string test = u"";
237 int32_t callId = 1;
238 int32_t value = 1;
239 bool enabled;
240 ASSERT_NE(callManagerService->SetCameraZoom(zoomRatio), TELEPHONY_SUCCESS);
241 ASSERT_NE(callManagerService->SetPausePicture(callId, test), TELEPHONY_SUCCESS);
242 ASSERT_NE(callManagerService->SetDeviceDirection(callId, value), TELEPHONY_SUCCESS);
243 ASSERT_NE(callManagerService->CancelCallUpgrade(callId), TELEPHONY_SUCCESS);
244 ASSERT_NE(callManagerService->RequestCameraCapabilities(callId), TELEPHONY_SUCCESS);
245 ASSERT_NE(callManagerService->IsEmergencyPhoneNumber(test, 0, enabled), TELEPHONY_SUCCESS);
246 ASSERT_NE(callManagerService->FormatPhoneNumber(test, test, test), TELEPHONY_SUCCESS);
247 ASSERT_NE(callManagerService->FormatPhoneNumberToE164(test, test, test), TELEPHONY_SUCCESS);
248 ASSERT_NE(callManagerService->GetMainCallId(value, value), TELEPHONY_SUCCESS);
249 std::vector<std::u16string> callIdList;
250 ASSERT_NE(callManagerService->GetSubCallIdList(0, callIdList), TELEPHONY_SUCCESS);
251 ASSERT_NE(callManagerService->GetCallIdListForConference(0, callIdList), TELEPHONY_SUCCESS);
252 ASSERT_NE(callManagerService->GetImsConfig(0, ImsConfigItem::ITEM_VIDEO_QUALITY), TELEPHONY_SUCCESS);
253 ASSERT_NE(callManagerService->SetImsConfig(0, ImsConfigItem::ITEM_VIDEO_QUALITY, test), TELEPHONY_SUCCESS);
254 ASSERT_NE(callManagerService->GetImsFeatureValue(0, FeatureType::TYPE_VOICE_OVER_LTE), TELEPHONY_SUCCESS);
255 ASSERT_NE(callManagerService->SetImsFeatureValue(0, FeatureType::TYPE_VOICE_OVER_LTE, 0), TELEPHONY_SUCCESS);
256 ASSERT_NE(callManagerService->UpdateImsCallMode(0, ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_SUCCESS);
257 ASSERT_NE(callManagerService->EnableImsSwitch(false), TELEPHONY_SUCCESS);
258 ASSERT_NE(callManagerService->DisableImsSwitch(false), TELEPHONY_SUCCESS);
259 ASSERT_NE(callManagerService->IsImsSwitchEnabled(0, enabled), TELEPHONY_SUCCESS);
260 ASSERT_NE(callManagerService->SetVoNRState(0, value), TELEPHONY_SUCCESS);
261 ASSERT_NE(callManagerService->GetVoNRState(0, value), TELEPHONY_SUCCESS);
262 std::vector<std::u16string> numberList;
263 ASSERT_NE(callManagerService->JoinConference(false, numberList), TELEPHONY_SUCCESS);
264 std::vector<OttCallDetailsInfo> ottVec;
265 ASSERT_NE(callManagerService->ReportOttCallDetailsInfo(ottVec), TELEPHONY_SUCCESS);
266 ASSERT_NE(callManagerService->GetMainCallId(value, value), TELEPHONY_SUCCESS);
267 }
268
269 /**
270 * @tc.number Telephony_CallManagerService_003
271 * @tc.name test error nullptr branch with permission
272 * @tc.desc Function test
273 */
274 HWTEST_F(CallManagerGtest, Telephony_CallManagerService_003, Function | MediumTest | Level3)
275 {
276 AccessToken token;
277 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
278 callManagerService->Init();
279 callManagerService->RegisterCallBack(nullptr);
280 callManagerService->UnRegisterCallBack();
281 callManagerService->ObserverOnCallDetailsChange();
282 callManagerService->RegisterVoipCallManagerCallback();
283 callManagerService->UnRegisterVoipCallManagerCallback();
284 int32_t callId = 0;
285 bool proceed = false;
286 callManagerService->PostDialProceed(callId, proceed);
287 OttCallDetailsInfo info;
288 const char *number = "000000";
289 memcpy_s(info.phoneNum, kMaxNumberLen, number, strlen(number));
290 const char *bundleName = "com.ohos.tddtest";
291 memcpy_s(info.bundleName, kMaxNumberLen, bundleName, strlen(bundleName));
292 info.callState = TelCallState::CALL_STATUS_DIALING;
293 info.videoState = VideoStateType::TYPE_VOICE;
294 std::vector<OttCallDetailsInfo> ottVec { info };
295 callManagerService->ReportOttCallDetailsInfo(ottVec);
296 OttCallEventInfo eventInfo;
297 callManagerService->ReportOttCallEventInfo(eventInfo);
298 int32_t slotId = 0;
299 callManagerService->CloseUnFinishedUssd(slotId);
300 std::string specialCode;
301 callManagerService->InputDialerSpecialCode(specialCode);
302 callManagerService->RemoveMissedIncomingCallNotification();
303 callManagerService->SetVoIPCallState(0);
304 int32_t state = 1;
305 callManagerService->GetVoIPCallState(state);
306 CallManagerProxyType proxyType = CallManagerProxyType::PROXY_BLUETOOTH_CALL;
307 callManagerService->GetProxyObjectPtr(proxyType);
308 callManagerService->GetBundleInfo();
309 callManagerService->ReportAudioDeviceInfo();
310 std::string eventName = "EVENT_IS_CELIA_CALL";
311 ASSERT_NE(callManagerService->SendCallUiEvent(callId, eventName), TELEPHONY_SUCCESS);
312 }
313
314 /**
315 * @tc.number Telephony_CallManagerServiceStub_001
316 * @tc.name test error nullptr branch with permission
317 * @tc.desc Function test
318 */
319 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_001, Function | MediumTest | Level3)
320 {
321 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
322 MessageParcel data;
323 MessageParcel reply;
324 MessageOption option;
325 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
326 data.RewindRead(0);
327 int32_t res = -1;
328 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_DIAL_CALL),
329 data, reply, option);
330 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_ANSWER_CALL),
331 data, reply, option);
332 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_REJECT_CALL),
333 data, reply, option);
334 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_HOLD_CALL),
335 data, reply, option);
336 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_UNHOLD_CALL),
337 data, reply, option);
338 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_DISCONNECT_CALL),
339 data, reply, option);
340 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_CALL_STATE),
341 data, reply, option);
342 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SWAP_CALL),
343 data, reply, option);
344 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_HAS_CALL),
345 data, reply, option);
346 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_IS_NEW_CALL_ALLOWED),
347 data, reply, option);
348 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_IS_RINGING),
349 data, reply, option);
350 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_IS_EMERGENCY_CALL),
351 data, reply, option);
352 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_IS_EMERGENCY_NUMBER),
353 data, reply, option);
354 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_IS_FORMAT_NUMBER),
355 data, reply, option);
356 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
357 CallManagerInterfaceCode::INTERFACE_IS_FORMAT_NUMBER_E164), data, reply, option);
358 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_COMBINE_CONFERENCE),
359 data, reply, option);
360 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SEPARATE_CONFERENCE),
361 data, reply, option);
362 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_START_DTMF),
363 data, reply, option);
364 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_STOP_DTMF),
365 data, reply, option);
366 res = callManagerService->OnRemoteRequest(static_cast<uint32_t>(
367 CallManagerInterfaceCode::INTERFACE_POST_DIAL_PROCEED), data, reply, option);
368 ASSERT_NE(res, TELEPHONY_SUCCESS);
369 }
370
371 /**
372 * @tc.number Telephony_CallManagerServiceStub_002
373 * @tc.name test error nullptr branch with permission
374 * @tc.desc Function test
375 */
376 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_002, Function | MediumTest | Level3)
377 {
378 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
379 MessageParcel data;
380 MessageParcel reply;
381 MessageOption option;
382 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
383 data.RewindRead(0);
384 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_CALL_WAITING),
385 data, reply, option);
386 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_CALL_WAITING),
387 data, reply, option);
388 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_CALL_RESTRICTION),
389 data, reply, option);
390 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_CALL_RESTRICTION),
391 data, reply, option);
392 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
393 CallManagerInterfaceCode::INTERFACE_SET_CALL_RESTRICTION_PASSWORD), data, reply, option);
394 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_CALL_TRANSFER),
395 data, reply, option);
396 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_CALL_TRANSFER),
397 data, reply, option);
398 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
399 CallManagerInterfaceCode::INTERFACE_CAN_SET_CALL_TRANSFER_TIME), data, reply, option);
400 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_MAINID),
401 data, reply, option);
402 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_SUBCALL_LIST_ID),
403 data, reply, option);
404 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
405 CallManagerInterfaceCode::INTERFACE_GET_CALL_LIST_ID_FOR_CONFERENCE), data, reply, option);
406 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_MUTE),
407 data, reply, option);
408 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_MUTE_RINGER),
409 data, reply, option);
410 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_AUDIO_DEVICE),
411 data, reply, option);
412 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_CTRL_CAMERA),
413 data, reply, option);
414 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_PREVIEW_WINDOW),
415 data, reply, option);
416 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_DISPLAY_WINDOW),
417 data, reply, option);
418 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_CAMERA_ZOOM),
419 data, reply, option);
420 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_PAUSE_IMAGE),
421 data, reply, option);
422 int32_t res = callManagerService->OnRemoteRequest(static_cast<uint32_t>(
423 CallManagerInterfaceCode::INTERFACE_SET_DEVICE_DIRECTION), data, reply, option);
424 ASSERT_NE(res, TELEPHONY_SUCCESS);
425 }
426
427 /**
428 * @tc.number Telephony_CallManagerServiceStub_003
429 * @tc.name test error nullptr branch with permission
430 * @tc.desc Function test
431 */
432 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_003, Function | MediumTest | Level3)
433 {
434 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
435 MessageParcel data;
436 MessageParcel reply;
437 MessageOption option;
438 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
439 data.RewindRead(0);
440 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SETCALL_PREFERENCEMODE),
441 data, reply, option);
442 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_IMS_CONFIG),
443 data, reply, option);
444 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_IMS_CONFIG),
445 data, reply, option);
446 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_IMS_FEATURE_VALUE),
447 data, reply, option);
448 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_IMS_FEATURE_VALUE),
449 data, reply, option);
450 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_UPDATE_CALL_MEDIA_MODE),
451 data, reply, option);
452 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_ENABLE_VOLTE),
453 data, reply, option);
454 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_DISABLE_VOLTE),
455 data, reply, option);
456 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_IS_VOLTE_ENABLED),
457 data, reply, option);
458 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_START_RTT),
459 data, reply, option);
460 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_STOP_RTT),
461 data, reply, option);
462 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_JOIN_CONFERENCE),
463 data, reply, option);
464 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
465 CallManagerInterfaceCode::INTERFACE_REPORT_OTT_CALL_DETAIL_INFO), data, reply, option);
466 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
467 CallManagerInterfaceCode::INTERFACE_REPORT_OTT_CALL_EVENT_INFO), data, reply, option);
468 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_PROXY_OBJECT_PTR),
469 data, reply, option);
470 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_CLOSE_UNFINISHED_USSD),
471 data, reply, option);
472 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_REPORT_AUDIO_DEVICE_INFO),
473 data, reply, option);
474 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
475 CallManagerInterfaceCode::INTERFACE_INPUT_DIALER_SPECIAL_CODE), data, reply, option);
476 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
477 CallManagerInterfaceCode::INTERFACE_CANCEL_MISSED_INCOMING_CALL_NOTIFICATION), data, reply, option);
478 int32_t res = callManagerService->OnRemoteRequest(static_cast<uint32_t>(
479 CallManagerInterfaceCode::INTERFACE_SET_VONR_STATE), data, reply, option);
480 ASSERT_NE(res, TELEPHONY_SUCCESS);
481 }
482
483 /**
484 * @tc.number Telephony_CallManagerServiceStub_004
485 * @tc.name test error nullptr branch with permission
486 * @tc.desc Function test
487 */
488 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_004, Function | MediumTest | Level3)
489 {
490 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
491 MessageParcel data;
492 MessageParcel reply;
493 MessageOption option;
494 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
495 data.RewindRead(0);
496 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_VONR_STATE),
497 data, reply, option);
498 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_KICK_OUT_CONFERENCE),
499 data, reply, option);
500 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_VOIP_CALL_STATE),
501 data, reply, option);
502 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_VOIP_CALL_STATE),
503 data, reply, option);
504 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_CANCEL_CALL_UPGRADE),
505 data, reply, option);
506 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
507 CallManagerInterfaceCode::INTERFACE_REQUEST_CAMERA_CAPABILITIES), data, reply, option);
508 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_REGISTER_CALLBACK),
509 data, reply, option);
510 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_UNREGISTER_CALLBACK),
511 data, reply, option);
512 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
513 CallManagerInterfaceCode::INTERFACE_VOIP_REGISTER_CALLBACK), data, reply, option);
514 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
515 CallManagerInterfaceCode::INTERFACE_VOIP_UNREGISTER_CALLBACK), data, reply, option);
516 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
517 CallManagerInterfaceCode::INTERFACE_OBSERVER_ON_CALL_DETAILS_CHANGE), data, reply, option);
518 ASSERT_NE(callManagerService->OnRemoteRequest(
519 static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SEND_CALLUI_EVENT),
520 data, reply, option), TELEPHONY_SUCCESS);
521 }
522
523 /**
524 * @tc.number Telephony_CallManagerServiceStub_005
525 * @tc.name test error nullptr branch with permission
526 * @tc.desc Function test
527 */
528 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_005, Function | MediumTest | Level3)
529 {
530 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
531 MessageParcel data;
532 MessageParcel reply;
533 int32_t callId = 0;
534 data.WriteInt32(callId);
535 data.RewindRead(0);
536 callManagerService->OnHangUpCall(data, reply);
537 callManagerService->OnGetCallState(data, reply);
538 callManagerService->OnHoldCall(data, reply);
539 callManagerService->OnUnHoldCall(data, reply);
540 callManagerService->OnSwitchCall(data, reply);
541 callManagerService->OnHasCall(data, reply);
542 callManagerService->OnIsNewCallAllowed(data, reply);
543 callManagerService->OnMuteRinger(data, reply);
544 callManagerService->OnIsRinging(data, reply);
545 callManagerService->OnIsInEmergencyCall(data, reply);
546 callManagerService->OnStopDtmf(data, reply);
547 callManagerService->OnGetCallWaiting(data, reply);
548 callManagerService->OnCombineConference(data, reply);
549 callManagerService->OnSeparateConference(data, reply);
550 callManagerService->OnKickOutFromConference(data, reply);
551 callManagerService->OnGetMainCallId(data, reply);
552 callManagerService->OnGetSubCallIdList(data, reply);
553 callManagerService->OnGetCallIdListForConference(data, reply);
554 callManagerService->OnEnableVoLte(data, reply);
555 callManagerService->OnDisableVoLte(data, reply);
556 callManagerService->OnIsVoLteEnabled(data, reply);
557 callManagerService->OnGetVoNRState(data, reply);
558 callManagerService->OnStopRtt(data, reply);
559 callManagerService->OnCloseUnFinishedUssd(data, reply);
560 callManagerService->OnInputDialerSpecialCode(data, reply);
561 callManagerService->OnRemoveMissedIncomingCallNotification(data, reply);
562 callManagerService->OnSetVoIPCallState(data, reply);
563 callManagerService->OnGetVoIPCallState(data, reply);
564 callManagerService->OnReportAudioDeviceInfo(data, reply);
565 callManagerService->OnCancelCallUpgrade(data, reply);
566 callManagerService->OnRequestCameraCapabilities(data, reply);
567 callManagerService->OnSetAudioDevice(data, reply);
568 callManagerService->OnRegisterVoipCallManagerCallback(data, reply);
569 callManagerService->OnUnRegisterVoipCallManagerCallback(data, reply);
570 ASSERT_EQ(callManagerService->OnGetProxyObjectPtr(data, reply), TELEPHONY_SUCCESS);
571 }
572
573 /**
574 * @tc.number Telephony_CallManagerServiceStub_006
575 * @tc.name test error nullptr branch with permission
576 * @tc.desc Function test
577 */
578 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_006, Function | MediumTest | Level3)
579 {
580 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
581 MessageParcel data;
582 MessageParcel reply;
583 int32_t callId = 0;
584 int32_t videoState = 1;
585 data.WriteInt32(callId);
586 data.WriteInt32(videoState);
587 data.RewindRead(0);
588 callManagerService->OnAcceptCall(data, reply);
589 callManagerService->OnGetCallRestriction(data, reply);
590 callManagerService->OnGetTransferNumber(data, reply);
591 callManagerService->OnSetCallPreferenceMode(data, reply);
592 callManagerService->OnSetDeviceDirection(data, reply);
593 callManagerService->OnGetImsConfig(data, reply);
594 callManagerService->OnGetImsFeatureValue(data, reply);
595 callManagerService->OnSetVoNRState(data, reply);
596
597 MessageParcel data1;
598 MessageParcel reply1;
599 std::string message("hello");
600 data1.WriteInt32(callId);
601 data1.WriteBool(false);
602 data1.WriteString16(Str8ToStr16(message));
603 data1.RewindRead(0);
604 callManagerService->OnRejectCall(data1, reply1);
605
606 MessageParcel data2;
607 MessageParcel reply2;
608 data2.WriteBool(false);
609 data2.RewindRead(0);
610 callManagerService->OnSetMute(data2, reply2);
611
612 MessageParcel data3;
613 data3.WriteInt32(callId);
614 data3.WriteInt8('c');
615 data3.RewindRead(0);
616 callManagerService->OnStartDtmf(data3, reply);
617
618 MessageParcel data4;
619 data4.WriteInt32(callId);
620 data4.WriteBool(false);
621 data4.RewindRead(0);
622 callManagerService->OnPostDialProceed(data4, reply);
623 callManagerService->OnSetCallWaiting(data4, reply);
624
625 MessageParcel data5;
626 data5.WriteInt32(callId);
627 std::vector<std::u16string> numberList;
628 data5.WriteString16Vector(numberList);
629 data5.RewindRead(0);
630 ASSERT_EQ(callManagerService->OnJoinConference(data5, reply), TELEPHONY_SUCCESS);
631 }
632
633 /**
634 * @tc.number Telephony_CallManagerServiceStub_007
635 * @tc.name test error nullptr branch with permission
636 * @tc.desc Function test
637 */
638 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_007, Function | MediumTest | Level3)
639 {
640 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
641 MessageParcel data;
642 MessageParcel reply;
643 int32_t callId = 0;
644 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
645 data.WriteInt32(callId);
646 CallRestrictionInfo callRestrictionInfo;
647 int length = sizeof(CallRestrictionInfo);
648 data.WriteRawData((const void *)&callRestrictionInfo, length);
649 data.RewindRead(0);
650 callManagerService->OnSetCallRestriction(data, reply);
651
652 MessageParcel data1;
653 char accountNum[kMaxNumberLen + 1] = { 0 };
654 data1.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
655 data1.WriteInt32(callId);
656 data1.WriteInt32(0);
657 data1.WriteCString(accountNum);
658 data1.WriteCString(accountNum);
659 data1.RewindRead(0);
660 callManagerService->OnSetCallRestrictionPassword(data1, reply);
661
662 MessageParcel data2;
663 data2.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
664 data2.WriteInt32(callId);
665 CallTransferInfo callTransferInfo;
666 length = sizeof(CallTransferInfo);
667 data2.WriteRawData((const void *)&callRestrictionInfo, length);
668 data2.RewindRead(0);
669 callManagerService->OnSetTransferNumber(data2, reply);
670
671 MessageParcel data3;
672 data3.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
673 data3.WriteInt32(callId);
674 data3.WriteBool(true);
675 data3.RewindRead(0);
676 callManagerService->OnCanSetCallTransferTime(data3, reply);
677
678 MessageParcel data4;
679 std::string message("hello");
680 data4.WriteInt32(callId);
681 data4.WriteString16(Str8ToStr16(message));
682 data4.RewindRead(0);
683 callManagerService->OnControlCamera(data4, reply);
684 callManagerService->OnSetPausePicture(data4, reply);
685 callManagerService->OnStartRtt(data4, reply);
686
687 MessageParcel data5;
688 float fnum = 0.0;
689 data5.WriteFloat(fnum);
690 data5.RewindRead(0);
691 ASSERT_EQ(callManagerService->OnSetCameraZoom(data5, reply), TELEPHONY_SUCCESS);
692 }
693
694 /**
695 * @tc.number Telephony_CallManagerServiceStub_008
696 * @tc.name test error nullptr branch with permission
697 * @tc.desc Function test
698 */
699 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_008, Function | MediumTest | Level3)
700 {
701 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
702 MessageParcel data6;
703 MessageParcel reply;
704 int32_t callId = 0;
705 std::string message("12345678");
706 data6.WriteString16(Str8ToStr16(message));
707 data6.WriteInt32(callId);
708 data6.RewindRead(0);
709 callManagerService->OnIsEmergencyPhoneNumber(data6, reply);
710
711 MessageParcel data7;
712 std::string callNumber("12345678");
713 std::string countryCode("101");
714 data7.WriteString16(Str8ToStr16(callNumber));
715 data7.WriteString16(Str8ToStr16(countryCode));
716 data7.RewindRead(0);
717 callManagerService->OnFormatPhoneNumber(data7, reply);
718 callManagerService->OnFormatPhoneNumberToE164(data7, reply);
719
720 MessageParcel data8;
721 data8.WriteInt32(callId);
722 data8.WriteInt32(0);
723 data8.WriteString16(Str8ToStr16(message));
724 data8.RewindRead(0);
725 callManagerService->OnSetImsConfig(data8, reply);
726
727 MessageParcel data9;
728 data9.WriteInt32(callId);
729 data9.WriteInt32(0);
730 data9.WriteInt32(0);
731 data9.RewindRead(0);
732 callManagerService->OnSetImsFeatureValue(data9, reply);
733
734 MessageParcel data11;
735 data11.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
736 data11.WriteInt32(callId);
737 ImsCallMode imsCallMode;
738 int length = sizeof(ImsCallMode);
739 data11.WriteRawData((const void *)&imsCallMode, length);
740 data11.RewindRead(0);
741 ASSERT_EQ(callManagerService->OnUpdateCallMediaMode(data11, reply), TELEPHONY_SUCCESS);
742 }
743
744 /**
745 * @tc.number Telephony_CallManagerServiceStub_009
746 * @tc.name test error nullptr branch with permission
747 * @tc.desc Function test
748 */
749 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_009, Function | MediumTest | Level3)
750 {
751 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
752 MessageParcel data;
753 MessageParcel reply;
754 std::string message("12345678");
755 std::string bundleName("abc");
756 int32_t defaultNumber = 0;
757 data.WriteString16(Str8ToStr16(message));
758 data.WriteInt32(defaultNumber);
759 data.WriteInt32(defaultNumber);
760 data.WriteInt32(defaultNumber);
761 data.WriteInt32(defaultNumber);
762 data.WriteInt32(defaultNumber);
763 data.WriteString(bundleName);
764 callManagerService->OnDialCall(data, reply);
765
766 MessageParcel data12;
767 data12.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
768 OttCallDetailsInfo ottCallDetailsInfo;
769 int length = sizeof(OttCallDetailsInfo);
770 data12.WriteInt32(length);
771 data12.WriteRawData((const void *)&ottCallDetailsInfo, length);
772 data12.RewindRead(0);
773 callManagerService->OnReportOttCallDetailsInfo(data12, reply);
774
775 MessageParcel data13;
776 data13.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
777 OttCallEventInfo ottCallEventInfo;
778 length = sizeof(OttCallEventInfo);
779 data13.WriteRawData((const void *)&ottCallEventInfo, length);
780 data13.RewindRead(0);
781 callManagerService->OnReportOttCallEventInfo(data13, reply);
782
783 MessageParcel data15;
784 data15.WriteInt32(defaultNumber);
785 data15.WriteString("hello");
786 callManagerService->OnGetProxyObjectPtr(data15, reply);
787 ASSERT_NE(callManagerService->OnSendCallUiEvent(data15, reply), TELEPHONY_SUCCESS);
788 }
789
790 /**
791 * @tc.number Telephony_VoipCall_001
792 * @tc.name test error nullptr branch with permission
793 * @tc.desc Function test
794 */
795 HWTEST_F(CallManagerGtest, Telephony_VoipCall_001, Function | MediumTest | Level3)
796 {
797 AccessToken token;
798 DialParaInfo dialInfo;
799 std::shared_ptr<VoIPCall> voIPCall = std::make_shared<VoIPCall>(dialInfo);
800 EXPECT_EQ(voIPCall->DialingProcess(), TELEPHONY_SUCCESS);
801 EXPECT_EQ(voIPCall->AnswerCall(0), TELEPHONY_SUCCESS);
802 VoipCallEventInfo voipcallInfo;
803 EXPECT_EQ(voIPCall->PackVoipCallInfo(voipcallInfo), TELEPHONY_SUCCESS);
804 EXPECT_EQ(voIPCall->RejectCall(), TELEPHONY_SUCCESS);
805 EXPECT_EQ(voIPCall->HangUpCall(), TELEPHONY_SUCCESS);
806 EXPECT_EQ(voIPCall->HoldCall(), TELEPHONY_SUCCESS);
807 EXPECT_EQ(voIPCall->UnHoldCall(), TELEPHONY_SUCCESS);
808 EXPECT_EQ(voIPCall->SwitchCall(), TELEPHONY_SUCCESS);
809 EXPECT_EQ(voIPCall->SetMute(0, 0), TELEPHONY_SUCCESS);
810 CallAttributeInfo info;
811 voIPCall->GetCallAttributeInfo(info);
812 EXPECT_EQ(voIPCall->CombineConference(), TELEPHONY_SUCCESS);
813 voIPCall->HandleCombineConferenceFailEvent();
814 EXPECT_EQ(voIPCall->SeparateConference(), TELEPHONY_SUCCESS);
815 EXPECT_EQ(voIPCall->KickOutFromConference(), TELEPHONY_SUCCESS);
816 EXPECT_EQ(voIPCall->CanCombineConference(), TELEPHONY_SUCCESS);
817 EXPECT_EQ(voIPCall->CanSeparateConference(), TELEPHONY_SUCCESS);
818 EXPECT_EQ(voIPCall->CanKickOutFromConference(), TELEPHONY_SUCCESS);
819 int32_t mainCallId = 0;
820 EXPECT_EQ(voIPCall->GetMainCallId(mainCallId), TELEPHONY_SUCCESS);
821 std::vector<std::u16string> callIdList;
822 EXPECT_EQ(voIPCall->GetSubCallIdList(callIdList), TELEPHONY_SUCCESS);
823 EXPECT_EQ(voIPCall->GetCallIdListForConference(callIdList), TELEPHONY_SUCCESS);
824 EXPECT_EQ(voIPCall->IsSupportConferenceable(), TELEPHONY_SUCCESS);
825 EXPECT_EQ(voIPCall->LaunchConference(), TELEPHONY_SUCCESS);
826 EXPECT_EQ(voIPCall->ExitConference(), TELEPHONY_SUCCESS);
827 EXPECT_EQ(voIPCall->HoldConference(), TELEPHONY_SUCCESS);
828 }
829 } // namespace Telephony
830 } // namespace OHOS
831