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, TestSize.Level1)
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, TestSize.Level1)
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_EQ(callManagerService->SendUssdResponse(slotId, content), TELEPHONY_SUCCESS);
288 std::vector<std::string> dialingList;
289 std::vector<std::string> incomingList;
290 ASSERT_NE(callManagerService->SetCallPolicyInfo(false, dialingList, false, incomingList), TELEPHONY_SUCCESS);
291 }
292
293 /**
294 * @tc.number Telephony_CallManagerService_003
295 * @tc.name test error nullptr branch with permission
296 * @tc.desc Function test
297 */
298 HWTEST_F(CallManagerGtest, Telephony_CallManagerService_003, TestSize.Level1)
299 {
300 AccessToken token;
301 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
302 callManagerService->Init();
303 callManagerService->RegisterCallBack(nullptr);
304 callManagerService->UnRegisterCallBack();
305 callManagerService->ObserverOnCallDetailsChange();
306 callManagerService->RegisterVoipCallManagerCallback();
307 callManagerService->UnRegisterVoipCallManagerCallback();
308 int32_t callId = 0;
309 bool proceed = false;
310 callManagerService->PostDialProceed(callId, proceed);
311 OttCallDetailsInfo info;
312 const char *number = "000000";
313 memcpy_s(info.phoneNum, kMaxNumberLen, number, strlen(number));
314 const char *bundleName = "com.ohos.tddtest";
315 memcpy_s(info.bundleName, kMaxNumberLen, bundleName, strlen(bundleName));
316 info.callState = TelCallState::CALL_STATUS_DIALING;
317 info.videoState = VideoStateType::TYPE_VOICE;
318 std::vector<OttCallDetailsInfo> ottVec { info };
319 callManagerService->ReportOttCallDetailsInfo(ottVec);
320 OttCallEventInfo eventInfo;
321 callManagerService->ReportOttCallEventInfo(eventInfo);
322 int32_t slotId = 0;
323 callManagerService->CloseUnFinishedUssd(slotId);
324 std::string specialCode;
325 callManagerService->InputDialerSpecialCode(specialCode);
326 callManagerService->RemoveMissedIncomingCallNotification();
327 callManagerService->SetVoIPCallState(0);
328 int32_t state = 1;
329 callManagerService->GetVoIPCallState(state);
330 CallManagerProxyType proxyType = CallManagerProxyType::PROXY_BLUETOOTH_CALL;
331 callManagerService->GetProxyObjectPtr(proxyType);
332 callManagerService->GetBundleInfo();
333 callManagerService->ReportAudioDeviceInfo();
334 std::string eventName = "EVENT_IS_CELIA_CALL";
335 ASSERT_NE(callManagerService->SendCallUiEvent(callId, eventName), TELEPHONY_SUCCESS);
336 std::vector<std::string> dialingList;
337 std::vector<std::string> incomingList;
338 ASSERT_NE(callManagerService->SetCallPolicyInfo(false, dialingList, false, incomingList), TELEPHONY_SUCCESS);
339 }
340
341 /**
342 * @tc.number Telephony_CallManagerServiceStub_001
343 * @tc.name test error nullptr branch with permission
344 * @tc.desc Function test
345 */
346 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_001, TestSize.Level0)
347 {
348 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
349 MessageParcel data;
350 MessageParcel reply;
351 MessageOption option;
352 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
353 data.RewindRead(0);
354 int32_t res = -1;
355 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_DIAL_CALL),
356 data, reply, option);
357 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_ANSWER_CALL),
358 data, reply, option);
359 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_REJECT_CALL),
360 data, reply, option);
361 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_HOLD_CALL),
362 data, reply, option);
363 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_UNHOLD_CALL),
364 data, reply, option);
365 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_DISCONNECT_CALL),
366 data, reply, option);
367 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_CALL_STATE),
368 data, reply, option);
369 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SWAP_CALL),
370 data, reply, option);
371 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_HAS_CALL),
372 data, reply, option);
373 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_IS_NEW_CALL_ALLOWED),
374 data, reply, option);
375 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_IS_RINGING),
376 data, reply, option);
377 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_IS_EMERGENCY_CALL),
378 data, reply, option);
379 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_IS_EMERGENCY_NUMBER),
380 data, reply, option);
381 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_IS_FORMAT_NUMBER),
382 data, reply, option);
383 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
384 CallManagerInterfaceCode::INTERFACE_IS_FORMAT_NUMBER_E164), data, reply, option);
385 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_COMBINE_CONFERENCE),
386 data, reply, option);
387 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SEPARATE_CONFERENCE),
388 data, reply, option);
389 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_START_DTMF),
390 data, reply, option);
391 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_STOP_DTMF),
392 data, reply, option);
393 res = callManagerService->OnRemoteRequest(static_cast<uint32_t>(
394 CallManagerInterfaceCode::INTERFACE_POST_DIAL_PROCEED), data, reply, option);
395 ASSERT_NE(res, TELEPHONY_SUCCESS);
396 }
397
398 /**
399 * @tc.number Telephony_CallManagerServiceStub_002
400 * @tc.name test error nullptr branch with permission
401 * @tc.desc Function test
402 */
403 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_002, TestSize.Level0)
404 {
405 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
406 MessageParcel data;
407 MessageParcel reply;
408 MessageOption option;
409 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
410 data.RewindRead(0);
411 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_CALL_WAITING),
412 data, reply, option);
413 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_CALL_WAITING),
414 data, reply, option);
415 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_CALL_RESTRICTION),
416 data, reply, option);
417 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_CALL_RESTRICTION),
418 data, reply, option);
419 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
420 CallManagerInterfaceCode::INTERFACE_SET_CALL_RESTRICTION_PASSWORD), data, reply, option);
421 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_CALL_TRANSFER),
422 data, reply, option);
423 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_CALL_TRANSFER),
424 data, reply, option);
425 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
426 CallManagerInterfaceCode::INTERFACE_CAN_SET_CALL_TRANSFER_TIME), data, reply, option);
427 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_MAINID),
428 data, reply, option);
429 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_SUBCALL_LIST_ID),
430 data, reply, option);
431 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
432 CallManagerInterfaceCode::INTERFACE_GET_CALL_LIST_ID_FOR_CONFERENCE), data, reply, option);
433 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_MUTE),
434 data, reply, option);
435 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_MUTE_RINGER),
436 data, reply, option);
437 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_AUDIO_DEVICE),
438 data, reply, option);
439 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_CTRL_CAMERA),
440 data, reply, option);
441 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_PREVIEW_WINDOW),
442 data, reply, option);
443 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_DISPLAY_WINDOW),
444 data, reply, option);
445 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_CAMERA_ZOOM),
446 data, reply, option);
447 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_PAUSE_IMAGE),
448 data, reply, option);
449 int32_t res = callManagerService->OnRemoteRequest(static_cast<uint32_t>(
450 CallManagerInterfaceCode::INTERFACE_SET_DEVICE_DIRECTION), data, reply, option);
451 ASSERT_NE(res, TELEPHONY_SUCCESS);
452 }
453
454 /**
455 * @tc.number Telephony_CallManagerServiceStub_003
456 * @tc.name test error nullptr branch with permission
457 * @tc.desc Function test
458 */
459 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_003, TestSize.Level0)
460 {
461 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
462 MessageParcel data;
463 MessageParcel reply;
464 MessageOption option;
465 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
466 data.RewindRead(0);
467 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SETCALL_PREFERENCEMODE),
468 data, reply, option);
469 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_IMS_CONFIG),
470 data, reply, option);
471 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_IMS_CONFIG),
472 data, reply, option);
473 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_IMS_FEATURE_VALUE),
474 data, reply, option);
475 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_IMS_FEATURE_VALUE),
476 data, reply, option);
477 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_UPDATE_CALL_MEDIA_MODE),
478 data, reply, option);
479 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_ENABLE_VOLTE),
480 data, reply, option);
481 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_DISABLE_VOLTE),
482 data, reply, option);
483 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_IS_VOLTE_ENABLED),
484 data, reply, option);
485 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_START_RTT),
486 data, reply, option);
487 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_STOP_RTT),
488 data, reply, option);
489 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_JOIN_CONFERENCE),
490 data, reply, option);
491 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
492 CallManagerInterfaceCode::INTERFACE_REPORT_OTT_CALL_DETAIL_INFO), data, reply, option);
493 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
494 CallManagerInterfaceCode::INTERFACE_REPORT_OTT_CALL_EVENT_INFO), data, reply, option);
495 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_PROXY_OBJECT_PTR),
496 data, reply, option);
497 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_CLOSE_UNFINISHED_USSD),
498 data, reply, option);
499 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_REPORT_AUDIO_DEVICE_INFO),
500 data, reply, option);
501 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
502 CallManagerInterfaceCode::INTERFACE_INPUT_DIALER_SPECIAL_CODE), data, reply, option);
503 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
504 CallManagerInterfaceCode::INTERFACE_CANCEL_MISSED_INCOMING_CALL_NOTIFICATION), data, reply, option);
505 int32_t res = callManagerService->OnRemoteRequest(static_cast<uint32_t>(
506 CallManagerInterfaceCode::INTERFACE_SET_VONR_STATE), data, reply, option);
507 ASSERT_NE(res, TELEPHONY_SUCCESS);
508 }
509
510 /**
511 * @tc.number Telephony_CallManagerServiceStub_004
512 * @tc.name test error nullptr branch with permission
513 * @tc.desc Function test
514 */
515 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_004, TestSize.Level0)
516 {
517 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
518 MessageParcel data;
519 MessageParcel reply;
520 MessageOption option;
521 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
522 data.RewindRead(0);
523 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_VONR_STATE),
524 data, reply, option);
525 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_KICK_OUT_CONFERENCE),
526 data, reply, option);
527 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SET_VOIP_CALL_STATE),
528 data, reply, option);
529 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_GET_VOIP_CALL_STATE),
530 data, reply, option);
531 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_CANCEL_CALL_UPGRADE),
532 data, reply, option);
533 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
534 CallManagerInterfaceCode::INTERFACE_REQUEST_CAMERA_CAPABILITIES), data, reply, option);
535 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_REGISTER_CALLBACK),
536 data, reply, option);
537 callManagerService->OnRemoteRequest(static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_UNREGISTER_CALLBACK),
538 data, reply, option);
539 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
540 CallManagerInterfaceCode::INTERFACE_VOIP_REGISTER_CALLBACK), data, reply, option);
541 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
542 CallManagerInterfaceCode::INTERFACE_VOIP_UNREGISTER_CALLBACK), data, reply, option);
543 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
544 CallManagerInterfaceCode::INTERFACE_OBSERVER_ON_CALL_DETAILS_CHANGE), data, reply, option);
545 callManagerService->OnRemoteRequest(static_cast<uint32_t>(
546 CallManagerInterfaceCode::INTERFACE_SEND_USSD_RESPONSE), data, reply, option);
547 ASSERT_NE(callManagerService->OnRemoteRequest(
548 static_cast<uint32_t>(CallManagerInterfaceCode::INTERFACE_SEND_CALLUI_EVENT),
549 data, reply, option), TELEPHONY_SUCCESS);
550 }
551
552 /**
553 * @tc.number Telephony_CallManagerServiceStub_005
554 * @tc.name test error nullptr branch with permission
555 * @tc.desc Function test
556 */
557 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_005, TestSize.Level0)
558 {
559 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
560 MessageParcel data;
561 MessageParcel reply;
562 int32_t callId = 0;
563 data.WriteInt32(callId);
564 data.RewindRead(0);
565 callManagerService->OnHangUpCall(data, reply);
566 callManagerService->OnGetCallState(data, reply);
567 callManagerService->OnHoldCall(data, reply);
568 callManagerService->OnUnHoldCall(data, reply);
569 callManagerService->OnSwitchCall(data, reply);
570 callManagerService->OnHasCall(data, reply);
571 callManagerService->OnIsNewCallAllowed(data, reply);
572 callManagerService->OnMuteRinger(data, reply);
573 callManagerService->OnIsRinging(data, reply);
574 callManagerService->OnIsInEmergencyCall(data, reply);
575 callManagerService->OnStopDtmf(data, reply);
576 callManagerService->OnGetCallWaiting(data, reply);
577 callManagerService->OnCombineConference(data, reply);
578 callManagerService->OnSeparateConference(data, reply);
579 callManagerService->OnKickOutFromConference(data, reply);
580 callManagerService->OnGetMainCallId(data, reply);
581 callManagerService->OnGetSubCallIdList(data, reply);
582 callManagerService->OnGetCallIdListForConference(data, reply);
583 callManagerService->OnEnableVoLte(data, reply);
584 callManagerService->OnDisableVoLte(data, reply);
585 callManagerService->OnIsVoLteEnabled(data, reply);
586 callManagerService->OnGetVoNRState(data, reply);
587 callManagerService->OnStopRtt(data, reply);
588 callManagerService->OnCloseUnFinishedUssd(data, reply);
589 callManagerService->OnInputDialerSpecialCode(data, reply);
590 callManagerService->OnRemoveMissedIncomingCallNotification(data, reply);
591 callManagerService->OnSetVoIPCallState(data, reply);
592 callManagerService->OnGetVoIPCallState(data, reply);
593 callManagerService->OnReportAudioDeviceInfo(data, reply);
594 callManagerService->OnCancelCallUpgrade(data, reply);
595 callManagerService->OnRequestCameraCapabilities(data, reply);
596 callManagerService->OnSetAudioDevice(data, reply);
597 callManagerService->OnRegisterVoipCallManagerCallback(data, reply);
598 callManagerService->OnUnRegisterVoipCallManagerCallback(data, reply);
599 ASSERT_EQ(callManagerService->OnGetProxyObjectPtr(data, reply), TELEPHONY_SUCCESS);
600 }
601
602 /**
603 * @tc.number Telephony_CallManagerServiceStub_006
604 * @tc.name test error nullptr branch with permission
605 * @tc.desc Function test
606 */
607 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_006, TestSize.Level0)
608 {
609 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
610 MessageParcel data;
611 MessageParcel reply;
612 int32_t callId = 0;
613 int32_t videoState = 1;
614 data.WriteInt32(callId);
615 data.WriteInt32(videoState);
616 data.RewindRead(0);
617 callManagerService->OnAcceptCall(data, reply);
618 callManagerService->OnGetCallRestriction(data, reply);
619 callManagerService->OnGetTransferNumber(data, reply);
620 callManagerService->OnSetCallPreferenceMode(data, reply);
621 callManagerService->OnSetDeviceDirection(data, reply);
622 callManagerService->OnGetImsConfig(data, reply);
623 callManagerService->OnGetImsFeatureValue(data, reply);
624 callManagerService->OnSetVoNRState(data, reply);
625
626 MessageParcel data1;
627 MessageParcel reply1;
628 std::string message("hello");
629 data1.WriteInt32(callId);
630 data1.WriteBool(false);
631 data1.WriteString16(Str8ToStr16(message));
632 data1.RewindRead(0);
633 callManagerService->OnRejectCall(data1, reply1);
634
635 MessageParcel data2;
636 MessageParcel reply2;
637 data2.WriteBool(false);
638 data2.RewindRead(0);
639 callManagerService->OnSetMute(data2, reply2);
640
641 MessageParcel data3;
642 data3.WriteInt32(callId);
643 data3.WriteInt8('c');
644 data3.RewindRead(0);
645 callManagerService->OnStartDtmf(data3, reply);
646
647 MessageParcel data4;
648 data4.WriteInt32(callId);
649 data4.WriteBool(false);
650 data4.RewindRead(0);
651 callManagerService->OnPostDialProceed(data4, reply);
652 callManagerService->OnSetCallWaiting(data4, reply);
653
654 MessageParcel data5;
655 data5.WriteInt32(callId);
656 std::vector<std::u16string> numberList;
657 data5.WriteString16Vector(numberList);
658 data5.RewindRead(0);
659 ASSERT_EQ(callManagerService->OnJoinConference(data5, reply), TELEPHONY_SUCCESS);
660 }
661
662 /**
663 * @tc.number Telephony_CallManagerServiceStub_007
664 * @tc.name test error nullptr branch with permission
665 * @tc.desc Function test
666 */
667 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_007, TestSize.Level0)
668 {
669 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
670 MessageParcel data;
671 MessageParcel reply;
672 int32_t callId = 0;
673 data.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
674 data.WriteInt32(callId);
675 CallRestrictionInfo callRestrictionInfo;
676 int length = sizeof(CallRestrictionInfo);
677 data.WriteRawData((const void *)&callRestrictionInfo, length);
678 data.RewindRead(0);
679 callManagerService->OnSetCallRestriction(data, reply);
680
681 MessageParcel data1;
682 char accountNum[kMaxNumberLen + 1] = { 0 };
683 data1.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
684 data1.WriteInt32(callId);
685 data1.WriteInt32(0);
686 data1.WriteCString(accountNum);
687 data1.WriteCString(accountNum);
688 data1.RewindRead(0);
689 callManagerService->OnSetCallRestrictionPassword(data1, reply);
690
691 MessageParcel data2;
692 data2.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
693 data2.WriteInt32(callId);
694 CallTransferInfo callTransferInfo;
695 length = sizeof(CallTransferInfo);
696 data2.WriteRawData((const void *)&callRestrictionInfo, length);
697 data2.RewindRead(0);
698 callManagerService->OnSetTransferNumber(data2, reply);
699
700 MessageParcel data3;
701 data3.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
702 data3.WriteInt32(callId);
703 data3.WriteBool(true);
704 data3.RewindRead(0);
705 callManagerService->OnCanSetCallTransferTime(data3, reply);
706
707 MessageParcel data4;
708 std::string message("hello");
709 data4.WriteInt32(callId);
710 data4.WriteString16(Str8ToStr16(message));
711 data4.RewindRead(0);
712 callManagerService->OnControlCamera(data4, reply);
713 callManagerService->OnSetPausePicture(data4, reply);
714 callManagerService->OnStartRtt(data4, reply);
715
716 MessageParcel data5;
717 float fnum = 0.0;
718 data5.WriteFloat(fnum);
719 data5.RewindRead(0);
720 ASSERT_EQ(callManagerService->OnSetCameraZoom(data5, reply), TELEPHONY_SUCCESS);
721 }
722
723 /**
724 * @tc.number Telephony_CallManagerServiceStub_008
725 * @tc.name test error nullptr branch with permission
726 * @tc.desc Function test
727 */
728 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_008, TestSize.Level0)
729 {
730 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
731 MessageParcel data6;
732 MessageParcel reply;
733 int32_t callId = 0;
734 std::string message("12345678");
735 data6.WriteString16(Str8ToStr16(message));
736 data6.WriteInt32(callId);
737 data6.RewindRead(0);
738 callManagerService->OnIsEmergencyPhoneNumber(data6, reply);
739
740 MessageParcel data7;
741 std::string callNumber("12345678");
742 std::string countryCode("101");
743 data7.WriteString16(Str8ToStr16(callNumber));
744 data7.WriteString16(Str8ToStr16(countryCode));
745 data7.RewindRead(0);
746 callManagerService->OnFormatPhoneNumber(data7, reply);
747 callManagerService->OnFormatPhoneNumberToE164(data7, reply);
748
749 MessageParcel data8;
750 data8.WriteInt32(callId);
751 data8.WriteInt32(0);
752 data8.WriteString16(Str8ToStr16(message));
753 data8.RewindRead(0);
754 callManagerService->OnSetImsConfig(data8, reply);
755
756 MessageParcel data9;
757 data9.WriteInt32(callId);
758 data9.WriteInt32(0);
759 data9.WriteInt32(0);
760 data9.RewindRead(0);
761 callManagerService->OnSetImsFeatureValue(data9, reply);
762
763 MessageParcel data11;
764 data11.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
765 data11.WriteInt32(callId);
766 ImsCallMode imsCallMode;
767 int length = sizeof(ImsCallMode);
768 data11.WriteRawData((const void *)&imsCallMode, length);
769 data11.RewindRead(0);
770 ASSERT_EQ(callManagerService->OnUpdateCallMediaMode(data11, reply), TELEPHONY_SUCCESS);
771 MessageParcel data12;
772 data12.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
773 std::vector<std::string> dialingList;
774 std::vector<std::string> incomingList;
775 data12.WriteInt32(0);
776 data12.WriteStringVector(dialingList);
777 data12.WriteInt32(0);
778 data12.WriteStringVector(incomingList);
779 ASSERT_EQ(callManagerService->OnSetCallPolicyInfo(data12, reply), TELEPHONY_SUCCESS);
780 }
781
782 /**
783 * @tc.number Telephony_CallManagerServiceStub_009
784 * @tc.name test error nullptr branch with permission
785 * @tc.desc Function test
786 */
787 HWTEST_F(CallManagerGtest, Telephony_CallManagerServiceStub_009, TestSize.Level0)
788 {
789 std::shared_ptr<CallManagerService> callManagerService = std::make_shared<CallManagerService>();
790 MessageParcel data;
791 MessageParcel reply;
792 std::string message("12345678");
793 std::string bundleName("abc");
794 int32_t defaultNumber = 0;
795 data.WriteString16(Str8ToStr16(message));
796 data.WriteInt32(defaultNumber);
797 data.WriteInt32(defaultNumber);
798 data.WriteInt32(defaultNumber);
799 data.WriteInt32(defaultNumber);
800 data.WriteInt32(defaultNumber);
801 data.WriteString(bundleName);
802 callManagerService->OnDialCall(data, reply);
803 data.WriteBool(true);
804 callManagerService->OnDialCall(data, reply);
805
806 MessageParcel data12;
807 data12.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
808 OttCallDetailsInfo ottCallDetailsInfo;
809 int length = sizeof(OttCallDetailsInfo);
810 data12.WriteInt32(length);
811 data12.WriteRawData((const void *)&ottCallDetailsInfo, length);
812 data12.RewindRead(0);
813 callManagerService->OnReportOttCallDetailsInfo(data12, reply);
814
815 MessageParcel data13;
816 data13.WriteInterfaceToken(CallManagerServiceStub::GetDescriptor());
817 OttCallEventInfo ottCallEventInfo;
818 length = sizeof(OttCallEventInfo);
819 data13.WriteRawData((const void *)&ottCallEventInfo, length);
820 data13.RewindRead(0);
821 callManagerService->OnReportOttCallEventInfo(data13, reply);
822
823 MessageParcel data15;
824 data15.WriteInt32(defaultNumber);
825 data15.WriteString("hello");
826 callManagerService->OnGetProxyObjectPtr(data15, reply);
827 ASSERT_NE(callManagerService->OnSendCallUiEvent(data15, reply), TELEPHONY_SUCCESS);
828
829 MessageParcel data16;
830 data15.WriteInt32(0);
831 data15.WriteString("1");
832 callManagerService->OnGetProxyObjectPtr(data16, reply);
833 ASSERT_NE(callManagerService->OnSendUssdResponse(data16, reply), TELEPHONY_SUCCESS);
834 }
835
836 /**
837 * @tc.number Telephony_VoipCall_001
838 * @tc.name test error nullptr branch with permission
839 * @tc.desc Function test
840 */
841 HWTEST_F(CallManagerGtest, Telephony_VoipCall_001, TestSize.Level0)
842 {
843 AccessToken token;
844 DialParaInfo dialInfo;
845 std::shared_ptr<VoIPCall> voIPCall = std::make_shared<VoIPCall>(dialInfo);
846 EXPECT_EQ(voIPCall->DialingProcess(), TELEPHONY_SUCCESS);
847 EXPECT_EQ(voIPCall->AnswerCall(0), TELEPHONY_SUCCESS);
848 VoipCallEventInfo voipcallInfo;
849 EXPECT_EQ(voIPCall->PackVoipCallInfo(voipcallInfo), TELEPHONY_SUCCESS);
850 EXPECT_EQ(voIPCall->RejectCall(), TELEPHONY_SUCCESS);
851 EXPECT_EQ(voIPCall->HangUpCall(), TELEPHONY_SUCCESS);
852 EXPECT_EQ(voIPCall->HoldCall(), TELEPHONY_SUCCESS);
853 EXPECT_EQ(voIPCall->UnHoldCall(), TELEPHONY_SUCCESS);
854 EXPECT_EQ(voIPCall->SwitchCall(), TELEPHONY_SUCCESS);
855 EXPECT_EQ(voIPCall->SetMute(0, 0), TELEPHONY_SUCCESS);
856 CallAttributeInfo info;
857 voIPCall->GetCallAttributeInfo(info);
858 EXPECT_EQ(voIPCall->CombineConference(), TELEPHONY_SUCCESS);
859 voIPCall->HandleCombineConferenceFailEvent();
860 EXPECT_EQ(voIPCall->SeparateConference(), TELEPHONY_SUCCESS);
861 EXPECT_EQ(voIPCall->KickOutFromConference(), TELEPHONY_SUCCESS);
862 EXPECT_EQ(voIPCall->CanCombineConference(), TELEPHONY_SUCCESS);
863 EXPECT_EQ(voIPCall->CanSeparateConference(), TELEPHONY_SUCCESS);
864 EXPECT_EQ(voIPCall->CanKickOutFromConference(), TELEPHONY_SUCCESS);
865 int32_t mainCallId = 0;
866 EXPECT_EQ(voIPCall->GetMainCallId(mainCallId), TELEPHONY_SUCCESS);
867 std::vector<std::u16string> callIdList;
868 EXPECT_EQ(voIPCall->GetSubCallIdList(callIdList), TELEPHONY_SUCCESS);
869 EXPECT_EQ(voIPCall->GetCallIdListForConference(callIdList), TELEPHONY_SUCCESS);
870 EXPECT_EQ(voIPCall->IsSupportConferenceable(), TELEPHONY_SUCCESS);
871 EXPECT_EQ(voIPCall->LaunchConference(), TELEPHONY_SUCCESS);
872 EXPECT_EQ(voIPCall->ExitConference(), TELEPHONY_SUCCESS);
873 EXPECT_EQ(voIPCall->HoldConference(), TELEPHONY_SUCCESS);
874 }
875 } // namespace Telephony
876 } // namespace OHOS
877