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