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 #include "call_manager_gtest.h"
17
18 #include <cstring>
19 #include <gtest/gtest.h>
20 #include <string>
21
22 #include "bluetooth_hfp_ag.h"
23 #include "call_manager_service.h"
24 #include "telephony_types.h"
25
26 using namespace OHOS::Bluetooth;
27 namespace OHOS {
28 namespace Telephony {
29 using namespace testing::ext;
30 #ifndef TEL_TEST_UNSUPPORT
31 constexpr int16_t SIM1_SLOTID = 0;
32 constexpr int16_t SIM2_SLOTID = 1;
33 constexpr int16_t SIM1_SLOTID_NO_CARD = 0;
34 constexpr int16_t RETURN_VALUE_IS_ZERO = 0;
35 constexpr int16_t INVALID_NEGATIVE_ID = -100;
36 constexpr int16_t INVALID_POSITIVE_ID = 100;
37 #ifndef CALL_MANAGER_IMS_LITE_UNSUPPORT
38 constexpr int16_t CAMERA_ROTATION_90 = 90;
39 constexpr int16_t CAMERA_ROTATION_ERROR = 50;
40 #endif // CALL_MANAGER_IMS_LITE_UNSUPPORT
41 #endif // TEL_TEST_UNSUPPORT
42 constexpr int16_t SLEEP_1000_MS = 1000;
43 constexpr int BASE_TIME_MS = 1000;
44 constexpr int SLEEP_TIME_MS = 50;
45 constexpr int MAX_LIMIT_TIME = 18000;
46 constexpr int INVALID_DIAL_TYPE = 3;
47 const std::string PHONE_NUMBER = "xxxxx";
48
CallDetailsChange(const CallAttributeInfo & info)49 int32_t CallInfoManager::CallDetailsChange(const CallAttributeInfo &info)
50 {
51 TELEPHONY_LOGI("CallDetailsChange Start");
52 std::lock_guard<std::mutex> lock(mutex_);
53 updateCallInfo_ = info;
54 if (callIdSet_.find(updateCallInfo_.callId) == callIdSet_.end()) {
55 TELEPHONY_LOGI("CallDetailsChange new call");
56 callIdSet_.insert(updateCallInfo_.callId);
57 newCallId_ = updateCallInfo_.callId;
58 newCallState_ = (int32_t)updateCallInfo_.callState;
59 std::unordered_set<int32_t> newSet;
60 newSet.clear();
61 g_callStateMap.insert(std::pair<int32_t, std::unordered_set<int32_t>>(newCallId_, newSet));
62 }
63 g_callStateMap[updateCallInfo_.callId].insert((int32_t)updateCallInfo_.callState);
64 return TELEPHONY_SUCCESS;
65 }
66
HasActiveStatus()67 bool CallInfoManager::HasActiveStatus()
68 {
69 TELEPHONY_LOGI("Waiting for activation !");
70 int sumUseTime = 0;
71 int slipMs = SLEEP_TIME_MS;
72 do {
73 if (!(HasState(newCallId_, static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE)))) {
74 usleep(slipMs * BASE_TIME_MS);
75 sumUseTime += slipMs;
76 } else {
77 TELEPHONY_LOGI("===========wait %d ms callStatus:%d==============", sumUseTime, newCallState_);
78 return true;
79 }
80 } while (sumUseTime < MAX_LIMIT_TIME);
81 TELEPHONY_LOGI("===========wait %d ms callStatus:%d=====not active=========", sumUseTime, newCallState_);
82 return false;
83 }
84
HasState(int callId,int32_t callState)85 bool CallInfoManager::HasState(int callId, int32_t callState)
86 {
87 if (g_callStateMap.find(callId) == g_callStateMap.end()) {
88 return false;
89 }
90 if (g_callStateMap[callId].find(callState) == g_callStateMap[callId].end()) {
91 return false;
92 }
93 return true;
94 }
95
CallEventChange(const CallEventInfo & info)96 int32_t CallInfoManager::CallEventChange(const CallEventInfo &info)
97 {
98 return TELEPHONY_SUCCESS;
99 }
100
Init()101 void CallInfoManager::Init()
102 {
103 newCallId_ = -1;
104 updateCallInfo_.speakerphoneOn = -1;
105 updateCallInfo_.startTime = -1;
106 updateCallInfo_.isEcc = -1;
107 updateCallInfo_.accountId = -1;
108 updateCallInfo_.callType = CallType::TYPE_CS;
109 updateCallInfo_.callId = -1;
110 updateCallInfo_.callState = TelCallState::CALL_STATUS_IDLE;
111 updateCallInfo_.videoState = VideoStateType::TYPE_VOICE;
112 }
113
LockCallId(bool eq,int32_t targetId,int32_t slipMs,int32_t timeoutMs)114 void CallInfoManager::LockCallId(bool eq, int32_t targetId, int32_t slipMs, int32_t timeoutMs)
115 {
116 int32_t useTimeMs = 0;
117 std::cout << "wait for a few seconds......" << std::endl;
118 while ((updateCallInfo_.callId != targetId) && (useTimeMs < timeoutMs)) {
119 usleep(slipMs * SLEEP_1000_MS);
120 useTimeMs += slipMs;
121 }
122 std::cout << "\n===========wait " << useTimeMs << " ms target:" << updateCallInfo_.callId << std::endl;
123 if (eq) {
124 EXPECT_EQ(updateCallInfo_.callId, targetId);
125 } else {
126 EXPECT_NE(updateCallInfo_.callId, targetId);
127 }
128 }
129
LockCallState(bool eq,int32_t targetState,int32_t slipMs,int32_t timeoutMs)130 void CallInfoManager::LockCallState(bool eq, int32_t targetState, int32_t slipMs, int32_t timeoutMs)
131 {
132 if (CallManagerGtest::clientPtr_->GetCallState() == targetState) {
133 return;
134 }
135 int32_t usedTimeMs = 0;
136 std::cout << "wait for a few seconds......" << std::endl;
137 while ((CallManagerGtest::clientPtr_->GetCallState() != targetState) && (usedTimeMs < timeoutMs)) {
138 usleep(slipMs * SLEEP_1000_MS);
139 usedTimeMs += slipMs;
140 }
141 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
142 std::cout << "waited " << usedTimeMs << " seconds" << std::endl;
143 std::cout << "target call state:" << targetState << std::endl;
144 EXPECT_EQ(callState, targetState);
145 }
146
HangUpCall()147 void CallManagerGtest::HangUpCall()
148 {
149 clientPtr_->HangUpCall(newCallId_);
150 int useTimeMs = 0;
151 while ((CallInfoManager::HasState(newCallId_, (int32_t)TelCallState::CALL_STATUS_DISCONNECTED) != true) &&
152 (useTimeMs < SLEEP_12000_MS)) {
153 usleep((SLEEP_50_MS * SLEEP_1000_MS));
154 useTimeMs += SLEEP_50_MS;
155 }
156 TELEPHONY_LOGI("===========wait %d ms target:%d==============", useTimeMs,
157 CallInfoManager::HasState(newCallId_, (int32_t)TelCallState::CALL_STATUS_DISCONNECTED));
158 }
159
160 #ifndef TEL_TEST_UNSUPPORT
161 /********************************************* Test DialCall()***********************************************/
162 /**
163 * @tc.number Telephony_CallManager_DialCall_0100
164 * @tc.name make a normal phone call with card1, TYPE_VOICE
165 * @tc.desc Function test
166 * @tc.require: I5P2WO
167 */
168 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_0100, Function | MediumTest | Level2)
169 {
170 AccessToken token;
171 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
172 return;
173 }
174 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
175 std::string phoneNumber = "00000000000";
176 if (HasSimCard(SIM1_SLOTID)) {
177 InitDialInfo(
178 SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
179 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
180 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
181 }
182
183 if (HasSimCard(SIM2_SLOTID)) {
184 InitDialInfo(
185 SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
186 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
187 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
188 }
189 }
190
191 /**
192 * @tc.number Telephony_CallManager_DialCall_0200
193 * @tc.name make a normal phone call with null telephone numbers,
194 * wait for the correct status of the callback to execute correctly
195 * @tc.desc Function test
196 * @tc.require: I5P2WO
197 */
198 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_0200, Function | MediumTest | Level2)
199 {
200 AccessToken token;
201 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
202 return;
203 }
204 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
205 std::string phoneNumber = "";
206 if (HasSimCard(SIM1_SLOTID)) {
207 InitDialInfo(
208 SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
209 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
210 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
211 }
212 if (HasSimCard(SIM2_SLOTID)) {
213 InitDialInfo(
214 SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
215 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
216 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
217 }
218 }
219
220 /**
221 * @tc.number Telephony_CallManager_DialCall_0300
222 * @tc.name make a normal phone call with telephone numbers is negative number
223 * @tc.desc Function test
224 * @tc.require: I5P2WO
225 */
226 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_0300, Function | MediumTest | Level3)
227 {
228 AccessToken token;
229 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
230 return;
231 }
232 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
233 std::string phoneNumber = "-12354785268";
234 if (HasSimCard(SIM1_SLOTID)) {
235 InitDialInfo(
236 SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
237 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
238 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
239 }
240 if (HasSimCard(SIM2_SLOTID)) {
241 InitDialInfo(
242 SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
243 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
244 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
245 }
246 }
247
248 /**
249 * @tc.number Telephony_CallManager_DialCall_0400
250 * @tc.name make a normal phone call with telephone numbers is too long
251 * @tc.desc Function test
252 * @tc.require: I5P2WO
253 */
254 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_0400, Function | MediumTest | Level3)
255 {
256 AccessToken token;
257 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
258 return;
259 }
260 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
261 std::string phoneNumber = "19119080646435437102938190283912471651865810514786470168818468143768714648";
262 if (HasSimCard(SIM1_SLOTID)) {
263 InitDialInfo(
264 SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
265 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
266 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
267 }
268
269 if (HasSimCard(SIM2_SLOTID)) {
270 InitDialInfo(
271 SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
272 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
273 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
274 }
275 }
276
277 /**
278 * @tc.number Telephony_CallManager_DialCall_0500
279 * @tc.name If an invalid number is dialed, the DialCall() interface succeeds, but callId is not generated
280 * @tc.desc Function test
281 * @tc.require: I5P2WO
282 */
283 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_0500, Function | MediumTest | Level3)
284 {
285 AccessToken token;
286 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
287 return;
288 }
289 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
290 std::string phoneNumber = "19!@#$%^&*:";
291 if (HasSimCard(SIM1_SLOTID)) {
292 InitDialInfo(
293 SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
294 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
295 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
296 }
297 if (HasSimCard(SIM2_SLOTID)) {
298 InitDialInfo(
299 SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
300 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
301 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
302 }
303 }
304
305 /**
306 * @tc.number Telephony_CallManager_DialCall_1000 to do ...
307 * @tc.name make a normal phone call with card1, TYPE_VOICE, import phonynumber 10086
308 * @tc.desc Function test
309 */
310 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1000, Function | MediumTest | Level0)
311 {
312 AccessToken token;
313 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
314 return;
315 }
316 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
317 std::string phoneNumber = PHONE_NUMBER; // OPERATOR PHONY NUMBER
318 if (HasSimCard(SIM1_SLOTID)) {
319 InitDialInfo(
320 SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
321 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
322 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
323 }
324 if (HasSimCard(SIM2_SLOTID)) {
325 InitDialInfo(
326 SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
327 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
328 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
329 }
330 }
331
332 /**
333 * @tc.number Telephony_CallManager_DialCall_1100
334 * @tc.name make a normal phone call with card1, TYPE_VOICE, slot id was invalid
335 * @tc.desc Function test
336 * @tc.require: I5P2WA
337 */
338 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1100, Function | MediumTest | Level0)
339 {
340 AccessToken token;
341 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
342 return;
343 }
344 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
345 std::string phoneNumber = PHONE_NUMBER; // OPERATOR PHONY NUMBER
346 InitDialInfo(INVALID_SLOT_ID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
347 (int32_t)DialType::DIAL_CARRIER_TYPE);
348 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
349 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
350 }
351
352 /**
353 * @tc.number Telephony_CallManager_DialCall_1200
354 * @tc.name make a normal phone call with card1, TYPE_VOICE, slot id out of count
355 * @tc.desc Function test
356 * @tc.require: I5P2WA
357 */
358 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1200, Function | MediumTest | Level0)
359 {
360 AccessToken token;
361 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
362 return;
363 }
364 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
365 std::string phoneNumber = PHONE_NUMBER; // OPERATOR PHONY NUMBER
366 int32_t slotId = SIM_SLOT_COUNT; // out of the count
367 InitDialInfo(slotId, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
368 (int32_t)DialType::DIAL_CARRIER_TYPE);
369 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
370 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
371 }
372
373 /**
374 * @tc.number Telephony_CallManager_DialCall_1300
375 * @tc.name make a normal phone call with card1, TYPE_VOICE, video state was invalid
376 * @tc.desc Function test
377 * @tc.require: I5P2WA
378 */
379 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1300, Function | MediumTest | Level0)
380 {
381 AccessToken token;
382 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
383 return;
384 }
385 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
386 std::string phoneNumber = PHONE_NUMBER; // OPERATOR PHONY NUMBER
387 if (HasSimCard(SIM1_SLOTID)) {
388 InitDialInfo(
389 SIM1_SLOTID, INVALID_VIDEO_STATE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
390 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
391 EXPECT_EQ(ret, CALL_ERR_INVALID_VIDEO_STATE);
392 }
393 if (HasSimCard(SIM2_SLOTID)) {
394 InitDialInfo(
395 SIM2_SLOTID, INVALID_VIDEO_STATE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
396 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
397 EXPECT_EQ(ret, CALL_ERR_INVALID_VIDEO_STATE);
398 }
399 }
400
401 /**
402 * @tc.number Telephony_CallManager_DialCall_1400
403 * @tc.name make a normal phone call without permission
404 * @tc.desc Function test
405 */
406 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1400, Function | MediumTest | Level1)
407 {
408 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
409 return;
410 }
411 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
412 std::string phoneNumber = "00000000000";
413 if (HasSimCard(SIM1_SLOTID)) {
414 InitDialInfo(
415 SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
416 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
417 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
418 }
419
420 if (HasSimCard(SIM2_SLOTID)) {
421 InitDialInfo(
422 SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
423 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
424 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
425 }
426 }
427
428 /**
429 * @tc.number Telephony_CallManager_DialCall_1500
430 * @tc.name make a normal phone call with error dial type
431 * @tc.desc Function test
432 */
433 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1500, Function | MediumTest | Level1)
434 {
435 AccessToken token;
436 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
437 return;
438 }
439 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
440 std::string phoneNumber = "00000000000";
441 if (HasSimCard(SIM1_SLOTID)) {
442 InitDialInfo(
443 SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, INVALID_DIAL_TYPE);
444 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
445 EXPECT_EQ(ret, CALL_ERR_UNKNOW_DIAL_TYPE);
446 }
447
448 if (HasSimCard(SIM2_SLOTID)) {
449 InitDialInfo(
450 SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, INVALID_DIAL_TYPE);
451 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
452 EXPECT_EQ(ret, CALL_ERR_UNKNOW_DIAL_TYPE);
453 }
454 }
455
456 /**
457 * @tc.number Telephony_CallManager_DialCall_1600
458 * @tc.name make a normal phone call with card1, TYPE_VOICE, video state was invalid
459 * @tc.desc Function test
460 */
461 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1600, Function | MediumTest | Level0)
462 {
463 AccessToken token;
464 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
465 return;
466 }
467 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
468 std::string phoneNumber = PHONE_NUMBER; // OPERATOR PHONY NUMBER
469 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
470 if (HasSimCard(SIM1_SLOTID)) {
471 InitDialInfo(
472 SIM1_SLOTID, INVALID_VIDEO_STATE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
473 int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
474 EXPECT_EQ(ret, CALL_ERR_INVALID_VIDEO_STATE);
475 }
476 if (HasSimCard(SIM2_SLOTID)) {
477 InitDialInfo(
478 SIM2_SLOTID, INVALID_VIDEO_STATE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
479 int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
480 EXPECT_EQ(ret, CALL_ERR_INVALID_VIDEO_STATE);
481 }
482 }
483
484 /**
485 * @tc.number Telephony_CallManager_DialCall_1700
486 * @tc.name make a normal phone call with telephone numbers is too long
487 * @tc.desc Function test
488 */
489 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1700, Function | MediumTest | Level2)
490 {
491 AccessToken token;
492 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
493 return;
494 }
495 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
496 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
497 std::string phoneNumber =
498 "19119080646435437102938190283912471651865851478647016881846814376871464810514786470168818468143768714648";
499 if (HasSimCard(SIM1_SLOTID)) {
500 InitDialInfo(SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
501 (int32_t)DialType::DIAL_CARRIER_TYPE);
502 int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
503 EXPECT_EQ(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
504 }
505
506 if (HasSimCard(SIM2_SLOTID)) {
507 InitDialInfo(SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
508 (int32_t)DialType::DIAL_CARRIER_TYPE);
509 int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
510 EXPECT_EQ(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
511 }
512 }
513
514 /**
515 * @tc.number Telephony_CallManager_DialCall_1800
516 * @tc.name make a normal phone call with null telephone numbers,
517 * wait for the correct status of the callback to execute correctly
518 * @tc.desc Function test
519 */
520 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1800, Function | MediumTest | Level1)
521 {
522 AccessToken token;
523 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
524 return;
525 }
526 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
527 std::string phoneNumber = "";
528 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
529 if (HasSimCard(SIM1_SLOTID)) {
530 InitDialInfo(
531 SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
532 int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
533 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
534 }
535 if (HasSimCard(SIM2_SLOTID)) {
536 InitDialInfo(
537 SIM2_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, DIAL_SCENE_TEST, (int32_t)DialType::DIAL_CARRIER_TYPE);
538 int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
539 EXPECT_NE(ret, TELEPHONY_ERR_SUCCESS);
540 }
541 }
542
543 /**
544 * @tc.number Telephony_CallManager_DialCall_1900
545 * @tc.name make a normal phone call with card1, TYPE_VOICE, slot id out of count
546 * @tc.desc Function test
547 */
548 HWTEST_F(CallManagerGtest, Telephony_CallManager_DialCall_1900, Function | MediumTest | Level0)
549 {
550 AccessToken token;
551 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
552 return;
553 }
554 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
555 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
556 std::string phoneNumber = PHONE_NUMBER; // OPERATOR PHONY NUMBER
557 int32_t slotId = SIM_SLOT_COUNT; // out of the count
558 InitDialInfo(slotId, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
559 (int32_t)DialType::DIAL_CARRIER_TYPE);
560 int32_t ret = CallManagerGtest::blueToothClientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
561 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
562 }
563
564 /********************************************* Test AnswerCall() ***********************************************/
565 /**
566 * @tc.number Telephony_CallManager_AnswerCall_0100
567 * @tc.name test AnswerCall with the callId does not exist
568 * @tc.desc Function test
569 * @tc.require: I5P2WA
570 */
571 HWTEST_F(CallManagerGtest, Telephony_CallManager_AnswerCall_0100, Function | MediumTest | Level2)
572 {
573 AccessToken token;
574 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
575 return;
576 }
577 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
578 int32_t callId = INVALID_NEGATIVE_ID;
579 int32_t videoState = (int32_t)VideoStateType::TYPE_VOICE;
580 EXPECT_NE(CallManagerGtest::clientPtr_->AnswerCall(callId, videoState), RETURN_VALUE_IS_ZERO);
581 }
582
583 /**
584 * @tc.number Telephony_CallManager_AnswerCall_0200
585 * @tc.name test AnswerCall with the videoState does not exist
586 * @tc.desc Function test
587 * @tc.require: I5P2WA
588 */
589 HWTEST_F(CallManagerGtest, Telephony_CallManager_AnswerCall_0200, Function | MediumTest | Level2)
590 {
591 AccessToken token;
592 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
593 return;
594 }
595 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
596 int32_t callId = INVALID_POSITIVE_ID;
597 int32_t videoState = INVALID_NEGATIVE_ID;
598 EXPECT_NE(CallManagerGtest::clientPtr_->AnswerCall(callId, videoState), RETURN_VALUE_IS_ZERO);
599 }
600
601 /**
602 * @tc.number Telephony_CallManager_AnswerCall_0300
603 * @tc.name test AnswerCall without permission
604 * @tc.desc Function test
605 */
606 HWTEST_F(CallManagerGtest, Telephony_CallManager_AnswerCall_0300, Function | MediumTest | Level2)
607 {
608 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
609 return;
610 }
611 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
612 int32_t callId = INVALID_POSITIVE_ID;
613 int32_t videoState = INVALID_NEGATIVE_ID;
614 EXPECT_NE(CallManagerGtest::clientPtr_->AnswerCall(callId, videoState), RETURN_VALUE_IS_ZERO);
615 }
616
617 /**
618 * @tc.number Telephony_CallManager_AnswerCall_0400
619 * @tc.name test AnswerCall with the callId does not exist
620 * @tc.desc Function test
621 */
622 HWTEST_F(CallManagerGtest, Telephony_CallManager_AnswerCall_0400, Function | MediumTest | Level2)
623 {
624 AccessToken token;
625 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
626 return;
627 }
628 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
629 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
630 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->AnswerCall(), RETURN_VALUE_IS_ZERO);
631 }
632
633 /********************************************* Test RejectCall() ***********************************************/
634 /**
635 * @tc.number Telephony_CallManager_RejectCall_0100
636 * @tc.name test RejectCall with the callId does not exist
637 * @tc.desc Function test
638 */
639 HWTEST_F(CallManagerGtest, Telephony_CallManager_RejectCall_0100, Function | MediumTest | Level2)
640 {
641 AccessToken token;
642 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
643 return;
644 }
645 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
646 int32_t callId = INVALID_NEGATIVE_ID;
647 std::u16string textMessage = Str8ToStr16("this is a test message");
648 EXPECT_NE(CallManagerGtest::clientPtr_->RejectCall(callId, true, textMessage), RETURN_VALUE_IS_ZERO);
649 }
650
651 /**
652 * @tc.number Telephony_CallManager_RejectCall_0200
653 * @tc.name test RejectCall without permission
654 * @tc.desc Function test
655 */
656 HWTEST_F(CallManagerGtest, Telephony_CallManager_RejectCall_0200, Function | MediumTest | Level2)
657 {
658 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
659 return;
660 }
661 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
662 int32_t callId = INVALID_NEGATIVE_ID;
663 std::u16string textMessage = Str8ToStr16("this is a test message");
664 EXPECT_NE(CallManagerGtest::clientPtr_->RejectCall(callId, true, textMessage), RETURN_VALUE_IS_ZERO);
665 }
666
667 /**
668 * @tc.number Telephony_CallManager_RejectCall_0300
669 * @tc.name test RejectCall with the callId does not exist
670 * @tc.desc Function test
671 */
672 HWTEST_F(CallManagerGtest, Telephony_CallManager_RejectCall_0300, Function | MediumTest | Level2)
673 {
674 AccessToken token;
675 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
676 return;
677 }
678 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
679 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
680 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->RejectCall(), RETURN_VALUE_IS_ZERO);
681 }
682
683 /******************************************* Test HangUpCall() *********************************************/
684 /**
685 * @tc.number Telephony_CallManager_HangUpCall_0100
686 * @tc.name test disconnect call with wrong callId
687 * @tc.desc Function test
688 */
689 HWTEST_F(CallManagerGtest, Telephony_CallManager_HangUpCall_0100, Function | MediumTest | Level2)
690 {
691 AccessToken token;
692 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
693 return;
694 }
695 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
696 int32_t callId = INVALID_NEGATIVE_ID;
697 EXPECT_NE(CallManagerGtest::clientPtr_->HangUpCall(callId), RETURN_VALUE_IS_ZERO);
698 }
699
700 /**
701 * @tc.number Telephony_CallManager_HangUpCall_0200 to do ...
702 * @tc.name test ring disconnect call after DialCall,
703 * wait for the correct status of the callback to execute correctly
704 * @tc.desc Function test
705 */
706 HWTEST_F(CallManagerGtest, Telephony_CallManager_HangUpCall_0200, Function | MediumTest | Level2)
707 {
708 AccessToken token;
709 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
710 return;
711 }
712 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
713 InitDialInfo(0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
714 (int32_t)DialType::DIAL_CARRIER_TYPE);
715 int32_t callId = INVALID_NEGATIVE_ID;
716 EXPECT_NE(CallManagerGtest::clientPtr_->HangUpCall(callId), RETURN_VALUE_IS_ZERO);
717 }
718
719 /**
720 * @tc.number Telephony_CallManager_HangUpCall_0300 to do ...
721 * @tc.name test ring disconnect call after DialCall without permission
722 * @tc.desc Function test
723 */
724 HWTEST_F(CallManagerGtest, Telephony_CallManager_HangUpCall_0300, Function | MediumTest | Level2)
725 {
726 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
727 return;
728 }
729 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
730 InitDialInfo(
731 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
732 int32_t callId = INVALID_NEGATIVE_ID;
733 EXPECT_NE(CallManagerGtest::clientPtr_->HangUpCall(callId), RETURN_VALUE_IS_ZERO);
734 }
735
736 /**
737 * @tc.number Telephony_CallManager_HangUpCall_0400 to do ...
738 * @tc.name test ring disconnect call after DialCall
739 * @tc.desc Function test
740 */
741 HWTEST_F(CallManagerGtest, Telephony_CallManager_HangUpCall_0400, Function | MediumTest | Level2)
742 {
743 AccessToken token;
744 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
745 return;
746 }
747 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
748 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
749 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->HangUpCall(), RETURN_VALUE_IS_ZERO);
750 }
751
752 /******************************************* Test GetCallState() *********************************************/
753 /**
754 * @tc.number Telephony_CallManager_GetCallState_0100
755 * @tc.name test GetCallState() without call
756 * @tc.desc Function test
757 */
758 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallState_0100, Function | MediumTest | Level1)
759 {
760 AccessToken token;
761 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
762 return;
763 }
764 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
765 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallState(), (int32_t)CallStateToApp::CALL_STATE_IDLE);
766 }
767
768 /**
769 * @tc.number Telephony_CallManager_GetCallState_0200 to do ...
770 * @tc.name test GetCallState() after call
771 * wait for the correct status of the callback to execute correctly
772 * @tc.desc Function test
773 */
774 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallState_0200, Function | MediumTest | Level1)
775 {
776 AccessToken token;
777 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
778 return;
779 }
780 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
781 InitDialInfo(0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
782 (int32_t)DialType::DIAL_CARRIER_TYPE);
783 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallState(), (int32_t)CallStateToApp::CALL_STATE_IDLE);
784 }
785
786 /**
787 * @tc.number Telephony_CallManager_GetCallState_0300
788 * @tc.name test GetCallState()
789 * @tc.desc Function test
790 */
791 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallState_0300, Function | MediumTest | Level1)
792 {
793 AccessToken token;
794 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
795 return;
796 }
797 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
798 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
799 EXPECT_EQ(CallManagerGtest::blueToothClientPtr_->GetCallState(), TELEPHONY_SUCCESS);
800 }
801
802 /******************************************* Test HoldCall() *********************************************/
803 /**
804 * @tc.number Telephony_CallManager_HoldCall_0100
805 * @tc.name Hold calls for non-existent call ID
806 * @tc.desc Function test
807 */
808 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0100, Function | MediumTest | Level2)
809 {
810 AccessToken token;
811 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
812 return;
813 }
814 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
815 int32_t callId = INVALID_NEGATIVE_ID;
816 EXPECT_NE(CallManagerGtest::clientPtr_->HoldCall(callId), RETURN_VALUE_IS_ZERO);
817 }
818
819 /**
820 * @tc.number Telephony_CallManager_HoldCall_0200 to do ...
821 * @tc.name coming call test hold call, return non 0
822 * wait for the correct status of the callback to execute correctly
823 * @tc.desc Function test
824 */
825 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0200, Function | MediumTest | Level2)
826 {
827 AccessToken token;
828 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
829 return;
830 }
831 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
832 InitDialInfo(0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
833 (int32_t)DialType::DIAL_CARRIER_TYPE);
834 int32_t callId = INVALID_NEGATIVE_ID;
835 EXPECT_NE(CallManagerGtest::clientPtr_->HoldCall(callId), RETURN_VALUE_IS_ZERO);
836 }
837
838 /**
839 * @tc.number Telephony_CallManager_HoldCall_0600 to do ...
840 * @tc.name coming an active call test hold call, return 0
841 * wait for the correct status of the callback to execute correctly
842 * @tc.desc Function test
843 */
844 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0600, Function | MediumTest | Level0)
845 {
846 AccessToken token;
847 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
848 return;
849 }
850 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
851 InitDialInfo(0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
852 (int32_t)DialType::DIAL_CARRIER_TYPE);
853 int32_t callId = INVALID_NEGATIVE_ID;
854 EXPECT_NE(CallManagerGtest::clientPtr_->HoldCall(callId), RETURN_VALUE_IS_ZERO);
855 }
856
857 /**
858 * @tc.number Telephony_CallManager_HoldCall_0300 to do ...
859 * @tc.name coming call test hold call without permission
860 * @tc.desc Function test
861 */
862 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0300, Function | MediumTest | Level2)
863 {
864 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
865 return;
866 }
867 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
868 InitDialInfo(
869 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
870 int32_t callId = INVALID_NEGATIVE_ID;
871 EXPECT_NE(CallManagerGtest::clientPtr_->HoldCall(callId), RETURN_VALUE_IS_ZERO);
872 }
873
874 /**
875 * @tc.number Telephony_CallManager_HoldCall_0400
876 * @tc.name Hold calls for non-existent call ID
877 * @tc.desc Function test
878 */
879 HWTEST_F(CallManagerGtest, Telephony_CallManager_HoldCall_0400, Function | MediumTest | Level2)
880 {
881 AccessToken token;
882 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
883 return;
884 }
885 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
886 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
887 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->HoldCall(), RETURN_VALUE_IS_ZERO);
888 }
889
890 /******************************************* Test UnHoldCall() *********************************************/
891 /**
892 * @tc.number Telephony_CallManager_UnHoldCall_0100
893 * @tc.name Replies calls to a call ID that does not exist, return non 0
894 * @tc.desc Function test
895 */
896 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnHoldCall_0100, Function | MediumTest | Level2)
897 {
898 AccessToken token;
899 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
900 return;
901 }
902 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
903 int32_t callId = INVALID_NEGATIVE_ID;
904 EXPECT_NE(CallManagerGtest::clientPtr_->UnHoldCall(callId), RETURN_VALUE_IS_ZERO);
905 }
906
907 /**
908 * @tc.number Telephony_CallManager_UnHoldCall_0200 to do ...
909 * @tc.name Passing in the suspended call ID, test UnHoldCall() return non 0
910 * wait for the correct status of the callback to execute correctly
911 * @tc.desc Function test
912 */
913 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnHoldCall_0200, Function | MediumTest | Level2)
914 {
915 AccessToken token;
916 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
917 return;
918 }
919 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
920 InitDialInfo(0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
921 (int32_t)DialType::DIAL_CARRIER_TYPE);
922 int32_t callId = INVALID_NEGATIVE_ID;
923 EXPECT_NE(CallManagerGtest::clientPtr_->UnHoldCall(callId), RETURN_VALUE_IS_ZERO);
924 }
925
926 /**
927 * @tc.number Telephony_CallManager_UnHoldCall_0600 to do ...
928 * @tc.name coming a active call , holding the call ,and test unhold call , return 0
929 * wait for the correct status of the callback to execute correctly
930 * @tc.desc Function test
931 */
932 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnHoldCall_0600, Function | MediumTest | Level0)
933 {
934 AccessToken token;
935 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
936 return;
937 }
938 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
939 InitDialInfo(0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
940 (int32_t)DialType::DIAL_CARRIER_TYPE);
941 int32_t callId = INVALID_NEGATIVE_ID;
942 EXPECT_NE(CallManagerGtest::clientPtr_->UnHoldCall(callId), RETURN_VALUE_IS_ZERO);
943 }
944
945 /**
946 * @tc.number Telephony_CallManager_UnHoldCall_0300
947 * @tc.name Replies calls to a call ID that does not exist without permission
948 * @tc.desc Function test
949 */
950 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnHoldCall_0300, Function | MediumTest | Level2)
951 {
952 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
953 return;
954 }
955 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
956 int32_t callId = INVALID_NEGATIVE_ID;
957 EXPECT_NE(CallManagerGtest::clientPtr_->UnHoldCall(callId), RETURN_VALUE_IS_ZERO);
958 }
959
960 /**
961 * @tc.number Telephony_CallManager_UnHoldCall_0400
962 * @tc.name Replies calls to a call ID that does not exist, return non 0
963 * @tc.desc Function test
964 */
965 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnHoldCall_0400, Function | MediumTest | Level2)
966 {
967 AccessToken token;
968 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
969 return;
970 }
971 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
972 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
973 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->UnHoldCall(), RETURN_VALUE_IS_ZERO);
974 }
975
976 /******************************************* Test SwitchCall() *********************************************/
977 /**
978 * @tc.number Telephony_CallManager_SwitchCall_0100
979 * @tc.name Test returns 0 after switching call
980 * @tc.desc Function test
981 */
982 HWTEST_F(CallManagerGtest, Telephony_CallManager_SwitchCall_0100, Function | MediumTest | Level2)
983 {
984 AccessToken token;
985 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
986 return;
987 }
988 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
989 int32_t callId = INVALID_NEGATIVE_ID;
990 EXPECT_NE(CallManagerGtest::clientPtr_->SwitchCall(callId), RETURN_VALUE_IS_ZERO);
991 }
992
993 /**
994 * @tc.number Telephony_CallManager_SwitchCall_0200
995 * @tc.name Test returns 0 after switching call without permission
996 * @tc.desc Function test
997 */
998 HWTEST_F(CallManagerGtest, Telephony_CallManager_SwitchCall_0200, Function | MediumTest | Level2)
999 {
1000 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1001 return;
1002 }
1003 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
1004 int32_t callId = INVALID_NEGATIVE_ID;
1005 EXPECT_NE(CallManagerGtest::clientPtr_->SwitchCall(callId), RETURN_VALUE_IS_ZERO);
1006 }
1007
1008 /**
1009 * @tc.number Telephony_CallManager_SwitchCall_0300
1010 * @tc.name Test returns 0 after switching call
1011 * @tc.desc Function test
1012 */
1013 HWTEST_F(CallManagerGtest, Telephony_CallManager_SwitchCall_0300, Function | MediumTest | Level2)
1014 {
1015 AccessToken token;
1016 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1017 return;
1018 }
1019 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
1020 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
1021 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->SwitchCall(), RETURN_VALUE_IS_ZERO);
1022 }
1023
1024 /**
1025 * @tc.number Telephony_CallManager_SwitchCall_0400
1026 * @tc.name Test returns 0 after switching call, and DialCall(), return true
1027 * wait for the correct status of the callback to execute correctly
1028 * @tc.desc Function test
1029 */
1030 HWTEST_F(CallManagerGtest, Telephony_CallManager_SwitchCall_0400, Function | MediumTest | Level2)
1031 {
1032 AccessToken token;
1033 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1034 return;
1035 }
1036
1037 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
1038 std::string phoneNumber = "00000000000";
1039 int32_t callId = INVALID_NEGATIVE_ID;
1040 InitDialInfo(
1041 0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL, (int32_t)DialType::DIAL_CARRIER_TYPE);
1042 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
1043 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
1044 EXPECT_NE(CallManagerGtest::clientPtr_->SwitchCall(callId), RETURN_VALUE_IS_ZERO);
1045 }
1046
1047 /********************************************* Test HasCall() ***********************************************/
1048 /**
1049 * @tc.number Telephony_CallManager_HasCall_0100
1050 * @tc.name in CALL_STATE_IDLE status, than test Hascall(), return false
1051 * @tc.desc Function test
1052 */
1053 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasCall_0100, Function | MediumTest | Level1)
1054 {
1055 AccessToken token;
1056 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1057 return;
1058 }
1059 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
1060 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
1061 int32_t idleState = (int32_t)CallStateToApp::CALL_STATE_IDLE;
1062 ASSERT_EQ(callState, idleState);
1063 EXPECT_EQ(CallManagerGtest::clientPtr_->HasCall(), false);
1064 }
1065
1066 /**
1067 * @tc.number Telephony_CallManager_HasCall_0200 to do ...
1068 * @tc.name The wrong number is not on call, return false
1069 * @tc.desc Function test
1070 */
1071 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasCall_0200, Function | MediumTest | Level1)
1072 {
1073 AccessToken token;
1074 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1075 return;
1076 }
1077 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
1078 std::string phoneNumber = "";
1079 InitDialInfo(0, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
1080 (int32_t)DialType::DIAL_CARRIER_TYPE);
1081 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
1082 EXPECT_NE(ret, RETURN_VALUE_IS_ZERO);
1083 bool isRet = CallManagerGtest::clientPtr_->HasCall();
1084 EXPECT_NE(isRet, true);
1085 }
1086
1087 /**
1088 * @tc.number Telephony_CallManager_HasCall_0300 to do ...
1089 * @tc.name Free time test Hascall(), return false
1090 * @tc.desc Function test
1091 */
1092 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasCall_0300, Function | MediumTest | Level1)
1093 {
1094 AccessToken token;
1095 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1096 return;
1097 }
1098 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
1099 bool isRet = CallManagerGtest::clientPtr_->HasCall();
1100 EXPECT_NE(isRet, true);
1101 }
1102
1103 /**
1104 * @tc.number Telephony_CallManager_HasCall_0400
1105 * @tc.name in CALL_STATE_IDLE status, than test Hascall(), return false
1106 * @tc.desc Function test
1107 */
1108 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasCall_0400, Function | MediumTest | Level2)
1109 {
1110 AccessToken token;
1111 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1112 return;
1113 }
1114 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
1115 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
1116 int32_t idleState = (int32_t)CallStateToApp::CALL_STATE_IDLE;
1117 ASSERT_EQ(callState, idleState);
1118 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
1119 EXPECT_EQ(CallManagerGtest::blueToothClientPtr_->HasCall(), false);
1120 }
1121
1122 /********************************* Test IsNewCallAllowed() ***************************************/
1123 /**
1124 * @tc.number Telephony_CallManager_IsNewCallAllowed_0100
1125 * @tc.name The call failed after making a call without the card
1126 * @tc.desc Function test
1127 */
1128 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsNewCallAllowed_0100, Function | MediumTest | Level1)
1129 {
1130 AccessToken token;
1131 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1132 return;
1133 }
1134 std::string phoneNumber = "00000000000";
1135 InitDialInfo(SIM1_SLOTID, (int32_t)VideoStateType::TYPE_VOICE, (int32_t)DialScene::CALL_NORMAL,
1136 (int32_t)DialType::DIAL_CARRIER_TYPE);
1137 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
1138 ASSERT_EQ(ret, RETURN_VALUE_IS_ZERO);
1139 CallInfoManager::LockCallState(false, (int32_t)TelCallState::CALL_STATUS_ACTIVE, SLEEP_50_MS, SLEEP_12000_MS);
1140 bool enabled = false;
1141 EXPECT_EQ(CallManagerGtest::clientPtr_->IsNewCallAllowed(enabled), TELEPHONY_SUCCESS);
1142 EXPECT_EQ(enabled, true);
1143 }
1144
1145 /**
1146 * @tc.number Telephony_CallManager_IsNewCallAllowed_0200
1147 * @tc.name The call failed after making a call without the card
1148 * @tc.desc Function test
1149 */
1150 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsNewCallAllowed_0200, Function | MediumTest | Level1)
1151 {
1152 AccessToken token;
1153 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1154 return;
1155 }
1156 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
1157 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
1158 bool enabled = false;
1159 EXPECT_EQ(CallManagerGtest::blueToothClientPtr_->IsNewCallAllowed(enabled), TELEPHONY_SUCCESS);
1160 EXPECT_EQ(enabled, true);
1161 }
1162
1163 /********************************************* Test IsRinging() ***********************************************/
1164 /**
1165 * @tc.number Telephony_CallManager_IsRinging_0100
1166 * @tc.name There is no call, return true
1167 * @tc.desc Function test
1168 */
1169 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsRinging_0100, Function | MediumTest | Level1)
1170 {
1171 AccessToken token;
1172 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1173 return;
1174 }
1175 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
1176 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
1177 int32_t idleState = (int32_t)CallStateToApp::CALL_STATE_IDLE;
1178 ASSERT_EQ(callState, idleState);
1179 bool enabled = false;
1180 EXPECT_EQ(CallManagerGtest::clientPtr_->IsRinging(enabled), TELEPHONY_SUCCESS);
1181 EXPECT_NE(enabled, true);
1182 }
1183
1184 /**
1185 * @tc.number Telephony_CallManager_IsRinging_0200
1186 * @tc.name There is no call, return true
1187 * @tc.desc Function test
1188 */
1189 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsRinging_0200, Function | MediumTest | Level1)
1190 {
1191 AccessToken token;
1192 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1193 return;
1194 }
1195 CallInfoManager::LockCallState(false, (int32_t)CallStateToApp::CALL_STATE_IDLE, SLEEP_200_MS, SLEEP_30000_MS);
1196 int32_t callState = CallManagerGtest::clientPtr_->GetCallState();
1197 int32_t idleState = (int32_t)CallStateToApp::CALL_STATE_IDLE;
1198 ASSERT_EQ(callState, idleState);
1199 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
1200 bool enabled = false;
1201 EXPECT_EQ(CallManagerGtest::blueToothClientPtr_->IsRinging(enabled), TELEPHONY_SUCCESS);
1202 EXPECT_NE(enabled, true);
1203 }
1204
1205 /***************************************** Test CombineConference() ********************************************/
1206 /**
1207 * @tc.number Telephony_CallManager_CombineConference_0100
1208 * @tc.name Import callId "@&%￥", test CombineConference(), return non 0
1209 * @tc.desc Function test
1210 */
1211 HWTEST_F(CallManagerGtest, Telephony_CallManager_CombineConference_0100, Function | MediumTest | Level2)
1212 {
1213 AccessToken token;
1214 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1215 return;
1216 }
1217 int32_t callId = INVALID_NEGATIVE_ID;
1218 EXPECT_NE(CallManagerGtest::clientPtr_->CombineConference(callId), RETURN_VALUE_IS_ZERO);
1219 }
1220
1221 /**
1222 * @tc.number Telephony_CallManager_CombineConference_0200
1223 * @tc.name Import callId "100", test CombineConference(), return non 0
1224 * @tc.desc Function test
1225 */
1226 HWTEST_F(CallManagerGtest, Telephony_CallManager_CombineConference_0200, Function | MediumTest | Level2)
1227 {
1228 AccessToken token;
1229 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1230 return;
1231 }
1232 int32_t callId = INVALID_POSITIVE_ID;
1233 EXPECT_NE(CallManagerGtest::clientPtr_->CombineConference(callId), RETURN_VALUE_IS_ZERO);
1234 }
1235
1236 /**
1237 * @tc.number Telephony_CallManager_CombineConference_0300
1238 * @tc.name Import callId "@&%￥", test CombineConference(), return non 0
1239 * @tc.desc Function test
1240 */
1241 HWTEST_F(CallManagerGtest, Telephony_CallManager_CombineConference_0300, Function | MediumTest | Level2)
1242 {
1243 AccessToken token;
1244 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1245 return;
1246 }
1247 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
1248 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->CombineConference(), RETURN_VALUE_IS_ZERO);
1249 }
1250
1251 /***************************************** Test SeparateConference() ********************************************/
1252 /**
1253 * @tc.number Telephony_CallManager_SeparateConference_0100
1254 * @tc.name Import callId " -100", test SeparateConference(), return non 0
1255 * @tc.desc Function test
1256 */
1257 HWTEST_F(CallManagerGtest, Telephony_CallManager_SeparateConference_0100, Function | MediumTest | Level2)
1258 {
1259 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1260 return;
1261 }
1262 int32_t callId = INVALID_NEGATIVE_ID;
1263 EXPECT_NE(CallManagerGtest::clientPtr_->SeparateConference(callId), RETURN_VALUE_IS_ZERO);
1264 }
1265
1266 /**
1267 * @tc.number Telephony_CallManager_SeparateConference_0200
1268 * @tc.name Import callId "100", test SeparateConference(), return non 0
1269 * @tc.desc Function test
1270 */
1271 HWTEST_F(CallManagerGtest, Telephony_CallManager_SeparateConference_0200, Function | MediumTest | Level2)
1272 {
1273 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1274 return;
1275 }
1276 int32_t callId = INVALID_POSITIVE_ID;
1277 EXPECT_NE(CallManagerGtest::clientPtr_->SeparateConference(callId), RETURN_VALUE_IS_ZERO);
1278 }
1279
1280 /**
1281 * @tc.number Telephony_CallManager_SeparateConference_0300
1282 * @tc.name Import callId " -100", test SeparateConference(), return non 0
1283 * @tc.desc Function test
1284 */
1285 HWTEST_F(CallManagerGtest, Telephony_CallManager_SeparateConference_0300, Function | MediumTest | Level2)
1286 {
1287 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1288 return;
1289 }
1290 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
1291 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->SeparateConference(), RETURN_VALUE_IS_ZERO);
1292 }
1293
1294 /********************************************* Test GetMainCallId() ***********************************************/
1295 /**
1296 * @tc.number Telephony_CallManager_GetMainCallId_0100
1297 * @tc.name Import callId "abcd", test GetMainCallId(), return non 0
1298 * @tc.desc Function test
1299 */
1300 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetMainCallId_0100, Function | MediumTest | Level3)
1301 {
1302 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1303 return;
1304 }
1305 int32_t callId = INVALID_NEGATIVE_ID;
1306 int32_t mainCallId = INVALID_NEGATIVE_ID;
1307 EXPECT_NE(CallManagerGtest::clientPtr_->GetMainCallId(callId, mainCallId), TELEPHONY_ERR_SUCCESS);
1308 EXPECT_NE(mainCallId, RETURN_VALUE_IS_ZERO);
1309 }
1310
1311 /**
1312 * @tc.number Telephony_CallManager_GetMainCallId_0200
1313 * @tc.name Import callId "100", test GetMainCallId(), return non 0
1314 * @tc.desc Function test
1315 */
1316 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetMainCallId_0200, Function | MediumTest | Level3)
1317 {
1318 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1319 return;
1320 }
1321 int32_t callId = INVALID_POSITIVE_ID;
1322 int32_t mainCallId = INVALID_NEGATIVE_ID;
1323 EXPECT_NE(CallManagerGtest::clientPtr_->GetMainCallId(callId, mainCallId), TELEPHONY_ERR_SUCCESS);
1324 EXPECT_NE(mainCallId, RETURN_VALUE_IS_ZERO);
1325 }
1326
1327 /***************************************** Test GetSubCallIdList() ******************************************/
1328
1329 /**
1330 * @tc.number Telephony_CallManager_GetSubCallIdList_0100
1331 * @tc.name Import callId "abcd", test GetSubCallIdList(), return non 0
1332 * @tc.desc Function test
1333 */
1334 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetSubCallIdList_0100, Function | MediumTest | Level3)
1335 {
1336 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1337 return;
1338 }
1339 int32_t callId = INVALID_NEGATIVE_ID;
1340 std::vector<std::u16string> ans;
1341 ans.clear();
1342 int32_t result = CallManagerGtest::clientPtr_->GetSubCallIdList(callId, ans);
1343 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
1344 bool isEmpty = ans.empty();
1345 EXPECT_EQ(isEmpty, true);
1346 if (!ans.empty()) {
1347 ans.clear();
1348 }
1349 }
1350
1351 /**
1352 * @tc.number Telephony_CallManager_GetSubCallIdList_0200
1353 * @tc.name Import callId "100", test GetSubCallIdList(), return non 0
1354 * @tc.desc Function test
1355 */
1356 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetSubCallIdList_0200, Function | MediumTest | Level3)
1357 {
1358 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1359 return;
1360 }
1361 int32_t callId = INVALID_POSITIVE_ID;
1362 std::vector<std::u16string> ans;
1363 ans.clear();
1364 int32_t result = CallManagerGtest::clientPtr_->GetSubCallIdList(callId, ans);
1365 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
1366 bool isEmpty = ans.empty();
1367 EXPECT_EQ(isEmpty, true);
1368 if (!ans.empty()) {
1369 ans.clear();
1370 }
1371 }
1372
1373 /************************************ Test GetCallIdListForConference() ***************************************/
1374
1375 /**
1376 * @tc.number Telephony_CallManager_GetCallIdListForConference_0100
1377 * @tc.name Import callId "abcd", test GetCallIdListForConference(), return non 0
1378 * @tc.desc Function test
1379 */
1380 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallIdListForConference_0100, Function | MediumTest | Level3)
1381 {
1382 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1383 return;
1384 }
1385 int32_t callId = INVALID_NEGATIVE_ID;
1386 std::vector<std::u16string> ans;
1387 ans.clear();
1388 int32_t result = CallManagerGtest::clientPtr_->GetCallIdListForConference(callId, ans);
1389 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
1390 bool isEmpty = ans.empty();
1391 EXPECT_EQ(isEmpty, true);
1392 if (!ans.empty()) {
1393 ans.clear();
1394 }
1395 }
1396
1397 /**
1398 * @tc.number Telephony_CallManager_GetCallIdListForConference_0200
1399 * @tc.name Import callId "100", test GetCallIdListForConference(), return non 0
1400 * @tc.desc Function test
1401 */
1402 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallIdListForConference_0200, Function | MediumTest | Level3)
1403 {
1404 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1405 return;
1406 }
1407 int32_t callId = INVALID_POSITIVE_ID;
1408 std::vector<std::u16string> ans;
1409 ans.clear();
1410 int32_t result = CallManagerGtest::clientPtr_->GetCallIdListForConference(callId, ans);
1411 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
1412 bool isEmpty = ans.empty();
1413 EXPECT_EQ(isEmpty, true);
1414 if (!ans.empty()) {
1415 ans.clear();
1416 }
1417 }
1418 /************************************* Test IsEmergencyPhoneNumber() ***************************************/
1419 /**
1420 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0100
1421 * @tc.name Call one phonynumber "0-0-0", test IsEmergencyPhoneNumber(), return false
1422 * @tc.desc Function test
1423 */
1424 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0100, Function | MediumTest | Level3)
1425 {
1426 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1427 return;
1428 }
1429 std::string number = "0-0-0";
1430 std::u16string phoneNumber = Str8ToStr16(number);
1431 if (HasSimCard(SIM1_SLOTID)) {
1432 bool enabled = false;
1433 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
1434 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
1435 EXPECT_NE(enabled, true);
1436 }
1437 if (HasSimCard(SIM2_SLOTID)) {
1438 bool enabled = false;
1439 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
1440 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
1441 EXPECT_NE(enabled, true);
1442 }
1443 }
1444
1445 /**
1446 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0200
1447 * @tc.name Call one phonynumber "112", test IsEmergencyPhoneNumber(), return true
1448 * @tc.desc Function test
1449 * @tc.require: I5O1OQ
1450 */
1451 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0200, Function | MediumTest | Level2)
1452 {
1453 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1454 return;
1455 }
1456 std::string number = "112";
1457 std::u16string phoneNumber = Str8ToStr16(number);
1458 if (HasSimCard(SIM1_SLOTID)) {
1459 bool enabled = false;
1460 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
1461 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
1462 EXPECT_EQ(enabled, true);
1463 }
1464 if (HasSimCard(SIM2_SLOTID)) {
1465 bool enabled = false;
1466 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
1467 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
1468 EXPECT_EQ(enabled, true);
1469 }
1470 }
1471
1472 /**
1473 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0300
1474 * @tc.name Call one phonynumber "911", test IsEmergencyPhoneNumber(), return true
1475 * @tc.desc Function test
1476 */
1477 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0300, Function | MediumTest | Level2)
1478 {
1479 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1480 return;
1481 }
1482 std::string number = "911";
1483 std::u16string phoneNumber = Str8ToStr16(number);
1484 if (HasSimCard(SIM1_SLOTID)) {
1485 bool enabled = false;
1486 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
1487 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
1488 EXPECT_EQ(enabled, true);
1489 }
1490 if (HasSimCard(SIM2_SLOTID)) {
1491 bool enabled = false;
1492 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
1493 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
1494 EXPECT_EQ(enabled, true);
1495 }
1496 }
1497
1498 /**
1499 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0400
1500 * @tc.name Call one phonynumber "08", test IsEmergencyPhoneNumber(), return true
1501 * @tc.desc Function test
1502 */
1503 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0400, Function | MediumTest | Level3)
1504 {
1505 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1506 return;
1507 }
1508 int32_t slotId = SIM1_SLOTID_NO_CARD;
1509 std::string number = "08";
1510 std::u16string phoneNumber = Str8ToStr16(number);
1511 bool enabled = false;
1512 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
1513 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
1514 EXPECT_EQ(enabled, true);
1515 }
1516
1517 /**
1518 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0500
1519 * @tc.name Call one phonynumber "118", test IsEmergencyPhoneNumber(), return false
1520 * @tc.desc Function test
1521 */
1522 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0500, Function | MediumTest | Level2)
1523 {
1524 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1525 return;
1526 }
1527 int32_t slotId = SIM1_SLOTID_NO_CARD;
1528 std::string number = "118";
1529 std::u16string phoneNumber = Str8ToStr16(number);
1530 bool enabled = false;
1531 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
1532 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
1533 EXPECT_EQ(enabled, true);
1534 }
1535
1536 /**
1537 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0600
1538 * @tc.name Call one phonynumber "119", test IsEmergencyPhoneNumber(), return true
1539 * @tc.desc Function test
1540 */
1541 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0600, Function | MediumTest | Level2)
1542 {
1543 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1544 return;
1545 }
1546 std::string number = "119";
1547 std::u16string phoneNumber = Str8ToStr16(number);
1548 if (HasSimCard(SIM1_SLOTID)) {
1549 bool enabled = false;
1550 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM1_SLOTID, enabled);
1551 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
1552 EXPECT_EQ(enabled, true);
1553 }
1554 if (HasSimCard(SIM2_SLOTID)) {
1555 bool enabled = false;
1556 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, SIM2_SLOTID, enabled);
1557 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
1558 EXPECT_EQ(enabled, true);
1559 }
1560 }
1561
1562 /**
1563 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0700
1564 * @tc.name Call one phonynumber "999", test IsEmergencyPhoneNumber(), return true
1565 * @tc.desc Function test
1566 */
1567 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0700, Function | MediumTest | Level2)
1568 {
1569 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1570 return;
1571 }
1572 int32_t slotId = SIM1_SLOTID_NO_CARD;
1573 std::string number = "999";
1574 std::u16string phoneNumber = Str8ToStr16(number);
1575 bool enabled = false;
1576 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
1577 EXPECT_EQ(result, TELEPHONY_ERR_SUCCESS);
1578 EXPECT_EQ(enabled, true);
1579 }
1580
1581 /**
1582 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0800
1583 * @tc.name Call one phonynumber "", test IsEmergencyPhoneNumber(), return false
1584 * @tc.desc Function test
1585 */
1586 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0800, Function | MediumTest | Level2)
1587 {
1588 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1589 return;
1590 }
1591 int32_t slotId = SIM1_SLOTID_NO_CARD;
1592 std::string number = "";
1593 std::u16string phoneNumber = Str8ToStr16(number);
1594 bool enabled = false;
1595 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
1596 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
1597 EXPECT_NE(enabled, true);
1598 }
1599
1600 /**
1601 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_0900
1602 * @tc.name Call one phonynumber "", test IsEmergencyPhoneNumber(), return false
1603 * @tc.desc Function test
1604 */
1605 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_0900, Function | MediumTest | Level2)
1606 {
1607 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1608 return;
1609 }
1610 int32_t slotId = SIM1_SLOTID_NO_CARD;
1611 std::string number = "@123";
1612 std::u16string phoneNumber = Str8ToStr16(number);
1613 bool enabled = false;
1614 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
1615 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
1616 EXPECT_NE(enabled, true);
1617 }
1618
1619 /**
1620 * @tc.number Telephony_CallManager_IsEmergencyPhoneNumber_1000
1621 * @tc.name Call one phonynumber "", test IsEmergencyPhoneNumber(), return false
1622 * @tc.desc Function test
1623 */
1624 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsEmergencyPhoneNumber_1000, Function | MediumTest | Level2)
1625 {
1626 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1627 return;
1628 }
1629 int32_t slotId = SIM1_SLOTID_NO_CARD;
1630 std::string number = "+1+1+9";
1631 std::u16string phoneNumber = Str8ToStr16(number);
1632 bool enabled = false;
1633 int32_t result = CallManagerGtest::clientPtr_->IsEmergencyPhoneNumber(phoneNumber, slotId, enabled);
1634 EXPECT_NE(result, TELEPHONY_ERR_SUCCESS);
1635 EXPECT_NE(enabled, true);
1636 }
1637
1638 /********************************************* Test GetCallWaiting() ***********************************************/
1639
1640 /**
1641 * @tc.number Telephony_CallManager_GetCallWaiting_0100
1642 * @tc.name Import slotId 1, test GetCallWaiting(), return 0
1643 * @tc.desc Function test
1644 */
1645 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallWaiting_0100, Function | MediumTest | Level3)
1646 {
1647 AccessToken token;
1648 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1649 return;
1650 }
1651
1652 if (HasSimCard(SIM1_SLOTID)) {
1653 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallWaiting(SIM1_SLOTID), RETURN_VALUE_IS_ZERO);
1654 }
1655 if (HasSimCard(SIM2_SLOTID)) {
1656 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallWaiting(SIM2_SLOTID), RETURN_VALUE_IS_ZERO);
1657 }
1658 }
1659
1660 /**
1661 * @tc.number Telephony_CallManager_GetCallWaiting_0200
1662 * @tc.name test GetCallWaiting without permission
1663 * @tc.desc Function test
1664 */
1665 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallWaiting_0200, Function | MediumTest | Level3)
1666 {
1667 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1668 return;
1669 }
1670
1671 if (HasSimCard(SIM1_SLOTID)) {
1672 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallWaiting(SIM1_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
1673 }
1674 if (HasSimCard(SIM2_SLOTID)) {
1675 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallWaiting(SIM2_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
1676 }
1677 }
1678
1679 /********************************************* Test StartDtmf() ***********************************************/
1680
1681 /**
1682 * @tc.number Telephony_CallManager_StartDtmf_0100
1683 * @tc.name Import callId abcd, test StartDtmf(), return non 0
1684 * @tc.desc Function test
1685 */
1686 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0100, Function | MediumTest | Level2)
1687 {
1688 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1689 return;
1690 }
1691 int32_t callId = INVALID_NEGATIVE_ID;
1692 char str = '1';
1693 EXPECT_NE(CallManagerGtest::clientPtr_->StartDtmf(callId, str), RETURN_VALUE_IS_ZERO);
1694 }
1695
1696 /**
1697 * @tc.number Telephony_CallManager_StartDtmf_0200
1698 * @tc.name Import callId 100, test StartDtmf(), return non 0
1699 * @tc.desc Function test
1700 */
1701 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0200, Function | MediumTest | Level2)
1702 {
1703 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1704 return;
1705 }
1706 int32_t callId = INVALID_POSITIVE_ID;
1707 char str = '1';
1708 EXPECT_NE(CallManagerGtest::clientPtr_->StartDtmf(callId, str), RETURN_VALUE_IS_ZERO);
1709 }
1710
1711 /**
1712 * @tc.number Telephony_CallManager_StartDtmf_0300
1713 * @tc.name Import callId 100, test StartDtmf(), return non 0
1714 * @tc.desc Function test
1715 */
1716 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartDtmf_0300, Function | MediumTest | Level2)
1717 {
1718 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1719 return;
1720 }
1721
1722 char str = '1';
1723 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
1724 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->StartDtmf(str), RETURN_VALUE_IS_ZERO);
1725 }
1726
1727 /********************************************* Test StopDtmf() ***********************************************/
1728
1729 /**
1730 * @tc.number Telephony_CallManager_StopDtmf_0100
1731 * @tc.name Import callId abcd, test StopDtmf(), return non 0
1732 * @tc.desc Function test
1733 */
1734 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0100, Function | MediumTest | Level2)
1735 {
1736 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1737 return;
1738 }
1739 int32_t callId = INVALID_NEGATIVE_ID;
1740 EXPECT_NE(CallManagerGtest::clientPtr_->StopDtmf(callId), RETURN_VALUE_IS_ZERO);
1741 }
1742
1743 /**
1744 * @tc.number Telephony_CallManager_StopDtmf_0200
1745 * @tc.name Import callId 100, test StopDtmf(), return non 0
1746 * @tc.desc Function test
1747 */
1748 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0200, Function | MediumTest | Level2)
1749 {
1750 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1751 return;
1752 }
1753 int32_t callId = INVALID_POSITIVE_ID;
1754 EXPECT_NE(CallManagerGtest::clientPtr_->StopDtmf(callId), RETURN_VALUE_IS_ZERO);
1755 }
1756
1757 /**
1758 * @tc.number Telephony_CallManager_StopDtmf_0300
1759 * @tc.name Import callId, test StopDtmf(), return non 0
1760 * @tc.desc Function test
1761 */
1762 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopDtmf_0300, Function | MediumTest | Level2)
1763 {
1764 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1765 return;
1766 }
1767 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
1768 EXPECT_NE(CallManagerGtest::blueToothClientPtr_->StopDtmf(), RETURN_VALUE_IS_ZERO);
1769 }
1770
1771 /******************************** Test FormatPhoneNumber() * **************************************/
1772
1773 /**
1774 * @tc.number Telephony_CallManager_FormatPhoneNumber_0100
1775 * @tc.name Import phonyNumber 01085198748, test FormatPhoneNumber(), return 010-8519-8748
1776 * @tc.desc Function test
1777 */
1778 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0100, Function | MediumTest | Level3)
1779 {
1780 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1781 return;
1782 }
1783 std::string number = "01085198748";
1784 std::string Code = "Kr";
1785 std::string formatBefore = "";
1786 std::u16string phonyNumber = Str8ToStr16(number);
1787 std::u16string countryCode = Str8ToStr16(Code);
1788 std::u16string formatNumber = Str8ToStr16(formatBefore);
1789 EXPECT_EQ(
1790 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
1791 }
1792
1793 /**
1794 * @tc.number Telephony_CallManager_FormatPhoneNumber_0200
1795 * @tc.name Import countryCode KR, test FormatPhoneNumber(), return 010-8519-8748
1796 * @tc.desc Function test
1797 */
1798 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0200, Function | MediumTest | Level3)
1799 {
1800 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1801 return;
1802 }
1803 std::string number = "010-8519-8748";
1804 std::string Code = "KR";
1805 std::string formatBefore = "";
1806 std::u16string phonyNumber = Str8ToStr16(number);
1807 std::u16string countryCode = Str8ToStr16(Code);
1808 std::u16string formatNumber = Str8ToStr16(formatBefore);
1809 EXPECT_NE(
1810 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
1811 }
1812
1813 /**
1814 * @tc.number Telephony_CallManager_FormatPhoneNumber_0300
1815 * @tc.name Import phonyNumber (03)38122111, test FormatPhoneNumber(), return 03-3812-2111
1816 * @tc.desc Function test
1817 */
1818 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0300, Function | MediumTest | Level3)
1819 {
1820 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1821 return;
1822 }
1823 std::string number = "(03)38122111";
1824 std::string Code = "JP";
1825 std::string formatBefore = "";
1826 std::u16string phonyNumber = Str8ToStr16(number);
1827 std::u16string countryCode = Str8ToStr16(Code);
1828 std::u16string formatNumber = Str8ToStr16(formatBefore);
1829 EXPECT_EQ(
1830 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
1831 }
1832
1833 /**
1834 * @tc.number Telephony_CallManager_FormatPhoneNumber_0400
1835 * @tc.name Import phonyNumber 13888888888, test FormatPhoneNumber(), return 138 8888 8888
1836 * @tc.desc Function test
1837 */
1838 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0400, Function | MediumTest | Level3)
1839 {
1840 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1841 return;
1842 }
1843 std::string number = "13888888888";
1844 std::string Code = "CN";
1845 std::string formatBefore = "";
1846 std::u16string phonyNumber = Str8ToStr16(number);
1847 std::u16string countryCode = Str8ToStr16(Code);
1848 std::u16string formatNumber = Str8ToStr16(formatBefore);
1849 EXPECT_EQ(
1850 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
1851 }
1852
1853 /**
1854 * @tc.number Telephony_CallManager_FormatPhoneNumber_0500
1855 * @tc.name Import phonyNumber +81338122111, test FormatPhoneNumber(), return 03-3812-2111
1856 * @tc.desc Function test
1857 */
1858 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0500, Function | MediumTest | Level3)
1859 {
1860 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1861 return;
1862 }
1863 std::string number = "+81338122111";
1864 std::string Code = "jp";
1865 std::string formatBefore = "";
1866 std::u16string phonyNumber = Str8ToStr16(number);
1867 std::u16string countryCode = Str8ToStr16(Code);
1868 std::u16string formatNumber = Str8ToStr16(formatBefore);
1869 EXPECT_EQ(
1870 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
1871 }
1872
1873 /**
1874 * @tc.number Telephony_CallManager_FormatPhoneNumber_0600
1875 * @tc.name Import phonyNumber 666666999999, test FormatPhoneNumber(), return 666666999999
1876 * @tc.desc Function test
1877 */
1878 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0600, Function | MediumTest | Level3)
1879 {
1880 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1881 return;
1882 }
1883 std::string number = "666666999999";
1884 std::string Code = "CN";
1885 std::string formatBefore = "";
1886 std::u16string phonyNumber = Str8ToStr16(number);
1887 std::u16string countryCode = Str8ToStr16(Code);
1888 std::u16string formatNumber = Str8ToStr16(formatBefore);
1889 EXPECT_NE(
1890 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
1891 }
1892
1893 /**
1894 * @tc.number Telephony_CallManager_FormatPhoneNumber_0700
1895 * @tc.name Import countryCode abcdefg, test FormatPhoneNumber(), return 83886082
1896 * @tc.desc Function test
1897 */
1898 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumber_0700, Function | MediumTest | Level3)
1899 {
1900 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1901 return;
1902 }
1903 std::string number = "13888888888";
1904 std::string Code = "abcdefg";
1905 std::string formatBefore = "";
1906 std::u16string phonyNumber = Str8ToStr16(number);
1907 std::u16string countryCode = Str8ToStr16(Code);
1908 std::u16string formatNumber = Str8ToStr16(formatBefore);
1909 EXPECT_NE(
1910 CallManagerGtest::clientPtr_->FormatPhoneNumber(phonyNumber, countryCode, formatNumber), RETURN_VALUE_IS_ZERO);
1911 }
1912
1913 /******************************* Test FormatPhoneNumberToE164() ***************************************/
1914
1915 /**
1916 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0100
1917 * @tc.name Import phonyNumber 01085198748, test FormatPhoneNumberToE164(), return +821085198748
1918 * @tc.desc Function test
1919 */
1920 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0100, Function | MediumTest | Level2)
1921 {
1922 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1923 return;
1924 }
1925 std::string number = "01085198748";
1926 std::string Code = "Kr";
1927 std::string formatBefore = "";
1928 std::u16string phonyNumber = Str8ToStr16(number);
1929 std::u16string countryCode = Str8ToStr16(Code);
1930 std::u16string formatNumber = Str8ToStr16(formatBefore);
1931 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
1932 RETURN_VALUE_IS_ZERO);
1933 }
1934
1935 /**
1936 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0200
1937 * @tc.name Import countryCode KR, test FormatPhoneNumberToE164(), return +81338122111
1938 * @tc.desc Function test
1939 */
1940 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0200, Function | MediumTest | Level2)
1941 {
1942 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1943 return;
1944 }
1945 std::string number = "(03)38122111";
1946 std::string Code = "JP";
1947 std::string formatBefore = "";
1948 std::u16string phonyNumber = Str8ToStr16(number);
1949 std::u16string countryCode = Str8ToStr16(Code);
1950 std::u16string formatNumber = Str8ToStr16(formatBefore);
1951 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
1952 RETURN_VALUE_IS_ZERO);
1953 }
1954
1955 /**
1956 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0300
1957 * @tc.name Import phonyNumber 13888888888, test FormatPhoneNumberToE164(), return +8613888888888
1958 * @tc.desc Function test
1959 */
1960 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0300, Function | MediumTest | Level2)
1961 {
1962 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1963 return;
1964 }
1965 std::string number = "13888888888";
1966 std::string Code = "cn";
1967 std::string formatBefore = "";
1968 std::u16string phonyNumber = Str8ToStr16(number);
1969 std::u16string countryCode = Str8ToStr16(Code);
1970 std::u16string formatNumber = Str8ToStr16(formatBefore);
1971 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
1972 RETURN_VALUE_IS_ZERO);
1973 }
1974
1975 /**
1976 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0400
1977 * @tc.name Import phonyNumber +81338122111, test FormatPhoneNumberToE164(), return +81338122111
1978 * @tc.desc Function test
1979 */
1980 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0400, Function | MediumTest | Level2)
1981 {
1982 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
1983 return;
1984 }
1985 std::string number = "+81338122111";
1986 std::string Code = "jp";
1987 std::string formatBefore = "";
1988 std::u16string phonyNumber = Str8ToStr16(number);
1989 std::u16string countryCode = Str8ToStr16(Code);
1990 std::u16string formatNumber = Str8ToStr16(formatBefore);
1991 EXPECT_NE(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
1992 RETURN_VALUE_IS_ZERO);
1993 }
1994
1995 /**
1996 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0500
1997 * @tc.name Import phonyNumber 03-3812-2111, test FormatPhoneNumberToE164(), return +81338122111
1998 * @tc.desc Function test
1999 */
2000 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0500, Function | MediumTest | Level2)
2001 {
2002 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2003 return;
2004 }
2005 std::string number = "03-3812-2111";
2006 std::string Code = "JP";
2007 std::string formatBefore = "";
2008 std::u16string phonyNumber = Str8ToStr16(number);
2009 std::u16string countryCode = Str8ToStr16(Code);
2010 std::u16string formatNumber = Str8ToStr16(formatBefore);
2011 EXPECT_EQ(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
2012 RETURN_VALUE_IS_ZERO);
2013 }
2014
2015 /**
2016 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0600
2017 * @tc.name Import phonyNumber 666666999999, test FormatPhoneNumberToE164(), return 83886082
2018 * @tc.desc Function test
2019 */
2020 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0600, Function | MediumTest | Level2)
2021 {
2022 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2023 return;
2024 }
2025 std::string number = "666666999999";
2026 std::string Code = "CN";
2027 std::string formatBefore = "";
2028 std::u16string phonyNumber = Str8ToStr16(number);
2029 std::u16string countryCode = Str8ToStr16(Code);
2030 std::u16string formatNumber = Str8ToStr16(formatBefore);
2031 EXPECT_NE(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
2032 RETURN_VALUE_IS_ZERO);
2033 }
2034
2035 /**
2036 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0700
2037 * @tc.name Import countryCode abcdefg, test FormatPhoneNumberToE164(), return 83886082
2038 * @tc.desc Function test
2039 */
2040 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0700, Function | MediumTest | Level3)
2041 {
2042 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2043 return;
2044 }
2045 std::string number = "13888888888";
2046 std::string Code = "abcdefg";
2047 std::string formatBefore = "";
2048 std::u16string phonyNumber = Str8ToStr16(number);
2049 std::u16string countryCode = Str8ToStr16(Code);
2050 std::u16string formatNumber = Str8ToStr16(formatBefore);
2051 EXPECT_NE(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
2052 RETURN_VALUE_IS_ZERO);
2053 }
2054
2055 /**
2056 * @tc.number Telephony_CallManager_FormatPhoneNumberToE164_0800
2057 * @tc.name Import countryCode abcdefg, test FormatPhoneNumberToE164(), return CALL_ERR_PHONE_NUMBER_EMPTY
2058 * @tc.desc Function test
2059 */
2060 HWTEST_F(CallManagerGtest, Telephony_CallManager_FormatPhoneNumberToE164_0800, Function | MediumTest | Level3)
2061 {
2062 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2063 return;
2064 }
2065 std::string number = "";
2066 std::string Code = "abcdefg";
2067 std::string formatBefore = "";
2068 std::u16string phonyNumber = Str8ToStr16(number);
2069 std::u16string countryCode = Str8ToStr16(Code);
2070 std::u16string formatNumber = Str8ToStr16(formatBefore);
2071 EXPECT_NE(CallManagerGtest::clientPtr_->FormatPhoneNumberToE164(phonyNumber, countryCode, formatNumber),
2072 RETURN_VALUE_IS_ZERO);
2073 }
2074
2075 /********************************************* Test SetCallWaiting() ***********************************************/
2076 /**
2077 * @tc.number Telephony_CallManager_SetCallWaiting_0100
2078 * @tc.name input slotId 0, test SetCallWaiting() enable callWaiting
2079 * @tc.desc Function test
2080 */
2081 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0100, Function | MediumTest | Level3)
2082 {
2083 AccessToken token;
2084 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2085 return;
2086 }
2087
2088 if (HasSimCard(SIM1_SLOTID)) {
2089 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(SIM1_SLOTID, true), RETURN_VALUE_IS_ZERO);
2090 }
2091 if (HasSimCard(SIM2_SLOTID)) {
2092 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(SIM2_SLOTID, true), RETURN_VALUE_IS_ZERO);
2093 }
2094 }
2095
2096 /**
2097 * @tc.number Telephony_CallManager_SetCallWaiting_0200
2098 * @tc.name input invalid slotId, test SetCallWaiting() enable callWaiting
2099 * @tc.desc Function test
2100 */
2101 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0200, Function | MediumTest | Level3)
2102 {
2103 AccessToken token;
2104 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2105 return;
2106 }
2107
2108 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(INVALID_SLOT_ID, true), CALL_ERR_INVALID_SLOT_ID);
2109 }
2110
2111 /**
2112 * @tc.number Telephony_CallManager_SetCallWaiting_0300
2113 * @tc.name input slotId was out of count, test SetCallWaiting() enable callWaiting
2114 * @tc.desc Function test
2115 */
2116 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0300, Function | MediumTest | Level3)
2117 {
2118 AccessToken token;
2119 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2120 return;
2121 }
2122
2123 int32_t slotId = SIM_SLOT_COUNT; // out of the count
2124 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(slotId, true), CALL_ERR_INVALID_SLOT_ID);
2125 }
2126
2127 /**
2128 * @tc.number Telephony_CallManager_SetCallWaiting_0400
2129 * @tc.name input slotId 0, test SetCallWaiting() disable callWaiting
2130 * @tc.desc Function test
2131 */
2132 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0400, Function | MediumTest | Level3)
2133 {
2134 AccessToken token;
2135 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2136 return;
2137 }
2138
2139 if (HasSimCard(SIM1_SLOTID)) {
2140 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(SIM1_SLOTID, false), RETURN_VALUE_IS_ZERO);
2141 }
2142 if (HasSimCard(SIM2_SLOTID)) {
2143 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(SIM2_SLOTID, false), RETURN_VALUE_IS_ZERO);
2144 }
2145 }
2146
2147 /**
2148 * @tc.number Telephony_CallManager_SetCallWaiting_0500
2149 * @tc.name input invalid slotId, test SetCallWaiting() disable callWaiting
2150 * @tc.desc Function test
2151 */
2152 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0500, Function | MediumTest | Level3)
2153 {
2154 AccessToken token;
2155 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2156 return;
2157 }
2158
2159 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(INVALID_SLOT_ID, false), CALL_ERR_INVALID_SLOT_ID);
2160 }
2161
2162 /**
2163 * @tc.number Telephony_CallManager_SetCallWaiting_0600
2164 * @tc.name input slotId was out of count, test SetCallWaiting() enable callWaiting
2165 * @tc.desc Function test
2166 */
2167 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0600, Function | MediumTest | Level3)
2168 {
2169 AccessToken token;
2170 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2171 return;
2172 }
2173
2174 int32_t slotId = SIM_SLOT_COUNT; // out of the count
2175 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(slotId, false), CALL_ERR_INVALID_SLOT_ID);
2176 }
2177
2178 /**
2179 * @tc.number Telephony_CallManager_SetCallWaiting_0700
2180 * @tc.name test SetCallWaiting without permission
2181 * @tc.desc Function test
2182 */
2183 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallWaiting_0700, Function | MediumTest | Level3)
2184 {
2185 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2186 return;
2187 }
2188
2189 if (HasSimCard(SIM1_SLOTID)) {
2190 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(SIM1_SLOTID, true), TELEPHONY_ERR_PERMISSION_ERR);
2191 }
2192 if (HasSimCard(SIM2_SLOTID)) {
2193 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallWaiting(SIM2_SLOTID, true), TELEPHONY_ERR_PERMISSION_ERR);
2194 }
2195 }
2196
2197 /******************************************* Test GetCallRestriction() ********************************************/
2198 /**
2199 * @tc.number Telephony_CallManager_GetCallRestriction_0100
2200 * @tc.name input slotId 0, CallRestrictionType RESTRICTION_TYPE_ALL_INCOMING, test GetCallRestriction()
2201 * @tc.desc Function test
2202 */
2203 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0100, Function | MediumTest | Level3)
2204 {
2205 AccessToken token;
2206 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2207 return;
2208 }
2209
2210 if (HasSimCard(SIM1_SLOTID)) {
2211 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
2212 SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
2213 RETURN_VALUE_IS_ZERO);
2214 }
2215 if (HasSimCard(SIM2_SLOTID)) {
2216 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
2217 SIM2_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
2218 RETURN_VALUE_IS_ZERO);
2219 }
2220 }
2221
2222 /**
2223 * @tc.number Telephony_CallManager_GetCallRestriction_0200
2224 * @tc.name input invalid slotId, CallRestrictionType RESTRICTION_TYPE_ALL_INCOMING, test GetCallRestriction()
2225 * return failed
2226 * @tc.desc Function test
2227 */
2228 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0200, Function | MediumTest | Level3)
2229 {
2230 AccessToken token;
2231 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2232 return;
2233 }
2234
2235 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
2236 INVALID_SLOT_ID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
2237 CALL_ERR_INVALID_SLOT_ID);
2238 }
2239
2240 /**
2241 * @tc.number Telephony_CallManager_GetCallRestriction_0300
2242 * @tc.name input invalid was out of count, CallRestrictionType RESTRICTION_TYPE_ALL_INCOMING,
2243 * test GetCallRestriction() return failed
2244 * @tc.desc Function test
2245 */
2246 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0300, Function | MediumTest | Level3)
2247 {
2248 AccessToken token;
2249 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2250 return;
2251 }
2252
2253 int32_t slotId = SIM_SLOT_COUNT; // out of the count
2254 EXPECT_EQ(
2255 CallManagerGtest::clientPtr_->GetCallRestriction(slotId, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
2256 CALL_ERR_INVALID_SLOT_ID);
2257 }
2258
2259 /**
2260 * @tc.number Telephony_CallManager_GetCallRestriction_0400
2261 * @tc.name input slotId 0, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING, test GetCallRestriction()
2262 * @tc.desc Function test
2263 */
2264 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0400, Function | MediumTest | Level3)
2265 {
2266 AccessToken token;
2267 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2268 return;
2269 }
2270
2271 if (HasSimCard(SIM1_SLOTID)) {
2272 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
2273 SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING),
2274 RETURN_VALUE_IS_ZERO);
2275 }
2276 if (HasSimCard(SIM2_SLOTID)) {
2277 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
2278 SIM2_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING),
2279 RETURN_VALUE_IS_ZERO);
2280 }
2281 }
2282
2283 /**
2284 * @tc.number Telephony_CallManager_GetCallRestriction_0500
2285 * @tc.name input invalid slotId, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING, test GetCallRestriction()
2286 * return failed
2287 * @tc.desc Function test
2288 */
2289 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0500, Function | MediumTest | Level3)
2290 {
2291 AccessToken token;
2292 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2293 return;
2294 }
2295
2296 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
2297 INVALID_SLOT_ID, CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING),
2298 CALL_ERR_INVALID_SLOT_ID);
2299 }
2300
2301 /**
2302 * @tc.number Telephony_CallManager_GetCallRestriction_0600
2303 * @tc.name input slotId was out of count, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING,
2304 * test GetCallRestriction() return failed
2305 * @tc.desc Function test
2306 */
2307 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0600, Function | MediumTest | Level3)
2308 {
2309 AccessToken token;
2310 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2311 return;
2312 }
2313
2314 int32_t slotId = SIM_SLOT_COUNT; // out of the count
2315 EXPECT_EQ(
2316 CallManagerGtest::clientPtr_->GetCallRestriction(slotId, CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING),
2317 CALL_ERR_INVALID_SLOT_ID);
2318 }
2319
2320 /**
2321 * @tc.number Telephony_CallManager_GetCallRestriction_0700
2322 * @tc.name input slotId 0, CallRestrictionType RESTRICTION_TYPE_ALL_INCOMING, test GetCallRestriction()
2323 * @tc.desc Function test
2324 */
2325 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallRestriction_0700, Function | MediumTest | Level3)
2326 {
2327 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2328 return;
2329 }
2330
2331 if (HasSimCard(SIM1_SLOTID)) {
2332 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
2333 SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
2334 TELEPHONY_ERR_PERMISSION_ERR);
2335 }
2336 if (HasSimCard(SIM2_SLOTID)) {
2337 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallRestriction(
2338 SIM2_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
2339 TELEPHONY_ERR_PERMISSION_ERR);
2340 }
2341 }
2342
2343 /******************************************* Test SetCallRestriction() ********************************************/
2344 /**
2345 * @tc.number Telephony_CallManager_SetCallRestriction_0100
2346 * @tc.name input slotId 0, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING,
2347 * CallRestrictionMode::RESTRICTION_MODE_ACTIVATION,
2348 * test SetCallRestriction()
2349 * @tc.desc Function test
2350 */
2351 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestriction_0100, Function | MediumTest | Level3)
2352 {
2353 AccessToken token;
2354 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2355 return;
2356 }
2357 CallRestrictionInfo info;
2358 info.fac = CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING;
2359 info.mode = CallRestrictionMode::RESTRICTION_MODE_ACTIVATION;
2360 if (strcpy_s(info.password, kMaxNumberLen + 1, "123") != EOK) {
2361 TELEPHONY_LOGE("strcpy_s fail.");
2362 return;
2363 }
2364
2365 if (HasSimCard(SIM1_SLOTID)) {
2366 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(SIM1_SLOTID, info), RETURN_VALUE_IS_ZERO);
2367 }
2368 if (HasSimCard(SIM2_SLOTID)) {
2369 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(SIM2_SLOTID, info), RETURN_VALUE_IS_ZERO);
2370 }
2371 }
2372
2373 /**
2374 * @tc.number Telephony_CallManager_SetCallRestriction_0200
2375 * @tc.name input invalid slotId, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING,
2376 * CallRestrictionMode::RESTRICTION_MODE_ACTIVATION,
2377 * test SetCallRestriction() return failed
2378 * @tc.desc Function test
2379 */
2380 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestriction_0200, Function | MediumTest | Level3)
2381 {
2382 AccessToken token;
2383 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2384 return;
2385 }
2386 CallRestrictionInfo info;
2387 info.fac = CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING;
2388 info.mode = CallRestrictionMode::RESTRICTION_MODE_ACTIVATION;
2389 if (strcpy_s(info.password, kMaxNumberLen + 1, "123") != EOK) {
2390 TELEPHONY_LOGE("strcpy_s fail.");
2391 return;
2392 }
2393
2394 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(INVALID_SLOT_ID, info), CALL_ERR_INVALID_SLOT_ID);
2395 }
2396
2397 /**
2398 * @tc.number Telephony_CallManager_SetCallRestriction_0300
2399 * @tc.name input slotId was out of count, CallRestrictionType RESTRICTION_TYPE_ALL_OUTGOING,
2400 * CallRestrictionMode::RESTRICTION_MODE_ACTIVATION,
2401 * test SetCallRestriction() return failed
2402 * @tc.desc Function test
2403 */
2404 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestriction_0300, Function | MediumTest | Level3)
2405 {
2406 AccessToken token;
2407 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2408 return;
2409 }
2410 CallRestrictionInfo info;
2411 info.fac = CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING;
2412 info.mode = CallRestrictionMode::RESTRICTION_MODE_ACTIVATION;
2413 if (strcpy_s(info.password, kMaxNumberLen + 1, "123") != EOK) {
2414 TELEPHONY_LOGE("strcpy_s fail.");
2415 return;
2416 }
2417
2418 int32_t slotId = SIM_SLOT_COUNT; // out of the count
2419 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(slotId, info), CALL_ERR_INVALID_SLOT_ID);
2420 }
2421
2422 /**
2423 * @tc.number Telephony_CallManager_SetCallRestriction_0400
2424 * @tc.name test SetCallRestriction() without permission
2425 * @tc.desc Function test
2426 */
2427 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallRestriction_0400, Function | MediumTest | Level3)
2428 {
2429 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2430 return;
2431 }
2432 CallRestrictionInfo info;
2433 info.fac = CallRestrictionType::RESTRICTION_TYPE_ALL_OUTGOING;
2434 info.mode = CallRestrictionMode::RESTRICTION_MODE_ACTIVATION;
2435 if (strcpy_s(info.password, kMaxNumberLen + 1, "123") != EOK) {
2436 TELEPHONY_LOGE("strcpy_s fail.");
2437 return;
2438 }
2439
2440 if (HasSimCard(SIM1_SLOTID)) {
2441 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(SIM1_SLOTID, info), TELEPHONY_ERR_PERMISSION_ERR);
2442 }
2443 if (HasSimCard(SIM2_SLOTID)) {
2444 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallRestriction(SIM2_SLOTID, info), TELEPHONY_ERR_PERMISSION_ERR);
2445 }
2446 }
2447
2448 /******************************************* Test GetCallTransferInfo() ********************************************/
2449 /**
2450 * @tc.number Telephony_CallManager_GetCallTransferInfo_0100
2451 * @tc.name input slotId 0, CallTransferType TRANSFER_TYPE_BUSY, test GetCallTransferInfo()
2452 * @tc.desc Function test
2453 */
2454 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0100, Function | MediumTest | Level3)
2455 {
2456 AccessToken token;
2457 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2458 return;
2459 }
2460
2461 if (HasSimCard(SIM1_SLOTID)) {
2462 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_BUSY),
2463 RETURN_VALUE_IS_ZERO);
2464 }
2465 if (HasSimCard(SIM2_SLOTID)) {
2466 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_BUSY),
2467 RETURN_VALUE_IS_ZERO);
2468 }
2469 }
2470
2471 /**
2472 * @tc.number Telephony_CallManager_GetCallTransferInfo_0200
2473 * @tc.name input invalid slotId, CallTransferType TRANSFER_TYPE_BUSY, test GetCallTransferInfo() return failed
2474 * @tc.desc Function test
2475 */
2476 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0200, Function | MediumTest | Level3)
2477 {
2478 AccessToken token;
2479 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2480 return;
2481 }
2482
2483 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(INVALID_SLOT_ID, CallTransferType::TRANSFER_TYPE_BUSY),
2484 CALL_ERR_INVALID_SLOT_ID);
2485 }
2486
2487 /**
2488 * @tc.number Telephony_CallManager_GetCallTransferInfo_0300
2489 * @tc.name input slotId was out of count, CallTransferType TRANSFER_TYPE_BUSY,
2490 * test GetCallTransferInfo() return failed
2491 * @tc.desc Function test
2492 */
2493 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0300, Function | MediumTest | Level3)
2494 {
2495 AccessToken token;
2496 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2497 return;
2498 }
2499
2500 int32_t slotId = SIM_SLOT_COUNT; // out of the count
2501 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(slotId, CallTransferType::TRANSFER_TYPE_BUSY),
2502 CALL_ERR_INVALID_SLOT_ID);
2503 }
2504
2505 /**
2506 * @tc.number Telephony_CallManager_GetCallTransferInfo_0400
2507 * @tc.name input slotId 0, CallTransferType TRANSFER_TYPE_NO_REPLY, test GetCallTransferInfo()
2508 * @tc.desc Function test
2509 */
2510 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0400, Function | MediumTest | Level3)
2511 {
2512 AccessToken token;
2513 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2514 return;
2515 }
2516
2517 if (HasSimCard(SIM1_SLOTID)) {
2518 EXPECT_EQ(
2519 CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_NO_REPLY),
2520 RETURN_VALUE_IS_ZERO);
2521 }
2522 if (HasSimCard(SIM2_SLOTID)) {
2523 EXPECT_EQ(
2524 CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM2_SLOTID, CallTransferType::TRANSFER_TYPE_NO_REPLY),
2525 RETURN_VALUE_IS_ZERO);
2526 }
2527 }
2528
2529 /**
2530 * @tc.number Telephony_CallManager_GetCallTransferInfo_0500
2531 * @tc.name input invalid slotId, CallTransferType TRANSFER_TYPE_NO_REPLY, test GetCallTransferInfo() return failed
2532 * @tc.desc Function test
2533 */
2534 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0500, Function | MediumTest | Level3)
2535 {
2536 AccessToken token;
2537 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2538 return;
2539 }
2540
2541 EXPECT_EQ(
2542 CallManagerGtest::clientPtr_->GetCallTransferInfo(INVALID_SLOT_ID, CallTransferType::TRANSFER_TYPE_NO_REPLY),
2543 CALL_ERR_INVALID_SLOT_ID);
2544 }
2545
2546 /**
2547 * @tc.number Telephony_CallManager_GetCallTransferInfo_0600
2548 * @tc.name input slotId was out of count, CallTransferType TRANSFER_TYPE_NO_REPLY,
2549 * test GetCallTransferInfo() return failed
2550 * @tc.desc Function test
2551 */
2552 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0600, Function | MediumTest | Level3)
2553 {
2554 AccessToken token;
2555 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2556 return;
2557 }
2558
2559 int32_t slotId = SIM_SLOT_COUNT; // out of the count
2560 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(slotId, CallTransferType::TRANSFER_TYPE_NO_REPLY),
2561 CALL_ERR_INVALID_SLOT_ID);
2562 }
2563
2564 /**
2565 * @tc.number Telephony_CallManager_GetCallTransferInfo_0700
2566 * @tc.name input slotId 0, CallTransferType TRANSFER_TYPE_NOT_REACHABLE, test GetCallTransferInfo()
2567 * @tc.desc Function test
2568 */
2569 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0700, Function | MediumTest | Level3)
2570 {
2571 AccessToken token;
2572 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2573 return;
2574 }
2575
2576 if (HasSimCard(SIM1_SLOTID)) {
2577 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(
2578 SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_NOT_REACHABLE),
2579 RETURN_VALUE_IS_ZERO);
2580 }
2581 if (HasSimCard(SIM2_SLOTID)) {
2582 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(
2583 SIM2_SLOTID, CallTransferType::TRANSFER_TYPE_NOT_REACHABLE),
2584 RETURN_VALUE_IS_ZERO);
2585 }
2586 }
2587
2588 /**
2589 * @tc.number Telephony_CallManager_GetCallTransferInfo_0800
2590 * @tc.name input invalid slotId, CallTransferType TRANSFER_TYPE_NOT_REACHABLE, test GetCallTransferInfo() return
2591 * failed
2592 * @tc.desc Function test
2593 */
2594 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0800, Function | MediumTest | Level3)
2595 {
2596 AccessToken token;
2597 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2598 return;
2599 }
2600
2601 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(
2602 INVALID_SLOT_ID, CallTransferType::TRANSFER_TYPE_NOT_REACHABLE),
2603 CALL_ERR_INVALID_SLOT_ID);
2604 }
2605
2606 /**
2607 * @tc.number Telephony_CallManager_GetCallTransferInfo_0900
2608 * @tc.name input slotId out of count, CallTransferType TRANSFER_TYPE_NOT_REACHABLE,
2609 * test GetCallTransferInfo() return failed
2610 * @tc.desc Function test
2611 */
2612 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_0900, Function | MediumTest | Level3)
2613 {
2614 AccessToken token;
2615 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2616 return;
2617 }
2618
2619 int32_t slotId = SIM_SLOT_COUNT; // out of the count
2620 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(slotId, CallTransferType::TRANSFER_TYPE_NOT_REACHABLE),
2621 CALL_ERR_INVALID_SLOT_ID);
2622 }
2623
2624 /**
2625 * @tc.number Telephony_CallManager_GetCallTransferInfo_1000
2626 * @tc.name input slotId 0, CallTransferType invalid, test GetCallTransferInfo() return failed
2627 * @tc.desc Function test
2628 */
2629 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_1000, Function | MediumTest | Level3)
2630 {
2631 AccessToken token;
2632 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2633 return;
2634 }
2635
2636 if (HasSimCard(SIM1_SLOTID)) {
2637 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, (CallTransferType)FALSE_DEFAULT),
2638 CALL_ERR_INVALID_TRANSFER_TYPE);
2639 }
2640 if (HasSimCard(SIM2_SLOTID)) {
2641 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM2_SLOTID, (CallTransferType)FALSE_DEFAULT),
2642 CALL_ERR_INVALID_TRANSFER_TYPE);
2643 }
2644 }
2645
2646 /**
2647 * @tc.number Telephony_CallManager_GetCallTransferInfo_1100
2648 * @tc.name test GetCallTransferInfo() without permission
2649 * @tc.desc Function test
2650 */
2651 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetCallTransferInfo_1100, Function | MediumTest | Level3)
2652 {
2653 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2654 return;
2655 }
2656
2657 if (HasSimCard(SIM1_SLOTID)) {
2658 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_BUSY),
2659 TELEPHONY_ERR_PERMISSION_ERR);
2660 }
2661 if (HasSimCard(SIM2_SLOTID)) {
2662 EXPECT_EQ(CallManagerGtest::clientPtr_->GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_BUSY),
2663 TELEPHONY_ERR_PERMISSION_ERR);
2664 }
2665 }
2666
2667 /******************************************* Test SetCallTransferInfo() ********************************************/
2668 /**
2669 * @tc.number Telephony_CallManager_SetCallTransferInfo_0100
2670 * @tc.name input slotId 0, CallTransferSettingType CALL_TRANSFER_ENABLE, CallTransferType TRANSFER_TYPE_BUSY,
2671 * test SetCallTransferInfo()
2672 * @tc.desc Function test
2673 */
2674 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0100, Function | MediumTest | Level3)
2675 {
2676 AccessToken token;
2677 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2678 return;
2679 }
2680 CallTransferInfo info;
2681 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
2682 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
2683 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "123") != EOK) {
2684 TELEPHONY_LOGE("strcpy_s fail.");
2685 return;
2686 }
2687
2688 if (HasSimCard(SIM1_SLOTID)) {
2689 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info), RETURN_VALUE_IS_ZERO);
2690 }
2691 if (HasSimCard(SIM2_SLOTID)) {
2692 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info), RETURN_VALUE_IS_ZERO);
2693 }
2694 }
2695
2696 /**
2697 * @tc.number Telephony_CallManager_SetCallTransferInfo_0200
2698 * @tc.name input invalid slotId, CallTransferSettingType CALL_TRANSFER_ENABLE, CallTransferType TRANSFER_TYPE_BUSY,
2699 * test SetCallTransferInfo() return failed
2700 * @tc.desc Function test
2701 */
2702 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0200, Function | MediumTest | Level3)
2703 {
2704 AccessToken token;
2705 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2706 return;
2707 }
2708 CallTransferInfo info;
2709 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
2710 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
2711 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "123") != EOK) {
2712 TELEPHONY_LOGE("strcpy_s fail.");
2713 return;
2714 }
2715
2716 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(INVALID_SLOT_ID, info), CALL_ERR_INVALID_SLOT_ID);
2717 }
2718
2719 /**
2720 * @tc.number Telephony_CallManager_SetCallTransferInfo_0300
2721 * @tc.name input slotId was out of count, CallTransferSettingType CALL_TRANSFER_ENABLE,
2722 * CallTransferType TRANSFER_TYPE_BUSY, test SetCallTransferInfo() return failed
2723 * @tc.desc Function test
2724 */
2725 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0300, Function | MediumTest | Level3)
2726 {
2727 AccessToken token;
2728 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2729 return;
2730 }
2731 CallTransferInfo info;
2732 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
2733 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
2734 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "123") != EOK) {
2735 TELEPHONY_LOGE("strcpy_s fail.");
2736 return;
2737 }
2738
2739 int32_t slotId = SIM_SLOT_COUNT; // out of the count
2740 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(slotId, info), CALL_ERR_INVALID_SLOT_ID);
2741 }
2742
2743 /**
2744 * @tc.number Telephony_CallManager_SetCallTransferInfo_0400
2745 * @tc.name input slotId 0, CallTransferSettingType CALL_TRANSFER_ENABLE, CallTransferType invalid,
2746 * test SetCallTransferInfo() return failed
2747 * @tc.desc Function test
2748 */
2749 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0400, Function | MediumTest | Level3)
2750 {
2751 AccessToken token;
2752 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2753 return;
2754 }
2755 CallTransferInfo info;
2756 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
2757 info.type = (CallTransferType)FALSE_DEFAULT;
2758 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "123") != EOK) {
2759 TELEPHONY_LOGE("strcpy_s fail.");
2760 return;
2761 }
2762
2763 if (HasSimCard(SIM1_SLOTID)) {
2764 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info), CALL_ERR_INVALID_TRANSFER_TYPE);
2765 }
2766 if (HasSimCard(SIM2_SLOTID)) {
2767 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info), CALL_ERR_INVALID_TRANSFER_TYPE);
2768 }
2769 }
2770
2771 /**
2772 * @tc.number Telephony_CallManager_SetCallTransferInfo_0500
2773 * @tc.name input slotId 0, CallTransferSettingType invalid, CallTransferType TRANSFER_TYPE_BUSY,
2774 * test SetCallTransferInfo() return failed
2775 * @tc.desc Function test
2776 */
2777 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0500, Function | MediumTest | Level3)
2778 {
2779 AccessToken token;
2780 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2781 return;
2782 }
2783 CallTransferInfo info;
2784 info.settingType = (CallTransferSettingType)FALSE_DEFAULT;
2785 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
2786 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "123") != EOK) {
2787 TELEPHONY_LOGE("strcpy_s fail.");
2788 return;
2789 }
2790
2791 if (HasSimCard(SIM1_SLOTID)) {
2792 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info),
2793 CALL_ERR_INVALID_TRANSFER_SETTING_TYPE);
2794 }
2795 if (HasSimCard(SIM2_SLOTID)) {
2796 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info),
2797 CALL_ERR_INVALID_TRANSFER_SETTING_TYPE);
2798 }
2799 }
2800
2801 /**
2802 * @tc.number Telephony_CallManager_SetCallTransferInfo_0600
2803 * @tc.name input slotId 0, CallTransferSettingType invalid, CallTransferType TRANSFER_TYPE_BUSY, transferNum was
2804 * too long, test SetCallTransferInfo() return failed
2805 * @tc.desc Function test
2806 */
2807 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0600, Function | MediumTest | Level3)
2808 {
2809 AccessToken token;
2810 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2811 return;
2812 }
2813 CallTransferInfo info;
2814 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
2815 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
2816 if (strcpy_s(info.transferNum, kMaxNumberLen + 2,
2817 "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901") !=
2818 EOK) {
2819 TELEPHONY_LOGE("strcpy_s fail.");
2820 return;
2821 }
2822
2823 if (HasSimCard(SIM1_SLOTID)) {
2824 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info), CALL_ERR_NUMBER_OUT_OF_RANGE);
2825 }
2826 if (HasSimCard(SIM2_SLOTID)) {
2827 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info), CALL_ERR_NUMBER_OUT_OF_RANGE);
2828 }
2829 }
2830
2831 /**
2832 * @tc.number Telephony_CallManager_SetCallTransferInfo_0700
2833 * @tc.name input slotId 0, CallTransferSettingType CALL_TRANSFER_ENABLE, CallTransferType TRANSFER_TYPE_BUSY,
2834 * test SetCallTransferInfo()
2835 * @tc.desc Function test
2836 */
2837 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallTransferInfo_0700, Function | MediumTest | Level3)
2838 {
2839 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2840 return;
2841 }
2842 CallTransferInfo info;
2843 info.settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE;
2844 info.type = CallTransferType::TRANSFER_TYPE_BUSY;
2845 if (strcpy_s(info.transferNum, kMaxNumberLen + 1, "123") != EOK) {
2846 TELEPHONY_LOGE("strcpy_s fail.");
2847 return;
2848 }
2849
2850 if (HasSimCard(SIM1_SLOTID)) {
2851 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM1_SLOTID, info), TELEPHONY_ERR_PERMISSION_ERR);
2852 }
2853 if (HasSimCard(SIM2_SLOTID)) {
2854 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallTransferInfo(SIM2_SLOTID, info), TELEPHONY_ERR_PERMISSION_ERR);
2855 }
2856 }
2857
2858 #ifndef CALL_MANAGER_IMS_LITE_UNSUPPORT
2859 /******************************************* Test EnableImsSwitch() ********************************************/
2860 /**
2861 * @tc.number Telephony_CallManager_EnableImsSwitch_0100
2862 * @tc.name input slotId 0, test EnableImsSwitch
2863 * @tc.desc Function test
2864 */
2865 HWTEST_F(CallManagerGtest, Telephony_CallManager_EnableImsSwitch_0100, Function | MediumTest | Level3)
2866 {
2867 AccessToken token;
2868 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2869 return;
2870 }
2871
2872 if (HasSimCard(SIM1_SLOTID)) {
2873 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(SIM1_SLOTID), RETURN_VALUE_IS_ZERO);
2874 }
2875 if (HasSimCard(SIM2_SLOTID)) {
2876 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(SIM2_SLOTID), RETURN_VALUE_IS_ZERO);
2877 }
2878 }
2879
2880 /**
2881 * @tc.number Telephony_CallManager_EnableImsSwitch_0200
2882 * @tc.name input invalid slotId, test EnableImsSwitch return failed
2883 * @tc.desc Function test
2884 */
2885 HWTEST_F(CallManagerGtest, Telephony_CallManager_EnableImsSwitch_0200, Function | MediumTest | Level3)
2886 {
2887 AccessToken token;
2888 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2889 return;
2890 }
2891
2892 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(INVALID_SLOT_ID), CALL_ERR_INVALID_SLOT_ID);
2893 }
2894
2895 /**
2896 * @tc.number Telephony_CallManager_EnableImsSwitch_0300
2897 * @tc.name input slotId was out of count, test EnableImsSwitch return failed
2898 * @tc.desc Function test
2899 */
2900 HWTEST_F(CallManagerGtest, Telephony_CallManager_EnableImsSwitch_0300, Function | MediumTest | Level3)
2901 {
2902 AccessToken token;
2903 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2904 return;
2905 }
2906
2907 int32_t slotId = SIM_SLOT_COUNT; // out of the count
2908 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(slotId), CALL_ERR_INVALID_SLOT_ID);
2909 }
2910
2911 /**
2912 * @tc.number Telephony_CallManager_EnableImsSwitch_0400
2913 * @tc.name test EnableImsSwitch without permission
2914 * @tc.desc Function test
2915 */
2916 HWTEST_F(CallManagerGtest, Telephony_CallManager_EnableImsSwitch_0400, Function | MediumTest | Level3)
2917 {
2918 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2919 return;
2920 }
2921
2922 if (HasSimCard(SIM1_SLOTID)) {
2923 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(SIM1_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
2924 }
2925 if (HasSimCard(SIM2_SLOTID)) {
2926 EXPECT_EQ(CallManagerGtest::clientPtr_->EnableImsSwitch(SIM2_SLOTID), TELEPHONY_ERR_PERMISSION_ERR);
2927 }
2928 }
2929
2930 /******************************************* Test DisableImsSwitch() ********************************************/
2931 /**
2932 * @tc.number Telephony_CallManager_DisableImsSwitch_0100
2933 * @tc.name input slotId 0, test DisableImsSwitch
2934 * @tc.desc Function test
2935 */
2936 HWTEST_F(CallManagerGtest, Telephony_CallManager_DisableImsSwitch_0100, Function | MediumTest | Level3)
2937 {
2938 AccessToken token;
2939 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2940 return;
2941 }
2942
2943 if (HasSimCard(SIM1_SLOTID)) {
2944 EXPECT_EQ(CallManagerGtest::clientPtr_->DisableImsSwitch(SIM1_SLOTID), RETURN_VALUE_IS_ZERO);
2945 }
2946 if (HasSimCard(SIM2_SLOTID)) {
2947 EXPECT_EQ(CallManagerGtest::clientPtr_->DisableImsSwitch(SIM2_SLOTID), RETURN_VALUE_IS_ZERO);
2948 }
2949 }
2950
2951 /**
2952 * @tc.number Telephony_CallManager_DisableImsSwitch_0200
2953 * @tc.name input invalid slotId, test DisableImsSwitch return failed
2954 * @tc.desc Function test
2955 */
2956 HWTEST_F(CallManagerGtest, Telephony_CallManager_DisableImsSwitch_0200, Function | MediumTest | Level3)
2957 {
2958 AccessToken token;
2959 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2960 return;
2961 }
2962
2963 EXPECT_EQ(CallManagerGtest::clientPtr_->DisableImsSwitch(INVALID_SLOT_ID), CALL_ERR_INVALID_SLOT_ID);
2964 }
2965
2966 /**
2967 * @tc.number Telephony_CallManager_DisableImsSwitch_0300
2968 * @tc.name input slotId was out of count, test DisableImsSwitch return failed
2969 * @tc.desc Function test
2970 */
2971 HWTEST_F(CallManagerGtest, Telephony_CallManager_DisableImsSwitch_0300, Function | MediumTest | Level3)
2972 {
2973 AccessToken token;
2974 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2975 return;
2976 }
2977
2978 int32_t slotId = SIM_SLOT_COUNT; // out of the count
2979 EXPECT_EQ(CallManagerGtest::clientPtr_->DisableImsSwitch(slotId), CALL_ERR_INVALID_SLOT_ID);
2980 }
2981
2982 /******************************************* Test IsImsSwitchEnabled() ********************************************/
2983 /**
2984 * @tc.number Telephony_CallManager_IsImsSwitchEnabled_0100
2985 * @tc.name input slotId 0, test IsImsSwitchEnabled
2986 * @tc.desc Function test
2987 */
2988 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsImsSwitchEnabled_0100, Function | MediumTest | Level3)
2989 {
2990 AccessToken token;
2991 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
2992 return;
2993 }
2994
2995 bool enabled;
2996 if (HasSimCard(SIM1_SLOTID)) {
2997 EXPECT_EQ(CallManagerGtest::clientPtr_->IsImsSwitchEnabled(SIM1_SLOTID, enabled), RETURN_VALUE_IS_ZERO);
2998 }
2999 if (HasSimCard(SIM2_SLOTID)) {
3000 EXPECT_EQ(CallManagerGtest::clientPtr_->IsImsSwitchEnabled(SIM2_SLOTID, enabled), RETURN_VALUE_IS_ZERO);
3001 }
3002 }
3003
3004 /**
3005 * @tc.number Telephony_CallManager_IsImsSwitchEnabled_0200
3006 * @tc.name input invalid slotId, test IsImsSwitchEnabled return failed
3007 * @tc.desc Function test
3008 */
3009 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsImsSwitchEnabled_0200, Function | MediumTest | Level3)
3010 {
3011 AccessToken token;
3012 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3013 return;
3014 }
3015
3016 bool enabled;
3017 EXPECT_EQ(CallManagerGtest::clientPtr_->IsImsSwitchEnabled(INVALID_SLOT_ID, enabled), CALL_ERR_INVALID_SLOT_ID);
3018 }
3019
3020 /**
3021 * @tc.number Telephony_CallManager_IsImsSwitchEnabled_0300
3022 * @tc.name input slotId was out of count, test IsImsSwitchEnabled return failed
3023 * @tc.desc Function test
3024 */
3025 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsImsSwitchEnabled_0300, Function | MediumTest | Level3)
3026 {
3027 AccessToken token;
3028 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3029 return;
3030 }
3031
3032 int32_t slotId = SIM_SLOT_COUNT; // out of the count
3033 bool enabled;
3034 EXPECT_EQ(CallManagerGtest::clientPtr_->IsImsSwitchEnabled(slotId, enabled), CALL_ERR_INVALID_SLOT_ID);
3035 }
3036
3037 /******************************************* Test ControlCamera() *********************************************/
3038 /**
3039 * @tc.number Telephony_CallManager_ControlCamera_0100
3040 * @tc.name input camera id lcam001, Test ControlCamera, returns 0 if success
3041 * @tc.desc Function test
3042 */
3043 HWTEST_F(CallManagerGtest, Telephony_CallManager_ControlCamera_0100, Function | MediumTest | Level0)
3044 {
3045 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3046 return;
3047 }
3048 // 3516DV300 camera id string is "lcam001"
3049 std::string id = "lcam001";
3050
3051 std::u16string cameraID = Str8ToStr16(id);
3052 EXPECT_EQ(CallManagerGtest::clientPtr_->ControlCamera(cameraID), RETURN_VALUE_IS_ZERO);
3053 }
3054
3055 /**
3056 * @tc.number Telephony_CallManager_ControlCamera_0200
3057 * @tc.name input error camera id xtsautotest123456, Test ControlCamera, return err code if failed
3058 * @tc.desc Function test
3059 */
3060 HWTEST_F(CallManagerGtest, Telephony_CallManager_ControlCamera_0200, Function | MediumTest | Level2)
3061 {
3062 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3063 return;
3064 }
3065 std::string id = "xtsautotest123456";
3066
3067 std::u16string cameraID = Str8ToStr16(id);
3068 EXPECT_NE(CallManagerGtest::clientPtr_->ControlCamera(cameraID), RETURN_VALUE_IS_ZERO);
3069 }
3070
3071 /**
3072 * @tc.number Telephony_CallManager_ControlCamera_0300
3073 * @tc.name input error camera id xtsautotest123456, Test ControlCamera,
3074 * then input empty camera id, Test ControlCamera
3075 * @tc.desc Function test
3076 */
3077 HWTEST_F(CallManagerGtest, Telephony_CallManager_ControlCamera_0300, Function | MediumTest | Level2)
3078 {
3079 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3080 return;
3081 }
3082 std::string id = "lcam001";
3083
3084 std::u16string cameraID = Str8ToStr16(id);
3085 EXPECT_EQ(CallManagerGtest::clientPtr_->ControlCamera(cameraID), RETURN_VALUE_IS_ZERO);
3086
3087 id = "";
3088 cameraID = Str8ToStr16(id);
3089 EXPECT_EQ(CallManagerGtest::clientPtr_->ControlCamera(cameraID), RETURN_VALUE_IS_ZERO);
3090 }
3091
3092 /**
3093 * @tc.number Telephony_CallManager_ControlCamera_0600
3094 * @tc.name input empty camera id, Test ControlCamera, returns error code if failed
3095 * @tc.desc Function test
3096 */
3097 HWTEST_F(CallManagerGtest, Telephony_CallManager_ControlCamera_0600, Function | MediumTest | Level2)
3098 {
3099 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3100 return;
3101 }
3102 std::string id = "";
3103
3104 std::u16string cameraID = Str8ToStr16(id);
3105 EXPECT_NE(CallManagerGtest::clientPtr_->ControlCamera(cameraID), RETURN_VALUE_IS_ZERO);
3106 }
3107
3108 /******************************************* Test SetPreviewWindow() *********************************************/
3109 /**
3110 * @tc.number Telephony_CallManager_SetPreviewWindow_0100
3111 * @tc.name input x:0, y:0, z:-1, width:200, height:200, Test set preview window
3112 * @tc.desc Function test
3113 */
3114 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPreviewWindow_0100, Function | MediumTest | Level2)
3115 {
3116 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3117 return;
3118 }
3119 VideoWindow window;
3120 window.x = 0;
3121 window.y = 0;
3122 window.z = -1;
3123 window.width = 200;
3124 window.height = 200;
3125 EXPECT_NE(CallManagerGtest::clientPtr_->SetPreviewWindow(window), RETURN_VALUE_IS_ZERO);
3126 }
3127
3128 /**
3129 * @tc.number Telephony_CallManager_SetPreviewWindow_0200
3130 * @tc.name input x:0, y:0, z:0, width:200, height:200, Test set preview window
3131 * @tc.desc Function test
3132 */
3133 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPreviewWindow_0200, Function | MediumTest | Level2)
3134 {
3135 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3136 return;
3137 }
3138 VideoWindow window;
3139 window.x = 0;
3140 window.y = 0;
3141 window.z = 0;
3142 window.width = 200;
3143 window.height = 200;
3144 EXPECT_EQ(CallManagerGtest::clientPtr_->SetPreviewWindow(window), RETURN_VALUE_IS_ZERO);
3145 }
3146
3147 /******************************************* Test SetDisplayWindow() *********************************************/
3148 /**
3149 * @tc.number Telephony_CallManager_SetDisplayWindow_0100
3150 * @tc.name input x:10, y:10, z:10, width:100, height:200, Test set display window
3151 * @tc.desc Function test
3152 */
3153 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDisplayWindow_0100, Function | MediumTest | Level2)
3154 {
3155 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3156 return;
3157 }
3158 VideoWindow window;
3159 window.x = 10;
3160 window.y = 10;
3161 window.z = 10;
3162 window.width = 100;
3163 window.height = 200;
3164 EXPECT_NE(CallManagerGtest::clientPtr_->SetDisplayWindow(window), RETURN_VALUE_IS_ZERO);
3165 }
3166
3167 /**
3168 * @tc.number Telephony_CallManager_SetDisplayWindow_0200
3169 * @tc.name input x:10, y:10, z:0, width:200, height:200, Test set display window
3170 * @tc.desc Function test
3171 */
3172 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDisplayWindow_0200, Function | MediumTest | Level2)
3173 {
3174 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3175 return;
3176 }
3177 VideoWindow window;
3178 window.x = 10;
3179 window.y = 10;
3180 window.z = 0;
3181 window.width = 200;
3182 window.height = 200;
3183 EXPECT_EQ(CallManagerGtest::clientPtr_->SetDisplayWindow(window), RETURN_VALUE_IS_ZERO);
3184 }
3185
3186 /******************************************* Test SetDeviceDirection() *********************************************/
3187 /**
3188 * @tc.number Telephony_CallManager_SetDeviceDirection_0100
3189 * @tc.name input invalid rotation, Test SetDeviceDirection, return error code if failed
3190 * @tc.desc Function test
3191 */
3192 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDeviceDirection_0100, Function | MediumTest | Level2)
3193 {
3194 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3195 return;
3196 }
3197 int32_t rotation = CAMERA_ROTATION_ERROR;
3198 EXPECT_NE(CallManagerGtest::clientPtr_->SetDeviceDirection(rotation), RETURN_VALUE_IS_ZERO);
3199 }
3200
3201 /**
3202 * @tc.number Telephony_CallManager_SetDeviceDirection_0200
3203 * @tc.name input rotation 0, Test SetDeviceDirection, return 0 if success
3204 * @tc.desc Function test
3205 */
3206 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDeviceDirection_0200, Function | MediumTest | Level2)
3207 {
3208 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3209 return;
3210 }
3211 int32_t rotation = 0;
3212 EXPECT_EQ(CallManagerGtest::clientPtr_->SetDeviceDirection(rotation), RETURN_VALUE_IS_ZERO);
3213 }
3214
3215 /**
3216 * @tc.number Telephony_CallManager_SetDeviceDirection_0300
3217 * @tc.name input rotation 90, Test SetDeviceDirection
3218 * @tc.desc Function test
3219 */
3220 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetDeviceDirection_0300, Function | MediumTest | Level1)
3221 {
3222 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3223 return;
3224 }
3225 int32_t rotation = CAMERA_ROTATION_90;
3226 EXPECT_EQ(CallManagerGtest::clientPtr_->SetDeviceDirection(rotation), RETURN_VALUE_IS_ZERO);
3227 }
3228
3229 /******************************************* Test SetCameraZoom() *********************************************/
3230 /**
3231 * @tc.number Telephony_CallManager_SetDeviceDirection_0100
3232 * @tc.name input zoomRatio 5.0, Test SetCameraZoom
3233 * @tc.desc Function test
3234 */
3235 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0100, Function | MediumTest | Level2)
3236 {
3237 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3238 return;
3239 }
3240 float zoomRatio = 5.0;
3241 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
3242 }
3243
3244 /**
3245 * @tc.number Telephony_CallManager_SetDeviceDirection_0200
3246 * @tc.name input zoomRatio 0.1, Test SetCameraZoom
3247 * @tc.desc Function test
3248 */
3249 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0200, Function | MediumTest | Level1)
3250 {
3251 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3252 return;
3253 }
3254 float zoomRatio = 0.1;
3255 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
3256 }
3257
3258 /**
3259 * @tc.number Telephony_CallManager_SetDeviceDirection_0300
3260 * @tc.name input zoomRatio 10.0, Test SetCameraZoom
3261 * @tc.desc Function test
3262 */
3263 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0300, Function | MediumTest | Level1)
3264 {
3265 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3266 return;
3267 }
3268 float zoomRatio = 10.0;
3269 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
3270 }
3271
3272 /**
3273 * @tc.number Telephony_CallManager_SetDeviceDirection_0400
3274 * @tc.name input invalid para zoomRatio 15.0, Test SetCameraZoom, return error code if failed
3275 * @tc.desc Function test
3276 */
3277 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0400, Function | MediumTest | Level1)
3278 {
3279 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3280 return;
3281 }
3282 float zoomRatio = 15.0;
3283 EXPECT_NE(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
3284 }
3285
3286 /**
3287 * @tc.number Telephony_CallManager_SetDeviceDirection_0500
3288 * @tc.name input invalid para zoomRatio 0.0, Test SetCameraZoom, return error code if failed
3289 * @tc.desc Function test
3290 */
3291 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0500, Function | MediumTest | Level1)
3292 {
3293 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3294 return;
3295 }
3296 float zoomRatio = 0.0;
3297 EXPECT_NE(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
3298 }
3299
3300 /**
3301 * @tc.number Telephony_CallManager_SetDeviceDirection_0600
3302 * @tc.name input invalid para zoomRatio -1.0, Test SetCameraZoom, return error code if failed
3303 * @tc.desc Function test
3304 */
3305 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0600, Function | MediumTest | Level1)
3306 {
3307 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3308 return;
3309 }
3310 float zoomRatio = -1.0;
3311 EXPECT_NE(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
3312 }
3313
3314 /**
3315 * @tc.number Telephony_CallManager_SetDeviceDirection_0700
3316 * @tc.name input invalid para zoomRatio 10.1, Test SetCameraZoom, return error code if failed
3317 * @tc.desc Function test
3318 */
3319 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCameraZoom_0700, Function | MediumTest | Level1)
3320 {
3321 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3322 return;
3323 }
3324 float zoomRatio = 10.1;
3325 EXPECT_NE(CallManagerGtest::clientPtr_->SetCameraZoom(zoomRatio), RETURN_VALUE_IS_ZERO);
3326 }
3327 /******************************************* Test SetPausePicture() *********************************************/
3328 /**
3329 * @tc.number Telephony_CallManager_SetPausePicture_0100
3330 * @tc.name input locale picture path /system/bin/test.png that does not exist, Test SetPausePicture,
3331 * return error code if failed
3332 * @tc.desc Function test
3333 */
3334 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0100, Function | MediumTest | Level1)
3335 {
3336 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3337 return;
3338 }
3339 std::string pathTemp = "/system/bin/test.png";
3340 std::u16string path = Str8ToStr16(pathTemp);
3341 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(path), RETURN_VALUE_IS_ZERO);
3342 }
3343
3344 /**
3345 * @tc.number Telephony_CallManager_SetPausePicture_0200
3346 * @tc.name input an invalid image format file path, Test SetPausePicture, return error code if failed
3347 * @tc.desc Function test
3348 */
3349 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0200, Function | MediumTest | Level1)
3350 {
3351 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3352 return;
3353 }
3354 std::string pathTemp = "/system/bin/test.jpg";
3355 std::u16string path = Str8ToStr16(pathTemp);
3356 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(path), RETURN_VALUE_IS_ZERO);
3357 }
3358
3359 /**
3360 * @tc.number Telephony_CallManager_SetPausePicture_0300
3361 * @tc.name input an invalid image format file path, Test SetPausePicture, return error code if failed
3362 * @tc.desc Function test
3363 */
3364 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0300, Function | MediumTest | Level1)
3365 {
3366 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3367 return;
3368 }
3369 std::string pathTemp = "/system/bin/test.bmp";
3370 std::u16string path = Str8ToStr16(pathTemp);
3371 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(path), RETURN_VALUE_IS_ZERO);
3372 }
3373
3374 /**
3375 * @tc.number Telephony_CallManager_SetPausePicture_0400
3376 * @tc.name input an invalid image format file path, Test SetPausePicture, return error code if failed
3377 * @tc.desc Function test
3378 */
3379 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0400, Function | MediumTest | Level1)
3380 {
3381 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3382 return;
3383 }
3384 std::string pathTemp = "/system/bin/test.webp";
3385 std::u16string path = Str8ToStr16(pathTemp);
3386 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(path), RETURN_VALUE_IS_ZERO);
3387 }
3388
3389 /**
3390 * @tc.number Telephony_CallManager_SetPausePicture_0500
3391 * @tc.name input remote picture path http://callManager.jpg that does not exist, Test SetPausePicture,
3392 * return error code if failed
3393 * @tc.desc Function test
3394 */
3395 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0500, Function | MediumTest | Level1)
3396 {
3397 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3398 return;
3399 }
3400 std::string pathTemp = "http://callManager.jpg";
3401 std::u16string path = Str8ToStr16(pathTemp);
3402 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(path), RETURN_VALUE_IS_ZERO);
3403 }
3404
3405 /**
3406 * @tc.number Telephony_CallManager_SetPausePicture_0600
3407 * @tc.name input empty picture path, Test SetPausePicture, return error code if failed
3408 * @tc.desc Function test
3409 */
3410 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetPausePicture_0600, Function | MediumTest | Level1)
3411 {
3412 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3413 return;
3414 }
3415 std::string pathTemp = "";
3416 std::u16string path = Str8ToStr16(pathTemp);
3417 EXPECT_NE(CallManagerGtest::clientPtr_->SetPausePicture(path), RETURN_VALUE_IS_ZERO);
3418 }
3419 #endif
3420
3421 /********************************************* Test SetAudioDevic()***********************************************/
3422 /**
3423 * @tc.number Telephony_CallManager_SetAudioDevice_0100
3424 * @tc.name make a normal buletoothAddress, set active bluetooth device
3425 * @tc.desc Function test
3426 * @tc.require: issueI5JUAQ
3427 */
3428 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetAudioDevice_0100, Function | MediumTest | Level2)
3429 {
3430 AccessToken token;
3431 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3432 return;
3433 }
3434
3435 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
3436 std::string phoneNumber = "00000000000";
3437 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
3438 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
3439
3440 HandsFreeAudioGateway *profile = HandsFreeAudioGateway::GetProfile();
3441 vector<BluetoothRemoteDevice> devices = profile->GetConnectedDevices();
3442 int deviceNum = devices.size();
3443 std::string address = "";
3444 const int32_t zeroDevice = 0;
3445 if (deviceNum > zeroDevice) {
3446 address = devices[0].GetDeviceAddr();
3447 }
3448
3449 if (CallInfoManager::HasActiveStatus()) {
3450 EXPECT_EQ(clientPtr_->SetAudioDevice(AudioDevice::DEVICE_BLUETOOTH_SCO, address), RETURN_VALUE_IS_ZERO);
3451 }
3452
3453 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
3454 HangUpCall();
3455 EXPECT_EQ(CallInfoManager::HasState(newCallId_, (int32_t)TelCallState::CALL_STATUS_DISCONNECTED), true);
3456 }
3457 }
3458
3459 /**
3460 * @tc.number Telephony_CallManager_SetAudioDevice_0200
3461 * @tc.name make EARPIECE device type, set active EARPIECE device
3462 * @tc.desc Function test
3463 * @tc.require: issueI5JUAQ
3464 */
3465 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetAudioDevice_0200, Function | MediumTest | Level2)
3466 {
3467 AccessToken token;
3468 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3469 return;
3470 }
3471
3472 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
3473 std::string phoneNumber = "00000000000";
3474 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
3475 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
3476 std::string address = "";
3477 if (CallInfoManager::HasActiveStatus()) {
3478 EXPECT_EQ(clientPtr_->SetAudioDevice(AudioDevice::DEVICE_EARPIECE, address), RETURN_VALUE_IS_ZERO);
3479 }
3480
3481 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
3482 HangUpCall();
3483 EXPECT_EQ(CallInfoManager::HasState(newCallId_, (int32_t)TelCallState::CALL_STATUS_DISCONNECTED), true);
3484 }
3485 }
3486
3487 /**
3488 * @tc.number Telephony_CallManager_SetAudioDevice_0300
3489 * @tc.name make SPEAKER device type, set active SPEAKER device
3490 * @tc.desc Function test
3491 * @tc.require: issueI5JUAQ
3492 */
3493 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetAudioDevice_0300, Function | MediumTest | Level2)
3494 {
3495 AccessToken token;
3496 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3497 return;
3498 }
3499
3500 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
3501 std::string phoneNumber = "00000000000";
3502 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
3503 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
3504
3505 std::string address = "";
3506 if (CallInfoManager::HasActiveStatus()) {
3507 EXPECT_EQ(clientPtr_->SetAudioDevice(AudioDevice::DEVICE_SPEAKER, address), RETURN_VALUE_IS_ZERO);
3508 }
3509
3510 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
3511 HangUpCall();
3512 EXPECT_EQ(CallInfoManager::HasState(newCallId_, (int32_t)TelCallState::CALL_STATUS_DISCONNECTED), true);
3513 }
3514 }
3515
3516 /**
3517 * @tc.number Telephony_CallManager_SetAudioDevice_0400
3518 * @tc.name make DEVICE_WIRED_HEADSET device type, set active DEVICE_WIRED_HEADSET device
3519 * @tc.desc Function test
3520 * @tc.require: issueI5JUAQ
3521 */
3522 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetAudioDevice_0400, Function | MediumTest | Level2)
3523 {
3524 AccessToken token;
3525 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3526 return;
3527 }
3528
3529 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
3530 std::string phoneNumber = "00000000000";
3531 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
3532 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
3533
3534 std::string address = "";
3535 if (CallInfoManager::HasActiveStatus()) {
3536 EXPECT_EQ(clientPtr_->SetAudioDevice(AudioDevice::DEVICE_WIRED_HEADSET, address), RETURN_VALUE_IS_ZERO);
3537 }
3538
3539 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
3540 HangUpCall();
3541 EXPECT_EQ(CallInfoManager::HasState(newCallId_, (int32_t)TelCallState::CALL_STATUS_DISCONNECTED), true);
3542 }
3543 }
3544
3545 /**
3546 * @tc.number Telephony_CallManager_SetAudioDevice_0500
3547 * @tc.name make a empty buletoothAddress, set active bluetooth device
3548 * @tc.desc Function test
3549 * @tc.require: issueI5JUAQ
3550 */
3551 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetAudioDevice_0500, Function | MediumTest | Level2)
3552 {
3553 AccessToken token;
3554 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3555 return;
3556 }
3557
3558 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
3559 std::string phoneNumber = "00000000000";
3560 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
3561 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
3562
3563 std::string address = "";
3564 if (CallInfoManager::HasActiveStatus()) {
3565 EXPECT_EQ(clientPtr_->SetAudioDevice(AudioDevice::DEVICE_BLUETOOTH_SCO, address), RETURN_VALUE_IS_ZERO);
3566 }
3567
3568 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
3569 HangUpCall();
3570 EXPECT_EQ(CallInfoManager::HasState(newCallId_, (int32_t)TelCallState::CALL_STATUS_DISCONNECTED), true);
3571 }
3572 }
3573
3574 /**
3575 * @tc.number Telephony_CallManager_SetAudioDevice_0600
3576 * @tc.name make SPEAKER device type, set disable device
3577 * @tc.desc Function test
3578 * @tc.require: issueI5JUAQ
3579 */
3580 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetAudioDevice_0600, Function | MediumTest | Level2)
3581 {
3582 AccessToken token;
3583 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3584 return;
3585 }
3586
3587 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
3588 std::string phoneNumber = "00000000000";
3589 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
3590 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
3591
3592 std::string address = "";
3593 if (CallInfoManager::HasActiveStatus()) {
3594 EXPECT_EQ(clientPtr_->SetAudioDevice(AudioDevice::DEVICE_DISABLE, address), RETURN_VALUE_IS_ZERO);
3595 }
3596
3597 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
3598 HangUpCall();
3599 EXPECT_EQ(CallInfoManager::HasState(newCallId_, (int32_t)TelCallState::CALL_STATUS_DISCONNECTED), true);
3600 }
3601 }
3602
3603 /**
3604 * @tc.number Telephony_CallManager_SetAudioDevice_0700
3605 * @tc.name make SPEAKER device type, set unknown device
3606 * @tc.desc Function test
3607 * @tc.require: issueI5JUAQ
3608 */
3609 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetAudioDevice_0700, Function | MediumTest | Level2)
3610 {
3611 AccessToken token;
3612 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3613 return;
3614 }
3615
3616 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
3617 std::string phoneNumber = "00000000000";
3618 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
3619 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
3620
3621 std::string address = "";
3622 if (CallInfoManager::HasActiveStatus()) {
3623 EXPECT_EQ(clientPtr_->SetAudioDevice(AudioDevice::DEVICE_UNKNOWN, address), RETURN_VALUE_IS_ZERO);
3624 }
3625
3626 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
3627 HangUpCall();
3628 EXPECT_EQ(CallInfoManager::HasState(newCallId_, (int32_t)TelCallState::CALL_STATUS_DISCONNECTED), true);
3629 }
3630 }
3631
3632 /********************************************* Test SetMuted()***********************************************/
3633 /**
3634 * @tc.number Telephony_CallManager_SetMuted_0100
3635 * @tc.name set muted true
3636 * @tc.desc Function test
3637 * @tc.require: issueI5K59I
3638 */
3639 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetMuted_0100, Function | MediumTest | Level2)
3640 {
3641 AccessToken token;
3642 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3643 return;
3644 }
3645
3646 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
3647 std::string phoneNumber = "00000000000";
3648 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
3649 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
3650 bool muted = true;
3651 if (CallInfoManager::HasActiveStatus()) {
3652 EXPECT_EQ(CallManagerGtest::clientPtr_->SetMuted(muted), RETURN_VALUE_IS_ZERO);
3653 }
3654
3655 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
3656 HangUpCall();
3657 EXPECT_EQ(CallInfoManager::HasState(newCallId_, (int32_t)TelCallState::CALL_STATUS_DISCONNECTED), true);
3658 }
3659 }
3660
3661 /**
3662 * @tc.number Telephony_CallManager_SetMuted_0200
3663 * @tc.name without call, set muted failed
3664 * @tc.desc Function test
3665 * @tc.require: issueI5K59I
3666 */
3667 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetMuted_0200, Function | MediumTest | Level2)
3668 {
3669 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3670 return;
3671 }
3672
3673 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
3674 bool muted = true;
3675
3676 EXPECT_EQ(CallManagerGtest::clientPtr_->SetMuted(muted), CALL_ERR_AUDIO_SETTING_MUTE_FAILED);
3677 }
3678
3679 /**
3680 * @tc.number Telephony_CallManager_SetMuted_0300
3681 * @tc.name set muted true
3682 * @tc.desc Function test
3683 * @tc.require: issueI5K59I
3684 */
3685 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetMuted_0300, Function | MediumTest | Level2)
3686 {
3687 AccessToken token;
3688 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3689 return;
3690 }
3691
3692 EXPECT_EQ(CallManagerGtest::IsServiceConnected(), true);
3693 std::string phoneNumber = "00000000000";
3694 int32_t ret = CallManagerGtest::clientPtr_->DialCall(Str8ToStr16(phoneNumber), dialInfo_);
3695 EXPECT_EQ(ret, RETURN_VALUE_IS_ZERO);
3696 bool muted = false;
3697 if (CallInfoManager::HasActiveStatus()) {
3698 EXPECT_EQ(CallManagerGtest::clientPtr_->SetMuted(muted), RETURN_VALUE_IS_ZERO);
3699 }
3700
3701 if (clientPtr_->GetCallState() == static_cast<int>(CallStateToApp::CALL_STATE_OFFHOOK)) {
3702 HangUpCall();
3703 EXPECT_EQ(CallInfoManager::HasState(newCallId_, (int32_t)TelCallState::CALL_STATUS_DISCONNECTED), true);
3704 }
3705 }
3706
3707 /********************************************* Test RegisterCallBack() ***********************************************/
3708 /**
3709 * @tc.number Telephony_CallManager_RegisterCallBack_0100
3710 * @tc.name test register callback
3711 * @tc.desc Function test
3712 */
3713 HWTEST_F(CallManagerGtest, Telephony_CallManager_RegisterCallBack_0100, Function | MediumTest | Level3)
3714 {
3715 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3716 return;
3717 }
3718
3719 std::unique_ptr<CallManagerCallback> callManagerCallbackPtr = std::make_unique<CallManagerCallBackStub>();
3720 if (callManagerCallbackPtr == nullptr) {
3721 return;
3722 }
3723 EXPECT_EQ(CallManagerGtest::clientPtr_->RegisterCallBack(std::move(callManagerCallbackPtr)), RETURN_VALUE_IS_ZERO);
3724 }
3725
3726 /*************************************** Test UnRegisterCallBack() ********************************************/
3727 /**
3728 * @tc.number Telephony_CallManager_UnRegisterCallBack_0100
3729 * @tc.name test register callback
3730 * @tc.desc Function test
3731 */
3732 HWTEST_F(CallManagerGtest, Telephony_CallManager_UnRegisterCallBack_0100, Function | MediumTest | Level3)
3733 {
3734 AccessToken token;
3735 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3736 return;
3737 }
3738
3739 EXPECT_EQ(CallManagerGtest::clientPtr_->UnRegisterCallBack(), RETURN_VALUE_IS_ZERO);
3740 }
3741
3742 /************************************ Test SetCallPreferenceMode() *****************************************/
3743 /**
3744 * @tc.number Telephony_CallManager_SetCallPreferenceMode_0100
3745 * @tc.name test set call preference mode cs voice only
3746 * @tc.desc Function test
3747 */
3748 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallPreferenceMode_0100, Function | MediumTest | Level3)
3749 {
3750 AccessToken token;
3751 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3752 return;
3753 }
3754
3755 int32_t mode = CS_VOICE_ONLY;
3756 if (HasSimCard(SIM1_SLOTID)) {
3757 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM1_SLOTID, mode), RETURN_VALUE_IS_ZERO);
3758 }
3759 if (HasSimCard(SIM2_SLOTID)) {
3760 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM2_SLOTID, mode), RETURN_VALUE_IS_ZERO);
3761 }
3762 }
3763
3764 /**
3765 * @tc.number Telephony_CallManager_SetCallPreferenceMode_0200
3766 * @tc.name test set call preference mode with error mode
3767 * @tc.desc Function test
3768 */
3769 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallPreferenceMode_0200, Function | MediumTest | Level3)
3770 {
3771 AccessToken token;
3772 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3773 return;
3774 }
3775
3776 int32_t mode = 0;
3777 if (HasSimCard(SIM1_SLOTID)) {
3778 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM1_SLOTID, mode), RETURN_VALUE_IS_ZERO);
3779 }
3780 if (HasSimCard(SIM2_SLOTID)) {
3781 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM2_SLOTID, mode), RETURN_VALUE_IS_ZERO);
3782 }
3783 }
3784
3785 /**
3786 * @tc.number Telephony_CallManager_SetCallPreferenceMode_0300
3787 * @tc.name test set call preference mode with cs voice prefered
3788 * @tc.desc Function test
3789 */
3790 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallPreferenceMode_0300, Function | MediumTest | Level3)
3791 {
3792 AccessToken token;
3793 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3794 return;
3795 }
3796
3797 int32_t mode = CS_VOICE_PREFERRED;
3798 if (HasSimCard(SIM1_SLOTID)) {
3799 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM1_SLOTID, mode), RETURN_VALUE_IS_ZERO);
3800 }
3801 if (HasSimCard(SIM2_SLOTID)) {
3802 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM2_SLOTID, mode), RETURN_VALUE_IS_ZERO);
3803 }
3804 }
3805
3806 /**
3807 * @tc.number Telephony_CallManager_SetCallPreferenceMode_0400
3808 * @tc.name test set call preference mode with ims ps voice prefered
3809 * @tc.desc Function test
3810 */
3811 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallPreferenceMode_0400, Function | MediumTest | Level3)
3812 {
3813 AccessToken token;
3814 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3815 return;
3816 }
3817
3818 int32_t mode = IMS_PS_VOICE_PREFERRED;
3819 if (HasSimCard(SIM1_SLOTID)) {
3820 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM1_SLOTID, mode), RETURN_VALUE_IS_ZERO);
3821 }
3822 if (HasSimCard(SIM2_SLOTID)) {
3823 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM2_SLOTID, mode), RETURN_VALUE_IS_ZERO);
3824 }
3825 }
3826
3827 /**
3828 * @tc.number Telephony_CallManager_SetCallPreferenceMode_0500
3829 * @tc.name test set call preference mode with ims ps voice only
3830 * @tc.desc Function test
3831 */
3832 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetCallPreferenceMode_0500, Function | MediumTest | Level3)
3833 {
3834 AccessToken token;
3835 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3836 return;
3837 }
3838
3839 int32_t mode = IMS_PS_VOICE_ONLY;
3840 if (HasSimCard(SIM1_SLOTID)) {
3841 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM1_SLOTID, mode), RETURN_VALUE_IS_ZERO);
3842 }
3843 if (HasSimCard(SIM2_SLOTID)) {
3844 EXPECT_EQ(CallManagerGtest::clientPtr_->SetCallPreferenceMode(SIM2_SLOTID, mode), RETURN_VALUE_IS_ZERO);
3845 }
3846 }
3847
3848 /*************************************** Test IsInEmergencyCall() **************************************/
3849 /**
3850 * @tc.number Telephony_CallManager_IsInEmergencyCall_0100
3851 * @tc.name test is in emergency call
3852 * @tc.desc Function test
3853 */
3854 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsInEmergencyCall_0100, Function | MediumTest | Level3)
3855 {
3856 AccessToken token;
3857 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3858 return;
3859 }
3860 bool enabled = false;
3861 EXPECT_EQ(CallManagerGtest::clientPtr_->IsInEmergencyCall(enabled), TELEPHONY_SUCCESS);
3862 EXPECT_EQ(enabled, false);
3863 }
3864
3865 /**
3866 * @tc.number Telephony_CallManager_IsInEmergencyCall_0200
3867 * @tc.name test is in emergency call
3868 * @tc.desc Function test
3869 */
3870 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsInEmergencyCall_0200, Function | MediumTest | Level3)
3871 {
3872 AccessToken token;
3873 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3874 return;
3875 }
3876 ASSERT_TRUE(blueToothClientPtr_ != nullptr);
3877 bool enabled = false;
3878 EXPECT_EQ(CallManagerGtest::blueToothClientPtr_->IsInEmergencyCall(enabled), TELEPHONY_SUCCESS);
3879 EXPECT_EQ(enabled, false);
3880 }
3881
3882 /**
3883 * @tc.number Telephony_CallManager_IsInEmergencyCall_0300
3884 * @tc.name test is in emergency call without permission
3885 * @tc.desc Function test
3886 */
3887 HWTEST_F(CallManagerGtest, Telephony_CallManager_IsInEmergencyCall_0300, Function | MediumTest | Level3)
3888 {
3889 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3890 return;
3891 }
3892 bool enabled = false;
3893 EXPECT_NE(CallManagerGtest::clientPtr_->IsInEmergencyCall(enabled), TELEPHONY_SUCCESS);
3894 EXPECT_EQ(enabled, false);
3895 }
3896
3897 /****************************************** Test MuteRinger() *******************************************/
3898 /**
3899 * @tc.number Telephony_CallManager_MuteRinger_0100
3900 * @tc.name test mute ringer
3901 * @tc.desc Function test
3902 */
3903 HWTEST_F(CallManagerGtest, Telephony_CallManager_MuteRinger_0100, Function | MediumTest | Level3)
3904 {
3905 AccessToken token;
3906 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3907 return;
3908 }
3909
3910 EXPECT_EQ(CallManagerGtest::clientPtr_->MuteRinger(), RETURN_VALUE_IS_ZERO);
3911 }
3912
3913 /********************************************* Test GetImsConfig() ************************************************/
3914 /**
3915 * @tc.number Telephony_CallManager_GetImsConfig_0100
3916 * @tc.name test get ims config item video quality
3917 * @tc.desc Function test
3918 */
3919 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsConfig_0100, Function | MediumTest | Level3)
3920 {
3921 AccessToken token;
3922 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3923 return;
3924 }
3925
3926 if (HasSimCard(SIM1_SLOTID)) {
3927 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsConfig(SIM1_SLOTID, ITEM_VIDEO_QUALITY), RETURN_VALUE_IS_ZERO);
3928 }
3929 if (HasSimCard(SIM2_SLOTID)) {
3930 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsConfig(SIM2_SLOTID, ITEM_VIDEO_QUALITY), RETURN_VALUE_IS_ZERO);
3931 }
3932 }
3933
3934 /**
3935 * @tc.number Telephony_CallManager_GetImsConfig_0200
3936 * @tc.name test get ims config item ims switch status
3937 * @tc.desc Function test
3938 */
3939 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsConfig_0200, Function | MediumTest | Level3)
3940 {
3941 AccessToken token;
3942 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3943 return;
3944 }
3945
3946 if (HasSimCard(SIM1_SLOTID)) {
3947 EXPECT_EQ(
3948 CallManagerGtest::clientPtr_->GetImsConfig(SIM1_SLOTID, ITEM_IMS_SWITCH_STATUS), RETURN_VALUE_IS_ZERO);
3949 }
3950 if (HasSimCard(SIM2_SLOTID)) {
3951 EXPECT_EQ(
3952 CallManagerGtest::clientPtr_->GetImsConfig(SIM2_SLOTID, ITEM_IMS_SWITCH_STATUS), RETURN_VALUE_IS_ZERO);
3953 }
3954 }
3955
3956 /**
3957 * @tc.number Telephony_CallManager_GetImsConfig_0300
3958 * @tc.name test get ims config item with invalid item
3959 * @tc.desc Function test
3960 */
3961 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsConfig_0300, Function | MediumTest | Level3)
3962 {
3963 AccessToken token;
3964 ImsConfigItem item = static_cast<ImsConfigItem>(2);
3965 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3966 return;
3967 }
3968
3969 if (HasSimCard(SIM1_SLOTID)) {
3970 EXPECT_EQ(
3971 CallManagerGtest::clientPtr_->GetImsConfig(SIM1_SLOTID, item), RETURN_VALUE_IS_ZERO);
3972 }
3973 if (HasSimCard(SIM2_SLOTID)) {
3974 EXPECT_EQ(
3975 CallManagerGtest::clientPtr_->GetImsConfig(SIM2_SLOTID, item), RETURN_VALUE_IS_ZERO);
3976 }
3977 }
3978
3979 /********************************************* Test SetImsConfig() ************************************************/
3980 /**
3981 * @tc.number Telephony_CallManager_SetImsConfig_0100
3982 * @tc.name test set ims config item video quality
3983 * @tc.desc Function test
3984 */
3985 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsConfig_0100, Function | MediumTest | Level3)
3986 {
3987 AccessToken token;
3988 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
3989 return;
3990 }
3991
3992 std::u16string value = u"123";
3993 if (HasSimCard(SIM1_SLOTID)) {
3994 EXPECT_EQ(
3995 CallManagerGtest::clientPtr_->SetImsConfig(SIM1_SLOTID, ITEM_VIDEO_QUALITY, value), RETURN_VALUE_IS_ZERO);
3996 }
3997 if (HasSimCard(SIM2_SLOTID)) {
3998 EXPECT_EQ(
3999 CallManagerGtest::clientPtr_->SetImsConfig(SIM2_SLOTID, ITEM_VIDEO_QUALITY, value), RETURN_VALUE_IS_ZERO);
4000 }
4001 }
4002
4003 /**
4004 * @tc.number Telephony_CallManager_SetImsConfig_0200
4005 * @tc.name test set ims config item ims switch status
4006 * @tc.desc Function test
4007 */
4008 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsConfig_0200, Function | MediumTest | Level3)
4009 {
4010 AccessToken token;
4011 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4012 return;
4013 }
4014
4015 std::u16string value = u"123";
4016 if (HasSimCard(SIM1_SLOTID)) {
4017 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsConfig(SIM1_SLOTID, ITEM_IMS_SWITCH_STATUS, value),
4018 RETURN_VALUE_IS_ZERO);
4019 }
4020 if (HasSimCard(SIM2_SLOTID)) {
4021 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsConfig(SIM2_SLOTID, ITEM_IMS_SWITCH_STATUS, value),
4022 RETURN_VALUE_IS_ZERO);
4023 }
4024 }
4025
4026 /**
4027 * @tc.number Telephony_CallManager_SetImsConfig_0300
4028 * @tc.name test set ims config item with invalid item
4029 * @tc.desc Function test
4030 */
4031 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsConfig_0300, Function | MediumTest | Level3)
4032 {
4033 AccessToken token;
4034 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4035 return;
4036 }
4037
4038 std::u16string value = u"123";
4039 ImsConfigItem item = static_cast<ImsConfigItem>(2);
4040 if (HasSimCard(SIM1_SLOTID)) {
4041 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsConfig(SIM1_SLOTID, item, value),
4042 RETURN_VALUE_IS_ZERO);
4043 }
4044 if (HasSimCard(SIM2_SLOTID)) {
4045 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsConfig(SIM2_SLOTID, item, value),
4046 RETURN_VALUE_IS_ZERO);
4047 }
4048 }
4049
4050 /*********************************** Test GetImsFeatureValue() ****************************************/
4051 /**
4052 * @tc.number Telephony_CallManager_GetImsFeatureValue_0100
4053 * @tc.name test get ims feature value type voice over lte
4054 * @tc.desc Function test
4055 */
4056 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsFeatureValue_0100, Function | MediumTest | Level3)
4057 {
4058 AccessToken token;
4059 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4060 return;
4061 }
4062
4063 if (HasSimCard(SIM1_SLOTID)) {
4064 EXPECT_EQ(
4065 CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM1_SLOTID, TYPE_VOICE_OVER_LTE), RETURN_VALUE_IS_ZERO);
4066 }
4067 if (HasSimCard(SIM2_SLOTID)) {
4068 EXPECT_EQ(
4069 CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM2_SLOTID, TYPE_VOICE_OVER_LTE), RETURN_VALUE_IS_ZERO);
4070 }
4071 }
4072
4073 /**
4074 * @tc.number Telephony_CallManager_GetImsFeatureValue_0200
4075 * @tc.name test get ims feature value type video over lte
4076 * @tc.desc Function test
4077 */
4078 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsFeatureValue_0200, Function | MediumTest | Level3)
4079 {
4080 AccessToken token;
4081 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4082 return;
4083 }
4084
4085 if (HasSimCard(SIM1_SLOTID)) {
4086 EXPECT_EQ(
4087 CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM1_SLOTID, TYPE_VIDEO_OVER_LTE), RETURN_VALUE_IS_ZERO);
4088 }
4089 if (HasSimCard(SIM2_SLOTID)) {
4090 EXPECT_EQ(
4091 CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM2_SLOTID, TYPE_VIDEO_OVER_LTE), RETURN_VALUE_IS_ZERO);
4092 }
4093 }
4094
4095 /**
4096 * @tc.number Telephony_CallManager_GetImsFeatureValue_0300
4097 * @tc.name test get ims feature value type ss over ut
4098 * @tc.desc Function test
4099 */
4100 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsFeatureValue_0300, Function | MediumTest | Level3)
4101 {
4102 AccessToken token;
4103 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4104 return;
4105 }
4106
4107 if (HasSimCard(SIM1_SLOTID)) {
4108 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM1_SLOTID, TYPE_SS_OVER_UT), RETURN_VALUE_IS_ZERO);
4109 }
4110 if (HasSimCard(SIM2_SLOTID)) {
4111 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM2_SLOTID, TYPE_SS_OVER_UT), RETURN_VALUE_IS_ZERO);
4112 }
4113 }
4114
4115 /**
4116 * @tc.number Telephony_CallManager_GetImsFeatureValue_0400
4117 * @tc.name test get ims feature value with invalid type
4118 * @tc.desc Function test
4119 */
4120 HWTEST_F(CallManagerGtest, Telephony_CallManager_GetImsFeatureValue_0400, Function | MediumTest | Level3)
4121 {
4122 AccessToken token;
4123 FeatureType type = static_cast<FeatureType>(3);
4124 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4125 return;
4126 }
4127
4128 if (HasSimCard(SIM1_SLOTID)) {
4129 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM1_SLOTID, type), RETURN_VALUE_IS_ZERO);
4130 }
4131 if (HasSimCard(SIM2_SLOTID)) {
4132 EXPECT_EQ(CallManagerGtest::clientPtr_->GetImsFeatureValue(SIM2_SLOTID, type), RETURN_VALUE_IS_ZERO);
4133 }
4134 }
4135
4136 /***************************************** Test SetImsFeatureValue() ***************************************/
4137 /**
4138 * @tc.number Telephony_CallManager_SetImsFeatureValue_0100
4139 * @tc.name test set ims feature value type voice over lte
4140 * @tc.desc Function test
4141 */
4142 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsFeatureValue_0100, Function | MediumTest | Level3)
4143 {
4144 AccessToken token;
4145 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4146 return;
4147 }
4148
4149 int32_t value = 1;
4150 if (HasSimCard(SIM1_SLOTID)) {
4151 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM1_SLOTID, TYPE_VOICE_OVER_LTE, value),
4152 RETURN_VALUE_IS_ZERO);
4153 }
4154 if (HasSimCard(SIM2_SLOTID)) {
4155 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM2_SLOTID, TYPE_VOICE_OVER_LTE, value),
4156 RETURN_VALUE_IS_ZERO);
4157 }
4158 }
4159
4160 /**
4161 * @tc.number Telephony_CallManager_SetImsFeatureValue_0200
4162 * @tc.name test set ims feature value type video over lte
4163 * @tc.desc Function test
4164 */
4165 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsFeatureValue_0200, Function | MediumTest | Level3)
4166 {
4167 AccessToken token;
4168 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4169 return;
4170 }
4171
4172 int32_t value = 1;
4173 if (HasSimCard(SIM1_SLOTID)) {
4174 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM1_SLOTID, TYPE_VIDEO_OVER_LTE, value),
4175 RETURN_VALUE_IS_ZERO);
4176 }
4177 if (HasSimCard(SIM2_SLOTID)) {
4178 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM2_SLOTID, TYPE_VIDEO_OVER_LTE, value),
4179 RETURN_VALUE_IS_ZERO);
4180 }
4181 }
4182
4183 /**
4184 * @tc.number Telephony_CallManager_SetImsFeatureValue_0300
4185 * @tc.name test set ims feature value type ss over ut
4186 * @tc.desc Function test
4187 */
4188 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsFeatureValue_0300, Function | MediumTest | Level3)
4189 {
4190 AccessToken token;
4191 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4192 return;
4193 }
4194
4195 int32_t value = 1;
4196 if (HasSimCard(SIM1_SLOTID)) {
4197 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM1_SLOTID, TYPE_SS_OVER_UT, value),
4198 RETURN_VALUE_IS_ZERO);
4199 }
4200 if (HasSimCard(SIM2_SLOTID)) {
4201 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM2_SLOTID, TYPE_SS_OVER_UT, value),
4202 RETURN_VALUE_IS_ZERO);
4203 }
4204 }
4205
4206 /**
4207 * @tc.number Telephony_CallManager_SetImsFeatureValue_0400
4208 * @tc.name test set ims feature value with invalid type
4209 * @tc.desc Function test
4210 */
4211 HWTEST_F(CallManagerGtest, Telephony_CallManager_SetImsFeatureValue_0400, Function | MediumTest | Level3)
4212 {
4213 AccessToken token;
4214 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4215 return;
4216 }
4217
4218 int32_t value = 1;
4219 FeatureType type = static_cast<FeatureType>(3);
4220 if (HasSimCard(SIM1_SLOTID)) {
4221 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM1_SLOTID, type, value), RETURN_VALUE_IS_ZERO);
4222 }
4223 if (HasSimCard(SIM2_SLOTID)) {
4224 EXPECT_EQ(CallManagerGtest::clientPtr_->SetImsFeatureValue(SIM2_SLOTID, type, value), RETURN_VALUE_IS_ZERO);
4225 }
4226 }
4227
4228 /************************************** Test UpdateImsCallMode() ****************************************/
4229 /**
4230 * @tc.number Telephony_CallManager_UpdateImsCallMode_0100
4231 * @tc.name test update ims call mode audio only
4232 * @tc.desc Function test
4233 */
4234 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0100, Function | MediumTest | Level3)
4235 {
4236 AccessToken token;
4237 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4238 return;
4239 }
4240
4241 int32_t callId = 1;
4242 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_AUDIO_ONLY), RETURN_VALUE_IS_ZERO);
4243 }
4244
4245 /**
4246 * @tc.number Telephony_CallManager_UpdateImsCallMode_0200
4247 * @tc.name test update ims call mode send only
4248 * @tc.desc Function test
4249 */
4250 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0200, Function | MediumTest | Level3)
4251 {
4252 AccessToken token;
4253 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4254 return;
4255 }
4256
4257 int32_t callId = 1;
4258 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_SEND_ONLY), RETURN_VALUE_IS_ZERO);
4259 }
4260
4261 /**
4262 * @tc.number Telephony_CallManager_UpdateImsCallMode_0300
4263 * @tc.name test update ims call mode recerve only
4264 * @tc.desc Function test
4265 */
4266 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0300, Function | MediumTest | Level3)
4267 {
4268 AccessToken token;
4269 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4270 return;
4271 }
4272
4273 int32_t callId = 1;
4274 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_RECEIVE_ONLY), RETURN_VALUE_IS_ZERO);
4275 }
4276
4277 /**
4278 * @tc.number Telephony_CallManager_UpdateImsCallMode_0400
4279 * @tc.name test update ims call mode send receive
4280 * @tc.desc Function test
4281 */
4282 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0400, Function | MediumTest | Level3)
4283 {
4284 AccessToken token;
4285 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4286 return;
4287 }
4288
4289 int32_t callId = 1;
4290 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_SEND_RECEIVE), RETURN_VALUE_IS_ZERO);
4291 }
4292
4293 /**
4294 * @tc.number Telephony_CallManager_UpdateImsCallMode_0500
4295 * @tc.name test update ims call mode video paused
4296 * @tc.desc Function test
4297 */
4298 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0500, Function | MediumTest | Level3)
4299 {
4300 AccessToken token;
4301 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4302 return;
4303 }
4304
4305 int32_t callId = 1;
4306 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, CALL_MODE_VIDEO_PAUSED), RETURN_VALUE_IS_ZERO);
4307 }
4308
4309 /**
4310 * @tc.number Telephony_CallManager_UpdateImsCallMode_0600
4311 * @tc.name test update ims call with invalid mode
4312 * @tc.desc Function test
4313 */
4314 HWTEST_F(CallManagerGtest, Telephony_CallManager_UpdateImsCallMode_0600, Function | MediumTest | Level3)
4315 {
4316 AccessToken token;
4317 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4318 return;
4319 }
4320
4321 int32_t callId = 1;
4322 ImsCallMode mode = static_cast<ImsCallMode>(5);
4323 EXPECT_NE(CallManagerGtest::clientPtr_->UpdateImsCallMode(callId, mode), RETURN_VALUE_IS_ZERO);
4324 }
4325
4326 /********************************************* Test StartRtt() ************************************************/
4327 /**
4328 * @tc.number Telephony_CallManager_StartRtt_0100
4329 * @tc.name test start rtt
4330 * @tc.desc Function test
4331 */
4332 HWTEST_F(CallManagerGtest, Telephony_CallManager_StartRtt_0100, Function | MediumTest | Level3)
4333 {
4334 AccessToken token;
4335 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4336 return;
4337 }
4338
4339 std::u16string msg = u"123";
4340 int32_t callId = 1;
4341 EXPECT_NE(CallManagerGtest::clientPtr_->StartRtt(callId, msg), RETURN_VALUE_IS_ZERO);
4342 }
4343
4344 /********************************************* Test StopRtt() ************************************************/
4345 /**
4346 * @tc.number Telephony_CallManager_StopRtt_0100
4347 * @tc.name test stop rtt
4348 * @tc.desc Function test
4349 */
4350 HWTEST_F(CallManagerGtest, Telephony_CallManager_StopRtt_0100, Function | MediumTest | Level3)
4351 {
4352 AccessToken token;
4353 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4354 return;
4355 }
4356 int32_t callId = 1;
4357 EXPECT_NE(CallManagerGtest::clientPtr_->StopRtt(callId), RETURN_VALUE_IS_ZERO);
4358 }
4359
4360 /********************************************* Test JoinConference() *********************************************/
4361 /**
4362 * @tc.number Telephony_CallManager_JoinConference_0100
4363 * @tc.name test join conference
4364 * @tc.desc Function test
4365 */
4366 HWTEST_F(CallManagerGtest, Telephony_CallManager_JoinConference_0100, Function | MediumTest | Level3)
4367 {
4368 AccessToken token;
4369 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4370 return;
4371 }
4372 int32_t callId = 1;
4373 std::vector<std::u16string> numberList { u"0000000000" };
4374 EXPECT_NE(CallManagerGtest::clientPtr_->JoinConference(callId, numberList), RETURN_VALUE_IS_ZERO);
4375 }
4376
4377 /**
4378 * @tc.number Telephony_CallManager_JoinConference_0200
4379 * @tc.name test join conference with empty numberList
4380 * @tc.desc Function test
4381 */
4382 HWTEST_F(CallManagerGtest, Telephony_CallManager_JoinConference_0200, Function | MediumTest | Level3)
4383 {
4384 AccessToken token;
4385 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4386 return;
4387 }
4388 int32_t callId = 1;
4389 std::vector<std::u16string> numberList;
4390 EXPECT_NE(CallManagerGtest::clientPtr_->JoinConference(callId, numberList), CALL_ERR_PHONE_NUMBER_EMPTY);
4391 }
4392
4393 /*********************************** Test ReportOttCallDetailsInfo() ***********************************/
4394 /**
4395 * @tc.number Telephony_CallManager_ReportOttCallDetailsInfo_0100
4396 * @tc.name test report ott call details info
4397 * @tc.desc Function test
4398 */
4399 HWTEST_F(CallManagerGtest, Telephony_CallManager_ReportOttCallDetailsInfo_0100, Function | MediumTest | Level3)
4400 {
4401 AccessToken token;
4402 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4403 return;
4404 }
4405 OttCallDetailsInfo info;
4406 const char *number = "000000";
4407 memcpy_s(info.phoneNum, kMaxNumberLen, number, strlen(number));
4408 const char *bundleName = "com.ohos.tddtest";
4409 memcpy_s(info.bundleName, kMaxNumberLen, bundleName, strlen(bundleName));
4410 info.callState = TelCallState::CALL_STATUS_DIALING;
4411 info.videoState = VideoStateType::TYPE_VOICE;
4412 std::vector<OttCallDetailsInfo> ottVec { info };
4413 EXPECT_EQ(CallManagerGtest::clientPtr_->ReportOttCallDetailsInfo(ottVec), RETURN_VALUE_IS_ZERO);
4414 }
4415
4416 /**
4417 * @tc.number Telephony_CallManager_ReportOttCallDetailsInfo_0200
4418 * @tc.name test report ott call details info
4419 * @tc.desc Function test
4420 */
4421 HWTEST_F(CallManagerGtest, Telephony_CallManager_ReportOttCallDetailsInfo_0200, Function | MediumTest | Level3)
4422 {
4423 AccessToken token;
4424 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4425 return;
4426 }
4427 std::vector<OttCallDetailsInfo> ottVec;
4428 EXPECT_NE(CallManagerGtest::clientPtr_->ReportOttCallDetailsInfo(ottVec), RETURN_VALUE_IS_ZERO);
4429 }
4430
4431 /************************************* Test ReportOttCallEventInfo() ************************************/
4432 /**
4433 * @tc.number Telephony_CallManager_ReportOttCallEventInfo_0100
4434 * @tc.name test report ott call details info
4435 * @tc.desc Function test
4436 */
4437 HWTEST_F(CallManagerGtest, Telephony_CallManager_ReportOttCallEventInfo_0100, Function | MediumTest | Level3)
4438 {
4439 AccessToken token;
4440 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4441 return;
4442 }
4443 OttCallEventInfo info;
4444 info.ottCallEventId = OttCallEventId::OTT_CALL_EVENT_FUNCTION_UNSUPPORTED;
4445 char bundlename[] = "com.ohos.tddtest";
4446 memcpy_s(info.bundleName, kMaxNumberLen, bundlename, strlen(bundlename));
4447 EXPECT_NE(CallManagerGtest::clientPtr_->ReportOttCallEventInfo(info), RETURN_VALUE_IS_ZERO);
4448 }
4449
4450 /*********************************** Test HasVoiceCapability() ***************************************/
4451 /**
4452 * @tc.number Telephony_CallManager_HasVoiceCapability_0100
4453 * @tc.name test report ott call details info
4454 * @tc.desc Function test
4455 */
4456 HWTEST_F(CallManagerGtest, Telephony_CallManager_HasVoiceCapability_0100, Function | MediumTest | Level3)
4457 {
4458 AccessToken token;
4459 if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
4460 return;
4461 }
4462
4463 EXPECT_EQ(CallManagerGtest::clientPtr_->HasVoiceCapability(), true);
4464 }
4465
4466 /*********************************** Test Dump() ***************************************/
4467 /**
4468 * @tc.number Telephony_CallManager_TestDump_0100
4469 * @tc.name Test Dump
4470 * @tc.desc Function test
4471 */
4472 HWTEST_F(CallManagerGtest, Telephony_CallManager_TestDump_0100, Function | MediumTest | Level3)
4473 {
4474 std::vector<std::u16string> emptyArgs = {};
4475 std::vector<std::u16string> args = { u"test", u"test1" };
4476 EXPECT_EQ(DelayedSingleton<CallManagerService>::GetInstance()->Dump(-1, args), TELEPHONY_ERR_ARGUMENT_INVALID);
4477 EXPECT_EQ(DelayedSingleton<CallManagerService>::GetInstance()->Dump(0, emptyArgs), 0);
4478 EXPECT_EQ(DelayedSingleton<CallManagerService>::GetInstance()->Dump(0, args), 0);
4479 }
4480
4481 #else // TEL_TEST_UNSUPPORT
4482 /**************************************** Test For Unsupported Platform **********************************************/
4483 /**
4484 * @tc.number Telephony_CallManager_Mock_0100
4485 * @tc.name test for unsupported platform
4486 * @tc.desc Function test
4487 */
4488 HWTEST_F(CallManagerGtest, Telephony_CallManager_Mock_0100, Function | MediumTest | Level3)
4489 {
4490 EXPECT_TRUE(true);
4491 }
4492
4493 #endif // TEL_TEST_UNSUPPORT
4494 } // namespace Telephony
4495 } // namespace OHOS
4496
