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 /**
193 * @tc.number Telephony_CallManager_KickOutFromConference_0400
194 * @tc.name Import callId normal, test KickOutFromConference(), return non 0
195 * @tc.desc Function test
196 */
197 HWTEST_F(CallManagerGtest, Telephony_CallManager_KickOutFromConference_0400, Function | MediumTest | Level2)
198 {
199 AccessToken token;
200 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
201 return;
202 }
203
204 std::string number = "10086";
205 InitDialInfo(
206 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
207 EXPECT_GE(CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(number), dialInfo_), RETURN_VALUE_IS_ZERO);
208 if (CallInfoManager::HasActiveStatus()) {
209 EXPECT_NE(CallManagerGtest::clientPtr_->KickOutFromConference(g_newCallId), RETURN_VALUE_IS_ZERO);
210 }
211 sleep(WAIT_TIME);
212 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
213 HangUpCall();
214 }
215 }
216
217 /********************************************* Test GetMainCallId() ***********************************************/
218 /**
219 * @tc.number Telephony_CallManager_GetMainCallId_0100
220 * @tc.name Import callId "abcd", test GetMainCallId(), return non 0
221 * @tc.desc Function test
222 */
223 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetMainCallId_0100, TestSize.Level0)
224 {
225 AccessToken token;
226 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
227 return;
228 }
229 int32_t callId = INVALID_NEGATIVE_ID;
230 int32_t mainCallId = INVALID_NEGATIVE_ID;
231 EXPECT_NE(CallManagerGtest::clientPtr_->GetMainCallId(callId, mainCallId), TELEPHONY_ERR_SUCCESS);
232 EXPECT_NE(mainCallId, RETURN_VALUE_IS_ZERO);
233 }
234
235 /**
236 * @tc.number Telephony_CallManager_GetMainCallId_0200
237 * @tc.name Import callId "100", test GetMainCallId(), return non 0
238 * @tc.desc Function test
239 */
240 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetMainCallId_0200, TestSize.Level0)
241 {
242 AccessToken token;
243 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
244 return;
245 }
246 int32_t callId = INVALID_POSITIVE_ID;
247 int32_t mainCallId = INVALID_NEGATIVE_ID;
248 EXPECT_NE(CallManagerGtest::clientPtr_->GetMainCallId(callId, mainCallId), TELEPHONY_ERR_SUCCESS);
249 EXPECT_NE(mainCallId, RETURN_VALUE_IS_ZERO);
250 }
251
252 /***************************************** Test GetSubCallIdList() ******************************************/
253
254 /**
255 * @tc.number Telephony_CallManager_GetSubCallIdList_0100
256 * @tc.name Import callId "abcd", test GetSubCallIdList(), return non 0
257 * @tc.desc Function test
258 */
259 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetSubCallIdList_0100, TestSize.Level0)
260 {
261 AccessToken token;
262 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
263 return;
264 }
265 int32_t callId = INVALID_NEGATIVE_ID;
266 std::vector<std::u16string> list;
267 list.clear();
268 int32_t result = CallManagerGtest::clientPtr_->GetSubCallIdList(callId, list);
269 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
270 bool isEmpty = list.empty();
271 EXPECT_EQ(isEmpty, true);
272 if (!list.empty()) {
273 list.clear();
274 }
275 }
276
277 /**
278 * @tc.number Telephony_CallManager_GetSubCallIdList_0200
279 * @tc.name Import callId "100", test GetSubCallIdList(), return non 0
280 * @tc.desc Function test
281 */
282 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetSubCallIdList_0200, TestSize.Level0)
283 {
284 AccessToken token;
285 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
286 return;
287 }
288 int32_t callId = INVALID_POSITIVE_ID;
289 std::vector<std::u16string> ans;
290 ans.clear();
291 int32_t result = CallManagerGtest::clientPtr_->GetSubCallIdList(callId, ans);
292 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
293 bool isEmpty = ans.empty();
294 EXPECT_EQ(isEmpty, true);
295 if (!ans.empty()) {
296 ans.clear();
297 }
298 }
299
300 /************************************ Test GetCallIdListForConference() ***************************************/
301
302 /**
303 * @tc.number Telephony_CallManager_GetCallIdListForConference_0100
304 * @tc.name Import callId "abcd", test GetCallIdListForConference(), return non 0
305 * @tc.desc Function test
306 */
307 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallIdListForConference_0100, TestSize.Level0)
308 {
309 AccessToken token;
310 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
311 return;
312 }
313 int32_t callId = INVALID_NEGATIVE_ID;
314 std::vector<std::u16string> callIdList;
315 callIdList.clear();
316 int32_t result = CallManagerGtest::clientPtr_->GetCallIdListForConference(callId, callIdList);
317 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
318 bool isEmpty = callIdList.empty();
319 EXPECT_EQ(isEmpty, true);
320 if (!callIdList.empty()) {
321 callIdList.clear();
322 }
323 }
324
325 /**
326 * @tc.number Telephony_CallManager_GetCallIdListForConference_0200
327 * @tc.name Import callId "100", test GetCallIdListForConference(), return non 0
328 * @tc.desc Function test
329 */
330 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallIdListForConference_0200, TestSize.Level0)
331 {
332 AccessToken token;
333 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
334 return;
335 }
336 int32_t callId = INVALID_POSITIVE_ID;
337 std::vector<std::u16string> ans;
338 ans.clear();
339 int32_t result = CallManagerGtest::clientPtr_->GetCallIdListForConference(callId, ans);
340 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
341 bool isEmpty = ans.empty();
342 EXPECT_EQ(isEmpty, true);
343 if (!ans.empty()) {
344 ans.clear();
345 }
346 }
347 /************************************* Test IsEmergencyPhoneNumber() ***************************************/
348 /**
349 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0100
350 * @tc.name Call one phonynumber "0-0-0", test IsEmergencyPhoneNumber(), return false
351 * @tc.desc Function test
352 */
353 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0100, TestSize.Level0)
354 {
355 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
356 return;
357 }
358 std::string number = "0-0-0";
359 std::u16string phoneNumber = Str8ToStr16(number);
360 if (HasSimCard(SIM1_SLOTID)) {
361 bool enabled = false;
362 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
363 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
364 EXPECT_EQ(enabled, true);
365 }
366 if (HasSimCard(SIM2_SLOTID)) {
367 bool enabled = false;
368 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
369 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
370 EXPECT_EQ(enabled, true);
371 }
372 }
373
374 /**
375 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0200
376 * @tc.name Call one phonynumber "112", test IsEmergencyPhoneNumber(), return true
377 * @tc.desc Function test
378 * @tc.require: I5O1OQ
379 */
380 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0200, Function | MediumTest | Level2)
381 {
382 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
383 return;
384 }
385 std::u16string phoneNumber = Str8ToStr16("112");
386 if (HasSimCard(SIM2_SLOTID)) {
387 bool enabled = false;
388 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
389 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
390 EXPECT_EQ(enabled, true);
391 }
392 if (HasSimCard(SIM1_SLOTID)) {
393 bool enabled = false;
394 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
395 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
396 EXPECT_EQ(enabled, true);
397 }
398 }
399
400 /**
401 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0300
402 * @tc.name Call one phonynumber "911", test IsEmergencyPhoneNumber(), return true
403 * @tc.desc Function test
404 */
405 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0300, Function | MediumTest | Level2)
406 {
407 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
408 return;
409 }
410 std::u16string number = Str8ToStr16("911");
411 if (HasSimCard(SIM1_SLOTID)) {
412 bool enabled = false;
413 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(number, SIM1_SLOTID, enabled);
414 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
415 EXPECT_EQ(enabled, true);
416 }
417 if (HasSimCard(SIM2_SLOTID)) {
418 bool enabled = false;
419 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(number, SIM2_SLOTID, enabled);
420 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
421 EXPECT_EQ(enabled, true);
422 }
423 }
424
425 /**
426 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0400
427 * @tc.name Call one phonynumber "119", test IsEmergencyPhoneNumber(), return true
428 * @tc.desc Function test
429 */
430 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0400, Function | MediumTest | Level2)
431 {
432 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
433 return;
434 }
435 std::string number = "119";
436 std::u16string phoneNumber = Str8ToStr16(number);
437 if (HasSimCard(SIM1_SLOTID)) {
438 bool enabled = false;
439 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
440 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
441 EXPECT_EQ(enabled, true);
442 }
443 if (HasSimCard(SIM2_SLOTID)) {
444 bool enabled = false;
445 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
446 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
447 EXPECT_EQ(enabled, true);
448 }
449 }
450
451 /**
452 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0500
453 * @tc.name Call one phonynumber "999", test IsEmergencyPhoneNumber(), return true
454 * @tc.desc Function test
455 */
456 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0500, Function | MediumTest | Level2)
457 {
458 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
459 return;
460 }
461 int32_t slotId = SIM1_SLOTID_NO_CARD;
462 std::string number = "999";
463 std::u16string phoneNumber = Str8ToStr16(number);
464 bool enabled = false;
465 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
466 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
467 EXPECT_EQ(enabled, true);
468 }
469
470 /**
471 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0600
472 * @tc.name Call one phonynumber "", test IsEmergencyPhoneNumber(), return false
473 * @tc.desc Function test
474 */
475 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0600, Function | MediumTest | Level2)
476 {
477 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
478 return;
479 }
480 int32_t slotId = SIM1_SLOTID_NO_CARD;
481 std::string number = "";
482 std::u16string phoneNumber = Str8ToStr16(number);
483 bool enabled = false;
484 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
485 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
486 EXPECT_NE(enabled, true);
487 }
488
489 /**
490 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0700
491 * @tc.name Call one phonynumber "", test IsEmergencyPhoneNumber(), return false
492 * @tc.desc Function test
493 */
494 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0700, Function | MediumTest | Level2)
495 {
496 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
497 return;
498 }
499 int32_t slotId = SIM1_SLOTID_NO_CARD;
500 std::string number = "@123";
501 std::u16string phoneNumber = Str8ToStr16(number);
502 bool enabled = false;
503 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
504 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
505 EXPECT_NE(enabled, true);
506 }
507
508 /**
509 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_1000
510 * @tc.name Call one phonynumber "", test IsEmergencyPhoneNumber(), return false
511 * @tc.desc Function test
512 */
513 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_1000, Function | MediumTest | Level2)
514 {
515 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
516 return;
517 }
518 int32_t slotId = SIM1_SLOTID_NO_CARD;
519 std::string number = "+1+1+9";
520 std::u16string phoneNumber = Str8ToStr16(number);
521 bool enabled = false;
522 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
523 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
524 EXPECT_NE(enabled, true);
525 }
526
527 /********************************************* Test GetCallWaiting() ***********************************************/
528
529 /**
530 * @tc.number Telephony_CallManager_GetCallWaiting_0100
531 * @tc.name Import slotId 1, test GetCallWaiting(), return 0
532 * @tc.desc Function test
533 */
534 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallWaiting_0100, TestSize.Level0)
535 {
536 AccessToken token;
537 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
538 return;
539 }
540
541 if (HasSimCard(SIM1_SLOTID)) {
542 EXPECT_NE(CallManagerGtest::clientPtr_->GetCallWaiting(SIM1_SLOTID), RETURN_VALUE_IS_ZERO);
543 }
544 if (HasSimCard(SIM2_SLOTID)) {
545 EXPECT_NE(CallManagerGtest::clientPtr_->GetCallWaiting(SIM2_SLOTID), RETURN_VALUE_IS_ZERO);
546 }
547 }
548
549 /**
550 * @tc.number Telephony_CallManager_GetCallWaiting_0200
551 * @tc.name test GetCallWaiting without permission
552 * @tc.desc Function test
553 */
554 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallWaiting_0200, TestSize.Level0)
555 {
556 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
557 return;
558 }
559
560 if (HasSimCard(SIM1_SLOTID)) {
561 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallWaiting(SIM1_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
562 }
563 if (HasSimCard(SIM2_SLOTID)) {
564 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallWaiting(SIM2_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
565 }
566 }
567
568 /********************************************* Test StartDtmf() ***********************************************/
569
570 /**
571 * @tc.number Telephony_CallManager_StartDtmf_0100
572 * @tc.name Import callId abcd, test StartDtmf(), return non 0
573 * @tc.desc Function test
574 */
575 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0100, Function | MediumTest | Level2)
576 {
577 AccessToken token;
578 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
579 return;
580 }
581 int32_t callId = INVALID_NEGATIVE_ID;
582 char str = '1';
583 EXPECT_NE(CallManagerGtest::clientPtr_->StartDtmf(callId, str), RETURN_VALUE_IS_ZERO);
584 }
585
586 /**
587 * @tc.number Telephony_CallManager_StartDtmf_0200
588 * @tc.name Import callId 100, test StartDtmf(), return non 0
589 * @tc.desc Function test
590 */
591 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0200, Function | MediumTest | Level2)
592 {
593 AccessToken token;
594 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
595 return;
596 }
597 int32_t callId = INVALID_POSITIVE_ID;
598 char str = '1';
599 EXPECT_NE(CallManagerGtest::clientPtr_->StartDtmf(callId, str), RETURN_VALUE_IS_ZERO);
600 }
601
602 /**
603 * @tc.number Telephony_CallManager_StartDtmf_0300
604 * @tc.name Import callId 100, test StartDtmf(), return non 0
605 * @tc.desc Function test
606 */
607 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0300, Function | MediumTest | Level2)
608 {
609 AccessToken token;
610 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
611 return;
612 }
613
614 char str = '1';
615 EXPECT_NE(bluetoothCallClient.StartDtmf(str), RETURN_VALUE_IS_ZERO);
616 }
617
618 /**
619 * @tc.number Telephony_CallManager_StartDtmf_0400
620 * @tc.name Import callId abcd, test StartDtmf(), return non 0
621 * @tc.desc Function test
622 */
623 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0400, Function | MediumTest | Level2)
624 {
625 AccessToken token;
626 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
627 return;
628 }
629 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
630 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
631 HangUpCall();
632 }
633 std::string phoneNumber = "10086";
634 InitDialInfo(SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
635 (int32_t)DialType::DIAL_CARRIER_TYPE);
636 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
637 EXPECT_GE(ret, RETURN_VALUE_IS_ZERO);
638 if (CallInfoManager::HasActiveStatus()) {
639 EXPECT_GE(CallManagerGtest::clientPtr_->StartDtmf(g_newCallId, '1'), RETURN_VALUE_IS_ZERO);
640 }
641
642 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
643 sleep(WAIT_TIME);
644 HangUpCall();
645 }
646 }
647
648 /********************************************* Test StopDtmf() ***********************************************/
649
650 /**
651 * @tc.number Telephony_CallManager_StopDtmf_0100
652 * @tc.name Import callId abcd, test StopDtmf(), return non 0
653 * @tc.desc Function test
654 */
655 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0100, Function | MediumTest | Level2)
656 {
657 AccessToken token;
658 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
659 return;
660 }
661 int32_t callId = INVALID_NEGATIVE_ID;
662 EXPECT_NE(CallManagerGtest::clientPtr_->StopDtmf(callId), RETURN_VALUE_IS_ZERO);
663 }
664
665 /**
666 * @tc.number Telephony_CallManager_StopDtmf_0200
667 * @tc.name Import callId 100, test StopDtmf(), return non 0
668 * @tc.desc Function test
669 */
670 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0200, Function | MediumTest | Level2)
671 {
672 AccessToken token;
673 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
674 return;
675 }
676 int32_t callId = INVALID_POSITIVE_ID;
677 EXPECT_NE(CallManagerGtest::clientPtr_->StopDtmf(callId), RETURN_VALUE_IS_ZERO);
678 }
679
680 /**
681 * @tc.number Telephony_CallManager_StopDtmf_0300
682 * @tc.name Import callId, test StopDtmf(), return non 0
683 * @tc.desc Function test
684 */
685 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0300, Function | MediumTest | Level2)
686 {
687 AccessToken token;
688 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
689 return;
690 }
691 EXPECT_NE(bluetoothCallClient.StopDtmf(), RETURN_VALUE_IS_ZERO);
692 }
693
694 /**
695 * @tc.number Telephony_CallManager_StopDtmf_0400
696 * @tc.name Import callId abcd, test StopDtmf(), return non 0
697 * @tc.desc Function test
698 */
699 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0400, Function | MediumTest | Level2)
700 {
701 AccessToken token;
702 std::string phoneNumber = "10086";
703 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
704 return;
705 }
706 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
707 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
708 HangUpCall();
709 }
710 InitDialInfo(SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
711 (int32_t)DialType::DIAL_CARRIER_TYPE);
712 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
713 EXPECT_GE(ret, RETURN_VALUE_IS_ZERO);
714 if (CallInfoManager::HasActiveStatus()) {
715 sleep(WAIT_TIME);
716 EXPECT_EQ(CallManagerGtest::clientPtr_->StopDtmf(g_newCallId), RETURN_VALUE_IS_ZERO);
717 }
718 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
719 sleep(WAIT_TIME);
720 HangUpCall();
721 }
722 }
723
724 /**
725 * @tc.number Telephony_CallManager_PostDialProceed_0100
726 * @tc.name test post dial continue with proceed false
727 * @tc.desc Function test
728 */
729 HWTEST_F(
730 CallManagerGtest, Telephony_CallManager_PostDialProceed_0100, TestSize.Level1)
731 {
732 AccessToken token;
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_0200
743 * @tc.name test post dial continue without permission
744 * @tc.desc Function test
745 */
746 HWTEST_F(
747 CallManagerGtest, Telephony_CallManager_PostDialProceed_0200, TestSize.Level0)
748 {
749 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
750 return;
751 }
752 int32_t callId = 0;
753 bool proceed = false;
754 EXPECT_NE(CallManagerGtest::clientPtr_->PostDialProceed(callId, proceed), RETURN_VALUE_IS_ZERO);
755 }
756
757 /**
758 * @tc.number Telephony_CallManager_PostDialProceed_0300
759 * @tc.name test post dial in normal scene
760 * @tc.desc Function test
761 */
762 HWTEST_F(CallManagerGtest, Telephony_CallManager_PostDialProceed_0300, TestSize.Level0)
763 {
764 AccessToken token;
765 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
766 return;
767 }
768 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
769 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
770 HangUpCall();
771 }
772 if (HasSimCard(SIM1_SLOTID)) {
773 InitDialInfo(SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
774 (int32_t)DialType::DIAL_CARRIER_TYPE);
775 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16("10086;123"), dialInfo_);
776 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
777 if (CallInfoManager::HasActiveStatus()) {
778 sleep(1);
779 EXPECT_EQ(CallManagerGtest::clientPtr_->PostDialProceed(g_newCallId, true), RETURN_VALUE_IS_ZERO);
780 }
781 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
782 sleep(1);
783 HangUpCall();
784 }
785 }
786 if (HasSimCard(SIM2_SLOTID)) {
787 InitDialInfo(SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
788 (int32_t)DialType::DIAL_CARRIER_TYPE);
789 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16("10086;456"), dialInfo_);
790 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
791 if (CallInfoManager::HasActiveStatus()) {
792 sleep(1);
793 EXPECT_EQ(CallManagerGtest::clientPtr_->PostDialProceed(g_newCallId, true), RETURN_VALUE_IS_ZERO);
794 }
795 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
796 sleep(1);
797 HangUpCall();
798 }
799 }
800 }
801
802 /******************************** Test FormatPhoneNumber() * **************************************/
803
804 /**
805 * @tc.number Telephony_CallManager_FormatPhoneNumber_0100
806 * @tc.name Import phonyNumber 01085198749, test FormatPhoneNumber(), return 010-8519-8748
807 * @tc.desc Function test
808 */
809 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0100, TestSize.Level0)
810 {
811 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
812 return;
813 }
814 std::string number = "01085198749";
815 std::string Code = "Kr";
816 std::string formatBefore = "";
817 std::u16string phonyNumber = Str8ToStr16(number);
818 std::u16string countryCode = Str8ToStr16(Code);
819 std::u16string formatNumber = Str8ToStr16(formatBefore);
820 EXPECT_EQ(
821 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
822 }
823
824 /**
825 * @tc.number Telephony_CallManager_FormatPhoneNumber_0200
826 * @tc.name Import countryCode KR, test FormatPhoneNumber(), return 010-8519-8748
827 * @tc.desc Function test
828 */
829 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0200, TestSize.Level0)
830 {
831 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
832 return;
833 }
834 std::string number = "010-8519-8748";
835 std::string Code = "KR";
836 std::string formatBefore = "";
837 std::u16string phonyNumber = Str8ToStr16(number);
838 std::u16string countryCode = Str8ToStr16(Code);
839 std::u16string formatNumber = Str8ToStr16(formatBefore);
840 EXPECT_EQ(
841 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
842 }
843
844 /**
845 * @tc.number Telephony_CallManager_FormatPhoneNumber_0300
846 * @tc.name Import phonyNumber (03)38122112, test FormatPhoneNumber(), return 03-3812-2112
847 * @tc.desc Function test
848 */
849 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0300, TestSize.Level0)
850 {
851 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
852 return;
853 }
854 std::string number = "(03)38122112";
855 std::string Code = "JP";
856 std::string formatBefore = "";
857 std::u16string phonyNumber = Str8ToStr16(number);
858 std::u16string countryCode = Str8ToStr16(Code);
859 std::u16string formatNumber = Str8ToStr16(formatBefore);
860 EXPECT_EQ(
861 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
862 }
863
864 /**
865 * @tc.number Telephony_CallManager_FormatPhoneNumber_0400
866 * @tc.name Import phonyNumber 13888888888, test FormatPhoneNumber(), return 138 8888 8888
867 * @tc.desc Function test
868 */
869 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0400, TestSize.Level0)
870 {
871 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
872 return;
873 }
874 std::string number = "13888888888";
875 std::string Code = "CN";
876 std::string formatBefore = "";
877 std::u16string phonyNumber = Str8ToStr16(number);
878 std::u16string countryCode = Str8ToStr16(Code);
879 std::u16string formatNumber = Str8ToStr16(formatBefore);
880 EXPECT_EQ(
881 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
882 }
883
884 /**
885 * @tc.number Telephony_CallManager_FormatPhoneNumber_0500
886 * @tc.name Import phonyNumber +81338122121, test FormatPhoneNumber(), return 03-3812-2121
887 * @tc.desc Function test
888 */
889 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0500, TestSize.Level0)
890 {
891 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
892 return;
893 }
894 std::string number = "+81338122121";
895 std::string Code = "jp";
896 std::string formatBefore = "";
897 std::u16string phonyNumber = Str8ToStr16(number);
898 std::u16string countryCode = Str8ToStr16(Code);
899 std::u16string formatNumber = Str8ToStr16(formatBefore);
900 EXPECT_EQ(
901 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
902 }
903
904 /**
905 * @tc.number Telephony_CallManager_FormatPhoneNumber_0600
906 * @tc.name Import phonyNumber 666666999989, test FormatPhoneNumber(), return 666666999989
907 * @tc.desc Function test
908 */
909 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0600, TestSize.Level0)
910 {
911 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
912 return;
913 }
914 std::string number = "666666999989";
915 std::string Code = "CN";
916 std::string formatBefore = "";
917 std::u16string phonyNumber = Str8ToStr16(number);
918 std::u16string countryCode = Str8ToStr16(Code);
919 std::u16string formatNumber = Str8ToStr16(formatBefore);
920 EXPECT_EQ(
921 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
922 }
923
924 /**
925 * @tc.number Telephony_CallManager_FormatPhoneNumber_0700
926 * @tc.name Import countryCode abcdefg, test FormatPhoneNumber(), return 83886082
927 * @tc.desc Function test
928 */
929 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0700, TestSize.Level0)
930 {
931 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
932 return;
933 }
934 std::string number = "13888888889";
935 std::string Code = "abcdefg";
936 std::string formatBefore = "";
937 std::u16string phonyNumber = Str8ToStr16(number);
938 std::u16string countryCode = Str8ToStr16(Code);
939 std::u16string formatNumber = Str8ToStr16(formatBefore);
940 EXPECT_EQ(
941 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
942 }
943
944 /******************************* Test FormatPhoneNumberToE164() ***************************************/
945
946 /**
947 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0100
948 * @tc.name Import phonyNumber 01085198748, test FormatPhoneNumberToE164(), return +821085198748
949 * @tc.desc Function test
950 */
951 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0100, Function | MediumTest | Level2)
952 {
953 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
954 return;
955 }
956 std::string number = "01085198748";
957 std::string Code = "Kr";
958 std::string formatBefore = "";
959 std::u16string phonyNumber = Str8ToStr16(number);
960 std::u16string countryCode = Str8ToStr16(Code);
961 std::u16string formatNumber = Str8ToStr16(formatBefore);
962 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
963 RETURN_VALUE_IS_ZERO);
964 }
965 } // namespace Telephony
966 } // namespace OHOS
967