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 /********************************************* Test RejectCall() ***********************************************/
170 /**
171 * @tc.number Telephony_CallManager_RejectCall_0100
172 * @tc.name test RejectCall with the callId does not exist
173 * @tc.desc Function test
174 */
175 HWTEST_F(CallManagerGtest, Telephony_CallManager_RejectCall_0100, Function | MediumTest | Level2)
176 {
177 AccessToken token;
178 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
179 return;
180 }
181 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
182 int32_t callId = INVALID_NEGATIVE_ID;
183 std::u16string textMessage = Str8ToStr16("this is a test message");
184 EXPECT_NE(CallManagerGtest::clientPtr_->RejectCall(callId, true, textMessage), RETURN_VALUE_IS_ZERO);
185 }
186
187 /**
188 * @tc.number Telephony_CallManager_RejectCall_0200
189 * @tc.name test RejectCall without permission
190 * @tc.desc Function test
191 */
192 HWTEST_F(CallManagerGtest, Telephony_CallManager_RejectCall_0200, Function | MediumTest | Level2)
193 {
194 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
195 return;
196 }
197 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
198 int32_t callId = INVALID_NEGATIVE_ID;
199 std::u16string textMessage = Str8ToStr16("this is a test message");
200 EXPECT_NE(CallManagerGtest::clientPtr_->RejectCall(callId, true, textMessage), RETURN_VALUE_IS_ZERO);
201 }
202
203 /**
204 * @tc.number Telephony_CallManager_RejectCall_0300
205 * @tc.name test RejectCall with the callId does not exist
206 * @tc.desc Function test
207 */
208 HWTEST_F(CallManagerGtest, Telephony_CallManager_RejectCall_0300, Function | MediumTest | Level2)
209 {
210 AccessToken token;
211 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
212 return;
213 }
214 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
215 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
216 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->RejectCall(), RETURN_VALUE_IS_ZERO);
217 }
218
219 /******************************************* Test HangUpCall() *********************************************/
220 /**
221 * @tc.number Telephony_CallManager_HangUpCall_0100
222 * @tc.name test disconnect call with wrong callId
223 * @tc.desc Function test
224 */
225 HWTEST_F(CallManagerGtest, Telephony_CallManager_HangUpCall_0100, Function | MediumTest | Level2)
226 {
227 AccessToken token;
228 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
229 return;
230 }
231 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
232 int32_t callId = INVALID_NEGATIVE_ID;
233 EXPECT_NE(CallManagerGtest::clientPtr_->HangUpCall(callId), RETURN_VALUE_IS_ZERO);
234 }
235
236 /**
237 * @tc.number Telephony_CallManager_HangUpCall_0200 to do ...
238 * @tc.name test ring disconnect call after DialCall,
239 * wait for the correct status of the callback to execute correctly
240 * @tc.desc Function test
241 */
242 HWTEST_F(CallManagerGtest, Telephony_CallManager_HangUpCall_0200, Function | MediumTest | Level2)
243 {
244 AccessToken token;
245 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
246 return;
247 }
248 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
249 InitDialInfo(
250 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
251 int32_t callId = INVALID_NEGATIVE_ID;
252 EXPECT_NE(CallManagerGtest::clientPtr_->HangUpCall(callId), RETURN_VALUE_IS_ZERO);
253 }
254
255 /**
256 * @tc.number Telephony_CallManager_HangUpCall_0300 to do ...
257 * @tc.name test ring disconnect call after DialCall without permission
258 * @tc.desc Function test
259 */
260 HWTEST_F(CallManagerGtest, Telephony_CallManager_HangUpCall_0300, Function | MediumTest | Level2)
261 {
262 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
263 return;
264 }
265 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
266 InitDialInfo(
267 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
268 int32_t callId = INVALID_NEGATIVE_ID;
269 EXPECT_NE(CallManagerGtest::clientPtr_->HangUpCall(callId), RETURN_VALUE_IS_ZERO);
270 }
271
272 /**
273 * @tc.number Telephony_CallManager_HangUpCall_0400 to do ...
274 * @tc.name test ring disconnect call after DialCall
275 * @tc.desc Function test
276 */
277 HWTEST_F(CallManagerGtest, Telephony_CallManager_HangUpCall_0400, Function | MediumTest | Level2)
278 {
279 AccessToken token;
280 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
281 return;
282 }
283 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
284 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
285 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->HangUpCall(), RETURN_VALUE_IS_ZERO);
286 }
287
288 /******************************************* Test GetCallState() *********************************************/
289 /**
290 * @tc.number Telephony_CallManager_GetCallState_0100
291 * @tc.name test GetCallState() without call
292 * @tc.desc Function test
293 */
294 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallState_0100, Function | MediumTest | Level1)
295 {
296 AccessToken token;
297 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
298 return;
299 }
300 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
301 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallState(), (int32_t)CallStateToApp::CALL_STATE_IDLE);
302 }
303
304 /**
305 * @tc.number Telephony_CallManager_GetCallState_0200 to do ...
306 * @tc.name test GetCallState() after call
307 * wait for the correct status of the callback to execute correctly
308 * @tc.desc Function test
309 */
310 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallState_0200, Function | MediumTest | Level1)
311 {
312 AccessToken token;
313 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
314 return;
315 }
316 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
317 InitDialInfo(
318 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
319 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallState(), (int32_t)CallStateToApp::CALL_STATE_IDLE);
320 }
321
322 /**
323 * @tc.number Telephony_CallManager_GetCallState_0300
324 * @tc.name test GetCallState()
325 * @tc.desc Function test
326 */
327 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallState_0300, Function | MediumTest | Level1)
328 {
329 AccessToken token;
330 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
331 return;
332 }
333 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
334 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
335 EXPECT_EQ(CallManagerGtest::blueToothClientPtr_->GetCallState(), TELEPHONY_SUCCESS);
336 }
337
338 /**************************** Test ReportAudioDeviceInfo() ****************************/
339 /**
340 * @tc.number Telephony_CallManager_ReportAudioDeviceInfo_0100
341 * @tc.name test report audio device info
342 * @tc.desc Function test
343 */
344 HWTEST_F(CallManagerGtest, Telephony_CallManager_ReportAudioDeviceInfo_0100, Function | MediumTest | Level3)
345 {
346 AccessToken token;
347 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
348 return;
349 }
350 std::string phoneNumber = "10086";
351 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
352 HangUpCall();
353 }
354 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
355 EXPECT_EQ(CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_), RETURN_VALUE_IS_ZERO);
356 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_OFFHOOK, SLEEP_200_MS, SLEEP_30000_MS);
357 EXPECT_GE(CallManagerGtest::clientPtr_->ReportAudioDeviceInfo(), RETURN_VALUE_IS_ZERO);
358 sleep(1);
359 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
360 HangUpCall();
361 }
362 }
363
364 /**
365 * @tc.number Telephony_CallManager_ReportAudioDeviceInfo_0200
366 * @tc.name test report audio device info without active call
367 * @tc.desc Function test
368 */
369 HWTEST_F(CallManagerGtest, Telephony_CallManager_ReportAudioDeviceInfo_0200, Function | MediumTest | Level3)
370 {
371 AccessToken token;
372 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
373 return;
374 }
375 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
376 HangUpCall();
377 }
378 EXPECT_GE(CallManagerGtest::clientPtr_->ReportAudioDeviceInfo(), RETURN_VALUE_IS_ZERO);
379 }
380
381 /**
382 * @tc.number Telephony_CallManager_ReportAudioDeviceInfo_0300
383 * @tc.name test report audio device info without permission
384 * @tc.desc Function test
385 */
386 HWTEST_F(CallManagerGtest, Telephony_CallManager_ReportAudioDeviceInfo_0300, Function | MediumTest | Level3)
387 {
388 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
389 return;
390 }
391 EXPECT_NE(CallManagerGtest::clientPtr_->ReportAudioDeviceInfo(), RETURN_VALUE_IS_ZERO);
392 }
393
394 /******************************************* Test HoldCall() *********************************************/
395 /**
396 * @tc.number Telephony_CallManager_HoldCall_0100
397 * @tc.name Hold calls for non-existent call ID
398 * @tc.desc Function test
399 */
400 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0100, Function | MediumTest | Level2)
401 {
402 AccessToken token;
403 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
404 return;
405 }
406 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
407 int32_t callId = INVALID_NEGATIVE_ID;
408 EXPECT_NE(CallManagerGtest::clientPtr_->HoldCall(callId), RETURN_VALUE_IS_ZERO);
409 }
410
411 /**
412 * @tc.number Telephony_CallManager_HoldCall_0200 to do ...
413 * @tc.name coming call test hold call, return non 0
414 * wait for the correct status of the callback to execute correctly
415 * @tc.desc Function test
416 */
417 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0200, Function | MediumTest | Level2)
418 {
419 AccessToken token;
420 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
421 return;
422 }
423 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
424 InitDialInfo(
425 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
426 int32_t callId = INVALID_NEGATIVE_ID;
427 EXPECT_NE(CallManagerGtest::clientPtr_->HoldCall(callId), RETURN_VALUE_IS_ZERO);
428 }
429
430 /**
431 * @tc.number Telephony_CallManager_HoldCall_0300 to do ...
432 * @tc.name coming call test hold call without permission
433 * @tc.desc Function test
434 */
435 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0300, Function | MediumTest | Level2)
436 {
437 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
438 return;
439 }
440 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
441 InitDialInfo(
442 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
443 int32_t callId = INVALID_NEGATIVE_ID;
444 EXPECT_NE(CallManagerGtest::clientPtr_->HoldCall(callId), RETURN_VALUE_IS_ZERO);
445 }
446
447 /**
448 * @tc.number Telephony_CallManager_HoldCall_0400
449 * @tc.name Hold calls for non-existent call ID
450 * @tc.desc Function test
451 */
452 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0400, Function | MediumTest | Level2)
453 {
454 AccessToken token;
455 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
456 return;
457 }
458 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
459 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
460 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->HoldCall(), RETURN_VALUE_IS_ZERO);
461 }
462
463 /******************************************* Test UnHoldCall() *********************************************/
464 /**
465 * @tc.number Telephony_CallManager_UnHoldCall_0100
466 * @tc.name Replies calls to a call ID that does not exist, return non 0
467 * @tc.desc Function test
468 */
469 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnHoldCall_0100, Function | MediumTest | Level2)
470 {
471 AccessToken token;
472 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
473 return;
474 }
475 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
476 int32_t callId = INVALID_NEGATIVE_ID;
477 EXPECT_NE(CallManagerGtest::clientPtr_->UnHoldCall(callId), RETURN_VALUE_IS_ZERO);
478 }
479
480 /**
481 * @tc.number Telephony_CallManager_UnHoldCall_0200 to do ...
482 * @tc.name Passing in the suspended call ID, test UnHoldCall() return non 0
483 * wait for the correct status of the callback to execute correctly
484 * @tc.desc Function test
485 */
486 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnHoldCall_0200, Function | MediumTest | Level2)
487 {
488 AccessToken token;
489 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
490 return;
491 }
492 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
493 InitDialInfo(
494 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
495 int32_t callId = INVALID_NEGATIVE_ID;
496 EXPECT_NE(CallManagerGtest::clientPtr_->UnHoldCall(callId), RETURN_VALUE_IS_ZERO);
497 }
498
499 /**
500 * @tc.number Telephony_CallManager_UnHoldCall_0300
501 * @tc.name Replies calls to a call ID that does not exist without permission
502 * @tc.desc Function test
503 */
504 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnHoldCall_0300, Function | MediumTest | Level2)
505 {
506 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
507 return;
508 }
509 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
510 int32_t callId = INVALID_NEGATIVE_ID;
511 EXPECT_NE(CallManagerGtest::clientPtr_->UnHoldCall(callId), RETURN_VALUE_IS_ZERO);
512 }
513
514 /**
515 * @tc.number Telephony_CallManager_UnHoldCall_0400
516 * @tc.name Replies calls to a call ID that does not exist, return non 0
517 * @tc.desc Function test
518 */
519 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnHoldCall_0400, Function | MediumTest | Level2)
520 {
521 AccessToken token;
522 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
523 return;
524 }
525 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
526 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
527 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->UnHoldCall(), RETURN_VALUE_IS_ZERO);
528 }
529
530 /******************************************* Test SwitchCall() *********************************************/
531 /**
532 * @tc.number Telephony_CallManager_SwitchCall_0100
533 * @tc.name Test returns 0 after switching call
534 * @tc.desc Function test
535 */
536 HWTEST_F(CallManagerGtest, Telephony_CallManager_SwitchCall_0100, Function | MediumTest | Level2)
537 {
538 AccessToken token;
539 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
540 return;
541 }
542 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
543 int32_t callId = INVALID_NEGATIVE_ID;
544 EXPECT_NE(CallManagerGtest::clientPtr_->SwitchCall(callId), RETURN_VALUE_IS_ZERO);
545 }
546
547 /**
548 * @tc.number Telephony_CallManager_SwitchCall_0200
549 * @tc.name Test returns 0 after switching call without permission
550 * @tc.desc Function test
551 */
552 HWTEST_F(CallManagerGtest, Telephony_CallManager_SwitchCall_0200, Function | MediumTest | Level2)
553 {
554 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
555 return;
556 }
557 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
558 int32_t callId = INVALID_NEGATIVE_ID;
559 EXPECT_NE(CallManagerGtest::clientPtr_->SwitchCall(callId), RETURN_VALUE_IS_ZERO);
560 }
561
562 /**
563 * @tc.number Telephony_CallManager_SwitchCall_0300
564 * @tc.name Test returns 0 after switching call
565 * @tc.desc Function test
566 */
567 HWTEST_F(CallManagerGtest, Telephony_CallManager_SwitchCall_0300, Function | MediumTest | Level2)
568 {
569 AccessToken token;
570 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
571 return;
572 }
573 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
574 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
575 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->SwitchCall(), RETURN_VALUE_IS_ZERO);
576 }
577
578 /**
579 * @tc.number Telephony_CallManager_SwitchCall_0400
580 * @tc.name Test returns 0 after switching call, and DialCall(), return true
581 * wait for the correct status of the callback to execute correctly
582 * @tc.desc Function test
583 */
584 HWTEST_F(CallManagerGtest, Telephony_CallManager_SwitchCall_0400, Function | MediumTest | Level2)
585 {
586 AccessToken token;
587 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
588 return;
589 }
590
591 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
592 HangUpCall();
593 }
594 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
595 std::string phoneNumber = "44444444444";
596 int32_t callId = INVALID_NEGATIVE_ID;
597 InitDialInfo(
598 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
599 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
600 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
601 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_OFFHOOK, SLEEP_200_MS, SLEEP_30000_MS);
602 EXPECT_NE(CallManagerGtest::clientPtr_->SwitchCall(callId), RETURN_VALUE_IS_ZERO);
603 sleep(WAIT_TIME);
604 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
605 HangUpCall();
606 }
607 }
608
609 /********************************************* Test HasCall() ***********************************************/
610 /**
611 * @tc.number Telephony_CallManager_HasCall_0100
612 * @tc.name in CALL_STATE_IDLE status, than test Hascall(), return false
613 * @tc.desc Function test
614 */
615 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasCall_0100, Function | MediumTest | Level2)
616 {
617 AccessToken token;
618 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
619 return;
620 }
621 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
622 HangUpCall();
623 }
624 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
625 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
626 int32_t idleState = (int32_t)CallStateToApp::CALL_STATE_IDLE;
627 ASSERT_EQ(callState, idleState);
628 EXPECT_EQ(CallManagerGtest::clientPtr_->HasCall(), false);
629 }
630
631 /**
632 * @tc.number Telephony_CallManager_HasCall_0200 to do ...
633 * @tc.name The wrong number is not on call, return false
634 * @tc.desc Function test
635 */
636 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasCall_0200, Function | MediumTest | Level1)
637 {
638 AccessToken token;
639 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
640 return;
641 }
642
643 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
644 std::string phoneNumber = "";
645 InitDialInfo(
646 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
647 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
648 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
649 bool isRet = CallManagerGtest::clientPtr_->HasCall();
650 EXPECT_NE(isRet, true);
651 }
652
653 /**
654 * @tc.number Telephony_CallManager_HasCall_0300 to do ...
655 * @tc.name Free time test Hascall(), return false
656 * @tc.desc Function test
657 */
658 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasCall_0300, Function | MediumTest | Level1)
659 {
660 AccessToken token;
661 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
662 return;
663 }
664 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
665 bool isRet = CallManagerGtest::clientPtr_->HasCall();
666 EXPECT_NE(isRet, true);
667 }
668
669 /**
670 * @tc.number Telephony_CallManager_HasCall_0400
671 * @tc.name in CALL_STATE_IDLE status, than test Hascall(), return false
672 * @tc.desc Function test
673 */
674 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasCall_0400, Function | MediumTest | Level2)
675 {
676 AccessToken token;
677 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
678 return;
679 }
680 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
681 ASSERT_EQ(CallManagerGtest::clientPtr_->GetCallState(), (int32_t)CallStateToApp::CALL_STATE_IDLE);
682 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
683 EXPECT_EQ(CallManagerGtest::blueToothClientPtr_->HasCall(), false);
684 }
685
686 /********************************* Test IsNewCallAllowed() ***************************************/
687 /**
688 * @tc.number Telephony_CallManager_IsNewCallAllowed_0100
689 * @tc.name The call failed after making a call without the card
690 * @tc.desc Function test
691 */
692 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsNewCallAllowed_0100, Function | MediumTest | Level1)
693 {
694 AccessToken token;
695 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
696 return;
697 }
698 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
699 HangUpCall();
700 }
701 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
702 std::string phoneNumber = "55555555555";
703 InitDialInfo(SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
704 (int32_t)DialType::DIAL_CARRIER_TYPE);
705 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
706 ASSERT_EQ(ret, RETURN_VALUE_IS_ZERO);
707 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_OFFHOOK, SLEEP_200_MS, SLEEP_30000_MS);
708 bool enabled = false;
709 EXPECT_EQ(CallManagerGtest::clientPtr_->IsNewCallAllowed(enabled), TELEPHONY_SUCCESS);
710 EXPECT_EQ(enabled, false);
711 sleep(WAIT_TIME);
712 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
713 HangUpCall();
714 }
715 }
716
717 /**
718 * @tc.number Telephony_CallManager_IsNewCallAllowed_0200
719 * @tc.name The call failed after making a call without the card
720 * @tc.desc Function test
721 */
722 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsNewCallAllowed_0200, Function | MediumTest | Level1)
723 {
724 AccessToken token;
725 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
726 return;
727 }
728 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
729 HangUpCall();
730 }
731 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
732 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
733 bool enabled = false;
734 EXPECT_EQ(CallManagerGtest::blueToothClientPtr_->IsNewCallAllowed(enabled), TELEPHONY_SUCCESS);
735 EXPECT_EQ(enabled, true);
736 }
737
738 /********************************************* Test IsRinging() ***********************************************/
739 /**
740 * @tc.number Telephony_CallManager_IsRinging_0100
741 * @tc.name There is no call, return true
742 * @tc.desc Function test
743 */
744 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsRinging_0100, Function | MediumTest | Level1)
745 {
746 AccessToken token;
747 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
748 return;
749 }
750 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
751 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
752 int32_t idleState = (int32_t)CallStateToApp::CALL_STATE_IDLE;
753 ASSERT_EQ(callState, idleState);
754 bool enabled = false;
755 EXPECT_EQ(CallManagerGtest::clientPtr_->IsRinging(enabled), TELEPHONY_SUCCESS);
756 EXPECT_NE(enabled, true);
757 }
758
759 /**
760 * @tc.number Telephony_CallManager_IsRinging_0200
761 * @tc.name There is no call, return true
762 * @tc.desc Function test
763 */
764 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsRinging_0200, Function | MediumTest | Level1)
765 {
766 AccessToken token;
767 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
768 return;
769 }
770 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
771 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
772 int32_t idleState = (int32_t)CallStateToApp::CALL_STATE_IDLE;
773 ASSERT_EQ(callState, idleState);
774 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
775 bool enabled = false;
776 EXPECT_EQ(CallManagerGtest::blueToothClientPtr_->IsRinging(enabled), TELEPHONY_SUCCESS);
777 EXPECT_NE(enabled, true);
778 }
779
780 /***************************************** Test CombineConference() ********************************************/
781 /**
782 * @tc.number Telephony_CallManager_CombineConference_0100
783 * @tc.name Import callId "@&%￥", test CombineConference(), return non 0
784 * @tc.desc Function test
785 */
786 HWTEST_F(CallManagerGtest, Telephony_CallManager_CombineConference_0100, Function | MediumTest | Level2)
787 {
788 AccessToken token;
789 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
790 return;
791 }
792 int32_t callId = INVALID_NEGATIVE_ID;
793 EXPECT_NE(CallManagerGtest::clientPtr_->CombineConference(callId), RETURN_VALUE_IS_ZERO);
794 }
795
796 /**
797 * @tc.number Telephony_CallManager_CombineConference_0200
798 * @tc.name Import callId "100", test CombineConference(), return non 0
799 * @tc.desc Function test
800 */
801 HWTEST_F(CallManagerGtest, Telephony_CallManager_CombineConference_0200, Function | MediumTest | Level2)
802 {
803 AccessToken token;
804 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
805 return;
806 }
807 int32_t callId = INVALID_POSITIVE_ID;
808 EXPECT_NE(CallManagerGtest::clientPtr_->CombineConference(callId), RETURN_VALUE_IS_ZERO);
809 }
810
811 /**
812 * @tc.number Telephony_CallManager_CombineConference_0300
813 * @tc.name Import callId "@&%￥", test CombineConference(), return non 0
814 * @tc.desc Function test
815 */
816 HWTEST_F(CallManagerGtest, Telephony_CallManager_CombineConference_0300, Function | MediumTest | Level2)
817 {
818 AccessToken token;
819 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
820 return;
821 }
822 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
823 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->CombineConference(), RETURN_VALUE_IS_ZERO);
824 }
825
826 /**
827 * @tc.number Telephony_CallManager_CombineConference_0400
828 * @tc.name Import callId "@&%￥", test CombineConference(), return non 0
829 * @tc.desc Function test
830 */
831 HWTEST_F(CallManagerGtest, Telephony_CallManager_CombineConference_0400, Function | MediumTest | Level2)
832 {
833 AccessToken token;
834 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
835 return;
836 }
837
838 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
839 std::string phoneNumber = "10086";
840 InitDialInfo(
841 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
842 EXPECT_EQ(CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_), RETURN_VALUE_IS_ZERO);
843 if (CallInfoManager::HasActiveStatus()) {
844 EXPECT_NE(CallManagerGtest::clientPtr_->CombineConference(g_newCallId), RETURN_VALUE_IS_ZERO);
845 }
846 sleep(WAIT_TIME);
847 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
848 HangUpCall();
849 }
850 }
851
852 /***************************************** Test SeparateConference() ********************************************/
853 /**
854 * @tc.number Telephony_CallManager_SeparateConference_0100
855 * @tc.name Import callId " -100", test SeparateConference(), return non 0
856 * @tc.desc Function test
857 */
858 HWTEST_F(CallManagerGtest, Telephony_CallManager_SeparateConference_0100, Function | MediumTest | Level2)
859 {
860 AccessToken token;
861 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
862 return;
863 }
864 int32_t callId = INVALID_NEGATIVE_ID;
865 EXPECT_NE(CallManagerGtest::clientPtr_->SeparateConference(callId), RETURN_VALUE_IS_ZERO);
866 }
867
868 /**
869 * @tc.number Telephony_CallManager_SeparateConference_0200
870 * @tc.name Import callId "100", test SeparateConference(), return non 0
871 * @tc.desc Function test
872 */
873 HWTEST_F(CallManagerGtest, Telephony_CallManager_SeparateConference_0200, Function | MediumTest | Level2)
874 {
875 AccessToken token;
876 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
877 return;
878 }
879 int32_t callId = INVALID_POSITIVE_ID;
880 EXPECT_NE(CallManagerGtest::clientPtr_->SeparateConference(callId), RETURN_VALUE_IS_ZERO);
881 }
882
883 /**
884 * @tc.number Telephony_CallManager_SeparateConference_0300
885 * @tc.name Import callId " -100", test SeparateConference(), return non 0
886 * @tc.desc Function test
887 */
888 HWTEST_F(CallManagerGtest, Telephony_CallManager_SeparateConference_0300, Function | MediumTest | Level2)
889 {
890 AccessToken token;
891 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
892 return;
893 }
894 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
895 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->SeparateConference(), RETURN_VALUE_IS_ZERO);
896 }
897
898 /**
899 * @tc.number Telephony_CallManager_SeparateConference_0400
900 * @tc.name Import callId normal, test SeparateConference(), return non 0
901 * @tc.desc Function test
902 */
903 HWTEST_F(CallManagerGtest, Telephony_CallManager_SeparateConference_0400, Function | MediumTest | Level2)
904 {
905 AccessToken token;
906 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
907 return;
908 }
909
910 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
911 InitDialInfo(
912 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
913 EXPECT_EQ(CallManagerGtest::clientPtr_->DialCall(Str8ToStr16("10086"), dialInfo_), RETURN_VALUE_IS_ZERO);
914 if (CallInfoManager::HasActiveStatus()) {
915 EXPECT_NE(CallManagerGtest::clientPtr_->SeparateConference(g_newCallId), RETURN_VALUE_IS_ZERO);
916 }
917 sleep(WAIT_TIME);
918 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
919 HangUpCall();
920 }
921 }
922
923 /***************************************** Test KickOutFromConference() ********************************************/
924 /**
925 * @tc.number Telephony_CallManager_KickOutFromConference_0100
926 * @tc.name Import callId " -100", test KickOutFromConference(), return non 0
927 * @tc.desc Function test
928 */
929 HWTEST_F(CallManagerGtest, Telephony_CallManager_KickOutFromConference_0100, Function | MediumTest | Level2)
930 {
931 AccessToken token;
932 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
933 return;
934 }
935 int32_t callId = INVALID_NEGATIVE_ID;
936 EXPECT_NE(CallManagerGtest::clientPtr_->KickOutFromConference(callId), RETURN_VALUE_IS_ZERO);
937 }
938
939 /**
940 * @tc.number Telephony_CallManager_KickOutFromConference_0200
941 * @tc.name Import callId "100", test KickOutFromConference(), return non 0
942 * @tc.desc Function test
943 */
944 HWTEST_F(CallManagerGtest, Telephony_CallManager_KickOutFromConference_0200, Function | MediumTest | Level2)
945 {
946 AccessToken token;
947 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
948 return;
949 }
950 int32_t callId = INVALID_POSITIVE_ID;
951 EXPECT_NE(CallManagerGtest::clientPtr_->KickOutFromConference(callId), RETURN_VALUE_IS_ZERO);
952 }
953
954 /**
955 * @tc.number Telephony_CallManager_KickOutFromConference_0300
956 * @tc.name Import callId " -100", test KickOutFromConference(), return non 0
957 * @tc.desc Function test
958 */
959 HWTEST_F(CallManagerGtest, Telephony_CallManager_KickOutFromConference_0300, Function | MediumTest | Level2)
960 {
961 AccessToken token;
962 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
963 return;
964 }
965 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
966 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->KickOutFromConference(), RETURN_VALUE_IS_ZERO);
967 }
968 } // namespace Telephony
969 } // namespace OHOS
970