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 BluetoothCallClient &bluetoothCallClient = DelayedRefSingleton<BluetoothCallClient>::GetInstance();
52 std::unordered_map<int32_t, std::unordered_set<int32_t>> g_callStateMap;
53 int32_t g_newCallId = -1;
54 std::mutex CallInfoManager::mutex_;
55 int16_t CallInfoManager::newCallState_;
56 CallAttributeInfo CallInfoManager::updateCallInfo_;
57 std::unordered_set<int32_t> CallInfoManager::callIdSet_;
58
CallDetailsChange(const CallAttributeInfo & info)59 int32_t CallInfoManager::CallDetailsChange(const CallAttributeInfo &info)
60 {
61 TELEPHONY_LOGI("CallDetailsChange Start");
62 std::lock_guard<std::mutex> lock(mutex_);
63 updateCallInfo_ = info;
64 if (callIdSet_.find(updateCallInfo_.callId) == callIdSet_.end()) {
65 TELEPHONY_LOGI("CallDetailsChange new call");
66 callIdSet_.insert(updateCallInfo_.callId);
67 g_newCallId = updateCallInfo_.callId;
68 newCallState_ = (int32_t)updateCallInfo_.callState;
69 std::unordered_set<int32_t> newSet;
70 newSet.clear();
71 g_callStateMap.insert(std::pair<int32_t, std::unordered_set<int32_t>>(g_newCallId, newSet));
72 }
73 g_callStateMap[updateCallInfo_.callId].insert((int32_t)updateCallInfo_.callState);
74 return TELEPHONY_SUCCESS;
75 }
76
MeeTimeDetailsChange(const CallAttributeInfo & info)77 int32_t CallInfoManager::MeeTimeDetailsChange(const CallAttributeInfo &info)
78 {
79 TELEPHONY_LOGI("MeeTimeDetailsChange Start");
80 std::lock_guard<std::mutex> lock(mutex_);
81 updateCallInfo_ = info;
82 if (callIdSet_.find(updateCallInfo_.callId) == callIdSet_.end()) {
83 TELEPHONY_LOGI("MeeTimeDetailsChange new call");
84 callIdSet_.insert(updateCallInfo_.callId);
85 g_newCallId = updateCallInfo_.callId;
86 newCallState_ = (int32_t)updateCallInfo_.callState;
87 std::unordered_set<int32_t> newSet;
88 newSet.clear();
89 g_callStateMap.insert(std::pair<int32_t, std::unordered_set<int32_t>>(g_newCallId, newSet));
90 }
91 g_callStateMap[updateCallInfo_.callId].insert((int32_t)updateCallInfo_.callState);
92 return TELEPHONY_SUCCESS;
93 }
94
HasActiveStatus()95 bool CallInfoManager::HasActiveStatus()
96 {
97 TELEPHONY_LOGI("Waiting for activation !");
98 int sumUseTime = 0;
99 int slipMs = SLEEP_TIME_MS;
100 do {
101 if (!(HasState(g_newCallId, static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE)))) {
102 usleep(slipMs * BASE_TIME_MS);
103 sumUseTime += slipMs;
104 } else {
105 TELEPHONY_LOGI("===========wait %d ms callStatus:%d==============", sumUseTime, newCallState_);
106 return true;
107 }
108 } while (sumUseTime < MAX_LIMIT_TIME);
109 TELEPHONY_LOGI("===========wait %d ms callStatus:%d=====not active=========", sumUseTime, newCallState_);
110 return false;
111 }
112
HasState(int callId,int32_t callState)113 bool CallInfoManager::HasState(int callId, int32_t callState)
114 {
115 if (g_callStateMap.find(callId) == g_callStateMap.end()) {
116 return false;
117 }
118 if (g_callStateMap[callId].find(callState) == g_callStateMap[callId].end()) {
119 return false;
120 }
121 return true;
122 }
123
CallEventChange(const CallEventInfo & info)124 int32_t CallInfoManager::CallEventChange(const CallEventInfo &info)
125 {
126 return TELEPHONY_SUCCESS;
127 }
128
Init()129 void CallInfoManager::Init()
130 {
131 g_newCallId = -1;
132 updateCallInfo_.speakerphoneOn = -1;
133 updateCallInfo_.startTime = -1;
134 updateCallInfo_.isEcc = -1;
135 updateCallInfo_.accountId = -1;
136 updateCallInfo_.callType = CallType::TYPE_CS;
137 updateCallInfo_.callId = -1;
138 updateCallInfo_.callState = TelCallState::CALL_STATUS_IDLE;
139 updateCallInfo_.videoState = VideoStateType::TYPE_VOICE;
140 }
141
LockCallId(bool eq,int32_t targetId,int32_t slipMs,int32_t timeoutMs)142 void CallInfoManager::LockCallId(bool eq, int32_t targetId, int32_t slipMs, int32_t timeoutMs)
143 {
144 int32_t useTimeMs = 0;
145 std::cout << "wait for a few seconds......" << std::endl;
146 while ((updateCallInfo_.callId != targetId) && (useTimeMs < timeoutMs)) {
147 usleep(slipMs * SLEEP_1000_MS);
148 useTimeMs += slipMs;
149 }
150 std::cout << "\n===========wait " << useTimeMs << " ms target:" << updateCallInfo_.callId << std::endl;
151 if (eq) {
152 EXPECT_EQ(updateCallInfo_.callId, targetId);
153 } else {
154 EXPECT_NE(updateCallInfo_.callId, targetId);
155 }
156 }
157
LockCallState(bool eq,int32_t targetState,int32_t slipMs,int32_t timeoutMs)158 void CallInfoManager::LockCallState(bool eq, int32_t targetState, int32_t slipMs, int32_t timeoutMs)
159 {
160 if (CallManagerGtest::clientPtr_->GetCallState() == targetState) {
161 return;
162 }
163 int32_t usedTimeMs = 0;
164 std::cout << "wait for a few seconds......" << std::endl;
165 while ((CallManagerGtest::clientPtr_->GetCallState() != targetState) && (usedTimeMs < timeoutMs)) {
166 usleep(slipMs * SLEEP_1000_MS);
167 usedTimeMs += slipMs;
168 }
169 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
170 std::cout << "waited " << usedTimeMs << " seconds" << std::endl;
171 std::cout << "target call state:" << targetState << std::endl;
172 if (eq) {
173 EXPECT_EQ(callState, targetState);
174 } else {
175 EXPECT_NE(callState, targetState);
176 }
177 }
178
HangUpCall()179 void CallManagerGtest::HangUpCall()
180 {
181 clientPtr_->HangUpCall(INVALID_CALLID);
182 }
183
184 class ClientErrorBranchTest : public testing::Test {
185 public:
SetUpTestCase()186 static void SetUpTestCase() {};
TearDownTestCase()187 static void TearDownTestCase() {};
SetUp()188 void SetUp() {};
TearDown()189 void TearDown() {};
190 };
191
192 /********************************************* Test RejectCall() ***********************************************/
193 /**
194 * @tc.number Telephony_CallManager_RejectCall_0100
195 * @tc.name test RejectCall with the callId does not exist
196 * @tc.desc Function test
197 */
198 HWTEST_F(CallManagerGtest, Telephony_CallManager_RejectCall_0100, Function | MediumTest | Level2)
199 {
200 AccessToken token;
201 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
202 return;
203 }
204 int32_t callId = INVALID_NEGATIVE_ID;
205 std::u16string textMessage = Str8ToStr16("this is a test message");
206 EXPECT_NE(CallManagerGtest::clientPtr_->RejectCall(callId, true, textMessage), RETURN_VALUE_IS_ZERO);
207 }
208
209 /**
210 * @tc.number Telephony_CallManager_RejectCall_0200
211 * @tc.name test RejectCall without permission
212 * @tc.desc Function test
213 */
214 HWTEST_F(CallManagerGtest, Telephony_CallManager_RejectCall_0200, Function | MediumTest | Level2)
215 {
216 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
217 return;
218 }
219 int32_t callId = INVALID_NEGATIVE_ID;
220 std::u16string textMessage = Str8ToStr16("this is a test message");
221 EXPECT_NE(CallManagerGtest::clientPtr_->RejectCall(callId, true, textMessage), RETURN_VALUE_IS_ZERO);
222 }
223
224 /**
225 * @tc.number Telephony_CallManager_RejectCall_0300
226 * @tc.name test RejectCall with the callId does not exist
227 * @tc.desc Function test
228 */
229 HWTEST_F(CallManagerGtest, Telephony_CallManager_RejectCall_0300, Function | MediumTest | Level2)
230 {
231 AccessToken token;
232 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
233 return;
234 }
235 EXPECT_NE(bluetoothCallClient.RejectCall(), RETURN_VALUE_IS_ZERO);
236 }
237
238 /******************************************* Test HangUpCall() *********************************************/
239 /**
240 * @tc.number Telephony_CallManager_HangUpCall_0100
241 * @tc.name test disconnect call with wrong callId
242 * @tc.desc Function test
243 */
244 HWTEST_F(CallManagerGtest, Telephony_CallManager_HangUpCall_0100, Function | MediumTest | Level2)
245 {
246 AccessToken token;
247 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
248 return;
249 }
250 int32_t callId = INVALID_NEGATIVE_ID;
251 EXPECT_NE(CallManagerGtest::clientPtr_->HangUpCall(callId), RETURN_VALUE_IS_ZERO);
252 }
253
254 /**
255 * @tc.number Telephony_CallManager_HangUpCall_0200 to do ...
256 * @tc.name test ring disconnect call after DialCall,
257 * wait for the correct status of the callback to execute correctly
258 * @tc.desc Function test
259 */
260 HWTEST_F(CallManagerGtest, Telephony_CallManager_HangUpCall_0200, Function | MediumTest | Level2)
261 {
262 AccessToken token;
263 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
264 return;
265 }
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_0300 to do ...
274 * @tc.name test ring disconnect call after DialCall without permission
275 * @tc.desc Function test
276 */
277 HWTEST_F(CallManagerGtest, Telephony_CallManager_HangUpCall_0300, Function | MediumTest | Level2)
278 {
279 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
280 return;
281 }
282 InitDialInfo(
283 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
284 int32_t callId = INVALID_NEGATIVE_ID;
285 EXPECT_NE(CallManagerGtest::clientPtr_->HangUpCall(callId), RETURN_VALUE_IS_ZERO);
286 }
287
288 /**
289 * @tc.number Telephony_CallManager_HangUpCall_0400 to do ...
290 * @tc.name test ring disconnect call after DialCall
291 * @tc.desc Function test
292 */
293 HWTEST_F(CallManagerGtest, Telephony_CallManager_HangUpCall_0400, Function | MediumTest | Level2)
294 {
295 AccessToken token;
296 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
297 return;
298 }
299 EXPECT_NE(bluetoothCallClient.HangUpCall(), RETURN_VALUE_IS_ZERO);
300 }
301
302 /******************************************* Test GetCallState() *********************************************/
303 /**
304 * @tc.number Telephony_CallManager_GetCallState_0100
305 * @tc.name test GetCallState() without call
306 * @tc.desc Function test
307 */
308 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallState_0100, Function | MediumTest | Level1)
309 {
310 AccessToken token;
311 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
312 return;
313 }
314 EXPECT_GE(CallManagerGtest::clientPtr_->GetCallState(), (int32_t)CallStateToApp::CALL_STATE_IDLE);
315 }
316
317 /**
318 * @tc.number Telephony_CallManager_GetCallState_0200 to do ...
319 * @tc.name test GetCallState() after call
320 * wait for the correct status of the callback to execute correctly
321 * @tc.desc Function test
322 */
323 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallState_0200, Function | MediumTest | Level1)
324 {
325 AccessToken token;
326 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
327 return;
328 }
329 InitDialInfo(
330 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
331 EXPECT_GE(CallManagerGtest::clientPtr_->GetCallState(), (int32_t)CallStateToApp::CALL_STATE_IDLE);
332 }
333
334 /**
335 * @tc.number Telephony_CallManager_GetCallState_0300
336 * @tc.name test GetCallState()
337 * @tc.desc Function test
338 */
339 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallState_0300, Function | MediumTest | Level1)
340 {
341 AccessToken token;
342 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
343 return;
344 }
345 EXPECT_EQ(bluetoothCallClient.GetCallState(), TELEPHONY_SUCCESS);
346 }
347
348 /**************************** Test ReportAudioDeviceInfo() ****************************/
349 /**
350 * @tc.number Telephony_CallManager_ReportAudioDeviceInfo_0100
351 * @tc.name test report audio device info
352 * @tc.desc Function test
353 */
354 HWTEST_F(CallManagerGtest, Telephony_CallManager_ReportAudioDeviceInfo_0100, TestSize.Level0)
355 {
356 AccessToken token;
357 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
358 return;
359 }
360 std::string phoneNumber = "10086";
361 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
362 HangUpCall();
363 }
364 EXPECT_GE(CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_), RETURN_VALUE_IS_ZERO);
365 EXPECT_GE(CallManagerGtest::clientPtr_->ReportAudioDeviceInfo(), RETURN_VALUE_IS_ZERO);
366 sleep(1);
367 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
368 HangUpCall();
369 }
370 }
371
372 /**
373 * @tc.number Telephony_CallManager_ReportAudioDeviceInfo_0200
374 * @tc.name test report audio device info without active call
375 * @tc.desc Function test
376 */
377 HWTEST_F(CallManagerGtest, Telephony_CallManager_ReportAudioDeviceInfo_0200, TestSize.Level1)
378 {
379 AccessToken token;
380 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
381 return;
382 }
383 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
384 HangUpCall();
385 }
386 EXPECT_GE(CallManagerGtest::clientPtr_->ReportAudioDeviceInfo(), RETURN_VALUE_IS_ZERO);
387 }
388
389 /**
390 * @tc.number Telephony_CallManager_ReportAudioDeviceInfo_0300
391 * @tc.name test report audio device info without permission
392 * @tc.desc Function test
393 */
394 HWTEST_F(CallManagerGtest, Telephony_CallManager_ReportAudioDeviceInfo_0300, TestSize.Level0)
395 {
396 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
397 return;
398 }
399 EXPECT_NE(CallManagerGtest::clientPtr_->ReportAudioDeviceInfo(), RETURN_VALUE_IS_ZERO);
400 }
401
402 /******************************************* Test HoldCall() *********************************************/
403 /**
404 * @tc.number Telephony_CallManager_HoldCall_0100
405 * @tc.name Hold calls for non-existent call ID
406 * @tc.desc Function test
407 */
408 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0100, Function | MediumTest | Level2)
409 {
410 AccessToken token;
411 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
412 return;
413 }
414 int32_t callId = INVALID_NEGATIVE_ID;
415 EXPECT_NE(CallManagerGtest::clientPtr_->HoldCall(callId), RETURN_VALUE_IS_ZERO);
416 }
417
418 /**
419 * @tc.number Telephony_CallManager_HoldCall_0200 to do ...
420 * @tc.name coming call test hold call, return non 0
421 * wait for the correct status of the callback to execute correctly
422 * @tc.desc Function test
423 */
424 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0200, Function | MediumTest | Level2)
425 {
426 AccessToken token;
427 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
428 return;
429 }
430 InitDialInfo(
431 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
432 int32_t callId = INVALID_NEGATIVE_ID;
433 EXPECT_NE(CallManagerGtest::clientPtr_->HoldCall(callId), RETURN_VALUE_IS_ZERO);
434 }
435
436 /**
437 * @tc.number Telephony_CallManager_HoldCall_0300 to do ...
438 * @tc.name coming call test hold call without permission
439 * @tc.desc Function test
440 */
441 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0300, Function | MediumTest | Level2)
442 {
443 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
444 return;
445 }
446 InitDialInfo(
447 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
448 int32_t callId = INVALID_NEGATIVE_ID;
449 EXPECT_NE(CallManagerGtest::clientPtr_->HoldCall(callId), RETURN_VALUE_IS_ZERO);
450 }
451
452 /**
453 * @tc.number Telephony_CallManager_HoldCall_0400
454 * @tc.name Hold calls for non-existent call ID
455 * @tc.desc Function test
456 */
457 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0400, Function | MediumTest | Level2)
458 {
459 AccessToken token;
460 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
461 return;
462 }
463 EXPECT_NE(bluetoothCallClient.HoldCall(), RETURN_VALUE_IS_ZERO);
464 }
465
466 /******************************************* Test UnHoldCall() *********************************************/
467 /**
468 * @tc.number Telephony_CallManager_UnHoldCall_0100
469 * @tc.name Replies calls to a call ID that does not exist, return non 0
470 * @tc.desc Function test
471 */
472 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnHoldCall_0100, Function | MediumTest | Level2)
473 {
474 AccessToken token;
475 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
476 return;
477 }
478 int32_t callId = INVALID_NEGATIVE_ID;
479 EXPECT_NE(CallManagerGtest::clientPtr_->UnHoldCall(callId), RETURN_VALUE_IS_ZERO);
480 }
481
482 /**
483 * @tc.number Telephony_CallManager_UnHoldCall_0200 to do ...
484 * @tc.name Passing in the suspended call ID, test UnHoldCall() return non 0
485 * wait for the correct status of the callback to execute correctly
486 * @tc.desc Function test
487 */
488 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnHoldCall_0200, Function | MediumTest | Level2)
489 {
490 AccessToken token;
491 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
492 return;
493 }
494 InitDialInfo(
495 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
496 int32_t callId = INVALID_NEGATIVE_ID;
497 EXPECT_NE(CallManagerGtest::clientPtr_->UnHoldCall(callId), RETURN_VALUE_IS_ZERO);
498 }
499
500 /**
501 * @tc.number Telephony_CallManager_UnHoldCall_0300
502 * @tc.name Replies calls to a call ID that does not exist without permission
503 * @tc.desc Function test
504 */
505 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnHoldCall_0300, Function | MediumTest | Level2)
506 {
507 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
508 return;
509 }
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 EXPECT_NE(bluetoothCallClient.UnHoldCall(), RETURN_VALUE_IS_ZERO);
526 }
527
528 /******************************************* Test SwitchCall() *********************************************/
529 /**
530 * @tc.number Telephony_CallManager_SwitchCall_0100
531 * @tc.name Test returns 0 after switching call
532 * @tc.desc Function test
533 */
534 HWTEST_F(CallManagerGtest, Telephony_CallManager_SwitchCall_0100, Function | MediumTest | Level2)
535 {
536 AccessToken token;
537 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
538 return;
539 }
540 int32_t callId = INVALID_NEGATIVE_ID;
541 EXPECT_NE(CallManagerGtest::clientPtr_->SwitchCall(callId), RETURN_VALUE_IS_ZERO);
542 }
543
544 /**
545 * @tc.number Telephony_CallManager_SwitchCall_0200
546 * @tc.name Test returns 0 after switching call without permission
547 * @tc.desc Function test
548 */
549 HWTEST_F(CallManagerGtest, Telephony_CallManager_SwitchCall_0200, Function | MediumTest | Level2)
550 {
551 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
552 return;
553 }
554 int32_t callId = INVALID_NEGATIVE_ID;
555 EXPECT_NE(CallManagerGtest::clientPtr_->SwitchCall(callId), RETURN_VALUE_IS_ZERO);
556 }
557
558 /**
559 * @tc.number Telephony_CallManager_SwitchCall_0300
560 * @tc.name Test returns 0 after switching call
561 * @tc.desc Function test
562 */
563 HWTEST_F(CallManagerGtest, Telephony_CallManager_SwitchCall_0300, Function | MediumTest | Level2)
564 {
565 AccessToken token;
566 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
567 return;
568 }
569 EXPECT_NE(bluetoothCallClient.SwitchCall(), RETURN_VALUE_IS_ZERO);
570 }
571
572 /**
573 * @tc.number Telephony_CallManager_SwitchCall_0400
574 * @tc.name Test returns 0 after switching call, and DialCall(), return true
575 * wait for the correct status of the callback to execute correctly
576 * @tc.desc Function test
577 */
578 HWTEST_F(CallManagerGtest, Telephony_CallManager_SwitchCall_0400, Function | MediumTest | Level2)
579 {
580 AccessToken token;
581 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
582 return;
583 }
584
585 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
586 HangUpCall();
587 }
588 std::string phoneNumber = "44444444444";
589 int32_t callId = INVALID_NEGATIVE_ID;
590 InitDialInfo(
591 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
592 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
593 EXPECT_GE(ret, RETURN_VALUE_IS_ZERO);
594 EXPECT_NE(CallManagerGtest::clientPtr_->SwitchCall(callId), RETURN_VALUE_IS_ZERO);
595 sleep(WAIT_TIME);
596 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
597 HangUpCall();
598 }
599 }
600
601 /********************************************* Test HasCall() ***********************************************/
602 /**
603 * @tc.number Telephony_CallManager_HasCall_0100
604 * @tc.name in CALL_STATE_IDLE status, than test Hascall(), return false
605 * @tc.desc Function test
606 */
607 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasCall_0100, Function | MediumTest | Level2)
608 {
609 AccessToken token;
610 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
611 return;
612 }
613 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
614 HangUpCall();
615 }
616 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
617 int32_t idleState = (int32_t)CallStateToApp::CALL_STATE_IDLE;
618 ASSERT_GE(callState, idleState);
619 CallManagerGtest::clientPtr_->HasCall();
620 CallManagerGtest::clientPtr_->HasCall(false);
621 CallManagerGtest::clientPtr_->HasCall(true);
622 }
623
624 /**
625 * @tc.number Telephony_CallManager_HasCall_0200 to do ...
626 * @tc.name The wrong number is not on call, return false
627 * @tc.desc Function test
628 */
629 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasCall_0200, Function | MediumTest | Level1)
630 {
631 AccessToken token;
632 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
633 return;
634 }
635
636 std::string phoneNumber = "";
637 InitDialInfo(
638 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
639 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
640 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
641 CallManagerGtest::clientPtr_->HasCall();
642 CallManagerGtest::clientPtr_->HasCall(false);
643 CallManagerGtest::clientPtr_->HasCall(true);
644 }
645
646 /**
647 * @tc.number Telephony_CallManager_HasCall_0300 to do ...
648 * @tc.name Free time test Hascall(), return false
649 * @tc.desc Function test
650 */
651 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasCall_0300, Function | MediumTest | Level1)
652 {
653 AccessToken token;
654 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
655 return;
656 }
657 ASSERT_GE(CallManagerGtest::clientPtr_->GetCallState(), (int32_t)CallStateToApp::CALL_STATE_IDLE);
658 CallManagerGtest::clientPtr_->HasCall();
659 CallManagerGtest::clientPtr_->HasCall(false);
660 CallManagerGtest::clientPtr_->HasCall(true);
661 }
662
663 /**
664 * @tc.number Telephony_CallManager_HasCall_0400
665 * @tc.name in CALL_STATE_IDLE status, than test Hascall(), return false
666 * @tc.desc Function test
667 */
668 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasCall_0400, Function | MediumTest | Level2)
669 {
670 AccessToken token;
671 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
672 return;
673 }
674 ASSERT_GE(CallManagerGtest::clientPtr_->GetCallState(), (int32_t)CallStateToApp::CALL_STATE_IDLE);
675 bluetoothCallClient.HasCall();
676 }
677
678 /********************************* Test IsNewCallAllowed() ***************************************/
679 /**
680 * @tc.number Telephony_CallManager_IsNewCallAllowed_0100
681 * @tc.name The call failed after making a call without the card
682 * @tc.desc Function test
683 */
684 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsNewCallAllowed_0100, Function | MediumTest | Level1)
685 {
686 AccessToken token;
687 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
688 return;
689 }
690 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
691 HangUpCall();
692 }
693 std::string phoneNumber = "55555555555";
694 InitDialInfo(SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
695 (int32_t)DialType::DIAL_CARRIER_TYPE);
696 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
697 ASSERT_GE(ret, RETURN_VALUE_IS_ZERO);
698 bool enabled = false;
699 EXPECT_EQ(CallManagerGtest::clientPtr_->IsNewCallAllowed(enabled), TELEPHONY_SUCCESS);
700 EXPECT_EQ(enabled, true);
701 sleep(WAIT_TIME);
702 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
703 HangUpCall();
704 }
705 }
706
707 /**
708 * @tc.number Telephony_CallManager_IsNewCallAllowed_0200
709 * @tc.name The call failed after making a call without the card
710 * @tc.desc Function test
711 */
712 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsNewCallAllowed_0200, Function | MediumTest | Level1)
713 {
714 AccessToken token;
715 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
716 return;
717 }
718 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
719 HangUpCall();
720 }
721 bool enabled = false;
722 EXPECT_EQ(bluetoothCallClient.IsNewCallAllowed(enabled), TELEPHONY_SUCCESS);
723 EXPECT_EQ(enabled, true);
724 }
725
726 /********************************************* Test IsRinging() ***********************************************/
727 /**
728 * @tc.number Telephony_CallManager_IsRinging_0100
729 * @tc.name There is no call, return true
730 * @tc.desc Function test
731 */
732 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsRinging_0100, Function | MediumTest | Level1)
733 {
734 AccessToken token;
735 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
736 return;
737 }
738 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
739 int32_t idleState = (int32_t)CallStateToApp::CALL_STATE_IDLE;
740 ASSERT_GE(callState, idleState);
741 bool enabled = false;
742 EXPECT_EQ(CallManagerGtest::clientPtr_->IsRinging(enabled), TELEPHONY_SUCCESS);
743 EXPECT_NE(enabled, true);
744 }
745
746 /**
747 * @tc.number Telephony_CallManager_IsRinging_0200
748 * @tc.name There is no call, return true
749 * @tc.desc Function test
750 */
751 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsRinging_0200, Function | MediumTest | Level1)
752 {
753 AccessToken token;
754 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
755 return;
756 }
757 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
758 int32_t idleState = (int32_t)CallStateToApp::CALL_STATE_IDLE;
759 ASSERT_GE(callState, idleState);
760 bool enabled = false;
761 EXPECT_EQ(bluetoothCallClient.IsRinging(enabled), TELEPHONY_SUCCESS);
762 EXPECT_NE(enabled, true);
763 }
764
765 /***************************************** Test CombineConference() ********************************************/
766 /**
767 * @tc.number Telephony_CallManager_CombineConference_0100
768 * @tc.name Import callId "@&%￥", test CombineConference(), return non 0
769 * @tc.desc Function test
770 */
771 HWTEST_F(CallManagerGtest, Telephony_CallManager_CombineConference_0100, Function | MediumTest | Level2)
772 {
773 AccessToken token;
774 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
775 return;
776 }
777 int32_t callId = INVALID_NEGATIVE_ID;
778 EXPECT_NE(CallManagerGtest::clientPtr_->CombineConference(callId), RETURN_VALUE_IS_ZERO);
779 }
780
781 /**
782 * @tc.number Telephony_CallManager_CombineConference_0200
783 * @tc.name Import callId "100", test CombineConference(), return non 0
784 * @tc.desc Function test
785 */
786 HWTEST_F(CallManagerGtest, Telephony_CallManager_CombineConference_0200, Function | MediumTest | Level2)
787 {
788 AccessToken token;
789 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
790 return;
791 }
792 int32_t callId = INVALID_POSITIVE_ID;
793 EXPECT_NE(CallManagerGtest::clientPtr_->CombineConference(callId), RETURN_VALUE_IS_ZERO);
794 }
795
796 /**
797 * @tc.number Telephony_CallManager_CombineConference_0300
798 * @tc.name Import callId "@&%￥", test CombineConference(), return non 0
799 * @tc.desc Function test
800 */
801 HWTEST_F(CallManagerGtest, Telephony_CallManager_CombineConference_0300, Function | MediumTest | Level2)
802 {
803 AccessToken token;
804 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
805 return;
806 }
807 EXPECT_NE(bluetoothCallClient.CombineConference(), RETURN_VALUE_IS_ZERO);
808 }
809
810 /**
811 * @tc.number Telephony_CallManager_CombineConference_0400
812 * @tc.name Import callId "@&%￥", test CombineConference(), return non 0
813 * @tc.desc Function test
814 */
815 HWTEST_F(CallManagerGtest, Telephony_CallManager_CombineConference_0400, Function | MediumTest | Level2)
816 {
817 AccessToken token;
818 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
819 return;
820 }
821
822 std::string phoneNumber = "10086";
823 InitDialInfo(
824 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
825 EXPECT_GE(CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_), RETURN_VALUE_IS_ZERO);
826 if (CallInfoManager::HasActiveStatus()) {
827 EXPECT_NE(CallManagerGtest::clientPtr_->CombineConference(g_newCallId), RETURN_VALUE_IS_ZERO);
828 }
829 sleep(WAIT_TIME);
830 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
831 HangUpCall();
832 }
833 }
834
835 /***************************************** Test SeparateConference() ********************************************/
836 /**
837 * @tc.number Telephony_CallManager_SeparateConference_0100
838 * @tc.name Import callId " -100", test SeparateConference(), return non 0
839 * @tc.desc Function test
840 */
841 HWTEST_F(CallManagerGtest, Telephony_CallManager_SeparateConference_0100, Function | MediumTest | Level2)
842 {
843 AccessToken token;
844 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
845 return;
846 }
847 int32_t callId = INVALID_NEGATIVE_ID;
848 EXPECT_NE(CallManagerGtest::clientPtr_->SeparateConference(callId), RETURN_VALUE_IS_ZERO);
849 }
850
851 /**
852 * @tc.number Telephony_CallManager_SeparateConference_0200
853 * @tc.name Import callId "100", test SeparateConference(), return non 0
854 * @tc.desc Function test
855 */
856 HWTEST_F(CallManagerGtest, Telephony_CallManager_SeparateConference_0200, Function | MediumTest | Level2)
857 {
858 AccessToken token;
859 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
860 return;
861 }
862 int32_t callId = INVALID_POSITIVE_ID;
863 EXPECT_NE(CallManagerGtest::clientPtr_->SeparateConference(callId), RETURN_VALUE_IS_ZERO);
864 }
865
866 /**
867 * @tc.number Telephony_CallManager_SeparateConference_0300
868 * @tc.name Import callId " -100", test SeparateConference(), return non 0
869 * @tc.desc Function test
870 */
871 HWTEST_F(CallManagerGtest, Telephony_CallManager_SeparateConference_0300, Function | MediumTest | Level2)
872 {
873 AccessToken token;
874 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
875 return;
876 }
877 EXPECT_NE(bluetoothCallClient.SeparateConference(), RETURN_VALUE_IS_ZERO);
878 }
879
880 /**
881 * @tc.number Telephony_CallManager_SeparateConference_0400
882 * @tc.name Import callId normal, test SeparateConference(), return non 0
883 * @tc.desc Function test
884 */
885 HWTEST_F(CallManagerGtest, Telephony_CallManager_SeparateConference_0400, Function | MediumTest | Level2)
886 {
887 AccessToken token;
888 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
889 return;
890 }
891
892 InitDialInfo(
893 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
894 EXPECT_GE(CallManagerGtest::clientPtr_->DialCall(Str8ToStr16("10086"), dialInfo_), RETURN_VALUE_IS_ZERO);
895 if (CallInfoManager::HasActiveStatus()) {
896 EXPECT_NE(CallManagerGtest::clientPtr_->SeparateConference(g_newCallId), RETURN_VALUE_IS_ZERO);
897 }
898 sleep(WAIT_TIME);
899 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
900 HangUpCall();
901 }
902 }
903
904 /***************************************** Test KickOutFromConference() ********************************************/
905 /**
906 * @tc.number Telephony_CallManager_KickOutFromConference_0100
907 * @tc.name Import callId " -100", test KickOutFromConference(), return non 0
908 * @tc.desc Function test
909 */
910 HWTEST_F(CallManagerGtest, Telephony_CallManager_KickOutFromConference_0100, Function | MediumTest | Level2)
911 {
912 AccessToken token;
913 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
914 return;
915 }
916 int32_t callId = INVALID_NEGATIVE_ID;
917 EXPECT_NE(CallManagerGtest::clientPtr_->KickOutFromConference(callId), RETURN_VALUE_IS_ZERO);
918 }
919
920 /**
921 * @tc.number Telephony_CallManager_KickOutFromConference_0200
922 * @tc.name Import callId "100", test KickOutFromConference(), return non 0
923 * @tc.desc Function test
924 */
925 HWTEST_F(CallManagerGtest, Telephony_CallManager_KickOutFromConference_0200, Function | MediumTest | Level2)
926 {
927 AccessToken token;
928 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
929 return;
930 }
931 int32_t callId = INVALID_POSITIVE_ID;
932 EXPECT_NE(CallManagerGtest::clientPtr_->KickOutFromConference(callId), RETURN_VALUE_IS_ZERO);
933 }
934
935 /**
936 * @tc.number Telephony_CallManager_KickOutFromConference_0300
937 * @tc.name Import callId " -100", test KickOutFromConference(), return non 0
938 * @tc.desc Function test
939 */
940 HWTEST_F(CallManagerGtest, Telephony_CallManager_KickOutFromConference_0300, Function | MediumTest | Level2)
941 {
942 AccessToken token;
943 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
944 return;
945 }
946 EXPECT_NE(bluetoothCallClient.KickOutFromConference(), RETURN_VALUE_IS_ZERO);
947 }
948 } // namespace Telephony
949 } // namespace OHOS
950