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 /******************************************* Test SetCameraZoom() *********************************************/
188 /**
189 * @tc.number Telephony_CallManager_SetCameraZoom_0100
190 * @tc.name input zoomRatio 5.0, Test SetCameraZoom
191 * @tc.desc Function test
192 */
193 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0100, Function | MediumTest | Level2)
194 {
195 AccessToken token;
196 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
197 return;
198 }
199 float zoomRatio = 5.0;
200 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
201 }
202
203 /**
204 * @tc.number Telephony_CallManager_SetCameraZoom_0200
205 * @tc.name input zoomRatio 0.1, Test SetCameraZoom
206 * @tc.desc Function test
207 */
208 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0200, Function | MediumTest | Level2)
209 {
210 AccessToken token;
211 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
212 return;
213 }
214 float zoomRatio = 0.1;
215 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
216 }
217
218 /**
219 * @tc.number Telephony_CallManager_SetCameraZoom_0300
220 * @tc.name input zoomRatio 10.0, Test SetCameraZoom
221 * @tc.desc Function test
222 */
223 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0300, Function | MediumTest | Level2)
224 {
225 AccessToken token;
226 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
227 return;
228 }
229 float zoomRatio = 10.0;
230 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
231 }
232
233 /**
234 * @tc.number Telephony_CallManager_SetCameraZoom_0400
235 * @tc.name input invalid para zoomRatio 15.0, Test SetCameraZoom, return error code if failed
236 * @tc.desc Function test
237 */
238 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0400, Function | MediumTest | Level2)
239 {
240 AccessToken token;
241 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
242 return;
243 }
244 float zoomRatio = 15.0;
245 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
246 }
247
248 /**
249 * @tc.number Telephony_CallManager_SetCameraZoom_0500
250 * @tc.name input invalid para zoomRatio 0.0, Test SetCameraZoom, return error code if failed
251 * @tc.desc Function test
252 */
253 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0500, Function | MediumTest | Level2)
254 {
255 AccessToken token;
256 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
257 return;
258 }
259 float zoomRatio = 0.0;
260 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
261 }
262
263 /**
264 * @tc.number Telephony_CallManager_SetCameraZoom_0600
265 * @tc.name input invalid para zoomRatio -1.0, Test SetCameraZoom, return error code if failed
266 * @tc.desc Function test
267 */
268 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0600, Function | MediumTest | Level2)
269 {
270 AccessToken token;
271 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
272 return;
273 }
274 float zoomRatio = -1.0;
275 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
276 }
277
278 /**
279 * @tc.number Telephony_CallManager_SetCameraZoom_0700
280 * @tc.name input invalid para zoomRatio 10.1, Test SetCameraZoom, return error code if failed
281 * @tc.desc Function test
282 */
283 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0700, Function | MediumTest | Level2)
284 {
285 AccessToken token;
286 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
287 return;
288 }
289 float zoomRatio = 10.1;
290 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
291 }
292 /******************************************* Test SetPausePicture() *********************************************/
293 /**
294 * @tc.number Telephony_CallManager_SetPausePicture_0100
295 * @tc.name input locale picture path /system/bin/test.png that does not exist, Test SetPausePicture,
296 * return error code if failed
297 * @tc.desc Function test
298 */
299 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0100, Function | MediumTest | Level2)
300 {
301 AccessToken token;
302 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
303 return;
304 }
305 int32_t callId = 1;
306 std::string pathTemp = "/system/bin/test.png";
307 std::u16string path = Str8ToStr16(pathTemp);
308 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(callId, path), RETURN_VALUE_IS_ZERO);
309 }
310
311 /**
312 * @tc.number Telephony_CallManager_SetPausePicture_0200
313 * @tc.name input an invalid image format file path, Test SetPausePicture, return error code if failed
314 * @tc.desc Function test
315 */
316 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0200, Function | MediumTest | Level2)
317 {
318 AccessToken token;
319 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
320 return;
321 }
322 int32_t callId = 1;
323 std::string pathTemp = "/system/bin/test.jpg";
324 std::u16string path = Str8ToStr16(pathTemp);
325 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(callId, path), RETURN_VALUE_IS_ZERO);
326 }
327
328 /**
329 * @tc.number Telephony_CallManager_SetPausePicture_0300
330 * @tc.name input an invalid image format file path, Test SetPausePicture, return error code if failed
331 * @tc.desc Function test
332 */
333 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0300, Function | MediumTest | Level2)
334 {
335 AccessToken token;
336 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
337 return;
338 }
339 int32_t callId = 1;
340 std::string pathTemp = "/system/bin/test.bmp";
341 std::u16string path = Str8ToStr16(pathTemp);
342 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(callId, path), RETURN_VALUE_IS_ZERO);
343 }
344
345 /**
346 * @tc.number Telephony_CallManager_SetPausePicture_0400
347 * @tc.name input an invalid image format file path, Test SetPausePicture, return error code if failed
348 * @tc.desc Function test
349 */
350 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0400, 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 = "/system/bin/test.webp";
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_0500
364 * @tc.name input remote picture path http://callManager.jpg that does not exist, Test SetPausePicture,
365 * return error code if failed
366 * @tc.desc Function test
367 */
368 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0500, Function | MediumTest | Level2)
369 {
370 AccessToken token;
371 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
372 return;
373 }
374 int32_t callId = 1;
375 std::string pathTemp = "http://callManager.jpg";
376 std::u16string path = Str8ToStr16(pathTemp);
377 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(callId, path), RETURN_VALUE_IS_ZERO);
378 }
379
380 /**
381 * @tc.number Telephony_CallManager_SetPausePicture_0600
382 * @tc.name input empty picture path, Test SetPausePicture, return error code if failed
383 * @tc.desc Function test
384 */
385 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0600, Function | MediumTest | Level2)
386 {
387 AccessToken token;
388 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
389 return;
390 }
391 int32_t callId = 1;
392 std::string pathTemp = "";
393 std::u16string path = Str8ToStr16(pathTemp);
394 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(callId, path), RETURN_VALUE_IS_ZERO);
395 }
396
397 /**
398 * @tc.number Telephony_CallManager_CancelCallUpgrade_0100
399 * @tc.name input callId:1, Test CancelCallUpgrade, return error code if failed
400 * @tc.desc Function test
401 */
402 HWTEST_F(CallManagerGtest, Telephony_CallManager_CancelCallUpgrade_0100, Function | MediumTest | Level2)
403 {
404 AccessToken token;
405 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
406 return;
407 }
408 int32_t callId = 1;
409 EXPECT_NE(CallManagerGtest::clientPtr_->CancelCallUpgrade(callId), RETURN_VALUE_IS_ZERO);
410 }
411
412 /**
413 * @tc.number Telephony_CallManager_RequestCameraCapabilities_0100
414 * @tc.name input callId:1, Test RequestCameraCapabilities, return error code if failed
415 * @tc.desc Function test
416 */
417 HWTEST_F(CallManagerGtest, Telephony_CallManager_RequestCameraCapabilities_0100, Function | MediumTest | Level2)
418 {
419 AccessToken token;
420 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
421 return;
422 }
423 int32_t callId = 1;
424 EXPECT_NE(CallManagerGtest::clientPtr_->RequestCameraCapabilities(callId), RETURN_VALUE_IS_ZERO);
425 }
426
427 /************************************** Test UpdateImsCallMode() ****************************************/
428 /**
429 * @tc.number Telephony_CallManager_UpdateImsCallMode_0100
430 * @tc.name test update ims call mode audio only
431 * @tc.desc Function test
432 */
433 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0100, Function | MediumTest | Level3)
434 {
435 AccessToken token;
436 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
437 return;
438 }
439
440 int32_t callId = 1;
441 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_AUDIO_ONLY), RETURN_VALUE_IS_ZERO);
442 }
443
444 /**
445 * @tc.number Telephony_CallManager_UpdateImsCallMode_0200
446 * @tc.name test update ims call mode send only
447 * @tc.desc Function test
448 */
449 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0200, Function | MediumTest | Level3)
450 {
451 AccessToken token;
452 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
453 return;
454 }
455
456 int32_t callId = 1;
457 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_SEND_ONLY), RETURN_VALUE_IS_ZERO);
458 }
459
460 /**
461 * @tc.number Telephony_CallManager_UpdateImsCallMode_0300
462 * @tc.name test update ims call mode recerve only
463 * @tc.desc Function test
464 */
465 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0300, Function | MediumTest | Level3)
466 {
467 AccessToken token;
468 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
469 return;
470 }
471
472 int32_t callId = 1;
473 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_RECEIVE_ONLY), RETURN_VALUE_IS_ZERO);
474 }
475
476 /**
477 * @tc.number Telephony_CallManager_UpdateImsCallMode_0400
478 * @tc.name test update ims call mode send receive
479 * @tc.desc Function test
480 */
481 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0400, Function | MediumTest | Level3)
482 {
483 AccessToken token;
484 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
485 return;
486 }
487
488 int32_t callId = 1;
489 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_SEND_RECEIVE), RETURN_VALUE_IS_ZERO);
490 }
491
492 /**
493 * @tc.number Telephony_CallManager_UpdateImsCallMode_0500
494 * @tc.name test update ims call mode video paused
495 * @tc.desc Function test
496 */
497 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0500, Function | MediumTest | Level3)
498 {
499 AccessToken token;
500 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
501 return;
502 }
503
504 int32_t callId = 1;
505 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_VIDEO_PAUSED), RETURN_VALUE_IS_ZERO);
506 }
507
508 /**
509 * @tc.number Telephony_CallManager_UpdateImsCallMode_0600
510 * @tc.name test update ims call with invalid mode
511 * @tc.desc Function test
512 */
513 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0600, Function | MediumTest | Level3)
514 {
515 AccessToken token;
516 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
517 return;
518 }
519
520 int32_t callId = 1;
521 ImsCallMode mode = static_cast<ImsCallMode>(5);
522 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, mode), RETURN_VALUE_IS_ZERO);
523 }
524
525 /********************************************* Test StartRtt() ************************************************/
526 /**
527 * @tc.number Telephony_CallManager_StartRtt_0100
528 * @tc.name test start rtt
529 * @tc.desc Function test
530 */
531 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartRtt_0100, Function | MediumTest | Level3)
532 {
533 AccessToken token;
534 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
535 return;
536 }
537
538 std::u16string msg = u"123";
539 int32_t callId = 1;
540 EXPECT_NE(CallManagerGtest::clientPtr_->StartRtt(callId, msg), RETURN_VALUE_IS_ZERO);
541 }
542
543 /********************************************* Test StopRtt() ************************************************/
544 /**
545 * @tc.number Telephony_CallManager_StopRtt_0100
546 * @tc.name test stop rtt
547 * @tc.desc Function test
548 */
549 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopRtt_0100, Function | MediumTest | Level3)
550 {
551 AccessToken token;
552 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
553 return;
554 }
555 int32_t callId = 1;
556 EXPECT_NE(CallManagerGtest::clientPtr_->StopRtt(callId), RETURN_VALUE_IS_ZERO);
557 }
558
559 /**************************************** Test CanSetCallTransferTime() ******************************************/
560 /**
561 * @tc.number Telephony_CallManager_CanSetCallTransferTime_0100
562 * @tc.name input invalid slotId, test CanSetCallTransferTime() return failed
563 * @tc.desc Function test
564 */
565 HWTEST_F(CallManagerGtest, Telephony_CallManager_CanSetCallTransferTime_0100, Function | MediumTest | Level3)
566 {
567 AccessToken token;
568 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
569 return;
570 }
571
572 bool result;
573 EXPECT_EQ(CallManagerGtest::clientPtr_->CanSetCallTransferTime(INVALID_SLOT_ID, result), CALL_ERR_INVALID_SLOT_ID);
574 }
575
576 /**
577 * @tc.number Telephony_CallManager_CanSetCallTransferTime_0200
578 * @tc.name input slotId was out of count
579 * test CanSetCallTransferTime() return failed
580 * @tc.desc Function test
581 */
582 HWTEST_F(CallManagerGtest, Telephony_CallManager_CanSetCallTransferTime_0200, Function | MediumTest | Level3)
583 {
584 AccessToken token;
585 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
586 return;
587 }
588
589 bool result;
590 int32_t slotId = SIM_SLOT_COUNT; // out of the count
591 EXPECT_EQ(CallManagerGtest::clientPtr_->CanSetCallTransferTime(slotId, result), CALL_ERR_INVALID_SLOT_ID);
592 }
593
594 /**
595 * @tc.number Telephony_CallManager_CanSetCallTransferTime_0300
596 * @tc.name test CanSetCallTransferTime() without permission
597 * @tc.desc Function test
598 */
599 HWTEST_F(CallManagerGtest, Telephony_CallManager_CanSetCallTransferTime_0300, Function | MediumTest | Level3)
600 {
601 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
602 return;
603 }
604
605 bool result;
606 if (HasSimCard(SIM1_SLOTID)) {
607 EXPECT_EQ(
608 CallManagerGtest::clientPtr_->CanSetCallTransferTime(SIM1_SLOTID, result), TELEPHONY_ERR_PERMISSION_ERR);
609 }
610 if (HasSimCard(SIM2_SLOTID)) {
611 EXPECT_EQ(
612 CallManagerGtest::clientPtr_->CanSetCallTransferTime(SIM2_SLOTID, result), TELEPHONY_ERR_PERMISSION_ERR);
613 }
614 }
615
616 /**
617 * @tc.number Telephony_CallManager_Telephony_CallManager_SendUssdResponse_0100SetAudioDevice_0100
618 * @tc.name input slotId:0, content:1, Test SendUssdResponse, return error code if failed
619 * @tc.desc Function test
620 * @tc.require: issueI5JUAQ
621 */
622 HWTEST_F(CallManagerGtest, Telephony_CallManager_SendUssdResponse_0100, Function | MediumTest | Level2)
623 {
624 AccessToken token;
625 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
626 return;
627 }
628 std::string content = "1";
629 if (HasSimCard(SIM1_SLOTID)) {
630 EXPECT_EQ(CallManagerGtest::clientPtr_->SendUssdResponse(SIM1_SLOTID, content), RETURN_VALUE_IS_ZERO);
631 return;
632 }
633 if (HasSimCard(SIM2_SLOTID)) {
634 EXPECT_EQ(CallManagerGtest::clientPtr_->SendUssdResponse(SIM2_SLOTID, content), RETURN_VALUE_IS_ZERO);
635 return;
636 }
637 }
638 } // namespace Telephony
639 } // namespace OHOS
640
