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
MeeTimeDetailsChange(const CallAttributeInfo & info)76 int32_t CallInfoManager::MeeTimeDetailsChange(const CallAttributeInfo &info)
77 {
78 TELEPHONY_LOGI("MeeTimeDetailsChange Start");
79 std::lock_guard<std::mutex> lock(mutex_);
80 updateCallInfo_ = info;
81 if (callIdSet_.find(updateCallInfo_.callId) == callIdSet_.end()) {
82 TELEPHONY_LOGI("MeeTimeDetailsChange new call");
83 callIdSet_.insert(updateCallInfo_.callId);
84 g_newCallId = updateCallInfo_.callId;
85 newCallState_ = (int32_t)updateCallInfo_.callState;
86 std::unordered_set<int32_t> newSet;
87 newSet.clear();
88 g_callStateMap.insert(std::pair<int32_t, std::unordered_set<int32_t>>(g_newCallId, newSet));
89 }
90 g_callStateMap[updateCallInfo_.callId].insert((int32_t)updateCallInfo_.callState);
91 return TELEPHONY_SUCCESS;
92 }
93
HasActiveStatus()94 bool CallInfoManager::HasActiveStatus()
95 {
96 TELEPHONY_LOGI("Waiting for activation !");
97 int sumUseTime = 0;
98 int slipMs = SLEEP_TIME_MS;
99 do {
100 if (!(HasState(g_newCallId, static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE)))) {
101 usleep(slipMs * BASE_TIME_MS);
102 sumUseTime += slipMs;
103 } else {
104 TELEPHONY_LOGI("===========wait %d ms callStatus:%d==============", sumUseTime, newCallState_);
105 return true;
106 }
107 } while (sumUseTime < MAX_LIMIT_TIME);
108 TELEPHONY_LOGI("===========wait %d ms callStatus:%d=====not active=========", sumUseTime, newCallState_);
109 return false;
110 }
111
HasState(int callId,int32_t callState)112 bool CallInfoManager::HasState(int callId, int32_t callState)
113 {
114 if (g_callStateMap.find(callId) == g_callStateMap.end()) {
115 return false;
116 }
117 if (g_callStateMap[callId].find(callState) == g_callStateMap[callId].end()) {
118 return false;
119 }
120 return true;
121 }
122
CallEventChange(const CallEventInfo & info)123 int32_t CallInfoManager::CallEventChange(const CallEventInfo &info)
124 {
125 return TELEPHONY_SUCCESS;
126 }
127
Init()128 void CallInfoManager::Init()
129 {
130 g_newCallId = -1;
131 updateCallInfo_.speakerphoneOn = -1;
132 updateCallInfo_.startTime = -1;
133 updateCallInfo_.isEcc = -1;
134 updateCallInfo_.accountId = -1;
135 updateCallInfo_.callType = CallType::TYPE_CS;
136 updateCallInfo_.callId = -1;
137 updateCallInfo_.callState = TelCallState::CALL_STATUS_IDLE;
138 updateCallInfo_.videoState = VideoStateType::TYPE_VOICE;
139 }
140
LockCallId(bool eq,int32_t targetId,int32_t slipMs,int32_t timeoutMs)141 void CallInfoManager::LockCallId(bool eq, int32_t targetId, int32_t slipMs, int32_t timeoutMs)
142 {
143 int32_t useTimeMs = 0;
144 std::cout << "wait for a few seconds......" << std::endl;
145 while ((updateCallInfo_.callId != targetId) && (useTimeMs < timeoutMs)) {
146 usleep(slipMs * SLEEP_1000_MS);
147 useTimeMs += slipMs;
148 }
149 std::cout << "\n===========wait " << useTimeMs << " ms target:" << updateCallInfo_.callId << std::endl;
150 if (eq) {
151 EXPECT_EQ(updateCallInfo_.callId, targetId);
152 } else {
153 EXPECT_NE(updateCallInfo_.callId, targetId);
154 }
155 }
156
LockCallState(bool eq,int32_t targetState,int32_t slipMs,int32_t timeoutMs)157 void CallInfoManager::LockCallState(bool eq, int32_t targetState, int32_t slipMs, int32_t timeoutMs)
158 {
159 if (CallManagerGtest::clientPtr_->GetCallState() == targetState) {
160 return;
161 }
162 int32_t usedTimeMs = 0;
163 std::cout << "wait for a few seconds......" << std::endl;
164 while ((CallManagerGtest::clientPtr_->GetCallState() != targetState) && (usedTimeMs < timeoutMs)) {
165 usleep(slipMs * SLEEP_1000_MS);
166 usedTimeMs += slipMs;
167 }
168 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
169 std::cout << "waited " << usedTimeMs << " seconds" << std::endl;
170 std::cout << "target call state:" << targetState << std::endl;
171 EXPECT_EQ(callState, targetState);
172 }
173
HangUpCall()174 void CallManagerGtest::HangUpCall()
175 {
176 clientPtr_->HangUpCall(INVALID_CALLID);
177 }
178
179 class ClientErrorBranchTest : public testing::Test {
180 public:
SetUpTestCase()181 static void SetUpTestCase() {};
TearDownTestCase()182 static void TearDownTestCase() {};
SetUp()183 void SetUp() {};
TearDown()184 void TearDown() {};
185 };
186
187 /**
188 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0200
189 * @tc.name Import countryCode KR, test FormatPhoneNumberToE164(), return +81338122111
190 * @tc.desc Function test
191 */
192 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0200, Function | MediumTest | Level2)
193 {
194 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
195 return;
196 }
197 std::string number = "(03)38122111";
198 std::string Code = "JP";
199 std::string formatBefore = "";
200 std::u16string phonyNumber = Str8ToStr16(number);
201 std::u16string countryCode = Str8ToStr16(Code);
202 std::u16string formatNumber = Str8ToStr16(formatBefore);
203 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
204 RETURN_VALUE_IS_ZERO);
205 }
206
207 /**
208 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0300
209 * @tc.name Import phonyNumber 13888888888, test FormatPhoneNumberToE164(), return +8613888888888
210 * @tc.desc Function test
211 */
212 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0300, Function | MediumTest | Level2)
213 {
214 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
215 return;
216 }
217 std::string number = "13888888888";
218 std::string Code = "cn";
219 std::string formatBefore = "";
220 std::u16string phonyNumber = Str8ToStr16(number);
221 std::u16string countryCode = Str8ToStr16(Code);
222 std::u16string formatNumber = Str8ToStr16(formatBefore);
223 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
224 RETURN_VALUE_IS_ZERO);
225 }
226
227 /**
228 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0400
229 * @tc.name Import phonyNumber +81338122111, test FormatPhoneNumberToE164(), return +81338122111
230 * @tc.desc Function test
231 */
232 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0400, Function | MediumTest | Level2)
233 {
234 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
235 return;
236 }
237 std::string number = "+81338122111";
238 std::string Code = "jp";
239 std::string formatBefore = "";
240 std::u16string phonyNumber = Str8ToStr16(number);
241 std::u16string countryCode = Str8ToStr16(Code);
242 std::u16string formatNumber = Str8ToStr16(formatBefore);
243 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
244 RETURN_VALUE_IS_ZERO);
245 }
246
247 /**
248 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0500
249 * @tc.name Import phonyNumber 03-3812-2111, test FormatPhoneNumberToE164(), return +81338122111
250 * @tc.desc Function test
251 */
252 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0500, Function | MediumTest | Level2)
253 {
254 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
255 return;
256 }
257 std::string number = "03-3812-2111";
258 std::string Code = "JP";
259 std::string formatBefore = "";
260 std::u16string phonyNumber = Str8ToStr16(number);
261 std::u16string countryCode = Str8ToStr16(Code);
262 std::u16string formatNumber = Str8ToStr16(formatBefore);
263 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
264 RETURN_VALUE_IS_ZERO);
265 }
266
267 /**
268 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0600
269 * @tc.name Import phonyNumber 666666999999, test FormatPhoneNumberToE164(), return 83886082
270 * @tc.desc Function test
271 */
272 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0600, Function | MediumTest | Level2)
273 {
274 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
275 return;
276 }
277 std::string number = "666666999999";
278 std::string Code = "CN";
279 std::string formatBefore = "";
280 std::u16string phonyNumber = Str8ToStr16(number);
281 std::u16string countryCode = Str8ToStr16(Code);
282 std::u16string formatNumber = Str8ToStr16(formatBefore);
283 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
284 RETURN_VALUE_IS_ZERO);
285 }
286
287 /**
288 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0700
289 * @tc.name Import countryCode abcdefg, test FormatPhoneNumberToE164(), return 83886082
290 * @tc.desc Function test
291 */
292 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0700, Function | MediumTest | Level3)
293 {
294 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
295 return;
296 }
297 std::string number = "13888888888";
298 std::string Code = "abcdefg";
299 std::string formatBefore = "";
300 std::u16string phonyNumber = Str8ToStr16(number);
301 std::u16string countryCode = Str8ToStr16(Code);
302 std::u16string formatNumber = Str8ToStr16(formatBefore);
303 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
304 RETURN_VALUE_IS_ZERO);
305 }
306
307 /**
308 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0800
309 * @tc.name Import countryCode abcdefg, test FormatPhoneNumberToE164(), return CALL_ERR_PHONE_NUMBER_EMPTY
310 * @tc.desc Function test
311 */
312 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0800, Function | MediumTest | Level3)
313 {
314 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
315 return;
316 }
317 std::string number = "";
318 std::string Code = "abcdefg";
319 std::string formatBefore = "";
320 std::u16string phonyNumber = Str8ToStr16(number);
321 std::u16string countryCode = Str8ToStr16(Code);
322 std::u16string formatNumber = Str8ToStr16(formatBefore);
323 EXPECT_NE(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
324 RETURN_VALUE_IS_ZERO);
325 }
326
327 /**
328 * @tc.number Telephony_CallManager_SetCallWaiting_0200
329 * @tc.name input invalid slotId, test SetCallWaiting() enable callWaiting
330 * @tc.desc Function test
331 */
332 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0200, Function | MediumTest | Level3)
333 {
334 AccessToken token;
335 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
336 return;
337 }
338
339 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(INVALID_SLOT_ID, true), CALL_ERR_INVALID_SLOT_ID);
340 }
341
342 /**
343 * @tc.number Telephony_CallManager_SetCallWaiting_0300
344 * @tc.name input slotId was out of count, test SetCallWaiting() enable callWaiting
345 * @tc.desc Function test
346 */
347 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0300, Function | MediumTest | Level3)
348 {
349 AccessToken token;
350 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
351 return;
352 }
353
354 int32_t slotId = SIM_SLOT_COUNT; // out of the count
355 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(slotId, true), CALL_ERR_INVALID_SLOT_ID);
356 }
357
358 /**
359 * @tc.number Telephony_CallManager_SetCallWaiting_0500
360 * @tc.name input invalid slotId, test SetCallWaiting() disable callWaiting
361 * @tc.desc Function test
362 */
363 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0500, Function | MediumTest | Level3)
364 {
365 AccessToken token;
366 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
367 return;
368 }
369
370 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(INVALID_SLOT_ID, false), CALL_ERR_INVALID_SLOT_ID);
371 }
372
373 /**
374 * @tc.number Telephony_CallManager_SetCallWaiting_0600
375 * @tc.name input slotId was out of count, test SetCallWaiting() enable callWaiting
376 * @tc.desc Function test
377 */
378 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0600, Function | MediumTest | Level3)
379 {
380 AccessToken token;
381 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
382 return;
383 }
384
385 int32_t slotId = SIM_SLOT_COUNT; // out of the count
386 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(slotId, false), CALL_ERR_INVALID_SLOT_ID);
387 }
388
389 /**
390 * @tc.number Telephony_CallManager_SetCallWaiting_0700
391 * @tc.name test SetCallWaiting without permission
392 * @tc.desc Function test
393 */
394 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0700, Function | MediumTest | Level3)
395 {
396 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
397 return;
398 }
399
400 if (HasSimCard(SIM1_SLOTID)) {
401 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(SIM1_SLOTID, true), TELEPHONY_ERR_PERMISSION_ERR);
402 }
403 if (HasSimCard(SIM2_SLOTID)) {
404 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(SIM2_SLOTID, true), TELEPHONY_ERR_PERMISSION_ERR);
405 }
406 }
407
408 /******************************************* Test GetCallRestriction() ********************************************/
409
410 /**
411 * @tc.number Telephony_CallManager_GetCallRestriction_0200
412 * @tc.name input invalid slotId, CallRestrictionType RESTRICTION_TYPE_ALL_INCOMING, test GetCallRestriction()
413 * return failed
414 * @tc.desc Function test
415 */
416 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0200, Function | MediumTest | Level3)
417 {
418 AccessToken token;
419 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
420 return;
421 }
422
423 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
424 INVALID_SLOT_ID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
425 CALL_ERR_INVALID_SLOT_ID);
426 }
427
428 /**
429 * @tc.number Telephony_CallManager_GetCallRestriction_0300
430 * @tc.name input invalid was out of count, CallRestrictionType RESTRICTION_TYPE_ALL_INCOMING,
431 * test GetCallRestriction() return failed
432 * @tc.desc Function test
433 */
434 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0300, Function | MediumTest | Level3)
435 {
436 AccessToken token;
437 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
438 return;
439 }
440
441 int32_t slotId = SIM_SLOT_COUNT; // out of the count
442 EXPECT_EQ(
443 CallManagerGtest::clientPtr_->GetCallRestriction(slotId, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
444 CALL_ERR_INVALID_SLOT_ID);
445 }
446
447 /**
448 * @tc.number Telephony_CallManager_GetCallRestriction_0500
449 * @tc.name input invalid slotId, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING, test GetCallRestriction()
450 * return failed
451 * @tc.desc Function test
452 */
453 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0500, Function | MediumTest | Level3)
454 {
455 AccessToken token;
456 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
457 return;
458 }
459
460 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
461 INVALID_SLOT_ID, CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING),
462 CALL_ERR_INVALID_SLOT_ID);
463 }
464
465 /**
466 * @tc.number Telephony_CallManager_GetCallRestriction_0600
467 * @tc.name input slotId was out of count, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING,
468 * test GetCallRestriction() return failed
469 * @tc.desc Function test
470 */
471 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0600, Function | MediumTest | Level3)
472 {
473 AccessToken token;
474 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
475 return;
476 }
477
478 int32_t slotId = SIM_SLOT_COUNT; // out of the count
479 EXPECT_EQ(
480 CallManagerGtest::clientPtr_->GetCallRestriction(slotId, CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING),
481 CALL_ERR_INVALID_SLOT_ID);
482 }
483
484 /**
485 * @tc.number Telephony_CallManager_GetCallRestriction_0700
486 * @tc.name input slotId 0, CallRestrictionType RESTRICTION_TYPE_ALL_INCOMING, test GetCallRestriction()
487 * @tc.desc Function test
488 */
489 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0700, Function | MediumTest | Level3)
490 {
491 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
492 return;
493 }
494
495 if (HasSimCard(SIM1_SLOTID)) {
496 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
497 SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
498 TELEPHONY_ERR_PERMISSION_ERR);
499 }
500 if (HasSimCard(SIM2_SLOTID)) {
501 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
502 SIM2_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
503 TELEPHONY_ERR_PERMISSION_ERR);
504 }
505 }
506
507 /******************************************* Test SetCallRestriction() ********************************************/
508 /**
509 * @tc.number Telephony_CallManager_SetCallRestriction_0200
510 * @tc.name input invalid slotId, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING,
511 * CallRestrictionMode::RESTRICTION_MODE_ACTIVATION,
512 * test SetCallRestriction() return failed
513 * @tc.desc Function test
514 */
515 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestriction_0200, Function | MediumTest | Level3)
516 {
517 AccessToken token;
518 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
519 return;
520 }
521 CallRestrictionInfo info;
522 info.fac = CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING;
523 info.mode = CallRestrictionMode::RESTRICTION_MODE_ACTIVATION;
524 if (strcpy_s(info.password, kMaxNumberLen + 1, "666") != EOK) {
525 TELEPHONY_LOGE("strcpy_s fail.");
526 return;
527 }
528
529 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(INVALID_SLOT_ID, info), CALL_ERR_INVALID_SLOT_ID);
530 }
531
532 /**
533 * @tc.number Telephony_CallManager_SetCallRestriction_0300
534 * @tc.name input slotId was out of count, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING,
535 * CallRestrictionMode::RESTRICTION_MODE_ACTIVATION,
536 * test SetCallRestriction() return failed
537 * @tc.desc Function test
538 */
539 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestriction_0300, Function | MediumTest | Level3)
540 {
541 AccessToken token;
542 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
543 return;
544 }
545 CallRestrictionInfo info;
546 info.fac = CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING;
547 info.mode = CallRestrictionMode::RESTRICTION_MODE_ACTIVATION;
548 if (strcpy_s(info.password, kMaxNumberLen + 1, "777") != EOK) {
549 TELEPHONY_LOGE("strcpy_s fail.");
550 return;
551 }
552
553 int32_t slotId = SIM_SLOT_COUNT; // out of the count
554 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(slotId, info), CALL_ERR_INVALID_SLOT_ID);
555 }
556
557 /**
558 * @tc.number Telephony_CallManager_SetCallRestriction_0400
559 * @tc.name test SetCallRestriction() without permission
560 * @tc.desc Function test
561 */
562 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestriction_0400, Function | MediumTest | Level3)
563 {
564 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
565 return;
566 }
567 CallRestrictionInfo info;
568 info.fac = CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING;
569 info.mode = CallRestrictionMode::RESTRICTION_MODE_ACTIVATION;
570 if (strcpy_s(info.password, kMaxNumberLen + 1, "888") != EOK) {
571 TELEPHONY_LOGE("strcpy_s fail.");
572 return;
573 }
574
575 if (HasSimCard(SIM1_SLOTID)) {
576 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(SIM1_SLOTID, info), TELEPHONY_ERR_PERMISSION_ERR);
577 }
578 if (HasSimCard(SIM2_SLOTID)) {
579 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(SIM2_SLOTID, info), TELEPHONY_ERR_PERMISSION_ERR);
580 }
581 }
582
583 /**************************************** Test SetCallRestrictionPassword() *****************************************/
584 /**
585 * @tc.number Telephony_CallManager_SetCallRestrictionPassword_0200
586 * @tc.name input invalid slotId, CallRestrictionType RESTRICTION_TYPE_ALL_CALLS,
587 * old pasword, new password, test SetCallRestrictionPassword() return failed
588 * @tc.desc Function test
589 */
590 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestrictionPassword_0200, Function | MediumTest | Level3)
591 {
592 AccessToken token;
593 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
594 return;
595 }
596 const char oldPassword[kMaxNumberLen + 1] = "1111";
597 const char newPassword[kMaxNumberLen + 1] = "2222";
598 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
599
600 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(INVALID_SLOT_ID, fac, oldPassword, newPassword),
601 CALL_ERR_INVALID_SLOT_ID);
602 }
603
604 /**
605 * @tc.number Telephony_CallManager_SetCallRestrictionPassword_0300
606 * @tc.name input slotId was out of count, CallRestrictionType RESTRICTION_TYPE_ALL_CALLS,
607 * old pasword, new password, test SetCallRestrictionPassword() return failed
608 * @tc.desc Function test
609 */
610 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestrictionPassword_0300, Function | MediumTest | Level3)
611 {
612 AccessToken token;
613 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
614 return;
615 }
616 const char oldPassword[kMaxNumberLen + 1] = "1111";
617 const char newPassword[kMaxNumberLen + 1] = "2222";
618 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
619
620 int32_t slotId = SIM_SLOT_COUNT; // out of the count
621 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(slotId, fac, oldPassword, newPassword),
622 CALL_ERR_INVALID_SLOT_ID);
623 }
624
625 /**
626 * @tc.number Telephony_CallManager_SetCallRestrictionPassword_0400
627 * @tc.name input slotId 0, CallRestrictionType invalid, test SetCallRestrictionPassword() return failed
628 * @tc.desc Function test
629 */
630 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestrictionPassword_0400, Function | MediumTest | Level3)
631 {
632 AccessToken token;
633 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
634 return;
635 }
636 const char oldPassword[kMaxNumberLen + 1] = "1111";
637 const char newPassword[kMaxNumberLen + 1] = "2222";
638 CallRestrictionType fac = (CallRestrictionType)FALSE_DEFAULT;
639
640 if (HasSimCard(SIM1_SLOTID)) {
641 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM1_SLOTID, fac, oldPassword, newPassword),
642 CALL_ERR_INVALID_RESTRICTION_TYPE);
643 }
644 if (HasSimCard(SIM2_SLOTID)) {
645 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM2_SLOTID, fac, oldPassword, newPassword),
646 CALL_ERR_INVALID_RESTRICTION_TYPE);
647 }
648 }
649
650 /**
651 * @tc.number Telephony_CallManager_SetCallRestrictionPassword_0500
652 * @tc.name input slotId 0, CallRestrictionType RESTRICTION_TYPE_ALL_CALLS,
653 * pasword invalid, test SetCallRestrictionPassword() return failed
654 * @tc.desc Function test
655 */
656 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestrictionPassword_0500, Function | MediumTest | Level3)
657 {
658 AccessToken token;
659 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
660 return;
661 }
662 const char oldPassword[kMaxNumberLen + 1] = { 0 };
663 const char newPassword[kMaxNumberLen + 1] = { 0 };
664 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
665
666 if (HasSimCard(SIM1_SLOTID)) {
667 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM1_SLOTID, fac, oldPassword, newPassword),
668 TELEPHONY_ERR_ARGUMENT_INVALID);
669 }
670 if (HasSimCard(SIM2_SLOTID)) {
671 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM2_SLOTID, fac, oldPassword, newPassword),
672 TELEPHONY_ERR_ARGUMENT_INVALID);
673 }
674 }
675
676 /**
677 * @tc.number Telephony_CallManager_SetCallRestrictionPassword_0600
678 * @tc.name test SetCallRestrictionPassword() without permission
679 * @tc.desc Function test
680 */
681 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestrictionPassword_0600, Function | MediumTest | Level3)
682 {
683 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
684 return;
685 }
686 const char oldPassword[kMaxNumberLen + 1] = "1111";
687 const char newPassword[kMaxNumberLen + 1] = "2222";
688 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
689
690 if (HasSimCard(SIM1_SLOTID)) {
691 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM1_SLOTID, fac, oldPassword, newPassword),
692 TELEPHONY_ERR_PERMISSION_ERR);
693 }
694 if (HasSimCard(SIM2_SLOTID)) {
695 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM2_SLOTID, fac, oldPassword, newPassword),
696 TELEPHONY_ERR_PERMISSION_ERR);
697 }
698 }
699
700 /******************************************* Test GetCallTransferInfo() ********************************************/
701 /**
702 * @tc.number Telephony_CallManager_GetCallTransferInfo_0200
703 * @tc.name input invalid slotId, CallTransferType TRANSFER_TYPE_BUSY, test GetCallTransferInfo() return failed
704 * @tc.desc Function test
705 */
706 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0200, Function | MediumTest | Level3)
707 {
708 AccessToken token;
709 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
710 return;
711 }
712
713 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(INVALID_SLOT_ID, CallTransferType::TRANSFER_TYPE_BUSY),
714 CALL_ERR_INVALID_SLOT_ID);
715 }
716
717 /**
718 * @tc.number Telephony_CallManager_GetCallTransferInfo_0300
719 * @tc.name input slotId was out of count, CallTransferType TRANSFER_TYPE_BUSY,
720 * test GetCallTransferInfo() return failed
721 * @tc.desc Function test
722 */
723 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0300, Function | MediumTest | Level3)
724 {
725 AccessToken token;
726 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
727 return;
728 }
729
730 int32_t slotId = SIM_SLOT_COUNT; // out of the count
731 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(slotId, CallTransferType::TRANSFER_TYPE_BUSY),
732 CALL_ERR_INVALID_SLOT_ID);
733 }
734
735 /**
736 * @tc.number Telephony_CallManager_GetCallTransferInfo_0500
737 * @tc.name input invalid slotId, CallTransferType TRANSFER_TYPE_NO_REPLY, test GetCallTransferInfo() return failed
738 * @tc.desc Function test
739 */
740 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0500, Function | MediumTest | Level3)
741 {
742 AccessToken token;
743 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
744 return;
745 }
746
747 EXPECT_EQ(
748 CallManagerGtest::clientPtr_->GetCallTransferInfo(INVALID_SLOT_ID, CallTransferType::TRANSFER_TYPE_NO_REPLY),
749 CALL_ERR_INVALID_SLOT_ID);
750 }
751
752 /**
753 * @tc.number Telephony_CallManager_GetCallTransferInfo_0600
754 * @tc.name input slotId was out of count, CallTransferType TRANSFER_TYPE_NO_REPLY,
755 * test GetCallTransferInfo() return failed
756 * @tc.desc Function test
757 */
758 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0600, Function | MediumTest | Level3)
759 {
760 AccessToken token;
761 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
762 return;
763 }
764
765 int32_t slotId = SIM_SLOT_COUNT; // out of the count
766 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(slotId, CallTransferType::TRANSFER_TYPE_NO_REPLY),
767 CALL_ERR_INVALID_SLOT_ID);
768 }
769
770 /**
771 * @tc.number Telephony_CallManager_GetCallTransferInfo_0800
772 * @tc.name input invalid slotId, CallTransferType TRANSFER_TYPE_NOT_REACHABLE, test GetCallTransferInfo() return
773 * failed
774 * @tc.desc Function test
775 */
776 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0800, Function | MediumTest | Level3)
777 {
778 AccessToken token;
779 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
780 return;
781 }
782
783 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(
784 INVALID_SLOT_ID, CallTransferType::TRANSFER_TYPE_NOT_REACHABLE),
785 CALL_ERR_INVALID_SLOT_ID);
786 }
787 } // namespace Telephony
788 } // namespace OHOS
789