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