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_GetCallTransferInfo_0900
171 * @tc.name input slotId out of count, CallTransferType TRANSFER_TYPE_NOT_REACHABLE,
172 * test GetCallTransferInfo() return failed
173 * @tc.desc Function test
174 */
175 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0900, Function | MediumTest | Level3)
176 {
177 AccessToken token;
178 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
179 return;
180 }
181
182 int32_t slotId = SIM_SLOT_COUNT; // out of the count
183 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(slotId, CallTransferType::TRANSFER_TYPE_NOT_REACHABLE),
184 CALL_ERR_INVALID_SLOT_ID);
185 }
186
187 /**
188 * @tc.number Telephony_CallManager_GetCallTransferInfo_1000
189 * @tc.name input slotId 0, CallTransferType invalid, test GetCallTransferInfo() return failed
190 * @tc.desc Function test
191 */
192 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_1000, Function | MediumTest | Level3)
193 {
194 AccessToken token;
195 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
196 return;
197 }
198
199 if (HasSimCard(SIM1_SLOTID)) {
200 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, (CallTransferType)FALSE_DEFAULT),
201 CALL_ERR_INVALID_TRANSFER_TYPE);
202 }
203 if (HasSimCard(SIM2_SLOTID)) {
204 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM2_SLOTID, (CallTransferType)FALSE_DEFAULT),
205 CALL_ERR_INVALID_TRANSFER_TYPE);
206 }
207 }
208
209 /**
210 * @tc.number Telephony_CallManager_GetCallTransferInfo_1100
211 * @tc.name test GetCallTransferInfo() without permission
212 * @tc.desc Function test
213 */
214 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_1100, Function | MediumTest | Level3)
215 {
216 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
217 return;
218 }
219
220 if (HasSimCard(SIM1_SLOTID)) {
221 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_BUSY),
222 TELEPHONY_ERR_PERMISSION_ERR);
223 }
224 if (HasSimCard(SIM2_SLOTID)) {
225 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_BUSY),
226 TELEPHONY_ERR_PERMISSION_ERR);
227 }
228 }
229
230 /******************************************* Test SetCallTransferInfo() ********************************************/
231 /**
232 * @tc.number Telephony_CallManager_SetCallTransferInfo_0100
233 * @tc.name input slotId 0, CallTransferSettingType CALL_TRANSFER_ENABLE, CallTransferType TRANSFER_TYPE_BUSY,
234 * test SetCallTransferInfo()
235 * @tc.desc Function test
236 */
237 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0100, Function | MediumTest | Level3)
238 {
239 AccessToken token;
240 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
241 return;
242 }
243 CallTransferInfo info;
244 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
245 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
246 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "111") != EOK) {
247 TELEPHONY_LOGE("strcpy_s fail.");
248 return;
249 }
250
251 if (HasSimCard(SIM1_SLOTID)) {
252 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info), RETURN_VALUE_IS_ZERO);
253 }
254 if (HasSimCard(SIM2_SLOTID)) {
255 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info), RETURN_VALUE_IS_ZERO);
256 }
257 }
258
259 /**
260 * @tc.number Telephony_CallManager_SetCallTransferInfo_0200
261 * @tc.name input invalid slotId, CallTransferSettingType CALL_TRANSFER_ENABLE, CallTransferType TRANSFER_TYPE_BUSY,
262 * test SetCallTransferInfo() return failed
263 * @tc.desc Function test
264 */
265 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0200, Function | MediumTest | Level3)
266 {
267 AccessToken token;
268 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
269 return;
270 }
271 CallTransferInfo info;
272 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
273 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
274 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "222") != EOK) {
275 TELEPHONY_LOGE("strcpy_s fail.");
276 return;
277 }
278
279 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(INVALID_SLOT_ID, info), CALL_ERR_INVALID_SLOT_ID);
280 }
281
282 /**
283 * @tc.number Telephony_CallManager_SetCallTransferInfo_0300
284 * @tc.name input slotId was out of count, CallTransferSettingType CALL_TRANSFER_ENABLE,
285 * CallTransferType TRANSFER_TYPE_BUSY, test SetCallTransferInfo() return failed
286 * @tc.desc Function test
287 */
288 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0300, Function | MediumTest | Level3)
289 {
290 AccessToken token;
291 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
292 return;
293 }
294 CallTransferInfo info;
295 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
296 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
297 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "333") != EOK) {
298 TELEPHONY_LOGE("strcpy_s fail.");
299 return;
300 }
301
302 int32_t slotId = SIM_SLOT_COUNT; // out of the count
303 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(slotId, info), CALL_ERR_INVALID_SLOT_ID);
304 }
305
306 /**
307 * @tc.number Telephony_CallManager_SetCallTransferInfo_0400
308 * @tc.name input slotId 0, CallTransferSettingType CALL_TRANSFER_ENABLE, CallTransferType invalid,
309 * test SetCallTransferInfo() return failed
310 * @tc.desc Function test
311 */
312 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0400, Function | MediumTest | Level3)
313 {
314 AccessToken token;
315 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
316 return;
317 }
318 CallTransferInfo info;
319 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
320 info.type = (CallTransferType)FALSE_DEFAULT;
321 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "123") != EOK) {
322 TELEPHONY_LOGE("strcpy_s fail.");
323 return;
324 }
325
326 if (HasSimCard(SIM1_SLOTID)) {
327 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info),
328 CALL_ERR_INVALID_TRANSFER_TYPE);
329 }
330 if (HasSimCard(SIM2_SLOTID)) {
331 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info),
332 CALL_ERR_INVALID_TRANSFER_TYPE);
333 }
334 }
335
336 /**
337 * @tc.number Telephony_CallManager_SetCallTransferInfo_0500
338 * @tc.name input slotId 0, CallTransferSettingType invalid, CallTransferType TRANSFER_TYPE_BUSY,
339 * test SetCallTransferInfo() return failed
340 * @tc.desc Function test
341 */
342 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0500, Function | MediumTest | Level3)
343 {
344 AccessToken token;
345 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
346 return;
347 }
348 CallTransferInfo info;
349 info.settingType = (CallTransferSettingType)FALSE_DEFAULT;
350 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
351 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "123") != EOK) {
352 TELEPHONY_LOGE("strcpy_s fail.");
353 return;
354 }
355
356 if (HasSimCard(SIM1_SLOTID)) {
357 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info),
358 CALL_ERR_INVALID_TRANSFER_SETTING_TYPE);
359 }
360 if (HasSimCard(SIM2_SLOTID)) {
361 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info),
362 CALL_ERR_INVALID_TRANSFER_SETTING_TYPE);
363 }
364 }
365
366 /**
367 * @tc.number Telephony_CallManager_SetCallTransferInfo_0600
368 * @tc.name input slotId 0, CallTransferSettingType invalid, CallTransferType TRANSFER_TYPE_BUSY, transferNum was
369 * too long, test SetCallTransferInfo() return failed
370 * @tc.desc Function test
371 */
372 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0600, Function | MediumTest | Level3)
373 {
374 AccessToken token;
375 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
376 return;
377 }
378 CallTransferInfo info;
379 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
380 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
381 if (strcpy_s(info.transferNum, kMaxNumberLen + 2,
382 "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
383 "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
384 "123456789012345678901234567890123456789012345678901234567890") != EOK) {
385 TELEPHONY_LOGE("strcpy_s fail.");
386 return;
387 }
388
389 if (HasSimCard(SIM1_SLOTID)) {
390 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info), CALL_ERR_NUMBER_OUT_OF_RANGE);
391 }
392 if (HasSimCard(SIM2_SLOTID)) {
393 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info), CALL_ERR_NUMBER_OUT_OF_RANGE);
394 }
395 }
396
397 /**
398 * @tc.number Telephony_CallManager_SetCallTransferInfo_0700
399 * @tc.name input slotId 0, CallTransferSettingType CALL_TRANSFER_ENABLE, CallTransferType TRANSFER_TYPE_BUSY,
400 * test SetCallTransferInfo()
401 * @tc.desc Function test
402 */
403 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0700, Function | MediumTest | Level3)
404 {
405 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
406 return;
407 }
408 CallTransferInfo info;
409 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
410 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
411 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "444") != EOK) {
412 TELEPHONY_LOGE("strcpy_s fail.");
413 return;
414 }
415
416 if (HasSimCard(SIM1_SLOTID)) {
417 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info), TELEPHONY_ERR_PERMISSION_ERR);
418 }
419 if (HasSimCard(SIM2_SLOTID)) {
420 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info), TELEPHONY_ERR_PERMISSION_ERR);
421 }
422 }
423
424 /******************************************* Test EnableImsSwitch() ********************************************/
425 /**
426 * @tc.number Telephony_CallManager_EnableImsSwitch_0100
427 * @tc.name input slotId 0, test EnableImsSwitch
428 * @tc.desc Function test
429 */
430 HWTEST_F(CallManagerGtest, Telephony_CallManager_EnableImsSwitch_0100, Function | MediumTest | Level3)
431 {
432 AccessToken token;
433 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
434 return;
435 }
436
437 if (HasSimCard(SIM1_SLOTID)) {
438 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(SIM1_SLOTID), RETURN_VALUE_IS_ZERO);
439 }
440 if (HasSimCard(SIM2_SLOTID)) {
441 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(SIM2_SLOTID), RETURN_VALUE_IS_ZERO);
442 }
443 }
444
445 /**
446 * @tc.number Telephony_CallManager_EnableImsSwitch_0200
447 * @tc.name input invalid slotId, test EnableImsSwitch return failed
448 * @tc.desc Function test
449 */
450 HWTEST_F(CallManagerGtest, Telephony_CallManager_EnableImsSwitch_0200, Function | MediumTest | Level3)
451 {
452 AccessToken token;
453 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
454 return;
455 }
456
457 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(INVALID_SLOT_ID), CALL_ERR_INVALID_SLOT_ID);
458 }
459
460 /**
461 * @tc.number Telephony_CallManager_EnableImsSwitch_0300
462 * @tc.name input slotId was out of count, test EnableImsSwitch return failed
463 * @tc.desc Function test
464 */
465 HWTEST_F(CallManagerGtest, Telephony_CallManager_EnableImsSwitch_0300, Function | MediumTest | Level3)
466 {
467 AccessToken token;
468 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
469 return;
470 }
471
472 int32_t slotId = SIM_SLOT_COUNT; // out of the count
473 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(slotId), CALL_ERR_INVALID_SLOT_ID);
474 }
475
476 /**
477 * @tc.number Telephony_CallManager_EnableImsSwitch_0400
478 * @tc.name test EnableImsSwitch without permission
479 * @tc.desc Function test
480 */
481 HWTEST_F(CallManagerGtest, Telephony_CallManager_EnableImsSwitch_0400, Function | MediumTest | Level3)
482 {
483 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
484 return;
485 }
486
487 if (HasSimCard(SIM1_SLOTID)) {
488 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(SIM1_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
489 }
490 if (HasSimCard(SIM2_SLOTID)) {
491 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(SIM2_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
492 }
493 }
494
495 /******************************************* Test DisableImsSwitch() ********************************************/
496 /**
497 * @tc.number Telephony_CallManager_DisableImsSwitch_0100
498 * @tc.name input slotId 0, test DisableImsSwitch
499 * @tc.desc Function test
500 */
501 HWTEST_F(CallManagerGtest, Telephony_CallManager_DisableImsSwitch_0100, Function | MediumTest | Level3)
502 {
503 AccessToken token;
504 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
505 return;
506 }
507
508 if (HasSimCard(SIM1_SLOTID)) {
509 EXPECT_EQ(CallManagerGtest::clientPtr_->DisableImsSwitch(SIM1_SLOTID), RETURN_VALUE_IS_ZERO);
510 }
511 if (HasSimCard(SIM2_SLOTID)) {
512 EXPECT_EQ(CallManagerGtest::clientPtr_->DisableImsSwitch(SIM2_SLOTID), RETURN_VALUE_IS_ZERO);
513 }
514 }
515
516 /**
517 * @tc.number Telephony_CallManager_DisableImsSwitch_0200
518 * @tc.name input invalid slotId, test DisableImsSwitch return failed
519 * @tc.desc Function test
520 */
521 HWTEST_F(CallManagerGtest, Telephony_CallManager_DisableImsSwitch_0200, Function | MediumTest | Level3)
522 {
523 AccessToken token;
524 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
525 return;
526 }
527
528 EXPECT_EQ(CallManagerGtest::clientPtr_->DisableImsSwitch(INVALID_SLOT_ID), CALL_ERR_INVALID_SLOT_ID);
529 }
530
531 /**
532 * @tc.number Telephony_CallManager_DisableImsSwitch_0300
533 * @tc.name input slotId was out of count, test DisableImsSwitch return failed
534 * @tc.desc Function test
535 */
536 HWTEST_F(CallManagerGtest, Telephony_CallManager_DisableImsSwitch_0300, Function | MediumTest | Level3)
537 {
538 AccessToken token;
539 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
540 return;
541 }
542
543 int32_t slotId = SIM_SLOT_COUNT; // out of the count
544 EXPECT_EQ(CallManagerGtest::clientPtr_->DisableImsSwitch(slotId), CALL_ERR_INVALID_SLOT_ID);
545 }
546
547 /******************************************* Test IsImsSwitchEnabled() ********************************************/
548 /**
549 * @tc.number Telephony_CallManager_IsImsSwitchEnabled_0100
550 * @tc.name input slotId 0, test IsImsSwitchEnabled
551 * @tc.desc Function test
552 */
553 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsImsSwitchEnabled_0100, Function | MediumTest | Level3)
554 {
555 AccessToken token;
556 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
557 return;
558 }
559
560 bool enabled;
561 if (HasSimCard(SIM1_SLOTID)) {
562 EXPECT_EQ(CallManagerGtest::clientPtr_->IsImsSwitchEnabled(SIM1_SLOTID, enabled), RETURN_VALUE_IS_ZERO);
563 }
564 if (HasSimCard(SIM2_SLOTID)) {
565 EXPECT_EQ(CallManagerGtest::clientPtr_->IsImsSwitchEnabled(SIM2_SLOTID, enabled), RETURN_VALUE_IS_ZERO);
566 }
567 }
568
569 /**
570 * @tc.number Telephony_CallManager_IsImsSwitchEnabled_0200
571 * @tc.name input invalid slotId, test IsImsSwitchEnabled return failed
572 * @tc.desc Function test
573 */
574 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsImsSwitchEnabled_0200, Function | MediumTest | Level3)
575 {
576 AccessToken token;
577 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
578 return;
579 }
580
581 bool enabled;
582 EXPECT_EQ(CallManagerGtest::clientPtr_->IsImsSwitchEnabled(INVALID_SLOT_ID, enabled), CALL_ERR_INVALID_SLOT_ID);
583 }
584
585 /**
586 * @tc.number Telephony_CallManager_IsImsSwitchEnabled_0300
587 * @tc.name input slotId was out of count, test IsImsSwitchEnabled return failed
588 * @tc.desc Function test
589 */
590 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsImsSwitchEnabled_0300, Function | MediumTest | Level3)
591 {
592 AccessToken token;
593 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
594 return;
595 }
596
597 int32_t slotId = SIM_SLOT_COUNT; // out of the count
598 bool enabled;
599 EXPECT_EQ(CallManagerGtest::clientPtr_->IsImsSwitchEnabled(slotId, enabled), CALL_ERR_INVALID_SLOT_ID);
600 }
601
602 /******************************************* Test SetVoNRState() ********************************************/
603 /**
604 * @tc.number Telephony_CallManager_SetVoNRState_0100
605 * @tc.name input slotId 0, VoNRstate ON(0) test SetVoNRState
606 * @tc.desc Function test
607 */
608 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoNRState_0100, Function | MediumTest | Level3)
609 {
610 AccessToken token;
611 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
612 return;
613 }
614 int32_t state = 0;
615 if (HasSimCard(SIM1_SLOTID)) {
616 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(SIM1_SLOTID, state), RETURN_VALUE_IS_ZERO);
617 }
618 if (HasSimCard(SIM2_SLOTID)) {
619 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(SIM2_SLOTID, state), RETURN_VALUE_IS_ZERO);
620 }
621 }
622
623 /**
624 * @tc.number Telephony_CallManager_SetVoNRState_0200
625 * @tc.name input slotId 0, VoNRstate OFF(1) test SetVoNRState
626 * @tc.desc Function test
627 */
628 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoNRState_0200, Function | MediumTest | Level3)
629 {
630 AccessToken token;
631 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
632 return;
633 }
634 int32_t state = 1;
635 if (HasSimCard(SIM1_SLOTID)) {
636 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(SIM1_SLOTID, state), RETURN_VALUE_IS_ZERO);
637 }
638 if (HasSimCard(SIM2_SLOTID)) {
639 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(SIM2_SLOTID, state), RETURN_VALUE_IS_ZERO);
640 }
641 }
642
643 /**
644 * @tc.number Telephony_CallManager_SetVoNRState_0300
645 * @tc.name input invalid slotId, test SetVoNRState return failed
646 * @tc.desc Function test
647 */
648 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoNRState_0300, Function | MediumTest | Level3)
649 {
650 AccessToken token;
651 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
652 return;
653 }
654 int32_t state = 0;
655 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(INVALID_SLOT_ID, state), CALL_ERR_INVALID_SLOT_ID);
656 }
657
658 /**
659 * @tc.number Telephony_CallManager_SetVoNRState_0400
660 * @tc.name input slotId was out of count, test SetVoNRState return failed
661 * @tc.desc Function test
662 */
663 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoNRState_0400, Function | MediumTest | Level3)
664 {
665 AccessToken token;
666 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
667 return;
668 }
669 int32_t state = 0;
670 int32_t slotId = SIM_SLOT_COUNT; // out of the count
671 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(slotId, state), CALL_ERR_INVALID_SLOT_ID);
672 }
673
674 /**
675 * @tc.number Telephony_CallManager_SetVoNRState_0500
676 * @tc.name input invalid state, test SetVoNRState return failed
677 * @tc.desc Function test
678 */
679 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoNRState_0500, Function | MediumTest | Level3)
680 {
681 AccessToken token;
682 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
683 return;
684 }
685 int32_t state = -1;
686 if (HasSimCard(SIM1_SLOTID)) {
687 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_ARGUMENT_INVALID);
688 }
689 if (HasSimCard(SIM2_SLOTID)) {
690 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(SIM2_SLOTID, state), TELEPHONY_ERR_ARGUMENT_INVALID);
691 }
692 }
693
694 /**
695 * @tc.number Telephony_CallManager_SetVoNRState_0600
696 * @tc.name test SetVoNRState without permission
697 * @tc.desc Function test
698 */
699 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetVoNRState_0600, Function | MediumTest | Level3)
700 {
701 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
702 return;
703 }
704 int32_t state = 0;
705 if (HasSimCard(SIM1_SLOTID)) {
706 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_PERMISSION_ERR);
707 }
708 if (HasSimCard(SIM2_SLOTID)) {
709 EXPECT_EQ(CallManagerGtest::clientPtr_->SetVoNRState(SIM2_SLOTID, state), TELEPHONY_ERR_PERMISSION_ERR);
710 }
711 }
712
713 /******************************************* Test GetVoNRState() ********************************************/
714 /**
715 * @tc.number Telephony_CallManager_GetVoNRState_0100
716 * @tc.name input slotId 0, test GetVoNRState
717 * @tc.desc Function test
718 */
719 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetVoNRState_0100, Function | MediumTest | Level3)
720 {
721 AccessToken token;
722 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
723 return;
724 }
725
726 int32_t state;
727 if (HasSimCard(SIM1_SLOTID)) {
728 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoNRState(SIM1_SLOTID, state), RETURN_VALUE_IS_ZERO);
729 }
730 if (HasSimCard(SIM2_SLOTID)) {
731 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoNRState(SIM2_SLOTID, state), RETURN_VALUE_IS_ZERO);
732 }
733 }
734
735 /**
736 * @tc.number Telephony_CallManager_GetVoNRState_0200
737 * @tc.name input invalid slotId, test GetVoNRState return failed
738 * @tc.desc Function test
739 */
740 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetVoNRState_0200, Function | MediumTest | Level3)
741 {
742 AccessToken token;
743 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
744 return;
745 }
746
747 int32_t state;
748 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoNRState(INVALID_SLOT_ID, state), CALL_ERR_INVALID_SLOT_ID);
749 }
750
751 /**
752 * @tc.number Telephony_CallManager_GetVoNRState_0300
753 * @tc.name input slotId was out of count, test GetVoNRState return failed
754 * @tc.desc Function test
755 */
756 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetVoNRState_0300, Function | MediumTest | Level3)
757 {
758 AccessToken token;
759 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
760 return;
761 }
762
763 int32_t slotId = SIM_SLOT_COUNT; // out of the count
764 int32_t state;
765 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoNRState(slotId, state), CALL_ERR_INVALID_SLOT_ID);
766 }
767
768 /**
769 * @tc.number Telephony_CallManager_GetVoNRState_0400
770 * @tc.name test GetVoNRState without permission
771 * @tc.desc Function test
772 */
773 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetVoNRState_0400, Function | MediumTest | Level3)
774 {
775 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
776 return;
777 }
778 int32_t state;
779 if (HasSimCard(SIM1_SLOTID)) {
780 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoNRState(SIM1_SLOTID, state), TELEPHONY_ERR_PERMISSION_ERR);
781 }
782 if (HasSimCard(SIM2_SLOTID)) {
783 EXPECT_EQ(CallManagerGtest::clientPtr_->GetVoNRState(SIM2_SLOTID, state), TELEPHONY_ERR_PERMISSION_ERR);
784 }
785 }
786
787 /******************************************* Test ControlCamera() *********************************************/
788 /**
789 * @tc.number Telephony_CallManager_ControlCamera_0100
790 * @tc.name input camera id lcam001, Test ControlCamera, returns 0 if success
791 * @tc.desc Function test
792 */
793 HWTEST_F(CallManagerGtest, Telephony_CallManager_ControlCamera_0100, Function | MediumTest | Level0)
794 {
795 AccessToken token;
796 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
797 return;
798 }
799 int32_t callId = 1;
800 // 3516DV300 camera id string is "lcam001"
801 std::string id = "lcam001";
802
803 std::u16string cameraID = Str8ToStr16(id);
804 EXPECT_NE(CallManagerGtest::clientPtr_->ControlCamera(callId, cameraID), RETURN_VALUE_IS_ZERO);
805 }
806
807 /**
808 * @tc.number Telephony_CallManager_ControlCamera_0200
809 * @tc.name input error camera id xtsautotest123456, Test ControlCamera, return err code if failed
810 * @tc.desc Function test
811 */
812 HWTEST_F(CallManagerGtest, Telephony_CallManager_ControlCamera_0200, Function | MediumTest | Level2)
813 {
814 AccessToken token;
815 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
816 return;
817 }
818 int32_t callId = 1;
819 std::string id = "xtsautotest123456";
820
821 std::u16string cameraID = Str8ToStr16(id);
822 EXPECT_NE(CallManagerGtest::clientPtr_->ControlCamera(callId, cameraID), RETURN_VALUE_IS_ZERO);
823 }
824
825 /**
826 * @tc.number Telephony_CallManager_ControlCamera_0300
827 * @tc.name input error camera id xtsautotest123456, Test ControlCamera,
828 * then input empty camera id, Test ControlCamera
829 * @tc.desc Function test
830 */
831 HWTEST_F(CallManagerGtest, Telephony_CallManager_ControlCamera_0300, Function | MediumTest | Level2)
832 {
833 AccessToken token;
834 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
835 return;
836 }
837 int32_t callId = 1;
838 std::string id = "lcam001";
839
840 std::u16string cameraID = Str8ToStr16(id);
841 EXPECT_NE(CallManagerGtest::clientPtr_->ControlCamera(callId, cameraID), RETURN_VALUE_IS_ZERO);
842
843 id = "";
844 cameraID = Str8ToStr16(id);
845 EXPECT_NE(CallManagerGtest::clientPtr_->ControlCamera(callId, cameraID), RETURN_VALUE_IS_ZERO);
846 }
847
848 /**
849 * @tc.number Telephony_CallManager_ControlCamera_0600
850 * @tc.name input empty camera id, Test ControlCamera, returns error code if failed
851 * @tc.desc Function test
852 */
853 HWTEST_F(CallManagerGtest, Telephony_CallManager_ControlCamera_0600, Function | MediumTest | Level2)
854 {
855 AccessToken token;
856 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
857 return;
858 }
859 int32_t callId = 1;
860 std::string id = "";
861
862 std::u16string cameraID = Str8ToStr16(id);
863 EXPECT_NE(CallManagerGtest::clientPtr_->ControlCamera(callId, cameraID), RETURN_VALUE_IS_ZERO);
864 }
865
866 /******************************************* Test SetPreviewWindow() *********************************************/
867 /**
868 * @tc.number Telephony_CallManager_SetPreviewWindow_0100
869 * @tc.name input previewSurfaceId:"", Test set preview window
870 * @tc.desc Function test
871 */
872 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPreviewWindow_0100, Function | MediumTest | Level2)
873 {
874 AccessToken token;
875 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
876 return;
877 }
878 int32_t callId = 1;
879 std::string previewSurfaceId = "";
880 EXPECT_NE(CallManagerGtest::clientPtr_->SetPreviewWindow(callId, previewSurfaceId), RETURN_VALUE_IS_ZERO);
881 }
882
883 /**
884 * @tc.number Telephony_CallManager_SetPreviewWindow_0200
885 * @tc.name input previewSurfaceId:123, Test set preview window
886 * @tc.desc Function test
887 */
888 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPreviewWindow_0200, Function | MediumTest | Level2)
889 {
890 AccessToken token;
891 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
892 return;
893 }
894 int32_t callId = 1;
895 std::string previewSurfaceId = "123";
896 EXPECT_NE(CallManagerGtest::clientPtr_->SetPreviewWindow(callId, previewSurfaceId), RETURN_VALUE_IS_ZERO);
897 }
898
899 /******************************************* Test SetDisplayWindow() *********************************************/
900 /**
901 * @tc.number Telephony_CallManager_SetDisplayWindow_0100
902 * @tc.name input displaySurfaceId:"", Test set display window
903 * @tc.desc Function test
904 */
905 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDisplayWindow_0100, Function | MediumTest | Level2)
906 {
907 AccessToken token;
908 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
909 return;
910 }
911 int32_t callId = 1;
912 std::string displaySurfaceId = "";
913 EXPECT_NE(CallManagerGtest::clientPtr_->SetDisplayWindow(callId, displaySurfaceId), RETURN_VALUE_IS_ZERO);
914 }
915
916 /**
917 * @tc.number Telephony_CallManager_SetDisplayWindow_0200
918 * @tc.name input displaySurfaceId:123, Test set display window
919 * @tc.desc Function test
920 */
921 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDisplayWindow_0200, Function | MediumTest | Level2)
922 {
923 AccessToken token;
924 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
925 return;
926 }
927 int32_t callId = 1;
928 std::string displaySurfaceId = "123";
929 EXPECT_NE(CallManagerGtest::clientPtr_->SetDisplayWindow(callId, displaySurfaceId), RETURN_VALUE_IS_ZERO);
930 }
931
932 /******************************************* Test SetDeviceDirection() *********************************************/
933 /**
934 * @tc.number Telephony_CallManager_SetDeviceDirection_0100
935 * @tc.name input invalid rotation, Test SetDeviceDirection, return error code if failed
936 * @tc.desc Function test
937 */
938 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDeviceDirection_0100, Function | MediumTest | Level2)
939 {
940 AccessToken token;
941 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
942 return;
943 }
944 int32_t callId = 1;
945 int32_t rotation = CAMERA_ROTATION_ERROR;
946 EXPECT_NE(CallManagerGtest::clientPtr_->SetDeviceDirection(callId, rotation), RETURN_VALUE_IS_ZERO);
947 }
948
949 /**
950 * @tc.number Telephony_CallManager_SetDeviceDirection_0200
951 * @tc.name input rotation 0, Test SetDeviceDirection, return 0 if success
952 * @tc.desc Function test
953 */
954 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDeviceDirection_0200, Function | MediumTest | Level2)
955 {
956 AccessToken token;
957 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
958 return;
959 }
960 int32_t callId = 1;
961 int32_t rotation = 0;
962 EXPECT_NE(CallManagerGtest::clientPtr_->SetDeviceDirection(callId, rotation), RETURN_VALUE_IS_ZERO);
963 }
964
965 /**
966 * @tc.number Telephony_CallManager_SetDeviceDirection_0300
967 * @tc.name input rotation 90, Test SetDeviceDirection
968 * @tc.desc Function test
969 */
970 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDeviceDirection_0300, Function | MediumTest | Level2)
971 {
972 AccessToken token;
973 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
974 return;
975 }
976 int32_t callId = 1;
977 int32_t rotation = CAMERA_ROTATION_90;
978 EXPECT_NE(CallManagerGtest::clientPtr_->SetDeviceDirection(callId, rotation), RETURN_VALUE_IS_ZERO);
979 }
980 } // namespace Telephony
981 } // namespace OHOS
982