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