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 /******************************************* Test SetCameraZoom() *********************************************/
170 /**
171 * @tc.number Telephony_CallManager_SetCameraZoom_0100
172 * @tc.name input zoomRatio 5.0, Test SetCameraZoom
173 * @tc.desc Function test
174 */
175 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0100, Function | MediumTest | Level2)
176 {
177 AccessToken token;
178 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
179 return;
180 }
181 float zoomRatio = 5.0;
182 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
183 }
184
185 /**
186 * @tc.number Telephony_CallManager_SetCameraZoom_0200
187 * @tc.name input zoomRatio 0.1, Test SetCameraZoom
188 * @tc.desc Function test
189 */
190 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0200, Function | MediumTest | Level2)
191 {
192 AccessToken token;
193 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
194 return;
195 }
196 float zoomRatio = 0.1;
197 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
198 }
199
200 /**
201 * @tc.number Telephony_CallManager_SetCameraZoom_0300
202 * @tc.name input zoomRatio 10.0, Test SetCameraZoom
203 * @tc.desc Function test
204 */
205 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0300, Function | MediumTest | Level2)
206 {
207 AccessToken token;
208 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
209 return;
210 }
211 float zoomRatio = 10.0;
212 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
213 }
214
215 /**
216 * @tc.number Telephony_CallManager_SetCameraZoom_0400
217 * @tc.name input invalid para zoomRatio 15.0, Test SetCameraZoom, return error code if failed
218 * @tc.desc Function test
219 */
220 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0400, Function | MediumTest | Level2)
221 {
222 AccessToken token;
223 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
224 return;
225 }
226 float zoomRatio = 15.0;
227 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
228 }
229
230 /**
231 * @tc.number Telephony_CallManager_SetCameraZoom_0500
232 * @tc.name input invalid para zoomRatio 0.0, Test SetCameraZoom, return error code if failed
233 * @tc.desc Function test
234 */
235 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0500, Function | MediumTest | Level2)
236 {
237 AccessToken token;
238 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
239 return;
240 }
241 float zoomRatio = 0.0;
242 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
243 }
244
245 /**
246 * @tc.number Telephony_CallManager_SetCameraZoom_0600
247 * @tc.name input invalid para zoomRatio -1.0, Test SetCameraZoom, return error code if failed
248 * @tc.desc Function test
249 */
250 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0600, Function | MediumTest | Level2)
251 {
252 AccessToken token;
253 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
254 return;
255 }
256 float zoomRatio = -1.0;
257 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
258 }
259
260 /**
261 * @tc.number Telephony_CallManager_SetCameraZoom_0700
262 * @tc.name input invalid para zoomRatio 10.1, Test SetCameraZoom, return error code if failed
263 * @tc.desc Function test
264 */
265 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0700, Function | MediumTest | Level2)
266 {
267 AccessToken token;
268 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
269 return;
270 }
271 float zoomRatio = 10.1;
272 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
273 }
274 /******************************************* Test SetPausePicture() *********************************************/
275 /**
276 * @tc.number Telephony_CallManager_SetPausePicture_0100
277 * @tc.name input locale picture path /system/bin/test.png that does not exist, Test SetPausePicture,
278 * return error code if failed
279 * @tc.desc Function test
280 */
281 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0100, Function | MediumTest | Level2)
282 {
283 AccessToken token;
284 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
285 return;
286 }
287 int32_t callId = 1;
288 std::string pathTemp = "/system/bin/test.png";
289 std::u16string path = Str8ToStr16(pathTemp);
290 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(callId, path), RETURN_VALUE_IS_ZERO);
291 }
292
293 /**
294 * @tc.number Telephony_CallManager_SetPausePicture_0200
295 * @tc.name input an invalid image format file path, Test SetPausePicture, return error code if failed
296 * @tc.desc Function test
297 */
298 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0200, Function | MediumTest | Level2)
299 {
300 AccessToken token;
301 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
302 return;
303 }
304 int32_t callId = 1;
305 std::string pathTemp = "/system/bin/test.jpg";
306 std::u16string path = Str8ToStr16(pathTemp);
307 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(callId, path), RETURN_VALUE_IS_ZERO);
308 }
309
310 /**
311 * @tc.number Telephony_CallManager_SetPausePicture_0300
312 * @tc.name input an invalid image format file path, Test SetPausePicture, return error code if failed
313 * @tc.desc Function test
314 */
315 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0300, Function | MediumTest | Level2)
316 {
317 AccessToken token;
318 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
319 return;
320 }
321 int32_t callId = 1;
322 std::string pathTemp = "/system/bin/test.bmp";
323 std::u16string path = Str8ToStr16(pathTemp);
324 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(callId, path), RETURN_VALUE_IS_ZERO);
325 }
326
327 /**
328 * @tc.number Telephony_CallManager_SetPausePicture_0400
329 * @tc.name input an invalid image format file path, Test SetPausePicture, return error code if failed
330 * @tc.desc Function test
331 */
332 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0400, Function | MediumTest | Level2)
333 {
334 AccessToken token;
335 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
336 return;
337 }
338 int32_t callId = 1;
339 std::string pathTemp = "/system/bin/test.webp";
340 std::u16string path = Str8ToStr16(pathTemp);
341 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(callId, path), RETURN_VALUE_IS_ZERO);
342 }
343
344 /**
345 * @tc.number Telephony_CallManager_SetPausePicture_0500
346 * @tc.name input remote picture path http://callManager.jpg that does not exist, Test SetPausePicture,
347 * return error code if failed
348 * @tc.desc Function test
349 */
350 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0500, Function | MediumTest | Level2)
351 {
352 AccessToken token;
353 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
354 return;
355 }
356 int32_t callId = 1;
357 std::string pathTemp = "http://callManager.jpg";
358 std::u16string path = Str8ToStr16(pathTemp);
359 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(callId, path), RETURN_VALUE_IS_ZERO);
360 }
361
362 /**
363 * @tc.number Telephony_CallManager_SetPausePicture_0600
364 * @tc.name input empty picture path, Test SetPausePicture, return error code if failed
365 * @tc.desc Function test
366 */
367 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0600, Function | MediumTest | Level2)
368 {
369 AccessToken token;
370 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
371 return;
372 }
373 int32_t callId = 1;
374 std::string pathTemp = "";
375 std::u16string path = Str8ToStr16(pathTemp);
376 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(callId, path), RETURN_VALUE_IS_ZERO);
377 }
378
379 /**
380 * @tc.number Telephony_CallManager_CancelCallUpgrade_0100
381 * @tc.name input callId:1, Test CancelCallUpgrade, return error code if failed
382 * @tc.desc Function test
383 */
384 HWTEST_F(CallManagerGtest, Telephony_CallManager_CancelCallUpgrade_0100, Function | MediumTest | Level2)
385 {
386 AccessToken token;
387 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
388 return;
389 }
390 int32_t callId = 1;
391 EXPECT_NE(CallManagerGtest::clientPtr_->CancelCallUpgrade(callId), RETURN_VALUE_IS_ZERO);
392 }
393
394 /**
395 * @tc.number Telephony_CallManager_RequestCameraCapabilities_0100
396 * @tc.name input callId:1, Test RequestCameraCapabilities, return error code if failed
397 * @tc.desc Function test
398 */
399 HWTEST_F(CallManagerGtest, Telephony_CallManager_RequestCameraCapabilities_0100, Function | MediumTest | Level2)
400 {
401 AccessToken token;
402 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
403 return;
404 }
405 int32_t callId = 1;
406 EXPECT_NE(CallManagerGtest::clientPtr_->RequestCameraCapabilities(callId), RETURN_VALUE_IS_ZERO);
407 }
408
409 /********************************************* Test GetImsConfig() ************************************************/
410 /**
411 * @tc.number Telephony_CallManager_GetImsConfig_0100
412 * @tc.name test get ims config item video quality
413 * @tc.desc Function test
414 */
415 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsConfig_0100, Function | MediumTest | Level3)
416 {
417 AccessToken token;
418 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
419 return;
420 }
421
422 if (HasSimCard(SIM1_SLOTID)) {
423 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsConfig(SIM1_SLOTID, ITEM_VIDEO_QUALITY), RETURN_VALUE_IS_ZERO);
424 }
425 if (HasSimCard(SIM2_SLOTID)) {
426 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsConfig(SIM2_SLOTID, ITEM_VIDEO_QUALITY), RETURN_VALUE_IS_ZERO);
427 }
428 }
429
430 /**
431 * @tc.number Telephony_CallManager_GetImsConfig_0200
432 * @tc.name test get ims config item ims switch status
433 * @tc.desc Function test
434 */
435 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsConfig_0200, Function | MediumTest | Level3)
436 {
437 AccessToken token;
438 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
439 return;
440 }
441
442 if (HasSimCard(SIM1_SLOTID)) {
443 EXPECT_EQ(
444 CallManagerGtest::clientPtr_->GetImsConfig(SIM1_SLOTID, ITEM_IMS_SWITCH_STATUS), RETURN_VALUE_IS_ZERO);
445 }
446 if (HasSimCard(SIM2_SLOTID)) {
447 EXPECT_EQ(
448 CallManagerGtest::clientPtr_->GetImsConfig(SIM2_SLOTID, ITEM_IMS_SWITCH_STATUS), RETURN_VALUE_IS_ZERO);
449 }
450 }
451
452 /**
453 * @tc.number Telephony_CallManager_GetImsConfig_0300
454 * @tc.name test get ims config item with invalid item
455 * @tc.desc Function test
456 */
457 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsConfig_0300, Function | MediumTest | Level3)
458 {
459 AccessToken token;
460 ImsConfigItem item = static_cast<ImsConfigItem>(2);
461 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
462 return;
463 }
464
465 if (HasSimCard(SIM1_SLOTID)) {
466 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsConfig(SIM1_SLOTID, item), RETURN_VALUE_IS_ZERO);
467 }
468 if (HasSimCard(SIM2_SLOTID)) {
469 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsConfig(SIM2_SLOTID, item), RETURN_VALUE_IS_ZERO);
470 }
471 }
472
473 /********************************************* Test SetImsConfig() ************************************************/
474 /**
475 * @tc.number Telephony_CallManager_SetImsConfig_0100
476 * @tc.name test set ims config item video quality
477 * @tc.desc Function test
478 */
479 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsConfig_0100, Function | MediumTest | Level3)
480 {
481 AccessToken token;
482 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
483 return;
484 }
485
486 std::u16string value = u"123";
487 if (HasSimCard(SIM1_SLOTID)) {
488 EXPECT_EQ(
489 CallManagerGtest::clientPtr_->SetImsConfig(SIM1_SLOTID, ITEM_VIDEO_QUALITY, value), RETURN_VALUE_IS_ZERO);
490 }
491 if (HasSimCard(SIM2_SLOTID)) {
492 EXPECT_EQ(
493 CallManagerGtest::clientPtr_->SetImsConfig(SIM2_SLOTID, ITEM_VIDEO_QUALITY, value), RETURN_VALUE_IS_ZERO);
494 }
495 }
496
497 /**
498 * @tc.number Telephony_CallManager_SetImsConfig_0200
499 * @tc.name test set ims config item ims switch status
500 * @tc.desc Function test
501 */
502 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsConfig_0200, Function | MediumTest | Level3)
503 {
504 AccessToken token;
505 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
506 return;
507 }
508
509 std::u16string value = u"123";
510 if (HasSimCard(SIM1_SLOTID)) {
511 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsConfig(SIM1_SLOTID, ITEM_IMS_SWITCH_STATUS, value),
512 RETURN_VALUE_IS_ZERO);
513 }
514 if (HasSimCard(SIM2_SLOTID)) {
515 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsConfig(SIM2_SLOTID, ITEM_IMS_SWITCH_STATUS, value),
516 RETURN_VALUE_IS_ZERO);
517 }
518 }
519
520 /**
521 * @tc.number Telephony_CallManager_SetImsConfig_0300
522 * @tc.name test set ims config item with invalid item
523 * @tc.desc Function test
524 */
525 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsConfig_0300, Function | MediumTest | Level3)
526 {
527 AccessToken token;
528 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
529 return;
530 }
531
532 std::u16string value = u"123";
533 ImsConfigItem item = static_cast<ImsConfigItem>(2);
534 if (HasSimCard(SIM1_SLOTID)) {
535 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsConfig(SIM1_SLOTID, item, value), RETURN_VALUE_IS_ZERO);
536 }
537 if (HasSimCard(SIM2_SLOTID)) {
538 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsConfig(SIM2_SLOTID, item, value), RETURN_VALUE_IS_ZERO);
539 }
540 }
541
542 /*********************************** Test GetImsFeatureValue() ****************************************/
543 /**
544 * @tc.number Telephony_CallManager_GetImsFeatureValue_0100
545 * @tc.name test get ims feature value type voice over lte
546 * @tc.desc Function test
547 */
548 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsFeatureValue_0100, Function | MediumTest | Level3)
549 {
550 AccessToken token;
551 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
552 return;
553 }
554
555 if (HasSimCard(SIM1_SLOTID)) {
556 EXPECT_EQ(
557 CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM1_SLOTID, TYPE_VOICE_OVER_LTE), RETURN_VALUE_IS_ZERO);
558 }
559 if (HasSimCard(SIM2_SLOTID)) {
560 EXPECT_EQ(
561 CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM2_SLOTID, TYPE_VOICE_OVER_LTE), RETURN_VALUE_IS_ZERO);
562 }
563 }
564
565 /**
566 * @tc.number Telephony_CallManager_GetImsFeatureValue_0200
567 * @tc.name test get ims feature value type video over lte
568 * @tc.desc Function test
569 */
570 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsFeatureValue_0200, Function | MediumTest | Level3)
571 {
572 AccessToken token;
573 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
574 return;
575 }
576
577 if (HasSimCard(SIM1_SLOTID)) {
578 EXPECT_EQ(
579 CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM1_SLOTID, TYPE_VIDEO_OVER_LTE), RETURN_VALUE_IS_ZERO);
580 }
581 if (HasSimCard(SIM2_SLOTID)) {
582 EXPECT_EQ(
583 CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM2_SLOTID, TYPE_VIDEO_OVER_LTE), RETURN_VALUE_IS_ZERO);
584 }
585 }
586
587 /**
588 * @tc.number Telephony_CallManager_GetImsFeatureValue_0300
589 * @tc.name test get ims feature value type ss over ut
590 * @tc.desc Function test
591 */
592 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsFeatureValue_0300, Function | MediumTest | Level3)
593 {
594 AccessToken token;
595 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
596 return;
597 }
598
599 if (HasSimCard(SIM1_SLOTID)) {
600 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM1_SLOTID, TYPE_SS_OVER_UT),
601 RETURN_VALUE_IS_ZERO);
602 }
603 if (HasSimCard(SIM2_SLOTID)) {
604 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM2_SLOTID, TYPE_SS_OVER_UT),
605 RETURN_VALUE_IS_ZERO);
606 }
607 }
608
609 /**
610 * @tc.number Telephony_CallManager_GetImsFeatureValue_0400
611 * @tc.name test get ims feature value with invalid type
612 * @tc.desc Function test
613 */
614 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsFeatureValue_0400, Function | MediumTest | Level3)
615 {
616 AccessToken token;
617 FeatureType type = static_cast<FeatureType>(3);
618 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
619 return;
620 }
621
622 if (HasSimCard(SIM1_SLOTID)) {
623 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM1_SLOTID, type), RETURN_VALUE_IS_ZERO);
624 }
625 if (HasSimCard(SIM2_SLOTID)) {
626 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM2_SLOTID, type), RETURN_VALUE_IS_ZERO);
627 }
628 }
629
630 /***************************************** Test SetImsFeatureValue() ***************************************/
631 /**
632 * @tc.number Telephony_CallManager_SetImsFeatureValue_0100
633 * @tc.name test set ims feature value type voice over lte
634 * @tc.desc Function test
635 */
636 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsFeatureValue_0100, Function | MediumTest | Level3)
637 {
638 AccessToken token;
639 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
640 return;
641 }
642
643 int32_t value = 1;
644 if (HasSimCard(SIM1_SLOTID)) {
645 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM1_SLOTID, TYPE_VOICE_OVER_LTE, value),
646 RETURN_VALUE_IS_ZERO);
647 }
648 if (HasSimCard(SIM2_SLOTID)) {
649 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM2_SLOTID, TYPE_VOICE_OVER_LTE, value),
650 RETURN_VALUE_IS_ZERO);
651 }
652 }
653
654 /**
655 * @tc.number Telephony_CallManager_SetImsFeatureValue_0200
656 * @tc.name test set ims feature value type video over lte
657 * @tc.desc Function test
658 */
659 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsFeatureValue_0200, Function | MediumTest | Level3)
660 {
661 AccessToken token;
662 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
663 return;
664 }
665
666 int32_t value = 1;
667 if (HasSimCard(SIM1_SLOTID)) {
668 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM1_SLOTID, TYPE_VIDEO_OVER_LTE, value),
669 RETURN_VALUE_IS_ZERO);
670 }
671 if (HasSimCard(SIM2_SLOTID)) {
672 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM2_SLOTID, TYPE_VIDEO_OVER_LTE, value),
673 RETURN_VALUE_IS_ZERO);
674 }
675 }
676
677 /**
678 * @tc.number Telephony_CallManager_SetImsFeatureValue_0300
679 * @tc.name test set ims feature value type ss over ut
680 * @tc.desc Function test
681 */
682 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsFeatureValue_0300, Function | MediumTest | Level3)
683 {
684 AccessToken token;
685 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
686 return;
687 }
688
689 int32_t value = 1;
690 if (HasSimCard(SIM1_SLOTID)) {
691 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM1_SLOTID, TYPE_SS_OVER_UT, value),
692 RETURN_VALUE_IS_ZERO);
693 }
694 if (HasSimCard(SIM2_SLOTID)) {
695 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM2_SLOTID, TYPE_SS_OVER_UT, value),
696 RETURN_VALUE_IS_ZERO);
697 }
698 }
699
700 /**
701 * @tc.number Telephony_CallManager_SetImsFeatureValue_0400
702 * @tc.name test set ims feature value with invalid type
703 * @tc.desc Function test
704 */
705 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsFeatureValue_0400, Function | MediumTest | Level3)
706 {
707 AccessToken token;
708 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
709 return;
710 }
711
712 int32_t value = 1;
713 FeatureType type = static_cast<FeatureType>(3);
714 if (HasSimCard(SIM1_SLOTID)) {
715 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM1_SLOTID, type, value), RETURN_VALUE_IS_ZERO);
716 }
717 if (HasSimCard(SIM2_SLOTID)) {
718 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM2_SLOTID, type, value), RETURN_VALUE_IS_ZERO);
719 }
720 }
721
722 /************************************** Test UpdateImsCallMode() ****************************************/
723 /**
724 * @tc.number Telephony_CallManager_UpdateImsCallMode_0100
725 * @tc.name test update ims call mode audio only
726 * @tc.desc Function test
727 */
728 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0100, Function | MediumTest | Level3)
729 {
730 AccessToken token;
731 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
732 return;
733 }
734
735 int32_t callId = 1;
736 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_AUDIO_ONLY), RETURN_VALUE_IS_ZERO);
737 }
738
739 /**
740 * @tc.number Telephony_CallManager_UpdateImsCallMode_0200
741 * @tc.name test update ims call mode send only
742 * @tc.desc Function test
743 */
744 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0200, Function | MediumTest | Level3)
745 {
746 AccessToken token;
747 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
748 return;
749 }
750
751 int32_t callId = 1;
752 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_SEND_ONLY), RETURN_VALUE_IS_ZERO);
753 }
754
755 /**
756 * @tc.number Telephony_CallManager_UpdateImsCallMode_0300
757 * @tc.name test update ims call mode recerve only
758 * @tc.desc Function test
759 */
760 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0300, Function | MediumTest | Level3)
761 {
762 AccessToken token;
763 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
764 return;
765 }
766
767 int32_t callId = 1;
768 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_RECEIVE_ONLY), RETURN_VALUE_IS_ZERO);
769 }
770
771 /**
772 * @tc.number Telephony_CallManager_UpdateImsCallMode_0400
773 * @tc.name test update ims call mode send receive
774 * @tc.desc Function test
775 */
776 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0400, Function | MediumTest | Level3)
777 {
778 AccessToken token;
779 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
780 return;
781 }
782
783 int32_t callId = 1;
784 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_SEND_RECEIVE), RETURN_VALUE_IS_ZERO);
785 }
786
787 /**
788 * @tc.number Telephony_CallManager_UpdateImsCallMode_0500
789 * @tc.name test update ims call mode video paused
790 * @tc.desc Function test
791 */
792 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0500, Function | MediumTest | Level3)
793 {
794 AccessToken token;
795 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
796 return;
797 }
798
799 int32_t callId = 1;
800 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_VIDEO_PAUSED), RETURN_VALUE_IS_ZERO);
801 }
802
803 /**
804 * @tc.number Telephony_CallManager_UpdateImsCallMode_0600
805 * @tc.name test update ims call with invalid mode
806 * @tc.desc Function test
807 */
808 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0600, Function | MediumTest | Level3)
809 {
810 AccessToken token;
811 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
812 return;
813 }
814
815 int32_t callId = 1;
816 ImsCallMode mode = static_cast<ImsCallMode>(5);
817 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, mode), RETURN_VALUE_IS_ZERO);
818 }
819
820 /********************************************* Test StartRtt() ************************************************/
821 /**
822 * @tc.number Telephony_CallManager_StartRtt_0100
823 * @tc.name test start rtt
824 * @tc.desc Function test
825 */
826 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartRtt_0100, Function | MediumTest | Level3)
827 {
828 AccessToken token;
829 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
830 return;
831 }
832
833 std::u16string msg = u"123";
834 int32_t callId = 1;
835 EXPECT_NE(CallManagerGtest::clientPtr_->StartRtt(callId, msg), RETURN_VALUE_IS_ZERO);
836 }
837
838 /********************************************* Test StopRtt() ************************************************/
839 /**
840 * @tc.number Telephony_CallManager_StopRtt_0100
841 * @tc.name test stop rtt
842 * @tc.desc Function test
843 */
844 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopRtt_0100, Function | MediumTest | Level3)
845 {
846 AccessToken token;
847 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
848 return;
849 }
850 int32_t callId = 1;
851 EXPECT_NE(CallManagerGtest::clientPtr_->StopRtt(callId), RETURN_VALUE_IS_ZERO);
852 }
853
854 /**************************************** Test CanSetCallTransferTime() ******************************************/
855 /**
856 * @tc.number Telephony_CallManager_CanSetCallTransferTime_0100
857 * @tc.name input invalid slotId, test CanSetCallTransferTime() return failed
858 * @tc.desc Function test
859 */
860 HWTEST_F(CallManagerGtest, Telephony_CallManager_CanSetCallTransferTime_0100, Function | MediumTest | Level3)
861 {
862 AccessToken token;
863 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
864 return;
865 }
866
867 bool result;
868 EXPECT_EQ(CallManagerGtest::clientPtr_->CanSetCallTransferTime(INVALID_SLOT_ID, result), CALL_ERR_INVALID_SLOT_ID);
869 }
870
871 /**
872 * @tc.number Telephony_CallManager_CanSetCallTransferTime_0200
873 * @tc.name input slotId was out of count
874 * test CanSetCallTransferTime() return failed
875 * @tc.desc Function test
876 */
877 HWTEST_F(CallManagerGtest, Telephony_CallManager_CanSetCallTransferTime_0200, Function | MediumTest | Level3)
878 {
879 AccessToken token;
880 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
881 return;
882 }
883
884 bool result;
885 int32_t slotId = SIM_SLOT_COUNT; // out of the count
886 EXPECT_EQ(CallManagerGtest::clientPtr_->CanSetCallTransferTime(slotId, result), CALL_ERR_INVALID_SLOT_ID);
887 }
888
889 /**
890 * @tc.number Telephony_CallManager_CanSetCallTransferTime_0300
891 * @tc.name test CanSetCallTransferTime() without permission
892 * @tc.desc Function test
893 */
894 HWTEST_F(CallManagerGtest, Telephony_CallManager_CanSetCallTransferTime_0300, Function | MediumTest | Level3)
895 {
896 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
897 return;
898 }
899
900 bool result;
901 if (HasSimCard(SIM1_SLOTID)) {
902 EXPECT_EQ(
903 CallManagerGtest::clientPtr_->CanSetCallTransferTime(SIM1_SLOTID, result), TELEPHONY_ERR_PERMISSION_ERR);
904 }
905 if (HasSimCard(SIM2_SLOTID)) {
906 EXPECT_EQ(
907 CallManagerGtest::clientPtr_->CanSetCallTransferTime(SIM2_SLOTID, result), TELEPHONY_ERR_PERMISSION_ERR);
908 }
909 }
910
911 /**
912 * @tc.number Telephony_CallManager_CanSetCallTransferTime_0400
913 * @tc.name test CanSetCallTransferTime() with normal situation
914 * @tc.desc Function test
915 */
916 HWTEST_F(CallManagerGtest, Telephony_CallManager_CanSetCallTransferTime_0400, Function | MediumTest | Level3)
917 {
918 AccessToken token;
919 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
920 return;
921 }
922
923 bool result;
924 if (HasSimCard(SIM1_SLOTID)) {
925 EXPECT_EQ(CallManagerGtest::clientPtr_->CanSetCallTransferTime(SIM1_SLOTID, result), RETURN_VALUE_IS_ZERO);
926 }
927 if (HasSimCard(SIM2_SLOTID)) {
928 EXPECT_EQ(CallManagerGtest::clientPtr_->CanSetCallTransferTime(SIM2_SLOTID, result), RETURN_VALUE_IS_ZERO);
929 }
930 }
931
932 /********************************************* Test SetAudioDevice()***********************************************/
933 /**
934 * @tc.number Telephony_CallManager_SetAudioDevice_0100
935 * @tc.name make a normal buletoothAddress, set active bluetooth device
936 * @tc.desc Function test
937 * @tc.require: issueI5JUAQ
938 */
939 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetAudioDevice_0100, Function | MediumTest | Level2)
940 {
941 AccessToken token;
942 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
943 return;
944 }
945 std::string phoneNumber = "66666666666";
946 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
947 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
948 HangUpCall();
949 }
950 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
951 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
952 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
953
954 HandsFreeAudioGateway *profile = HandsFreeAudioGateway::GetProfile();
955 vector<BluetoothRemoteDevice> devices = profile->GetConnectedDevices();
956 int deviceNum = devices.size();
957 std::string address = "";
958 const int32_t zeroDevice = 0;
959 if (deviceNum > zeroDevice) {
960 address = devices[0].GetDeviceAddr();
961 }
962
963 AudioDevice audioDevice;
964 if (memset_s(&audioDevice, sizeof(AudioDevice), 0, sizeof(AudioDevice)) != EOK) {
965 TELEPHONY_LOGE("memset_s fail");
966 return;
967 }
968 audioDevice.deviceType = AudioDeviceType::DEVICE_BLUETOOTH_SCO;
969 if (address.length() > kMaxAddressLen) {
970 TELEPHONY_LOGE("address is not too long");
971 return;
972 }
973 if (memcpy_s(audioDevice.address, kMaxAddressLen, address.c_str(), address.length()) != EOK) {
974 TELEPHONY_LOGE("memcpy_s address fail");
975 return;
976 }
977
978 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_OFFHOOK, SLEEP_200_MS, SLEEP_30000_MS);
979 EXPECT_NE(clientPtr_->SetAudioDevice(audioDevice), RETURN_VALUE_IS_ZERO);
980 }
981 } // namespace Telephony
982 } // namespace OHOS
983
