1 /*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #define private public
17 #define protected public
18 #include "call_manager_gtest.h"
19
20 #include <gtest/gtest.h>
21 #include <cstring>
22 #include <string>
23
24 #include "bluetooth_hfp_ag.h"
25 #include "call_manager_connect.h"
26 #include "call_manager_service.h"
27 #include "surface_utils.h"
28 #include "telephony_types.h"
29 #include "voip_call.h"
30
31 using namespace OHOS::Bluetooth;
32 namespace OHOS {
33 namespace Telephony {
34 using namespace testing::ext;
35 constexpr int16_t SIM2_SLOTID = 1;
36 constexpr int16_t SIM1_SLOTID_NO_CARD = 0;
37 constexpr int16_t RETURN_VALUE_IS_ZERO = 0;
38 constexpr int16_t INVALID_NEGATIVE_ID = -100;
39 constexpr int16_t INVALID_POSITIVE_ID = 100;
40 constexpr int INVALID_DIAL_TYPE = 3;
41 constexpr int WAIT_TIME = 3;
42 constexpr int16_t CAMERA_ROTATION_90 = 90;
43 constexpr int16_t CAMERA_ROTATION_ERROR = 50;
44 constexpr int16_t SLEEP_1000_MS = 1000;
45 constexpr int BASE_TIME_MS = 1000;
46 constexpr int SLEEP_TIME_MS = 50;
47 constexpr int MAX_LIMIT_TIME = 18000;
48 constexpr int16_t SIM1_SLOTID = 0;
49 const std::string PHONE_NUMBER = "0000000000";
50
51 std::unordered_map<int32_t, std::unordered_set<int32_t>> g_callStateMap;
52 int32_t g_newCallId = -1;
53 std::mutex CallInfoManager::mutex_;
54 int16_t CallInfoManager::newCallState_;
55 CallAttributeInfo CallInfoManager::updateCallInfo_;
56 std::unordered_set<int32_t> CallInfoManager::callIdSet_;
57
CallDetailsChange(const CallAttributeInfo & info)58 int32_t CallInfoManager::CallDetailsChange(const CallAttributeInfo &info)
59 {
60 TELEPHONY_LOGI("CallDetailsChange Start");
61 std::lock_guard<std::mutex> lock(mutex_);
62 updateCallInfo_ = info;
63 if (callIdSet_.find(updateCallInfo_.callId) == callIdSet_.end()) {
64 TELEPHONY_LOGI("CallDetailsChange new call");
65 callIdSet_.insert(updateCallInfo_.callId);
66 g_newCallId = updateCallInfo_.callId;
67 newCallState_ = (int32_t)updateCallInfo_.callState;
68 std::unordered_set<int32_t> newSet;
69 newSet.clear();
70 g_callStateMap.insert(std::pair<int32_t, std::unordered_set<int32_t>>(g_newCallId, newSet));
71 }
72 g_callStateMap[updateCallInfo_.callId].insert((int32_t)updateCallInfo_.callState);
73 return TELEPHONY_SUCCESS;
74 }
75
HasActiveStatus()76 bool CallInfoManager::HasActiveStatus()
77 {
78 TELEPHONY_LOGI("Waiting for activation !");
79 int sumUseTime = 0;
80 int slipMs = SLEEP_TIME_MS;
81 do {
82 if (!(HasState(g_newCallId, static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE)))) {
83 usleep(slipMs * BASE_TIME_MS);
84 sumUseTime += slipMs;
85 } else {
86 TELEPHONY_LOGI("===========wait %d ms callStatus:%d==============", sumUseTime, newCallState_);
87 return true;
88 }
89 } while (sumUseTime < MAX_LIMIT_TIME);
90 TELEPHONY_LOGI("===========wait %d ms callStatus:%d=====not active=========", sumUseTime, newCallState_);
91 return false;
92 }
93
HasState(int callId,int32_t callState)94 bool CallInfoManager::HasState(int callId, int32_t callState)
95 {
96 if (g_callStateMap.find(callId) == g_callStateMap.end()) {
97 return false;
98 }
99 if (g_callStateMap[callId].find(callState) == g_callStateMap[callId].end()) {
100 return false;
101 }
102 return true;
103 }
104
CallEventChange(const CallEventInfo & info)105 int32_t CallInfoManager::CallEventChange(const CallEventInfo &info)
106 {
107 return TELEPHONY_SUCCESS;
108 }
109
Init()110 void CallInfoManager::Init()
111 {
112 g_newCallId = -1;
113 updateCallInfo_.speakerphoneOn = -1;
114 updateCallInfo_.startTime = -1;
115 updateCallInfo_.isEcc = -1;
116 updateCallInfo_.accountId = -1;
117 updateCallInfo_.callType = CallType::TYPE_CS;
118 updateCallInfo_.callId = -1;
119 updateCallInfo_.callState = TelCallState::CALL_STATUS_IDLE;
120 updateCallInfo_.videoState = VideoStateType::TYPE_VOICE;
121 }
122
LockCallId(bool eq,int32_t targetId,int32_t slipMs,int32_t timeoutMs)123 void CallInfoManager::LockCallId(bool eq, int32_t targetId, int32_t slipMs, int32_t timeoutMs)
124 {
125 int32_t useTimeMs = 0;
126 std::cout << "wait for a few seconds......" << std::endl;
127 while ((updateCallInfo_.callId != targetId) && (useTimeMs < timeoutMs)) {
128 usleep(slipMs * SLEEP_1000_MS);
129 useTimeMs += slipMs;
130 }
131 std::cout << "\n===========wait " << useTimeMs << " ms target:" << updateCallInfo_.callId << std::endl;
132 if (eq) {
133 EXPECT_EQ(updateCallInfo_.callId, targetId);
134 } else {
135 EXPECT_NE(updateCallInfo_.callId, targetId);
136 }
137 }
138
LockCallState(bool eq,int32_t targetState,int32_t slipMs,int32_t timeoutMs)139 void CallInfoManager::LockCallState(bool eq, int32_t targetState, int32_t slipMs, int32_t timeoutMs)
140 {
141 if (CallManagerGtest::clientPtr_->GetCallState() == targetState) {
142 return;
143 }
144 int32_t usedTimeMs = 0;
145 std::cout << "wait for a few seconds......" << std::endl;
146 while ((CallManagerGtest::clientPtr_->GetCallState() != targetState) && (usedTimeMs < timeoutMs)) {
147 usleep(slipMs * SLEEP_1000_MS);
148 usedTimeMs += slipMs;
149 }
150 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
151 std::cout << "waited " << usedTimeMs << " seconds" << std::endl;
152 std::cout << "target call state:" << targetState << std::endl;
153 EXPECT_EQ(callState, targetState);
154 }
155
HangUpCall()156 void CallManagerGtest::HangUpCall()
157 {
158 clientPtr_->HangUpCall(INVALID_CALLID);
159 }
160
161 class ClientErrorBranchTest : public testing::Test {
162 public:
SetUpTestCase()163 static void SetUpTestCase() {};
TearDownTestCase()164 static void TearDownTestCase() {};
SetUp()165 void SetUp() {};
TearDown()166 void TearDown() {};
167 };
168
169 /**
170 * @tc.number Telephony_CallManager_KickOutFromConference_0400
171 * @tc.name Import callId normal, test KickOutFromConference(), return non 0
172 * @tc.desc Function test
173 */
174 HWTEST_F(CallManagerGtest, Telephony_CallManager_KickOutFromConference_0400, Function | MediumTest | Level2)
175 {
176 AccessToken token;
177 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
178 return;
179 }
180
181 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
182 std::string number = "10086";
183 InitDialInfo(
184 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
185 EXPECT_EQ(CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(number), dialInfo_), RETURN_VALUE_IS_ZERO);
186 if (CallInfoManager::HasActiveStatus()) {
187 EXPECT_NE(CallManagerGtest::clientPtr_->KickOutFromConference(g_newCallId), RETURN_VALUE_IS_ZERO);
188 }
189 sleep(WAIT_TIME);
190 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
191 HangUpCall();
192 }
193 }
194
195 /********************************************* Test GetMainCallId() ***********************************************/
196 /**
197 * @tc.number Telephony_CallManager_GetMainCallId_0100
198 * @tc.name Import callId "abcd", test GetMainCallId(), return non 0
199 * @tc.desc Function test
200 */
201 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetMainCallId_0100, Function | MediumTest | Level3)
202 {
203 AccessToken token;
204 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
205 return;
206 }
207 int32_t callId = INVALID_NEGATIVE_ID;
208 int32_t mainCallId = INVALID_NEGATIVE_ID;
209 EXPECT_NE(CallManagerGtest::clientPtr_->GetMainCallId(callId, mainCallId), TELEPHONY_ERR_SUCCESS);
210 EXPECT_NE(mainCallId, RETURN_VALUE_IS_ZERO);
211 }
212
213 /**
214 * @tc.number Telephony_CallManager_GetMainCallId_0200
215 * @tc.name Import callId "100", test GetMainCallId(), return non 0
216 * @tc.desc Function test
217 */
218 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetMainCallId_0200, Function | MediumTest | Level3)
219 {
220 AccessToken token;
221 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
222 return;
223 }
224 int32_t callId = INVALID_POSITIVE_ID;
225 int32_t mainCallId = INVALID_NEGATIVE_ID;
226 EXPECT_NE(CallManagerGtest::clientPtr_->GetMainCallId(callId, mainCallId), TELEPHONY_ERR_SUCCESS);
227 EXPECT_NE(mainCallId, RETURN_VALUE_IS_ZERO);
228 }
229
230 /***************************************** Test GetSubCallIdList() ******************************************/
231
232 /**
233 * @tc.number Telephony_CallManager_GetSubCallIdList_0100
234 * @tc.name Import callId "abcd", test GetSubCallIdList(), return non 0
235 * @tc.desc Function test
236 */
237 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetSubCallIdList_0100, Function | MediumTest | Level3)
238 {
239 AccessToken token;
240 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
241 return;
242 }
243 int32_t callId = INVALID_NEGATIVE_ID;
244 std::vector<std::u16string> list;
245 list.clear();
246 int32_t result = CallManagerGtest::clientPtr_->GetSubCallIdList(callId, list);
247 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
248 bool isEmpty = list.empty();
249 EXPECT_EQ(isEmpty, true);
250 if (!list.empty()) {
251 list.clear();
252 }
253 }
254
255 /**
256 * @tc.number Telephony_CallManager_GetSubCallIdList_0200
257 * @tc.name Import callId "100", test GetSubCallIdList(), return non 0
258 * @tc.desc Function test
259 */
260 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetSubCallIdList_0200, Function | MediumTest | Level3)
261 {
262 AccessToken token;
263 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
264 return;
265 }
266 int32_t callId = INVALID_POSITIVE_ID;
267 std::vector<std::u16string> ans;
268 ans.clear();
269 int32_t result = CallManagerGtest::clientPtr_->GetSubCallIdList(callId, ans);
270 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
271 bool isEmpty = ans.empty();
272 EXPECT_EQ(isEmpty, true);
273 if (!ans.empty()) {
274 ans.clear();
275 }
276 }
277
278 /************************************ Test GetCallIdListForConference() ***************************************/
279
280 /**
281 * @tc.number Telephony_CallManager_GetCallIdListForConference_0100
282 * @tc.name Import callId "abcd", test GetCallIdListForConference(), return non 0
283 * @tc.desc Function test
284 */
285 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallIdListForConference_0100, Function | MediumTest | Level3)
286 {
287 AccessToken token;
288 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
289 return;
290 }
291 int32_t callId = INVALID_NEGATIVE_ID;
292 std::vector<std::u16string> callIdList;
293 callIdList.clear();
294 int32_t result = CallManagerGtest::clientPtr_->GetCallIdListForConference(callId, callIdList);
295 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
296 bool isEmpty = callIdList.empty();
297 EXPECT_EQ(isEmpty, true);
298 if (!callIdList.empty()) {
299 callIdList.clear();
300 }
301 }
302
303 /**
304 * @tc.number Telephony_CallManager_GetCallIdListForConference_0200
305 * @tc.name Import callId "100", test GetCallIdListForConference(), return non 0
306 * @tc.desc Function test
307 */
308 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallIdListForConference_0200, Function | MediumTest | Level3)
309 {
310 AccessToken token;
311 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
312 return;
313 }
314 int32_t callId = INVALID_POSITIVE_ID;
315 std::vector<std::u16string> ans;
316 ans.clear();
317 int32_t result = CallManagerGtest::clientPtr_->GetCallIdListForConference(callId, ans);
318 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
319 bool isEmpty = ans.empty();
320 EXPECT_EQ(isEmpty, true);
321 if (!ans.empty()) {
322 ans.clear();
323 }
324 }
325 /************************************* Test IsEmergencyPhoneNumber() ***************************************/
326 /**
327 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0100
328 * @tc.name Call one phonynumber "0-0-0", test IsEmergencyPhoneNumber(), return false
329 * @tc.desc Function test
330 */
331 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0100, Function | MediumTest | Level3)
332 {
333 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
334 return;
335 }
336 std::string number = "0-0-0";
337 std::u16string phoneNumber = Str8ToStr16(number);
338 if (HasSimCard(SIM1_SLOTID)) {
339 bool enabled = false;
340 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
341 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
342 EXPECT_NE(enabled, true);
343 }
344 if (HasSimCard(SIM2_SLOTID)) {
345 bool enabled = false;
346 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
347 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
348 EXPECT_NE(enabled, true);
349 }
350 }
351
352 /**
353 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0200
354 * @tc.name Call one phonynumber "112", test IsEmergencyPhoneNumber(), return true
355 * @tc.desc Function test
356 * @tc.require: I5O1OQ
357 */
358 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0200, Function | MediumTest | Level2)
359 {
360 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
361 return;
362 }
363 std::u16string phoneNumber = Str8ToStr16("112");
364 if (HasSimCard(SIM2_SLOTID)) {
365 bool enabled = false;
366 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
367 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
368 EXPECT_EQ(enabled, true);
369 }
370 if (HasSimCard(SIM1_SLOTID)) {
371 bool enabled = false;
372 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
373 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
374 EXPECT_EQ(enabled, true);
375 }
376 }
377
378 /**
379 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0300
380 * @tc.name Call one phonynumber "911", test IsEmergencyPhoneNumber(), return true
381 * @tc.desc Function test
382 */
383 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0300, Function | MediumTest | Level2)
384 {
385 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
386 return;
387 }
388 std::u16string number = Str8ToStr16("911");
389 if (HasSimCard(SIM1_SLOTID)) {
390 bool enabled = false;
391 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(number, SIM1_SLOTID, enabled);
392 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
393 EXPECT_EQ(enabled, true);
394 }
395 if (HasSimCard(SIM2_SLOTID)) {
396 bool enabled = false;
397 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(number, SIM2_SLOTID, enabled);
398 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
399 EXPECT_EQ(enabled, true);
400 }
401 }
402
403 /**
404 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0400
405 * @tc.name Call one phonynumber "119", test IsEmergencyPhoneNumber(), return true
406 * @tc.desc Function test
407 */
408 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0400, Function | MediumTest | Level2)
409 {
410 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
411 return;
412 }
413 std::string number = "119";
414 std::u16string phoneNumber = Str8ToStr16(number);
415 if (HasSimCard(SIM1_SLOTID)) {
416 bool enabled = false;
417 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
418 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
419 EXPECT_EQ(enabled, true);
420 }
421 if (HasSimCard(SIM2_SLOTID)) {
422 bool enabled = false;
423 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
424 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
425 EXPECT_EQ(enabled, true);
426 }
427 }
428
429 /**
430 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0500
431 * @tc.name Call one phonynumber "999", test IsEmergencyPhoneNumber(), return true
432 * @tc.desc Function test
433 */
434 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0500, Function | MediumTest | Level2)
435 {
436 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
437 return;
438 }
439 int32_t slotId = SIM1_SLOTID_NO_CARD;
440 std::string number = "999";
441 std::u16string phoneNumber = Str8ToStr16(number);
442 bool enabled = false;
443 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
444 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
445 EXPECT_EQ(enabled, true);
446 }
447
448 /**
449 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0600
450 * @tc.name Call one phonynumber "", test IsEmergencyPhoneNumber(), return false
451 * @tc.desc Function test
452 */
453 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0600, Function | MediumTest | Level2)
454 {
455 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
456 return;
457 }
458 int32_t slotId = SIM1_SLOTID_NO_CARD;
459 std::string number = "";
460 std::u16string phoneNumber = Str8ToStr16(number);
461 bool enabled = false;
462 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
463 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
464 EXPECT_NE(enabled, true);
465 }
466
467 /**
468 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0700
469 * @tc.name Call one phonynumber "", test IsEmergencyPhoneNumber(), return false
470 * @tc.desc Function test
471 */
472 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0700, Function | MediumTest | Level2)
473 {
474 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
475 return;
476 }
477 int32_t slotId = SIM1_SLOTID_NO_CARD;
478 std::string number = "@123";
479 std::u16string phoneNumber = Str8ToStr16(number);
480 bool enabled = false;
481 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
482 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
483 EXPECT_NE(enabled, true);
484 }
485
486 /**
487 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_1000
488 * @tc.name Call one phonynumber "", test IsEmergencyPhoneNumber(), return false
489 * @tc.desc Function test
490 */
491 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_1000, Function | MediumTest | Level2)
492 {
493 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
494 return;
495 }
496 int32_t slotId = SIM1_SLOTID_NO_CARD;
497 std::string number = "+1+1+9";
498 std::u16string phoneNumber = Str8ToStr16(number);
499 bool enabled = false;
500 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
501 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
502 EXPECT_NE(enabled, true);
503 }
504
505 /********************************************* Test GetCallWaiting() ***********************************************/
506
507 /**
508 * @tc.number Telephony_CallManager_GetCallWaiting_0100
509 * @tc.name Import slotId 1, test GetCallWaiting(), return 0
510 * @tc.desc Function test
511 */
512 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallWaiting_0100, Function | MediumTest | Level3)
513 {
514 AccessToken token;
515 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
516 return;
517 }
518
519 if (HasSimCard(SIM1_SLOTID)) {
520 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallWaiting(SIM1_SLOTID), RETURN_VALUE_IS_ZERO);
521 }
522 if (HasSimCard(SIM2_SLOTID)) {
523 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallWaiting(SIM2_SLOTID), RETURN_VALUE_IS_ZERO);
524 }
525 }
526
527 /**
528 * @tc.number Telephony_CallManager_GetCallWaiting_0200
529 * @tc.name test GetCallWaiting without permission
530 * @tc.desc Function test
531 */
532 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallWaiting_0200, Function | MediumTest | Level3)
533 {
534 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
535 return;
536 }
537
538 if (HasSimCard(SIM1_SLOTID)) {
539 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallWaiting(SIM1_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
540 }
541 if (HasSimCard(SIM2_SLOTID)) {
542 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallWaiting(SIM2_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
543 }
544 }
545
546 /********************************************* Test StartDtmf() ***********************************************/
547
548 /**
549 * @tc.number Telephony_CallManager_StartDtmf_0100
550 * @tc.name Import callId abcd, test StartDtmf(), return non 0
551 * @tc.desc Function test
552 */
553 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0100, Function | MediumTest | Level2)
554 {
555 AccessToken token;
556 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
557 return;
558 }
559 int32_t callId = INVALID_NEGATIVE_ID;
560 char str = '1';
561 EXPECT_NE(CallManagerGtest::clientPtr_->StartDtmf(callId, str), RETURN_VALUE_IS_ZERO);
562 }
563
564 /**
565 * @tc.number Telephony_CallManager_StartDtmf_0200
566 * @tc.name Import callId 100, test StartDtmf(), return non 0
567 * @tc.desc Function test
568 */
569 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0200, Function | MediumTest | Level2)
570 {
571 AccessToken token;
572 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
573 return;
574 }
575 int32_t callId = INVALID_POSITIVE_ID;
576 char str = '1';
577 EXPECT_NE(CallManagerGtest::clientPtr_->StartDtmf(callId, str), RETURN_VALUE_IS_ZERO);
578 }
579
580 /**
581 * @tc.number Telephony_CallManager_StartDtmf_0300
582 * @tc.name Import callId 100, test StartDtmf(), return non 0
583 * @tc.desc Function test
584 */
585 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0300, Function | MediumTest | Level2)
586 {
587 AccessToken token;
588 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
589 return;
590 }
591
592 char str = '1';
593 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
594 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->StartDtmf(str), RETURN_VALUE_IS_ZERO);
595 }
596
597 /**
598 * @tc.number Telephony_CallManager_StartDtmf_0400
599 * @tc.name Import callId abcd, test StartDtmf(), return non 0
600 * @tc.desc Function test
601 */
602 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0400, Function | MediumTest | Level2)
603 {
604 AccessToken token;
605 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
606 return;
607 }
608 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
609 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
610 HangUpCall();
611 }
612 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
613 std::string phoneNumber = "10086";
614 InitDialInfo(SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
615 (int32_t)DialType::DIAL_CARRIER_TYPE);
616 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
617 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
618 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_OFFHOOK, SLEEP_200_MS, SLEEP_30000_MS);
619 if (CallInfoManager::HasActiveStatus()) {
620 EXPECT_EQ(CallManagerGtest::clientPtr_->StartDtmf(g_newCallId, '1'), RETURN_VALUE_IS_ZERO);
621 }
622
623 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
624 sleep(WAIT_TIME);
625 HangUpCall();
626 }
627 }
628
629 /********************************************* Test StopDtmf() ***********************************************/
630
631 /**
632 * @tc.number Telephony_CallManager_StopDtmf_0100
633 * @tc.name Import callId abcd, test StopDtmf(), return non 0
634 * @tc.desc Function test
635 */
636 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0100, Function | MediumTest | Level2)
637 {
638 AccessToken token;
639 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
640 return;
641 }
642 int32_t callId = INVALID_NEGATIVE_ID;
643 EXPECT_NE(CallManagerGtest::clientPtr_->StopDtmf(callId), RETURN_VALUE_IS_ZERO);
644 }
645
646 /**
647 * @tc.number Telephony_CallManager_StopDtmf_0200
648 * @tc.name Import callId 100, test StopDtmf(), return non 0
649 * @tc.desc Function test
650 */
651 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0200, Function | MediumTest | Level2)
652 {
653 AccessToken token;
654 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
655 return;
656 }
657 int32_t callId = INVALID_POSITIVE_ID;
658 EXPECT_NE(CallManagerGtest::clientPtr_->StopDtmf(callId), RETURN_VALUE_IS_ZERO);
659 }
660
661 /**
662 * @tc.number Telephony_CallManager_StopDtmf_0300
663 * @tc.name Import callId, test StopDtmf(), return non 0
664 * @tc.desc Function test
665 */
666 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0300, Function | MediumTest | Level2)
667 {
668 AccessToken token;
669 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
670 return;
671 }
672 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
673 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->StopDtmf(), RETURN_VALUE_IS_ZERO);
674 }
675
676 /**
677 * @tc.number Telephony_CallManager_StopDtmf_0400
678 * @tc.name Import callId abcd, test StopDtmf(), return non 0
679 * @tc.desc Function test
680 */
681 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0400, Function | MediumTest | Level2)
682 {
683 AccessToken token;
684 std::string phoneNumber = "10086";
685 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
686 return;
687 }
688 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
689 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
690 HangUpCall();
691 }
692 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
693 InitDialInfo(SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
694 (int32_t)DialType::DIAL_CARRIER_TYPE);
695 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
696 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
697 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_OFFHOOK, SLEEP_200_MS, SLEEP_30000_MS);
698 if (CallInfoManager::HasActiveStatus()) {
699 sleep(WAIT_TIME);
700 EXPECT_EQ(CallManagerGtest::clientPtr_->StopDtmf(g_newCallId), RETURN_VALUE_IS_ZERO);
701 }
702 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
703 sleep(WAIT_TIME);
704 HangUpCall();
705 }
706 }
707
708 /**
709 * @tc.number Telephony_CallManager_PostDialProceed_0100
710 * @tc.name test post dial continue with proceed false
711 * @tc.desc Function test
712 */
713 HWTEST_F(
714 CallManagerGtest, Telephony_CallManager_PostDialProceed_0100, Function | MediumTest | Level3)
715 {
716 AccessToken token;
717 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
718 return;
719 }
720 int32_t callId = 0;
721 bool proceed = false;
722 EXPECT_NE(CallManagerGtest::clientPtr_->PostDialProceed(callId, proceed), RETURN_VALUE_IS_ZERO);
723 }
724
725 /**
726 * @tc.number Telephony_CallManager_PostDialProceed_0200
727 * @tc.name test post dial continue without permission
728 * @tc.desc Function test
729 */
730 HWTEST_F(
731 CallManagerGtest, Telephony_CallManager_PostDialProceed_0200, Function | MediumTest | Level3)
732 {
733 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
734 return;
735 }
736 int32_t callId = 0;
737 bool proceed = false;
738 EXPECT_NE(CallManagerGtest::clientPtr_->PostDialProceed(callId, proceed), RETURN_VALUE_IS_ZERO);
739 }
740
741 /**
742 * @tc.number Telephony_CallManager_PostDialProceed_0300
743 * @tc.name test post dial in normal scene
744 * @tc.desc Function test
745 */
746 HWTEST_F(CallManagerGtest, Telephony_CallManager_PostDialProceed_0300, Function | MediumTest | Level3)
747 {
748 AccessToken token;
749 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
750 return;
751 }
752 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
753 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
754 HangUpCall();
755 }
756 if (HasSimCard(SIM1_SLOTID)) {
757 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
758 InitDialInfo(SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
759 (int32_t)DialType::DIAL_CARRIER_TYPE);
760 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16("10086;123"), dialInfo_);
761 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
762 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_OFFHOOK, SLEEP_200_MS,
763 SLEEP_30000_MS);
764 if (CallInfoManager::HasActiveStatus()) {
765 sleep(1);
766 EXPECT_EQ(CallManagerGtest::clientPtr_->PostDialProceed(g_newCallId, true), RETURN_VALUE_IS_ZERO);
767 }
768 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
769 sleep(1);
770 HangUpCall();
771 }
772 }
773 if (HasSimCard(SIM2_SLOTID)) {
774 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
775 InitDialInfo(SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
776 (int32_t)DialType::DIAL_CARRIER_TYPE);
777 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16("10086;456"), dialInfo_);
778 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
779 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_OFFHOOK, SLEEP_200_MS,
780 SLEEP_30000_MS);
781 if (CallInfoManager::HasActiveStatus()) {
782 sleep(1);
783 EXPECT_EQ(CallManagerGtest::clientPtr_->PostDialProceed(g_newCallId, true), RETURN_VALUE_IS_ZERO);
784 }
785 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
786 sleep(1);
787 HangUpCall();
788 }
789 }
790 }
791
792 /******************************** Test FormatPhoneNumber() * **************************************/
793
794 /**
795 * @tc.number Telephony_CallManager_FormatPhoneNumber_0100
796 * @tc.name Import phonyNumber 01085198749, test FormatPhoneNumber(), return 010-8519-8748
797 * @tc.desc Function test
798 */
799 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0100, Function | MediumTest | Level3)
800 {
801 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
802 return;
803 }
804 std::string number = "01085198749";
805 std::string Code = "Kr";
806 std::string formatBefore = "";
807 std::u16string phonyNumber = Str8ToStr16(number);
808 std::u16string countryCode = Str8ToStr16(Code);
809 std::u16string formatNumber = Str8ToStr16(formatBefore);
810 EXPECT_EQ(
811 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
812 }
813
814 /**
815 * @tc.number Telephony_CallManager_FormatPhoneNumber_0200
816 * @tc.name Import countryCode KR, test FormatPhoneNumber(), return 010-8519-8748
817 * @tc.desc Function test
818 */
819 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0200, Function | MediumTest | Level3)
820 {
821 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
822 return;
823 }
824 std::string number = "010-8519-8748";
825 std::string Code = "KR";
826 std::string formatBefore = "";
827 std::u16string phonyNumber = Str8ToStr16(number);
828 std::u16string countryCode = Str8ToStr16(Code);
829 std::u16string formatNumber = Str8ToStr16(formatBefore);
830 EXPECT_EQ(
831 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
832 }
833
834 /**
835 * @tc.number Telephony_CallManager_FormatPhoneNumber_0300
836 * @tc.name Import phonyNumber (03)38122112, test FormatPhoneNumber(), return 03-3812-2112
837 * @tc.desc Function test
838 */
839 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0300, Function | MediumTest | Level3)
840 {
841 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
842 return;
843 }
844 std::string number = "(03)38122112";
845 std::string Code = "JP";
846 std::string formatBefore = "";
847 std::u16string phonyNumber = Str8ToStr16(number);
848 std::u16string countryCode = Str8ToStr16(Code);
849 std::u16string formatNumber = Str8ToStr16(formatBefore);
850 EXPECT_EQ(
851 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
852 }
853
854 /**
855 * @tc.number Telephony_CallManager_FormatPhoneNumber_0400
856 * @tc.name Import phonyNumber 13888888888, test FormatPhoneNumber(), return 138 8888 8888
857 * @tc.desc Function test
858 */
859 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0400, Function | MediumTest | Level3)
860 {
861 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
862 return;
863 }
864 std::string number = "13888888888";
865 std::string Code = "CN";
866 std::string formatBefore = "";
867 std::u16string phonyNumber = Str8ToStr16(number);
868 std::u16string countryCode = Str8ToStr16(Code);
869 std::u16string formatNumber = Str8ToStr16(formatBefore);
870 EXPECT_EQ(
871 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
872 }
873
874 /**
875 * @tc.number Telephony_CallManager_FormatPhoneNumber_0500
876 * @tc.name Import phonyNumber +81338122121, test FormatPhoneNumber(), return 03-3812-2121
877 * @tc.desc Function test
878 */
879 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0500, Function | MediumTest | Level3)
880 {
881 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
882 return;
883 }
884 std::string number = "+81338122121";
885 std::string Code = "jp";
886 std::string formatBefore = "";
887 std::u16string phonyNumber = Str8ToStr16(number);
888 std::u16string countryCode = Str8ToStr16(Code);
889 std::u16string formatNumber = Str8ToStr16(formatBefore);
890 EXPECT_EQ(
891 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
892 }
893
894 /**
895 * @tc.number Telephony_CallManager_FormatPhoneNumber_0600
896 * @tc.name Import phonyNumber 666666999989, test FormatPhoneNumber(), return 666666999989
897 * @tc.desc Function test
898 */
899 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0600, Function | MediumTest | Level3)
900 {
901 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
902 return;
903 }
904 std::string number = "666666999989";
905 std::string Code = "CN";
906 std::string formatBefore = "";
907 std::u16string phonyNumber = Str8ToStr16(number);
908 std::u16string countryCode = Str8ToStr16(Code);
909 std::u16string formatNumber = Str8ToStr16(formatBefore);
910 EXPECT_EQ(
911 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
912 }
913
914 /**
915 * @tc.number Telephony_CallManager_FormatPhoneNumber_0700
916 * @tc.name Import countryCode abcdefg, test FormatPhoneNumber(), return 83886082
917 * @tc.desc Function test
918 */
919 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0700, Function | MediumTest | Level3)
920 {
921 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
922 return;
923 }
924 std::string number = "13888888889";
925 std::string Code = "abcdefg";
926 std::string formatBefore = "";
927 std::u16string phonyNumber = Str8ToStr16(number);
928 std::u16string countryCode = Str8ToStr16(Code);
929 std::u16string formatNumber = Str8ToStr16(formatBefore);
930 EXPECT_EQ(
931 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
932 }
933
934 /******************************* Test FormatPhoneNumberToE164() ***************************************/
935
936 /**
937 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0100
938 * @tc.name Import phonyNumber 01085198748, test FormatPhoneNumberToE164(), return +821085198748
939 * @tc.desc Function test
940 */
941 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0100, Function | MediumTest | Level2)
942 {
943 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
944 return;
945 }
946 std::string number = "01085198748";
947 std::string Code = "Kr";
948 std::string formatBefore = "";
949 std::u16string phonyNumber = Str8ToStr16(number);
950 std::u16string countryCode = Str8ToStr16(Code);
951 std::u16string formatNumber = Str8ToStr16(formatBefore);
952 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
953 RETURN_VALUE_IS_ZERO);
954 }
955 } // namespace Telephony
956 } // namespace OHOS
957