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, TestSize.Level0)
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, TestSize.Level0)
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 /********************************************* Test SetCallWaiting() ***********************************************/
328 /**
329 * @tc.number Telephony_CallManager_SetCallWaiting_0100
330 * @tc.name input slotId 0, test SetCallWaiting() enable callWaiting
331 * @tc.desc Function test
332 */
333 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0100, TestSize.Level0)
334 {
335 AccessToken token;
336 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
337 return;
338 }
339
340 if (HasSimCard(SIM1_SLOTID)) {
341 EXPECT_NE(CallManagerGtest::clientPtr_->SetCallWaiting(SIM1_SLOTID, true), RETURN_VALUE_IS_ZERO);
342 }
343 if (HasSimCard(SIM2_SLOTID)) {
344 EXPECT_NE(CallManagerGtest::clientPtr_->SetCallWaiting(SIM2_SLOTID, true), RETURN_VALUE_IS_ZERO);
345 }
346 }
347
348 /**
349 * @tc.number Telephony_CallManager_SetCallWaiting_0200
350 * @tc.name input invalid slotId, test SetCallWaiting() enable callWaiting
351 * @tc.desc Function test
352 */
353 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0200, TestSize.Level1)
354 {
355 AccessToken token;
356 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
357 return;
358 }
359
360 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(INVALID_SLOT_ID, true), CALL_ERR_INVALID_SLOT_ID);
361 }
362
363 /**
364 * @tc.number Telephony_CallManager_SetCallWaiting_0300
365 * @tc.name input slotId was out of count, test SetCallWaiting() enable callWaiting
366 * @tc.desc Function test
367 */
368 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0300, TestSize.Level0)
369 {
370 AccessToken token;
371 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
372 return;
373 }
374
375 int32_t slotId = SIM_SLOT_COUNT; // out of the count
376 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(slotId, true), CALL_ERR_INVALID_SLOT_ID);
377 }
378
379 /**
380 * @tc.number Telephony_CallManager_SetCallWaiting_0400
381 * @tc.name input slotId 0, test SetCallWaiting() disable callWaiting
382 * @tc.desc Function test
383 */
384 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0400, TestSize.Level0)
385 {
386 AccessToken token;
387 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
388 return;
389 }
390
391 if (HasSimCard(SIM1_SLOTID)) {
392 EXPECT_NE(CallManagerGtest::clientPtr_->SetCallWaiting(SIM1_SLOTID, false), RETURN_VALUE_IS_ZERO);
393 }
394 if (HasSimCard(SIM2_SLOTID)) {
395 EXPECT_NE(CallManagerGtest::clientPtr_->SetCallWaiting(SIM2_SLOTID, false), RETURN_VALUE_IS_ZERO);
396 }
397 }
398
399 /**
400 * @tc.number Telephony_CallManager_SetCallWaiting_0500
401 * @tc.name input invalid slotId, test SetCallWaiting() disable callWaiting
402 * @tc.desc Function test
403 */
404 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0500, TestSize.Level0)
405 {
406 AccessToken token;
407 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
408 return;
409 }
410
411 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(INVALID_SLOT_ID, false), CALL_ERR_INVALID_SLOT_ID);
412 }
413
414 /**
415 * @tc.number Telephony_CallManager_SetCallWaiting_0600
416 * @tc.name input slotId was out of count, test SetCallWaiting() enable callWaiting
417 * @tc.desc Function test
418 */
419 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0600, TestSize.Level0)
420 {
421 AccessToken token;
422 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
423 return;
424 }
425
426 int32_t slotId = SIM_SLOT_COUNT; // out of the count
427 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(slotId, false), CALL_ERR_INVALID_SLOT_ID);
428 }
429
430 /**
431 * @tc.number Telephony_CallManager_SetCallWaiting_0700
432 * @tc.name test SetCallWaiting without permission
433 * @tc.desc Function test
434 */
435 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0700, TestSize.Level0)
436 {
437 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
438 return;
439 }
440
441 if (HasSimCard(SIM1_SLOTID)) {
442 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(SIM1_SLOTID, true), TELEPHONY_ERR_PERMISSION_ERR);
443 }
444 if (HasSimCard(SIM2_SLOTID)) {
445 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(SIM2_SLOTID, true), TELEPHONY_ERR_PERMISSION_ERR);
446 }
447 }
448
449 /******************************************* Test GetCallRestriction() ********************************************/
450 /**
451 * @tc.number Telephony_CallManager_GetCallRestriction_0100
452 * @tc.name input slotId 0, CallRestrictionType RESTRICTION_TYPE_ALL_INCOMING, test GetCallRestriction()
453 * @tc.desc Function test
454 */
455 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0100, TestSize.Level0)
456 {
457 AccessToken token;
458 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
459 return;
460 }
461
462 if (HasSimCard(SIM1_SLOTID)) {
463 EXPECT_NE(CallManagerGtest::clientPtr_->GetCallRestriction(
464 SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
465 RETURN_VALUE_IS_ZERO);
466 }
467 if (HasSimCard(SIM2_SLOTID)) {
468 EXPECT_NE(CallManagerGtest::clientPtr_->GetCallRestriction(
469 SIM2_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
470 RETURN_VALUE_IS_ZERO);
471 }
472 }
473
474 /**
475 * @tc.number Telephony_CallManager_GetCallRestriction_0200
476 * @tc.name input invalid slotId, CallRestrictionType RESTRICTION_TYPE_ALL_INCOMING, test GetCallRestriction()
477 * return failed
478 * @tc.desc Function test
479 */
480 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0200, TestSize.Level0)
481 {
482 AccessToken token;
483 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
484 return;
485 }
486
487 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
488 INVALID_SLOT_ID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
489 CALL_ERR_INVALID_SLOT_ID);
490 }
491
492 /**
493 * @tc.number Telephony_CallManager_GetCallRestriction_0300
494 * @tc.name input invalid was out of count, CallRestrictionType RESTRICTION_TYPE_ALL_INCOMING,
495 * test GetCallRestriction() return failed
496 * @tc.desc Function test
497 */
498 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0300, TestSize.Level0)
499 {
500 AccessToken token;
501 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
502 return;
503 }
504
505 int32_t slotId = SIM_SLOT_COUNT; // out of the count
506 EXPECT_EQ(
507 CallManagerGtest::clientPtr_->GetCallRestriction(slotId, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
508 CALL_ERR_INVALID_SLOT_ID);
509 }
510
511 /**
512 * @tc.number Telephony_CallManager_GetCallRestriction_0400
513 * @tc.name input slotId 0, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING, test GetCallRestriction()
514 * @tc.desc Function test
515 */
516 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0400, TestSize.Level0)
517 {
518 AccessToken token;
519 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
520 return;
521 }
522
523 if (HasSimCard(SIM1_SLOTID)) {
524 EXPECT_NE(CallManagerGtest::clientPtr_->GetCallRestriction(
525 SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING),
526 RETURN_VALUE_IS_ZERO);
527 }
528 if (HasSimCard(SIM2_SLOTID)) {
529 EXPECT_NE(CallManagerGtest::clientPtr_->GetCallRestriction(
530 SIM2_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING),
531 RETURN_VALUE_IS_ZERO);
532 }
533 }
534
535 /**
536 * @tc.number Telephony_CallManager_GetCallRestriction_0500
537 * @tc.name input invalid slotId, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING, test GetCallRestriction()
538 * return failed
539 * @tc.desc Function test
540 */
541 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0500, TestSize.Level0)
542 {
543 AccessToken token;
544 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
545 return;
546 }
547
548 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
549 INVALID_SLOT_ID, CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING),
550 CALL_ERR_INVALID_SLOT_ID);
551 }
552
553 /**
554 * @tc.number Telephony_CallManager_GetCallRestriction_0600
555 * @tc.name input slotId was out of count, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING,
556 * test GetCallRestriction() return failed
557 * @tc.desc Function test
558 */
559 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0600, TestSize.Level0)
560 {
561 AccessToken token;
562 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
563 return;
564 }
565
566 int32_t slotId = SIM_SLOT_COUNT; // out of the count
567 EXPECT_EQ(
568 CallManagerGtest::clientPtr_->GetCallRestriction(slotId, CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING),
569 CALL_ERR_INVALID_SLOT_ID);
570 }
571
572 /**
573 * @tc.number Telephony_CallManager_GetCallRestriction_0700
574 * @tc.name input slotId 0, CallRestrictionType RESTRICTION_TYPE_ALL_INCOMING, test GetCallRestriction()
575 * @tc.desc Function test
576 */
577 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0700, TestSize.Level0)
578 {
579 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
580 return;
581 }
582
583 if (HasSimCard(SIM1_SLOTID)) {
584 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
585 SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
586 TELEPHONY_ERR_PERMISSION_ERR);
587 }
588 if (HasSimCard(SIM2_SLOTID)) {
589 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
590 SIM2_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
591 TELEPHONY_ERR_PERMISSION_ERR);
592 }
593 }
594
595 /******************************************* Test SetCallRestriction() ********************************************/
596 /**
597 * @tc.number Telephony_CallManager_SetCallRestriction_0100
598 * @tc.name input slotId 0, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING,
599 * CallRestrictionMode::RESTRICTION_MODE_ACTIVATION,
600 * test SetCallRestriction()
601 * @tc.desc Function test
602 */
603 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestriction_0100, TestSize.Level0)
604 {
605 AccessToken token;
606 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
607 return;
608 }
609 CallRestrictionInfo info;
610 info.fac = CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING;
611 info.mode = CallRestrictionMode::RESTRICTION_MODE_ACTIVATION;
612 if (strcpy_s(info.password, kMaxNumberLen + 1, "555") != EOK) {
613 TELEPHONY_LOGE("strcpy_s fail.");
614 return;
615 }
616
617 if (HasSimCard(SIM1_SLOTID)) {
618 EXPECT_NE(CallManagerGtest::clientPtr_->SetCallRestriction(SIM1_SLOTID, info), RETURN_VALUE_IS_ZERO);
619 }
620 if (HasSimCard(SIM2_SLOTID)) {
621 EXPECT_NE(CallManagerGtest::clientPtr_->SetCallRestriction(SIM2_SLOTID, info), RETURN_VALUE_IS_ZERO);
622 }
623 }
624
625 /**
626 * @tc.number Telephony_CallManager_SetCallRestriction_0200
627 * @tc.name input invalid slotId, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING,
628 * CallRestrictionMode::RESTRICTION_MODE_ACTIVATION,
629 * test SetCallRestriction() return failed
630 * @tc.desc Function test
631 */
632 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestriction_0200, TestSize.Level0)
633 {
634 AccessToken token;
635 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
636 return;
637 }
638 CallRestrictionInfo info;
639 info.fac = CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING;
640 info.mode = CallRestrictionMode::RESTRICTION_MODE_ACTIVATION;
641 if (strcpy_s(info.password, kMaxNumberLen + 1, "666") != EOK) {
642 TELEPHONY_LOGE("strcpy_s fail.");
643 return;
644 }
645
646 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(INVALID_SLOT_ID, info), CALL_ERR_INVALID_SLOT_ID);
647 }
648
649 /**
650 * @tc.number Telephony_CallManager_SetCallRestriction_0300
651 * @tc.name input slotId was out of count, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING,
652 * CallRestrictionMode::RESTRICTION_MODE_ACTIVATION,
653 * test SetCallRestriction() return failed
654 * @tc.desc Function test
655 */
656 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestriction_0300, TestSize.Level0)
657 {
658 AccessToken token;
659 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
660 return;
661 }
662 CallRestrictionInfo info;
663 info.fac = CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING;
664 info.mode = CallRestrictionMode::RESTRICTION_MODE_ACTIVATION;
665 if (strcpy_s(info.password, kMaxNumberLen + 1, "777") != EOK) {
666 TELEPHONY_LOGE("strcpy_s fail.");
667 return;
668 }
669
670 int32_t slotId = SIM_SLOT_COUNT; // out of the count
671 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(slotId, info), CALL_ERR_INVALID_SLOT_ID);
672 }
673
674 /**
675 * @tc.number Telephony_CallManager_SetCallRestriction_0400
676 * @tc.name test SetCallRestriction() without permission
677 * @tc.desc Function test
678 */
679 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestriction_0400, TestSize.Level0)
680 {
681 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
682 return;
683 }
684 CallRestrictionInfo info;
685 info.fac = CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING;
686 info.mode = CallRestrictionMode::RESTRICTION_MODE_ACTIVATION;
687 if (strcpy_s(info.password, kMaxNumberLen + 1, "888") != EOK) {
688 TELEPHONY_LOGE("strcpy_s fail.");
689 return;
690 }
691
692 if (HasSimCard(SIM1_SLOTID)) {
693 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(SIM1_SLOTID, info), TELEPHONY_ERR_PERMISSION_ERR);
694 }
695 if (HasSimCard(SIM2_SLOTID)) {
696 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(SIM2_SLOTID, info), TELEPHONY_ERR_PERMISSION_ERR);
697 }
698 }
699
700 /**************************************** Test SetCallRestrictionPassword() *****************************************/
701 /**
702 * @tc.number Telephony_CallManager_SetCallRestrictionPassword_0100
703 * @tc.name input slotId 0, CallRestrictionType RESTRICTION_TYPE_ALL_CALLS,
704 * old pasword, new password, test SetCallRestrictionPassword()
705 * @tc.desc Function test
706 */
707 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestrictionPassword_0100, TestSize.Level0)
708 {
709 AccessToken token;
710 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
711 return;
712 }
713 const char oldPassword[kMaxNumberLen + 1] = "1111";
714 const char newPassword[kMaxNumberLen + 1] = "2222";
715 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
716
717 if (HasSimCard(SIM1_SLOTID)) {
718 EXPECT_NE(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM1_SLOTID, fac, oldPassword, newPassword),
719 RETURN_VALUE_IS_ZERO);
720 }
721 if (HasSimCard(SIM2_SLOTID)) {
722 EXPECT_NE(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM2_SLOTID, fac, oldPassword, newPassword),
723 RETURN_VALUE_IS_ZERO);
724 }
725 }
726
727 /**
728 * @tc.number Telephony_CallManager_SetCallRestrictionPassword_0200
729 * @tc.name input invalid slotId, CallRestrictionType RESTRICTION_TYPE_ALL_CALLS,
730 * old pasword, new password, test SetCallRestrictionPassword() return failed
731 * @tc.desc Function test
732 */
733 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestrictionPassword_0200, TestSize.Level0)
734 {
735 AccessToken token;
736 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
737 return;
738 }
739 const char oldPassword[kMaxNumberLen + 1] = "1111";
740 const char newPassword[kMaxNumberLen + 1] = "2222";
741 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
742
743 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(INVALID_SLOT_ID, fac, oldPassword, newPassword),
744 CALL_ERR_INVALID_SLOT_ID);
745 }
746
747 /**
748 * @tc.number Telephony_CallManager_SetCallRestrictionPassword_0300
749 * @tc.name input slotId was out of count, CallRestrictionType RESTRICTION_TYPE_ALL_CALLS,
750 * old pasword, new password, test SetCallRestrictionPassword() return failed
751 * @tc.desc Function test
752 */
753 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestrictionPassword_0300, TestSize.Level0)
754 {
755 AccessToken token;
756 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
757 return;
758 }
759 const char oldPassword[kMaxNumberLen + 1] = "1111";
760 const char newPassword[kMaxNumberLen + 1] = "2222";
761 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
762
763 int32_t slotId = SIM_SLOT_COUNT; // out of the count
764 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(slotId, fac, oldPassword, newPassword),
765 CALL_ERR_INVALID_SLOT_ID);
766 }
767
768 /**
769 * @tc.number Telephony_CallManager_SetCallRestrictionPassword_0400
770 * @tc.name input slotId 0, CallRestrictionType invalid, test SetCallRestrictionPassword() return failed
771 * @tc.desc Function test
772 */
773 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestrictionPassword_0400, TestSize.Level0)
774 {
775 AccessToken token;
776 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
777 return;
778 }
779 const char oldPassword[kMaxNumberLen + 1] = "1111";
780 const char newPassword[kMaxNumberLen + 1] = "2222";
781 CallRestrictionType fac = (CallRestrictionType)FALSE_DEFAULT;
782
783 if (HasSimCard(SIM1_SLOTID)) {
784 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM1_SLOTID, fac, oldPassword, newPassword),
785 CALL_ERR_INVALID_RESTRICTION_TYPE);
786 }
787 if (HasSimCard(SIM2_SLOTID)) {
788 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM2_SLOTID, fac, oldPassword, newPassword),
789 CALL_ERR_INVALID_RESTRICTION_TYPE);
790 }
791 }
792
793 /**
794 * @tc.number Telephony_CallManager_SetCallRestrictionPassword_0500
795 * @tc.name input slotId 0, CallRestrictionType RESTRICTION_TYPE_ALL_CALLS,
796 * pasword invalid, test SetCallRestrictionPassword() return failed
797 * @tc.desc Function test
798 */
799 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestrictionPassword_0500, TestSize.Level0)
800 {
801 AccessToken token;
802 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
803 return;
804 }
805 const char oldPassword[kMaxNumberLen + 1] = { 0 };
806 const char newPassword[kMaxNumberLen + 1] = { 0 };
807 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
808
809 if (HasSimCard(SIM1_SLOTID)) {
810 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM1_SLOTID, fac, oldPassword, newPassword),
811 TELEPHONY_ERR_ARGUMENT_INVALID);
812 }
813 if (HasSimCard(SIM2_SLOTID)) {
814 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM2_SLOTID, fac, oldPassword, newPassword),
815 TELEPHONY_ERR_ARGUMENT_INVALID);
816 }
817 }
818
819 /**
820 * @tc.number Telephony_CallManager_SetCallRestrictionPassword_0600
821 * @tc.name test SetCallRestrictionPassword() without permission
822 * @tc.desc Function test
823 */
824 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestrictionPassword_0600, TestSize.Level0)
825 {
826 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
827 return;
828 }
829 const char oldPassword[kMaxNumberLen + 1] = "1111";
830 const char newPassword[kMaxNumberLen + 1] = "2222";
831 CallRestrictionType fac = CallRestrictionType::RESTRICTION_TYPE_ALL_CALLS;
832
833 if (HasSimCard(SIM1_SLOTID)) {
834 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM1_SLOTID, fac, oldPassword, newPassword),
835 TELEPHONY_ERR_PERMISSION_ERR);
836 }
837 if (HasSimCard(SIM2_SLOTID)) {
838 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestrictionPassword(SIM2_SLOTID, fac, oldPassword, newPassword),
839 TELEPHONY_ERR_PERMISSION_ERR);
840 }
841 }
842
843 /******************************************* Test GetCallTransferInfo() ********************************************/
844 /**
845 * @tc.number Telephony_CallManager_GetCallTransferInfo_0100
846 * @tc.name input slotId 0, CallTransferType TRANSFER_TYPE_BUSY, test GetCallTransferInfo()
847 * @tc.desc Function test
848 */
849 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0100, TestSize.Level0)
850 {
851 AccessToken token;
852 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
853 return;
854 }
855
856 if (HasSimCard(SIM1_SLOTID)) {
857 EXPECT_NE(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_BUSY),
858 RETURN_VALUE_IS_ZERO);
859 }
860 if (HasSimCard(SIM2_SLOTID)) {
861 EXPECT_NE(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_BUSY),
862 RETURN_VALUE_IS_ZERO);
863 }
864 }
865
866 /**
867 * @tc.number Telephony_CallManager_GetCallTransferInfo_0200
868 * @tc.name input invalid slotId, CallTransferType TRANSFER_TYPE_BUSY, test GetCallTransferInfo() return failed
869 * @tc.desc Function test
870 */
871 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0200, TestSize.Level0)
872 {
873 AccessToken token;
874 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
875 return;
876 }
877
878 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(INVALID_SLOT_ID, CallTransferType::TRANSFER_TYPE_BUSY),
879 CALL_ERR_INVALID_SLOT_ID);
880 }
881
882 /**
883 * @tc.number Telephony_CallManager_GetCallTransferInfo_0300
884 * @tc.name input slotId was out of count, CallTransferType TRANSFER_TYPE_BUSY,
885 * test GetCallTransferInfo() return failed
886 * @tc.desc Function test
887 */
888 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0300, TestSize.Level0)
889 {
890 AccessToken token;
891 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
892 return;
893 }
894
895 int32_t slotId = SIM_SLOT_COUNT; // out of the count
896 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(slotId, CallTransferType::TRANSFER_TYPE_BUSY),
897 CALL_ERR_INVALID_SLOT_ID);
898 }
899
900 /**
901 * @tc.number Telephony_CallManager_GetCallTransferInfo_0400
902 * @tc.name input slotId 0, CallTransferType TRANSFER_TYPE_NO_REPLY, test GetCallTransferInfo()
903 * @tc.desc Function test
904 */
905 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0400, TestSize.Level0)
906 {
907 AccessToken token;
908 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
909 return;
910 }
911
912 if (HasSimCard(SIM1_SLOTID)) {
913 EXPECT_NE(
914 CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_NO_REPLY),
915 RETURN_VALUE_IS_ZERO);
916 }
917 if (HasSimCard(SIM2_SLOTID)) {
918 EXPECT_NE(
919 CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM2_SLOTID, CallTransferType::TRANSFER_TYPE_NO_REPLY),
920 RETURN_VALUE_IS_ZERO);
921 }
922 }
923
924 /**
925 * @tc.number Telephony_CallManager_GetCallTransferInfo_0500
926 * @tc.name input invalid slotId, CallTransferType TRANSFER_TYPE_NO_REPLY, test GetCallTransferInfo() return failed
927 * @tc.desc Function test
928 */
929 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0500, TestSize.Level0)
930 {
931 AccessToken token;
932 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
933 return;
934 }
935
936 EXPECT_EQ(
937 CallManagerGtest::clientPtr_->GetCallTransferInfo(INVALID_SLOT_ID, CallTransferType::TRANSFER_TYPE_NO_REPLY),
938 CALL_ERR_INVALID_SLOT_ID);
939 }
940
941 /**
942 * @tc.number Telephony_CallManager_GetCallTransferInfo_0600
943 * @tc.name input slotId was out of count, CallTransferType TRANSFER_TYPE_NO_REPLY,
944 * test GetCallTransferInfo() return failed
945 * @tc.desc Function test
946 */
947 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0600, TestSize.Level0)
948 {
949 AccessToken token;
950 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
951 return;
952 }
953
954 int32_t slotId = SIM_SLOT_COUNT; // out of the count
955 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(slotId, CallTransferType::TRANSFER_TYPE_NO_REPLY),
956 CALL_ERR_INVALID_SLOT_ID);
957 }
958
959 /**
960 * @tc.number Telephony_CallManager_GetCallTransferInfo_0700
961 * @tc.name input slotId 0, CallTransferType TRANSFER_TYPE_NOT_REACHABLE, test GetCallTransferInfo()
962 * @tc.desc Function test
963 */
964 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0700, TestSize.Level0)
965 {
966 AccessToken token;
967 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
968 return;
969 }
970
971 if (HasSimCard(SIM1_SLOTID)) {
972 EXPECT_NE(CallManagerGtest::clientPtr_->GetCallTransferInfo(
973 SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_NOT_REACHABLE),
974 RETURN_VALUE_IS_ZERO);
975 }
976 if (HasSimCard(SIM2_SLOTID)) {
977 EXPECT_NE(CallManagerGtest::clientPtr_->GetCallTransferInfo(
978 SIM2_SLOTID, CallTransferType::TRANSFER_TYPE_NOT_REACHABLE),
979 RETURN_VALUE_IS_ZERO);
980 }
981 }
982
983 /**
984 * @tc.number Telephony_CallManager_GetCallTransferInfo_0800
985 * @tc.name input invalid slotId, CallTransferType TRANSFER_TYPE_NOT_REACHABLE, test GetCallTransferInfo() return
986 * failed
987 * @tc.desc Function test
988 */
989 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0800, TestSize.Level0)
990 {
991 AccessToken token;
992 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
993 return;
994 }
995
996 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(
997 INVALID_SLOT_ID, CallTransferType::TRANSFER_TYPE_NOT_REACHABLE),
998 CALL_ERR_INVALID_SLOT_ID);
999 }
1000 } // namespace Telephony
1001 } // namespace OHOS
1002