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 EXPECT_EQ(callState, targetState);
173 }
174
HangUpCall()175 void CallManagerGtest::HangUpCall()
176 {
177 clientPtr_->HangUpCall(INVALID_CALLID);
178 }
179
180 class ClientErrorBranchTest : public testing::Test {
181 public:
SetUpTestCase()182 static void SetUpTestCase() {};
TearDownTestCase()183 static void TearDownTestCase() {};
SetUp()184 void SetUp() {};
TearDown()185 void TearDown() {};
186 };
187
188 /********************************************* Test GetMainCallId() ***********************************************/
189 /**
190 * @tc.number Telephony_CallManager_GetMainCallId_0100
191 * @tc.name Import callId "abcd", test GetMainCallId(), return non 0
192 * @tc.desc Function test
193 */
194 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetMainCallId_0100, Function | MediumTest | Level3)
195 {
196 AccessToken token;
197 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
198 return;
199 }
200 int32_t callId = INVALID_NEGATIVE_ID;
201 int32_t mainCallId = INVALID_NEGATIVE_ID;
202 EXPECT_NE(CallManagerGtest::clientPtr_->GetMainCallId(callId, mainCallId), TELEPHONY_ERR_SUCCESS);
203 EXPECT_NE(mainCallId, RETURN_VALUE_IS_ZERO);
204 }
205
206 /**
207 * @tc.number Telephony_CallManager_GetMainCallId_0200
208 * @tc.name Import callId "100", test GetMainCallId(), return non 0
209 * @tc.desc Function test
210 */
211 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetMainCallId_0200, Function | MediumTest | Level3)
212 {
213 AccessToken token;
214 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
215 return;
216 }
217 int32_t callId = INVALID_POSITIVE_ID;
218 int32_t mainCallId = INVALID_NEGATIVE_ID;
219 EXPECT_NE(CallManagerGtest::clientPtr_->GetMainCallId(callId, mainCallId), TELEPHONY_ERR_SUCCESS);
220 EXPECT_NE(mainCallId, RETURN_VALUE_IS_ZERO);
221 }
222
223 /***************************************** Test GetSubCallIdList() ******************************************/
224
225 /**
226 * @tc.number Telephony_CallManager_GetSubCallIdList_0100
227 * @tc.name Import callId "abcd", test GetSubCallIdList(), return non 0
228 * @tc.desc Function test
229 */
230 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetSubCallIdList_0100, Function | MediumTest | Level3)
231 {
232 AccessToken token;
233 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
234 return;
235 }
236 int32_t callId = INVALID_NEGATIVE_ID;
237 std::vector<std::u16string> list;
238 list.clear();
239 int32_t result = CallManagerGtest::clientPtr_->GetSubCallIdList(callId, list);
240 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
241 bool isEmpty = list.empty();
242 EXPECT_EQ(isEmpty, true);
243 if (!list.empty()) {
244 list.clear();
245 }
246 }
247
248 /**
249 * @tc.number Telephony_CallManager_GetSubCallIdList_0200
250 * @tc.name Import callId "100", test GetSubCallIdList(), return non 0
251 * @tc.desc Function test
252 */
253 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetSubCallIdList_0200, Function | MediumTest | Level3)
254 {
255 AccessToken token;
256 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
257 return;
258 }
259 int32_t callId = INVALID_POSITIVE_ID;
260 std::vector<std::u16string> ans;
261 ans.clear();
262 int32_t result = CallManagerGtest::clientPtr_->GetSubCallIdList(callId, ans);
263 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
264 bool isEmpty = ans.empty();
265 EXPECT_EQ(isEmpty, true);
266 if (!ans.empty()) {
267 ans.clear();
268 }
269 }
270
271 /************************************ Test GetCallIdListForConference() ***************************************/
272
273 /**
274 * @tc.number Telephony_CallManager_GetCallIdListForConference_0100
275 * @tc.name Import callId "abcd", test GetCallIdListForConference(), return non 0
276 * @tc.desc Function test
277 */
278 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallIdListForConference_0100, Function | MediumTest | Level3)
279 {
280 AccessToken token;
281 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
282 return;
283 }
284 int32_t callId = INVALID_NEGATIVE_ID;
285 std::vector<std::u16string> callIdList;
286 callIdList.clear();
287 int32_t result = CallManagerGtest::clientPtr_->GetCallIdListForConference(callId, callIdList);
288 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
289 bool isEmpty = callIdList.empty();
290 EXPECT_EQ(isEmpty, true);
291 if (!callIdList.empty()) {
292 callIdList.clear();
293 }
294 }
295
296 /**
297 * @tc.number Telephony_CallManager_GetCallIdListForConference_0200
298 * @tc.name Import callId "100", test GetCallIdListForConference(), return non 0
299 * @tc.desc Function test
300 */
301 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallIdListForConference_0200, Function | MediumTest | Level3)
302 {
303 AccessToken token;
304 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
305 return;
306 }
307 int32_t callId = INVALID_POSITIVE_ID;
308 std::vector<std::u16string> ans;
309 ans.clear();
310 int32_t result = CallManagerGtest::clientPtr_->GetCallIdListForConference(callId, ans);
311 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
312 bool isEmpty = ans.empty();
313 EXPECT_EQ(isEmpty, true);
314 if (!ans.empty()) {
315 ans.clear();
316 }
317 }
318 /************************************* Test IsEmergencyPhoneNumber() ***************************************/
319 /**
320 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0100
321 * @tc.name Call one phonynumber "0-0-0", test IsEmergencyPhoneNumber(), return false
322 * @tc.desc Function test
323 */
324 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0100, Function | MediumTest | Level3)
325 {
326 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
327 return;
328 }
329 std::string number = "0-0-0";
330 std::u16string phoneNumber = Str8ToStr16(number);
331 if (HasSimCard(SIM1_SLOTID)) {
332 bool enabled = false;
333 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
334 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
335 EXPECT_NE(enabled, true);
336 }
337 if (HasSimCard(SIM2_SLOTID)) {
338 bool enabled = false;
339 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
340 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
341 EXPECT_NE(enabled, true);
342 }
343 }
344
345 /**
346 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0200
347 * @tc.name Call one phonynumber "112", test IsEmergencyPhoneNumber(), return true
348 * @tc.desc Function test
349 * @tc.require: I5O1OQ
350 */
351 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0200, Function | MediumTest | Level2)
352 {
353 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
354 return;
355 }
356 std::u16string phoneNumber = Str8ToStr16("112");
357 if (HasSimCard(SIM2_SLOTID)) {
358 bool enabled = false;
359 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
360 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
361 EXPECT_EQ(enabled, true);
362 }
363 if (HasSimCard(SIM1_SLOTID)) {
364 bool enabled = false;
365 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
366 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
367 EXPECT_EQ(enabled, true);
368 }
369 }
370
371 /**
372 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0300
373 * @tc.name Call one phonynumber "911", test IsEmergencyPhoneNumber(), return true
374 * @tc.desc Function test
375 */
376 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0300, Function | MediumTest | Level2)
377 {
378 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
379 return;
380 }
381 std::u16string number = Str8ToStr16("911");
382 if (HasSimCard(SIM1_SLOTID)) {
383 bool enabled = false;
384 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(number, SIM1_SLOTID, enabled);
385 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
386 EXPECT_EQ(enabled, true);
387 }
388 if (HasSimCard(SIM2_SLOTID)) {
389 bool enabled = false;
390 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(number, SIM2_SLOTID, enabled);
391 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
392 EXPECT_EQ(enabled, true);
393 }
394 }
395
396 /**
397 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0400
398 * @tc.name Call one phonynumber "119", test IsEmergencyPhoneNumber(), return true
399 * @tc.desc Function test
400 */
401 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0400, Function | MediumTest | Level2)
402 {
403 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
404 return;
405 }
406 std::string number = "119";
407 std::u16string phoneNumber = Str8ToStr16(number);
408 if (HasSimCard(SIM1_SLOTID)) {
409 bool enabled = false;
410 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
411 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
412 EXPECT_EQ(enabled, true);
413 }
414 if (HasSimCard(SIM2_SLOTID)) {
415 bool enabled = false;
416 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
417 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
418 EXPECT_EQ(enabled, true);
419 }
420 }
421
422 /**
423 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0500
424 * @tc.name Call one phonynumber "999", test IsEmergencyPhoneNumber(), return true
425 * @tc.desc Function test
426 */
427 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0500, Function | MediumTest | Level2)
428 {
429 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
430 return;
431 }
432 int32_t slotId = SIM1_SLOTID_NO_CARD;
433 std::string number = "999";
434 std::u16string phoneNumber = Str8ToStr16(number);
435 bool enabled = false;
436 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
437 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
438 EXPECT_EQ(enabled, true);
439 }
440
441 /**
442 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0600
443 * @tc.name Call one phonynumber "", test IsEmergencyPhoneNumber(), return false
444 * @tc.desc Function test
445 */
446 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0600, Function | MediumTest | Level2)
447 {
448 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
449 return;
450 }
451 int32_t slotId = SIM1_SLOTID_NO_CARD;
452 std::string number = "";
453 std::u16string phoneNumber = Str8ToStr16(number);
454 bool enabled = false;
455 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
456 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
457 EXPECT_NE(enabled, true);
458 }
459
460 /**
461 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0700
462 * @tc.name Call one phonynumber "", test IsEmergencyPhoneNumber(), return false
463 * @tc.desc Function test
464 */
465 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0700, Function | MediumTest | Level2)
466 {
467 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
468 return;
469 }
470 int32_t slotId = SIM1_SLOTID_NO_CARD;
471 std::string number = "@123";
472 std::u16string phoneNumber = Str8ToStr16(number);
473 bool enabled = false;
474 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
475 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
476 EXPECT_NE(enabled, true);
477 }
478
479 /**
480 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_1000
481 * @tc.name Call one phonynumber "", test IsEmergencyPhoneNumber(), return false
482 * @tc.desc Function test
483 */
484 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_1000, Function | MediumTest | Level2)
485 {
486 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
487 return;
488 }
489 int32_t slotId = SIM1_SLOTID_NO_CARD;
490 std::string number = "+1+1+9";
491 std::u16string phoneNumber = Str8ToStr16(number);
492 bool enabled = false;
493 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
494 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
495 EXPECT_NE(enabled, true);
496 }
497
498 /********************************************* Test GetCallWaiting() ***********************************************/
499 /**
500 * @tc.number Telephony_CallManager_GetCallWaiting_0200
501 * @tc.name test GetCallWaiting without permission
502 * @tc.desc Function test
503 */
504 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallWaiting_0200, Function | MediumTest | Level3)
505 {
506 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
507 return;
508 }
509
510 if (HasSimCard(SIM1_SLOTID)) {
511 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallWaiting(SIM1_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
512 }
513 if (HasSimCard(SIM2_SLOTID)) {
514 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallWaiting(SIM2_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
515 }
516 }
517
518 /********************************************* Test StartDtmf() ***********************************************/
519
520 /**
521 * @tc.number Telephony_CallManager_StartDtmf_0100
522 * @tc.name Import callId abcd, test StartDtmf(), return non 0
523 * @tc.desc Function test
524 */
525 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0100, Function | MediumTest | Level2)
526 {
527 AccessToken token;
528 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
529 return;
530 }
531 int32_t callId = INVALID_NEGATIVE_ID;
532 char str = '1';
533 EXPECT_NE(CallManagerGtest::clientPtr_->StartDtmf(callId, str), RETURN_VALUE_IS_ZERO);
534 }
535
536 /**
537 * @tc.number Telephony_CallManager_StartDtmf_0200
538 * @tc.name Import callId 100, test StartDtmf(), return non 0
539 * @tc.desc Function test
540 */
541 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0200, Function | MediumTest | Level2)
542 {
543 AccessToken token;
544 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
545 return;
546 }
547 int32_t callId = INVALID_POSITIVE_ID;
548 char str = '1';
549 EXPECT_NE(CallManagerGtest::clientPtr_->StartDtmf(callId, str), RETURN_VALUE_IS_ZERO);
550 }
551
552 /**
553 * @tc.number Telephony_CallManager_StartDtmf_0300
554 * @tc.name Import callId 100, test StartDtmf(), return non 0
555 * @tc.desc Function test
556 */
557 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0300, Function | MediumTest | Level2)
558 {
559 AccessToken token;
560 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
561 return;
562 }
563
564 char str = '1';
565 EXPECT_NE(bluetoothCallClient.StartDtmf(str), RETURN_VALUE_IS_ZERO);
566 }
567
568 /********************************************* Test StopDtmf() ***********************************************/
569
570 /**
571 * @tc.number Telephony_CallManager_StopDtmf_0100
572 * @tc.name Import callId abcd, test StopDtmf(), return non 0
573 * @tc.desc Function test
574 */
575 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_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 EXPECT_NE(CallManagerGtest::clientPtr_->StopDtmf(callId), RETURN_VALUE_IS_ZERO);
583 }
584
585 /**
586 * @tc.number Telephony_CallManager_StopDtmf_0200
587 * @tc.name Import callId 100, test StopDtmf(), return non 0
588 * @tc.desc Function test
589 */
590 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0200, Function | MediumTest | Level2)
591 {
592 AccessToken token;
593 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
594 return;
595 }
596 int32_t callId = INVALID_POSITIVE_ID;
597 EXPECT_NE(CallManagerGtest::clientPtr_->StopDtmf(callId), RETURN_VALUE_IS_ZERO);
598 }
599
600 /**
601 * @tc.number Telephony_CallManager_StopDtmf_0300
602 * @tc.name Import callId, test StopDtmf(), return non 0
603 * @tc.desc Function test
604 */
605 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0300, Function | MediumTest | Level2)
606 {
607 AccessToken token;
608 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
609 return;
610 }
611 EXPECT_NE(bluetoothCallClient.StopDtmf(), RETURN_VALUE_IS_ZERO);
612 }
613
614 /**
615 * @tc.number Telephony_CallManager_PostDialProceed_0100
616 * @tc.name test post dial continue with proceed false
617 * @tc.desc Function test
618 */
619 HWTEST_F(
620 CallManagerGtest, Telephony_CallManager_PostDialProceed_0100, Function | MediumTest | Level3)
621 {
622 AccessToken token;
623 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
624 return;
625 }
626 int32_t callId = 0;
627 bool proceed = false;
628 EXPECT_NE(CallManagerGtest::clientPtr_->PostDialProceed(callId, proceed), RETURN_VALUE_IS_ZERO);
629 }
630
631 /**
632 * @tc.number Telephony_CallManager_PostDialProceed_0200
633 * @tc.name test post dial continue without permission
634 * @tc.desc Function test
635 */
636 HWTEST_F(
637 CallManagerGtest, Telephony_CallManager_PostDialProceed_0200, Function | MediumTest | Level3)
638 {
639 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
640 return;
641 }
642 int32_t callId = 0;
643 bool proceed = false;
644 EXPECT_NE(CallManagerGtest::clientPtr_->PostDialProceed(callId, proceed), RETURN_VALUE_IS_ZERO);
645 }
646
647 /******************************** Test FormatPhoneNumber() * **************************************/
648 /**
649 * @tc.number Telephony_CallManager_FormatPhoneNumber_0100
650 * @tc.name Import phonyNumber 01085198749, test FormatPhoneNumber(), return 010-8519-8748
651 * @tc.desc Function test
652 */
653 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0100, Function | MediumTest | Level3)
654 {
655 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
656 return;
657 }
658 std::string number = "01085198749";
659 std::string Code = "Kr";
660 std::string formatBefore = "";
661 std::u16string phonyNumber = Str8ToStr16(number);
662 std::u16string countryCode = Str8ToStr16(Code);
663 std::u16string formatNumber = Str8ToStr16(formatBefore);
664 EXPECT_EQ(
665 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
666 }
667
668 /**
669 * @tc.number Telephony_CallManager_FormatPhoneNumber_0200
670 * @tc.name Import countryCode KR, test FormatPhoneNumber(), return 010-8519-8748
671 * @tc.desc Function test
672 */
673 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0200, Function | MediumTest | Level3)
674 {
675 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
676 return;
677 }
678 std::string number = "010-8519-8748";
679 std::string Code = "KR";
680 std::string formatBefore = "";
681 std::u16string phonyNumber = Str8ToStr16(number);
682 std::u16string countryCode = Str8ToStr16(Code);
683 std::u16string formatNumber = Str8ToStr16(formatBefore);
684 EXPECT_EQ(
685 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
686 }
687
688 /**
689 * @tc.number Telephony_CallManager_FormatPhoneNumber_0300
690 * @tc.name Import phonyNumber (03)38122112, test FormatPhoneNumber(), return 03-3812-2112
691 * @tc.desc Function test
692 */
693 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0300, Function | MediumTest | Level3)
694 {
695 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
696 return;
697 }
698 std::string number = "(03)38122112";
699 std::string Code = "JP";
700 std::string formatBefore = "";
701 std::u16string phonyNumber = Str8ToStr16(number);
702 std::u16string countryCode = Str8ToStr16(Code);
703 std::u16string formatNumber = Str8ToStr16(formatBefore);
704 EXPECT_EQ(
705 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
706 }
707
708 /**
709 * @tc.number Telephony_CallManager_FormatPhoneNumber_0400
710 * @tc.name Import phonyNumber 13888888888, test FormatPhoneNumber(), return 138 8888 8888
711 * @tc.desc Function test
712 */
713 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0400, Function | MediumTest | Level3)
714 {
715 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
716 return;
717 }
718 std::string number = "13888888888";
719 std::string Code = "CN";
720 std::string formatBefore = "";
721 std::u16string phonyNumber = Str8ToStr16(number);
722 std::u16string countryCode = Str8ToStr16(Code);
723 std::u16string formatNumber = Str8ToStr16(formatBefore);
724 EXPECT_EQ(
725 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
726 }
727
728 /**
729 * @tc.number Telephony_CallManager_FormatPhoneNumber_0500
730 * @tc.name Import phonyNumber +81338122121, test FormatPhoneNumber(), return 03-3812-2121
731 * @tc.desc Function test
732 */
733 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0500, Function | MediumTest | Level3)
734 {
735 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
736 return;
737 }
738 std::string number = "+81338122121";
739 std::string Code = "jp";
740 std::string formatBefore = "";
741 std::u16string phonyNumber = Str8ToStr16(number);
742 std::u16string countryCode = Str8ToStr16(Code);
743 std::u16string formatNumber = Str8ToStr16(formatBefore);
744 EXPECT_EQ(
745 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
746 }
747
748 /**
749 * @tc.number Telephony_CallManager_FormatPhoneNumber_0600
750 * @tc.name Import phonyNumber 666666999989, test FormatPhoneNumber(), return 666666999989
751 * @tc.desc Function test
752 */
753 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0600, Function | MediumTest | Level3)
754 {
755 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
756 return;
757 }
758 std::string number = "666666999989";
759 std::string Code = "CN";
760 std::string formatBefore = "";
761 std::u16string phonyNumber = Str8ToStr16(number);
762 std::u16string countryCode = Str8ToStr16(Code);
763 std::u16string formatNumber = Str8ToStr16(formatBefore);
764 EXPECT_EQ(
765 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
766 }
767
768 /**
769 * @tc.number Telephony_CallManager_FormatPhoneNumber_0700
770 * @tc.name Import countryCode abcdefg, test FormatPhoneNumber(), return 83886082
771 * @tc.desc Function test
772 */
773 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0700, Function | MediumTest | Level3)
774 {
775 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
776 return;
777 }
778 std::string number = "13888888889";
779 std::string Code = "abcdefg";
780 std::string formatBefore = "";
781 std::u16string phonyNumber = Str8ToStr16(number);
782 std::u16string countryCode = Str8ToStr16(Code);
783 std::u16string formatNumber = Str8ToStr16(formatBefore);
784 EXPECT_EQ(
785 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
786 }
787
788 /******************************* Test FormatPhoneNumberToE164() ***************************************/
789
790 /**
791 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0100
792 * @tc.name Import phonyNumber 01085198748, test FormatPhoneNumberToE164(), return +821085198748
793 * @tc.desc Function test
794 */
795 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0100, Function | MediumTest | Level2)
796 {
797 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
798 return;
799 }
800 std::string number = "01085198748";
801 std::string Code = "Kr";
802 std::string formatBefore = "";
803 std::u16string phonyNumber = Str8ToStr16(number);
804 std::u16string countryCode = Str8ToStr16(Code);
805 std::u16string formatNumber = Str8ToStr16(formatBefore);
806 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
807 RETURN_VALUE_IS_ZERO);
808 }
809 } // namespace Telephony
810 } // namespace OHOS
811