1 /*
2 * Copyright (C) 2021-2023 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 "gtest/gtest.h"
17
18 #define private public
19 #define protected public
20 #include "cellular_call_callback.h"
21 #include "cellular_call_handler.h"
22 #include "cellular_call_proxy.h"
23 #include "cellular_call_register.h"
24 #include "cellular_call_service.h"
25 #include "cellular_call_supplement.h"
26 #include "config_request.h"
27 #include "core_service_client.h"
28 #include "cs_control.h"
29 #include "tel_ril_call_parcel.h"
30 #include "operator_config_types.h"
31 #include "radio_event.h"
32 #include "securec.h"
33 #include "sim_state_type.h"
34 #include "system_ability_definition.h"
35 #include "token.h"
36
37 namespace OHOS {
38 namespace Telephony {
39 using namespace testing::ext;
40 const int32_t SIM1_SLOTID = 0;
41 const int32_t SIM2_SLOTID = 1;
42 const int32_t INVALID_SLOTID = 0xFF;
43 const std::string PHONE_NUMBER = "0000000";
44 const std::string PHONE_NUMBER_SECOND = "1111111";
45 const std::string PHONE_NUMBER_THIRD = "2222222";
46
47 class Cs1Test : public testing::Test {
48 public:
49 static void SetUpTestCase();
50 static void TearDownTestCase();
51 void SetUp();
52 void TearDown();
53 int32_t TestDialCallByCs(int32_t slotId, std::string code);
54 void JudgeIsEmergencyPhoneNumber();
HasSimCard(int32_t slotId)55 bool HasSimCard(int32_t slotId)
56 {
57 bool hasSimCard = false;
58 DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(slotId, hasSimCard);
59 return hasSimCard;
60 }
61 int32_t InitCellularCallInfo(int32_t accountId, std::string phonenumber, CellularCallInfo &callInfo);
62 };
63
TestDialCallByCs(int32_t slotId,std::string code)64 int32_t Cs1Test::TestDialCallByCs(int32_t slotId, std::string code)
65 {
66 AccessToken token;
67 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
68 if (systemAbilityMgr == nullptr) {
69 return TELEPHONY_ERR_FAIL;
70 }
71 auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
72 if (remote == nullptr) {
73 return TELEPHONY_ERR_FAIL;
74 }
75 auto telephonyService = iface_cast<CellularCallInterface>(remote);
76 if (telephonyService == nullptr) {
77 return TELEPHONY_ERR_FAIL;
78 }
79 CellularCallInfo callInfo;
80 int32_t ret = TELEPHONY_SUCCESS;
81 ret = InitCellularCallInfo(slotId, code, callInfo);
82 if (ret != TELEPHONY_SUCCESS) {
83 return ret;
84 }
85 // close ims, make this time use cs to test
86 ret = telephonyService->SetImsSwitchStatus(slotId, false);
87 if (ret != TELEPHONY_SUCCESS) {
88 return ret;
89 }
90 ret = telephonyService->Dial(callInfo);
91 return ret;
92 };
93
InitCellularCallInfo(int32_t accountId,std::string phonenumber,CellularCallInfo & callInfo)94 int32_t Cs1Test::InitCellularCallInfo(int32_t accountId, std::string phonenumber,
95 CellularCallInfo &callInfo)
96 {
97 callInfo.accountId = accountId;
98 callInfo.slotId = accountId;
99 callInfo.index = accountId;
100 callInfo.callType = CallType::TYPE_CS;
101 callInfo.videoState = 0; // 0 means audio
102 if (memset_s(callInfo.phoneNum, kMaxNumberLen, 0, kMaxNumberLen) != EOK) {
103 return TELEPHONY_ERR_MEMSET_FAIL;
104 }
105 if (phonenumber.length() > static_cast<size_t>(kMaxNumberLen)) {
106 return CALL_ERR_NUMBER_OUT_OF_RANGE;
107 }
108 if (memcpy_s(callInfo.phoneNum, kMaxNumberLen, phonenumber.c_str(), phonenumber.length()) != EOK) {
109 return TELEPHONY_ERR_MEMCPY_FAIL;
110 }
111 return TELEPHONY_SUCCESS;
112 };
113
JudgeIsEmergencyPhoneNumber()114 void Cs1Test::JudgeIsEmergencyPhoneNumber()
115 {
116 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
117 ASSERT_TRUE(systemAbilityMgr != nullptr);
118 auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
119 ASSERT_TRUE(remote != nullptr);
120 auto telephonyService = iface_cast<CellularCallInterface>(remote);
121 ASSERT_TRUE(telephonyService != nullptr);
122
123 bool enabled = false;
124 int32_t successCode = 1;
125 if (HasSimCard(SIM1_SLOTID)) {
126 telephonyService->IsEmergencyPhoneNumber(SIM1_SLOTID, "499", enabled);
127 EXPECT_NE(enabled, successCode);
128 telephonyService->IsEmergencyPhoneNumber(SIM1_SLOTID, "443", enabled);
129 EXPECT_NE(enabled, successCode);
130 telephonyService->IsEmergencyPhoneNumber(SIM1_SLOTID, "356", enabled);
131 EXPECT_NE(enabled, successCode);
132 telephonyService->IsEmergencyPhoneNumber(SIM1_SLOTID, "975", enabled);
133 EXPECT_NE(enabled, successCode);
134 telephonyService->IsEmergencyPhoneNumber(SIM1_SLOTID, "783", enabled);
135 EXPECT_NE(enabled, successCode);
136 telephonyService->IsEmergencyPhoneNumber(SIM1_SLOTID, "350", enabled);
137 EXPECT_NE(enabled, successCode);
138 }
139 if (HasSimCard(SIM2_SLOTID)) {
140 telephonyService->IsEmergencyPhoneNumber(SIM2_SLOTID, "499", enabled);
141 EXPECT_NE(enabled, successCode);
142 telephonyService->IsEmergencyPhoneNumber(SIM2_SLOTID, "443", enabled);
143 EXPECT_NE(enabled, successCode);
144 telephonyService->IsEmergencyPhoneNumber(SIM2_SLOTID, "356", enabled);
145 EXPECT_NE(enabled, successCode);
146 telephonyService->IsEmergencyPhoneNumber(SIM2_SLOTID, "975", enabled);
147 EXPECT_NE(enabled, successCode);
148 telephonyService->IsEmergencyPhoneNumber(SIM2_SLOTID, "783", enabled);
149 EXPECT_NE(enabled, successCode);
150 telephonyService->IsEmergencyPhoneNumber(SIM2_SLOTID, "350", enabled);
151 EXPECT_NE(enabled, successCode);
152 }
153 }
154
SetUpTestCase(void)155 void Cs1Test::SetUpTestCase(void)
156 {
157 // step 3: Set Up Test Case
158 }
159
TearDownTestCase(void)160 void Cs1Test::TearDownTestCase(void)
161 {
162 // step 3: Tear Down Test Case
163 }
164
SetUp(void)165 void Cs1Test::SetUp(void)
166 {
167 // step 3: input testcase setup step
168 }
169
TearDown(void)170 void Cs1Test::TearDown(void)
171 {
172 // step 3: input testcase teardown step
173 }
174
175 /**
176 * @tc.number cellular_call_cs_test_001
177 * @tc.name Test the corresponding functions by entering commands, such as 1 -- Dial, 2 -- Hangup, 3 -- Reject, etc
178 * @tc.desc Function test
179 */
180 HWTEST_F(Cs1Test, cellular_call_cs_test_001, Function | MediumTest | Level0)
181 {
182 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
183 ASSERT_TRUE(systemAbilityMgr != nullptr);
184 auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
185 ASSERT_TRUE(remote != nullptr);
186 auto telephonyService = iface_cast<CellularCallInterface>(remote);
187 ASSERT_TRUE(telephonyService != nullptr);
188 std::cout << "HWTEST_F cellular_call_cs_test_001";
189 }
190
191 /**
192 * @tc.number cellular_call_cs_test_002
193 * @tc.name Test the corresponding functions by entering commands, such as 1 -- Dial, 2 -- Hangup, 3 -- Reject, etc
194 * @tc.desc Function test
195 */
196 HWTEST_F(Cs1Test, cellular_call_cs_test_002, Function | MediumTest | Level1)
197 {
198 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
199 ASSERT_TRUE(systemAbilityMgr != nullptr);
200 auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
201 ASSERT_TRUE(remote != nullptr);
202 auto telephonyService = iface_cast<CellularCallInterface>(remote);
203 ASSERT_TRUE(telephonyService != nullptr);
204 std::cout << "HWTEST_F cellular_call_cs_test_002";
205 }
206
207 /**
208 * @tc.number Telephony_CallManager_SetEmergencyCallList_0101
209 * @tc.name SetEmergencyCallList "443,356,789",test SetEmergencyCallList(),return success
210 * @tc.desc Function test
211 */
212 HWTEST_F(Cs1Test, cellular_call_SetEmergencyCallList_0101, Function | MediumTest | Level3)
213 {
214 AccessToken token;
215 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
216 ASSERT_TRUE(systemAbilityMgr != nullptr);
217 auto emergencyRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
218 ASSERT_TRUE(emergencyRemote != nullptr);
219 auto telephonyService = iface_cast<CellularCallInterface>(emergencyRemote);
220 ASSERT_TRUE(telephonyService != nullptr);
221
222
223 std::vector<EmergencyCall> eccVec;
224 EmergencyCall temp0 = { "499", "460", EccType::TYPE_CATEGORY, SimpresentType::TYPE_NO_CARD,
225 AbnormalServiceType::TYPE_ALL };
226 EmergencyCall temp1 = { "443", "460", EccType::TYPE_POLICE, SimpresentType::TYPE_NO_CARD,
227 AbnormalServiceType::TYPE_ALL };
228 EmergencyCall temp2 = { "356", "460", EccType::TYPE_AMBULANCE, SimpresentType::TYPE_NO_CARD,
229 AbnormalServiceType::TYPE_ALL };
230 EmergencyCall temp3 = { "783", "460", EccType::TYPE_FIRE, SimpresentType::TYPE_NO_CARD,
231 AbnormalServiceType::TYPE_ALL };
232 EmergencyCall temp4 = { "975", "460", EccType::TYPE_SEA, SimpresentType::TYPE_HAS_CARD,
233 AbnormalServiceType::TYPE_ONLY_CS };
234 EmergencyCall temp5 = { "350", "460", EccType::TYPE_MOUNTAIN, SimpresentType::TYPE_HAS_CARD,
235 AbnormalServiceType::TYPE_ALL };
236 eccVec.push_back(temp0);
237 eccVec.push_back(temp1);
238 eccVec.push_back(temp2);
239 eccVec.push_back(temp3);
240 eccVec.push_back(temp4);
241 eccVec.push_back(temp5);
242 if (HasSimCard(SIM1_SLOTID)) {
243 EXPECT_EQ(telephonyService->SetEmergencyCallList(SIM1_SLOTID, eccVec), TELEPHONY_ERR_LOCAL_PTR_NULL);
244 }
245 if (HasSimCard(SIM2_SLOTID)) {
246 EXPECT_EQ(telephonyService->SetEmergencyCallList(SIM2_SLOTID, eccVec), TELEPHONY_ERR_LOCAL_PTR_NULL);
247 }
248 JudgeIsEmergencyPhoneNumber();
249 }
250
251 HWTEST_F(Cs1Test, cellular_call_IsOperatorConfigEmergencyCallList_0001, Function | MediumTest | Level3)
252 {
253 AccessToken token;
254 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
255 ASSERT_TRUE(systemAbilityMgr != nullptr);
256 auto operatorRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
257 ASSERT_TRUE(operatorRemote != nullptr);
258 auto telephonyService = iface_cast<CellularCallInterface>(operatorRemote);
259 ASSERT_TRUE(telephonyService != nullptr);
260
261 OperatorConfig opc;
262 if (HasSimCard(SIM1_SLOTID)) {
263 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOperatorConfigs(SIM1_SLOTID, opc);
264 if (opc.stringArrayValue.find(KEY_EMERGENCY_CALL_STRING_ARRAY) != opc.stringArrayValue.end()) {
265 for (auto number : opc.stringArrayValue[KEY_EMERGENCY_CALL_STRING_ARRAY]) {
266 bool enabled = false;
267 int32_t errorCode = telephonyService->IsEmergencyPhoneNumber(SIM1_SLOTID, number, enabled);
268 EXPECT_EQ(TELEPHONY_SUCCESS, errorCode);
269 }
270 }
271 }
272 if (HasSimCard(SIM2_SLOTID)) {
273 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOperatorConfigs(SIM2_SLOTID, opc);
274 if (opc.stringArrayValue.find(KEY_EMERGENCY_CALL_STRING_ARRAY) != opc.stringArrayValue.end()) {
275 for (auto number : opc.stringArrayValue[KEY_EMERGENCY_CALL_STRING_ARRAY]) {
276 bool enabled = false;
277 int32_t errorCode = telephonyService->IsEmergencyPhoneNumber(SIM2_SLOTID, number, enabled);
278 EXPECT_EQ(TELEPHONY_SUCCESS, errorCode);
279 }
280 }
281 }
282 }
283
284 /**
285 * @tc.number cellular_call_DialCall_0001
286 * @tc.name Test for SetClip function by cs
287 * @tc.desc Function test
288 */
289 HWTEST_F(Cs1Test, cellular_call_DialCall_0001, Function | MediumTest | Level2)
290 {
291 if (HasSimCard(SIM1_SLOTID)) {
292 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*30#");
293 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
294 }
295 if (HasSimCard(SIM2_SLOTID)) {
296 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*30#");
297 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
298 }
299 }
300
301 /**
302 * @tc.number cellular_call_DialCall_0002
303 * @tc.name Test for SetClip function by cs
304 * @tc.desc Function test
305 */
306 HWTEST_F(Cs1Test, cellular_call_DialCall_0002, Function | MediumTest | Level2)
307 {
308 if (HasSimCard(SIM1_SLOTID)) {
309 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#30#");
310 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
311 }
312 if (HasSimCard(SIM2_SLOTID)) {
313 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "#30#");
314 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
315 }
316 }
317
318 /**
319 * @tc.number cellular_call_DialCall_0003
320 * @tc.name Test for getClip function by cs
321 * @tc.desc Function test
322 */
323 HWTEST_F(Cs1Test, cellular_call_DialCall_0003, Function | MediumTest | Level2)
324 {
325 if (HasSimCard(SIM1_SLOTID)) {
326 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#30#");
327 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
328 }
329 if (HasSimCard(SIM2_SLOTID)) {
330 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*#30#");
331 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
332 }
333 }
334
335 /**
336 * @tc.number cellular_call_DialCall_0004
337 * @tc.name Test for SetClir function by cs
338 * @tc.desc Function test
339 */
340 HWTEST_F(Cs1Test, cellular_call_DialCall_0004, Function | MediumTest | Level2)
341 {
342 if (HasSimCard(SIM1_SLOTID)) {
343 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*31#");
344 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
345 }
346 if (HasSimCard(SIM2_SLOTID)) {
347 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*31#");
348 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
349 }
350 }
351
352 /**
353 * @tc.number cellular_call_DialCall_0005
354 * @tc.name Test for SetClir function by cs
355 * @tc.desc Function test
356 */
357 HWTEST_F(Cs1Test, cellular_call_DialCall_0005, Function | MediumTest | Level2)
358 {
359 if (HasSimCard(SIM1_SLOTID)) {
360 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#31#");
361 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
362 }
363 if (HasSimCard(SIM2_SLOTID)) {
364 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "#31#");
365 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
366 }
367 }
368
369 /**
370 * @tc.number cellular_call_DialCall_0006
371 * @tc.name Test for GetClir function by cs
372 * @tc.desc Function test
373 */
374 HWTEST_F(Cs1Test, cellular_call_DialCall_0006, Function | MediumTest | Level2)
375 {
376 if (HasSimCard(SIM1_SLOTID)) {
377 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#31#");
378 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
379 }
380 if (HasSimCard(SIM2_SLOTID)) {
381 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*#31#");
382 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
383 }
384 }
385
386 /**
387 * @tc.number cellular_call_DialCall_0007
388 * @tc.name Test for SetCallTransfer function by cs
389 * @tc.desc Function test
390 */
391 HWTEST_F(Cs1Test, cellular_call_DialCall_0007, Function | MediumTest | Level2)
392 {
393 if (HasSimCard(SIM1_SLOTID)) {
394 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*21#");
395 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
396 }
397 if (HasSimCard(SIM2_SLOTID)) {
398 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*21#");
399 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
400 }
401 }
402
403 /**
404 * @tc.number cellular_call_DialCall_0008
405 * @tc.name Test for SetCallTransfer function by cs
406 * @tc.desc Function test
407 */
408 HWTEST_F(Cs1Test, cellular_call_DialCall_0008, Function | MediumTest | Level2)
409 {
410 if (HasSimCard(SIM1_SLOTID)) {
411 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#21#");
412 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
413 }
414 if (HasSimCard(SIM2_SLOTID)) {
415 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "#21#");
416 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
417 }
418 }
419
420 /**
421 * @tc.number cellular_call_DialCall_0009
422 * @tc.name Test for GetCallTransfer function by cs
423 * @tc.desc Function test
424 */
425 HWTEST_F(Cs1Test, cellular_call_DialCall_0009, Function | MediumTest | Level2)
426 {
427 if (HasSimCard(SIM1_SLOTID)) {
428 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#21#");
429 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
430 }
431 if (HasSimCard(SIM2_SLOTID)) {
432 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*#21#");
433 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
434 }
435 }
436
437 /**
438 * @tc.number cellular_call_DialCall_0010
439 * @tc.name Test for SetCallRestriction function by cs
440 * @tc.desc Function test
441 */
442 HWTEST_F(Cs1Test, cellular_call_DialCall_0010, Function | MediumTest | Level2)
443 {
444 if (HasSimCard(SIM1_SLOTID)) {
445 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*33#");
446 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
447 }
448 if (HasSimCard(SIM2_SLOTID)) {
449 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*33#");
450 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
451 }
452 }
453
454 /**
455 * @tc.number cellular_call_DialCall_0011
456 * @tc.name Test for SetCallRestriction function by cs
457 * @tc.desc Function test
458 */
459 HWTEST_F(Cs1Test, cellular_call_DialCall_0011, Function | MediumTest | Level2)
460 {
461 if (HasSimCard(SIM1_SLOTID)) {
462 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#33#");
463 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
464 }
465 if (HasSimCard(SIM2_SLOTID)) {
466 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "#33#");
467 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
468 }
469 }
470
471 /**
472 * @tc.number cellular_call_DialCall_0012
473 * @tc.name Test for GetCallRestriction function by cs
474 * @tc.desc Function test
475 */
476 HWTEST_F(Cs1Test, cellular_call_DialCall_0012, Function | MediumTest | Level2)
477 {
478 if (HasSimCard(SIM1_SLOTID)) {
479 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#33#");
480 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
481 }
482 if (HasSimCard(SIM2_SLOTID)) {
483 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*#33#");
484 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
485 }
486 }
487
488 /**
489 * @tc.number cellular_call_DialCall_0013
490 * @tc.name Test for SetCallWaiting function by cs
491 * @tc.desc Function test
492 */
493 HWTEST_F(Cs1Test, cellular_call_DialCall_0013, Function | MediumTest | Level2)
494 {
495 if (HasSimCard(SIM1_SLOTID)) {
496 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*43#");
497 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
498 }
499 if (HasSimCard(SIM2_SLOTID)) {
500 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*43#");
501 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
502 }
503 }
504
505 /**
506 * @tc.number cellular_call_DialCall_0014
507 * @tc.name Test for SetCallWaiting function by cs
508 * @tc.desc Function test
509 */
510 HWTEST_F(Cs1Test, cellular_call_DialCall_0014, Function | MediumTest | Level2)
511 {
512 if (HasSimCard(SIM1_SLOTID)) {
513 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#43#");
514 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
515 }
516 if (HasSimCard(SIM2_SLOTID)) {
517 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "#43#");
518 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
519 }
520 }
521
522 /**
523 * @tc.number cellular_call_DialCall_0015
524 * @tc.name Test for GetCallWaiting function by cs
525 * @tc.desc Function test
526 */
527 HWTEST_F(Cs1Test, cellular_call_DialCall_0015, Function | MediumTest | Level2)
528 {
529 if (HasSimCard(SIM1_SLOTID)) {
530 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#43#");
531 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
532 }
533 if (HasSimCard(SIM2_SLOTID)) {
534 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*#43#");
535 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
536 }
537 }
538
539 /**
540 * @tc.number cellular_call_DialCall_0016
541 * @tc.name Test for AlterPinPassword function by cs
542 * @tc.desc Function test
543 */
544 HWTEST_F(Cs1Test, cellular_call_DialCall_0016, Function | MediumTest | Level2)
545 {
546 if (HasSimCard(SIM1_SLOTID)) {
547 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*04#");
548 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
549 }
550 if (HasSimCard(SIM2_SLOTID)) {
551 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*04#");
552 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
553 }
554 }
555
556 /**
557 * @tc.number cellular_call_DialCall_0017
558 * @tc.name Test for UnlockPuk function by cs
559 * @tc.desc Function test
560 */
561 HWTEST_F(Cs1Test, cellular_call_DialCall_0017, Function | MediumTest | Level2)
562 {
563 if (HasSimCard(SIM1_SLOTID)) {
564 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*05#");
565 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
566 }
567 if (HasSimCard(SIM2_SLOTID)) {
568 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*05#");
569 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
570 }
571 }
572
573 /**
574 * @tc.number cellular_call_DialCall_0018
575 * @tc.name Test for AlterPin2Password function by cs
576 * @tc.desc Function test
577 */
578 HWTEST_F(Cs1Test, cellular_call_DialCall_0018, Function | MediumTest | Level2)
579 {
580 if (HasSimCard(SIM1_SLOTID)) {
581 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*042#");
582 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
583 }
584 if (HasSimCard(SIM2_SLOTID)) {
585 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*042#");
586 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
587 }
588 }
589
590 /**
591 * @tc.number cellular_call_DialCall_0019
592 * @tc.name Test for UnlockPuk2 function by cs
593 * @tc.desc Function test
594 */
595 HWTEST_F(Cs1Test, cellular_call_DialCall_0019, Function | MediumTest | Level2)
596 {
597 if (HasSimCard(SIM1_SLOTID)) {
598 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*052#");
599 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
600 }
601 if (HasSimCard(SIM2_SLOTID)) {
602 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*052#");
603 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
604 }
605 }
606
607 /**
608 * @tc.number cellular_call_DialCall_0020
609 * @tc.name Test for SendUssd function by cs
610 * @tc.desc Function test
611 */
612 HWTEST_F(Cs1Test, cellular_call_DialCall_0020, Function | MediumTest | Level2)
613 {
614 if (HasSimCard(SIM1_SLOTID)) {
615 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*4444#");
616 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
617 }
618 if (HasSimCard(SIM2_SLOTID)) {
619 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*4444#");
620 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
621 }
622 }
623
624 /**
625 * @tc.number cellular_call_DialCall_0021
626 * @tc.name Test for dial function with invalid slot by cs
627 * @tc.desc Function test
628 */
629 HWTEST_F(Cs1Test, cellular_call_DialCall_0021, Function | MediumTest | Level2)
630 {
631 if (HasSimCard(SIM1_SLOTID)) {
632 int32_t ret = TestDialCallByCs(INVALID_SLOTID, PHONE_NUMBER);
633 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
634 }
635 if (HasSimCard(SIM2_SLOTID)) {
636 int32_t ret = TestDialCallByCs(INVALID_SLOTID, PHONE_NUMBER);
637 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
638 }
639 }
640
641 /**
642 * @tc.number cellular_call_HangUpCall_0001
643 * @tc.name Test for HangUp function by cs
644 * @tc.desc Function test
645 */
646 HWTEST_F(Cs1Test, cellular_call_HangUpCall_0001, Function | MediumTest | Level2)
647 {
648 AccessToken token;
649 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
650 ASSERT_TRUE(systemAbilityMgr != nullptr);
651 auto hangUpCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
652 ASSERT_TRUE(hangUpCallRemote != nullptr);
653 auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
654 ASSERT_TRUE(telephonyService != nullptr);
655 CellularCallInfo hangUpCallInfo;
656 if (HasSimCard(SIM1_SLOTID)) {
657 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, hangUpCallInfo);
658 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
659 ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
660 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
661 ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
662 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
663 }
664 if (HasSimCard(SIM2_SLOTID)) {
665 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, hangUpCallInfo);
666 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
667 ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
668 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
669 ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
670 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
671 }
672 }
673
674 /**
675 * @tc.number cellular_call_HangUpCall_0002
676 * @tc.name Test for HangUp function with invalid slot by cs
677 * @tc.desc Function test
678 */
679 HWTEST_F(Cs1Test, cellular_call_HangUpCall_0002, Function | MediumTest | Level2)
680 {
681 AccessToken token;
682 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
683 ASSERT_TRUE(systemAbilityMgr != nullptr);
684 auto hangUpCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
685 ASSERT_TRUE(hangUpCallRemote != nullptr);
686 auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
687 ASSERT_TRUE(telephonyService != nullptr);
688 if (HasSimCard(SIM1_SLOTID)) {
689 CellularCallInfo hangUpCallInfo;
690 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, hangUpCallInfo);
691 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
692 ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
693 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
694 }
695 if (HasSimCard(SIM2_SLOTID)) {
696 CellularCallInfo hangUpCallInfo;
697 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, hangUpCallInfo);
698 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
699 ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
700 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
701 }
702 }
703
704 /**
705 * @tc.number cellular_call_AnswerCall_0001
706 * @tc.name Test for answer function by cs
707 * @tc.desc Function test
708 */
709 HWTEST_F(Cs1Test, cellular_call_AnswerCall_0001, Function | MediumTest | Level2)
710 {
711 AccessToken token;
712 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
713 ASSERT_TRUE(systemAbilityMgr != nullptr);
714 auto answerCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
715 ASSERT_TRUE(answerCallRemote != nullptr);
716 auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
717 ASSERT_TRUE(telephonyService != nullptr);
718 if (HasSimCard(SIM1_SLOTID)) {
719 CellularCallInfo answerCallInfo;
720 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, answerCallInfo);
721 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
722 ret = telephonyService->Answer(answerCallInfo);
723 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
724 }
725 if (HasSimCard(SIM2_SLOTID)) {
726 CellularCallInfo answerCallInfo;
727 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, answerCallInfo);
728 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
729 ret = telephonyService->Answer(answerCallInfo);
730 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
731 }
732 }
733
734 /**
735 * @tc.number cellular_call_AnswerCall_0002
736 * @tc.name Test for answer function with invalid slot by cs
737 * @tc.desc Function test
738 */
739 HWTEST_F(Cs1Test, cellular_call_AnswerCall_0002, Function | MediumTest | Level2)
740 {
741 AccessToken token;
742 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
743 ASSERT_TRUE(systemAbilityMgr != nullptr);
744 auto answerCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
745 ASSERT_TRUE(answerCallRemote != nullptr);
746 auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
747 ASSERT_TRUE(telephonyService != nullptr);
748 if (HasSimCard(SIM1_SLOTID)) {
749 CellularCallInfo answerCallInfo;
750 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, answerCallInfo);
751 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
752 ret = telephonyService->Answer(answerCallInfo);
753 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
754 }
755 if (HasSimCard(SIM2_SLOTID)) {
756 CellularCallInfo answerCallInfo;
757 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, answerCallInfo);
758 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
759 ret = telephonyService->Answer(answerCallInfo);
760 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
761 }
762 }
763
764 /**
765 * @tc.number cellular_call_RejectCall_0001
766 * @tc.name Test for reject function by cs
767 * @tc.desc Function test
768 */
769 HWTEST_F(Cs1Test, cellular_call_RejectCall_0001, Function | MediumTest | Level2)
770 {
771 AccessToken token;
772 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
773 ASSERT_TRUE(systemAbilityMgr != nullptr);
774 auto rejectCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
775 ASSERT_TRUE(rejectCallRemote != nullptr);
776 auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
777 ASSERT_TRUE(telephonyService != nullptr);
778 if (HasSimCard(SIM1_SLOTID)) {
779 CellularCallInfo rejectCallInfo;
780 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, rejectCallInfo);
781 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
782 ret = telephonyService->Reject(rejectCallInfo);
783 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
784 }
785 if (HasSimCard(SIM2_SLOTID)) {
786 CellularCallInfo rejectCallInfo;
787 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, rejectCallInfo);
788 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
789 ret = telephonyService->Reject(rejectCallInfo);
790 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
791 }
792 }
793
794 /**
795 * @tc.number cellular_call_RejectCall_0002
796 * @tc.name Test for reject function with invalid slot by cs
797 * @tc.desc Function test
798 */
799 HWTEST_F(Cs1Test, cellular_call_RejectCall_0002, Function | MediumTest | Level2)
800 {
801 AccessToken token;
802 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
803 ASSERT_TRUE(systemAbilityMgr != nullptr);
804 auto rejectCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
805 ASSERT_TRUE(rejectCallRemote != nullptr);
806 auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
807 ASSERT_TRUE(telephonyService != nullptr);
808 if (HasSimCard(SIM1_SLOTID)) {
809 CellularCallInfo rejectCallInfo;
810 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, rejectCallInfo);
811 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
812 ret = telephonyService->Reject(rejectCallInfo);
813 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
814 }
815 if (HasSimCard(SIM2_SLOTID)) {
816 CellularCallInfo rejectCallInfo;
817 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, rejectCallInfo);
818 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
819 ret = telephonyService->Reject(rejectCallInfo);
820 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
821 }
822 }
823
824 /**
825 * @tc.number cellular_call_HoldCall_0001
826 * @tc.name Test for hold call function by cs
827 * @tc.desc Function test
828 */
829 HWTEST_F(Cs1Test, cellular_call_HoldCall_0001, Function | MediumTest | Level2)
830 {
831 AccessToken token;
832 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
833 ASSERT_TRUE(systemAbilityMgr != nullptr);
834 auto holdCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
835 ASSERT_TRUE(holdCallRemote != nullptr);
836 auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
837 ASSERT_TRUE(telephonyService != nullptr);
838 if (HasSimCard(SIM1_SLOTID)) {
839 CellularCallInfo holdCallInfo;
840 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, holdCallInfo);
841 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
842 ret = telephonyService->HoldCall(holdCallInfo);
843 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
844 }
845 if (HasSimCard(SIM2_SLOTID)) {
846 CellularCallInfo holdCallInfo;
847 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, holdCallInfo);
848 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
849 ret = telephonyService->HoldCall(holdCallInfo);
850 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
851 }
852 }
853
854 /**
855 * @tc.number cellular_call_HoldCall_0002
856 * @tc.name Test for hold function with invalid slot by cs
857 * @tc.desc Function test
858 */
859 HWTEST_F(Cs1Test, cellular_call_HoldCall_0002, Function | MediumTest | Level2)
860 {
861 AccessToken token;
862 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
863 ASSERT_TRUE(systemAbilityMgr != nullptr);
864 auto holdCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
865 ASSERT_TRUE(holdCallRemote != nullptr);
866 auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
867 ASSERT_TRUE(telephonyService != nullptr);
868 if (HasSimCard(SIM1_SLOTID)) {
869 CellularCallInfo holdCallInfo;
870 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, holdCallInfo);
871 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
872 ret = telephonyService->HoldCall(holdCallInfo);
873 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
874 }
875 if (HasSimCard(SIM2_SLOTID)) {
876 CellularCallInfo holdCallInfo;
877 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, holdCallInfo);
878 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
879 ret = telephonyService->HoldCall(holdCallInfo);
880 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
881 }
882 }
883
884 /**
885 * @tc.number cellular_call_UnHoldCall_0001
886 * @tc.name Test for unhold call function by cs
887 * @tc.desc Function test
888 */
889 HWTEST_F(Cs1Test, cellular_call_UnHoldCall_0001, Function | MediumTest | Level2)
890 {
891 AccessToken token;
892 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
893 ASSERT_TRUE(systemAbilityMgr != nullptr);
894 auto unHoldCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
895 ASSERT_TRUE(unHoldCallRemote != nullptr);
896 auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
897 ASSERT_TRUE(telephonyService != nullptr);
898 if (HasSimCard(SIM1_SLOTID)) {
899 CellularCallInfo unHoldCallInfo;
900 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, unHoldCallInfo);
901 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
902 ret = telephonyService->UnHoldCall(unHoldCallInfo);
903 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
904 }
905 if (HasSimCard(SIM2_SLOTID)) {
906 CellularCallInfo unHoldCallInfo;
907 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, unHoldCallInfo);
908 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
909 ret = telephonyService->UnHoldCall(unHoldCallInfo);
910 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
911 }
912 }
913
914 /**
915 * @tc.number cellular_call_UnHoldCall_0002
916 * @tc.name Test for unhold function with invalid slot by cs
917 * @tc.desc Function test
918 */
919 HWTEST_F(Cs1Test, cellular_call_UnHoldCall_0002, Function | MediumTest | Level2)
920 {
921 AccessToken token;
922 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
923 ASSERT_TRUE(systemAbilityMgr != nullptr);
924 auto unHoldCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
925 ASSERT_TRUE(unHoldCallRemote != nullptr);
926 auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
927 ASSERT_TRUE(telephonyService != nullptr);
928 if (HasSimCard(SIM1_SLOTID)) {
929 CellularCallInfo unHoldCallInfo;
930 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, unHoldCallInfo);
931 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
932 ret = telephonyService->UnHoldCall(unHoldCallInfo);
933 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
934 }
935 if (HasSimCard(SIM2_SLOTID)) {
936 CellularCallInfo unHoldCallInfo;
937 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, unHoldCallInfo);
938 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
939 ret = telephonyService->UnHoldCall(unHoldCallInfo);
940 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
941 }
942 }
943
944 /**
945 * @tc.number cellular_call_SwitchCall_0001
946 * @tc.name Test for switch call function by cs
947 * @tc.desc Function test
948 */
949 HWTEST_F(Cs1Test, cellular_call_SwitchCall_0001, Function | MediumTest | Level2)
950 {
951 AccessToken token;
952 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
953 ASSERT_TRUE(systemAbilityMgr != nullptr);
954 auto switchCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
955 ASSERT_TRUE(switchCallRemote != nullptr);
956 auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
957 ASSERT_TRUE(telephonyService != nullptr);
958 if (HasSimCard(SIM1_SLOTID)) {
959 CellularCallInfo switchCallInfo;
960 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, switchCallInfo);
961 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
962 ret = telephonyService->SwitchCall(switchCallInfo);
963 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
964 }
965 if (HasSimCard(SIM2_SLOTID)) {
966 CellularCallInfo switchCallInfo;
967 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, switchCallInfo);
968 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
969 ret = telephonyService->SwitchCall(switchCallInfo);
970 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
971 }
972 }
973
974 /**
975 * @tc.number cellular_call_SwitchCall_0002
976 * @tc.name Test for switch function with invalid slot by cs
977 * @tc.desc Function test
978 */
979 HWTEST_F(Cs1Test, cellular_call_SwitchCall_0002, Function | MediumTest | Level2)
980 {
981 AccessToken token;
982 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
983 ASSERT_TRUE(systemAbilityMgr != nullptr);
984 auto switchCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
985 ASSERT_TRUE(switchCallRemote != nullptr);
986 auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
987 ASSERT_TRUE(telephonyService != nullptr);
988 if (HasSimCard(SIM1_SLOTID)) {
989 CellularCallInfo switchCallInfo;
990 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, switchCallInfo);
991 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
992 ret = telephonyService->SwitchCall(switchCallInfo);
993 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
994 }
995 if (HasSimCard(SIM2_SLOTID)) {
996 CellularCallInfo switchCallInfo;
997 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, switchCallInfo);
998 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
999 ret = telephonyService->SwitchCall(switchCallInfo);
1000 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
1001 }
1002 }
1003 } // namespace Telephony
1004 } // namespace OHOS
1005