1 /*
2 * Copyright (C) 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 CsCallOperationTest : 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);
HasSimCard(int32_t slotId)54 bool HasSimCard(int32_t slotId)
55 {
56 bool hasSimCard = false;
57 DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(slotId, hasSimCard);
58 return hasSimCard;
59 }
60 int32_t InitCellularCallInfo(int32_t accountId, std::string phonenumber, CellularCallInfo &callInfo);
61 };
62
TestDialCallByCs(int32_t slotId,std::string code)63 int32_t CsCallOperationTest::TestDialCallByCs(int32_t slotId, std::string code)
64 {
65 AccessToken token;
66 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
67 if (systemAbilityMgr == nullptr) {
68 return TELEPHONY_ERR_FAIL;
69 }
70 auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
71 if (remote == nullptr) {
72 return TELEPHONY_ERR_FAIL;
73 }
74 auto telephonyService = iface_cast<CellularCallInterface>(remote);
75 if (telephonyService == nullptr) {
76 return TELEPHONY_ERR_FAIL;
77 }
78 CellularCallInfo callInfo;
79 int32_t ret = TELEPHONY_SUCCESS;
80 ret = InitCellularCallInfo(slotId, code, callInfo);
81 if (ret != TELEPHONY_SUCCESS) {
82 return ret;
83 }
84 // close ims, make this time use cs to test
85 ret = telephonyService->SetImsSwitchStatus(slotId, false);
86 if (ret != TELEPHONY_SUCCESS) {
87 return ret;
88 }
89 ret = telephonyService->Dial(callInfo);
90 return ret;
91 };
92
InitCellularCallInfo(int32_t accountId,std::string phonenumber,CellularCallInfo & callInfo)93 int32_t CsCallOperationTest::InitCellularCallInfo(int32_t accountId, std::string phonenumber,
94 CellularCallInfo &callInfo)
95 {
96 callInfo.accountId = accountId;
97 callInfo.slotId = accountId;
98 callInfo.index = accountId;
99 callInfo.callType = CallType::TYPE_CS;
100 callInfo.videoState = 0; // 0 means audio
101 if (memset_s(callInfo.phoneNum, kMaxNumberLen, 0, kMaxNumberLen) != EOK) {
102 return TELEPHONY_ERR_MEMSET_FAIL;
103 }
104 if (phonenumber.length() > static_cast<size_t>(kMaxNumberLen)) {
105 return CALL_ERR_NUMBER_OUT_OF_RANGE;
106 }
107 if (memcpy_s(callInfo.phoneNum, kMaxNumberLen, phonenumber.c_str(), phonenumber.length()) != EOK) {
108 return TELEPHONY_ERR_MEMCPY_FAIL;
109 }
110 return TELEPHONY_SUCCESS;
111 };
112
SetUpTestCase(void)113 void CsCallOperationTest::SetUpTestCase(void)
114 {
115 // step 3: Set Up Test Case
116 }
117
TearDownTestCase(void)118 void CsCallOperationTest::TearDownTestCase(void)
119 {
120 // step 3: Tear Down Test Case
121 }
122
SetUp(void)123 void CsCallOperationTest::SetUp(void)
124 {
125 // step 3: input testcase setup step
126 }
127
TearDown(void)128 void CsCallOperationTest::TearDown(void)
129 {
130 // step 3: input testcase teardown step
131 }
132
133 /**
134 * @tc.number cellular_call_DialCall_0001
135 * @tc.name Test for SetClip function by cs
136 * @tc.desc Function test
137 */
138 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0001, Function | MediumTest | Level2)
139 {
140 if (HasSimCard(SIM1_SLOTID)) {
141 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*30#");
142 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
143 }
144 if (HasSimCard(SIM2_SLOTID)) {
145 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*30#");
146 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
147 }
148 }
149
150 /**
151 * @tc.number cellular_call_DialCall_0002
152 * @tc.name Test for SetClip function by cs
153 * @tc.desc Function test
154 */
155 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0002, Function | MediumTest | Level2)
156 {
157 if (HasSimCard(SIM1_SLOTID)) {
158 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#30#");
159 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
160 }
161 if (HasSimCard(SIM2_SLOTID)) {
162 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "#30#");
163 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
164 }
165 }
166
167 /**
168 * @tc.number cellular_call_DialCall_0003
169 * @tc.name Test for getClip function by cs
170 * @tc.desc Function test
171 */
172 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0003, Function | MediumTest | Level2)
173 {
174 if (HasSimCard(SIM1_SLOTID)) {
175 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#30#");
176 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
177 }
178 if (HasSimCard(SIM2_SLOTID)) {
179 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*#30#");
180 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
181 }
182 }
183
184 /**
185 * @tc.number cellular_call_DialCall_0004
186 * @tc.name Test for SetClir function by cs
187 * @tc.desc Function test
188 */
189 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0004, Function | MediumTest | Level2)
190 {
191 if (HasSimCard(SIM1_SLOTID)) {
192 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*31#");
193 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
194 }
195 if (HasSimCard(SIM2_SLOTID)) {
196 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*31#");
197 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
198 }
199 }
200
201 /**
202 * @tc.number cellular_call_DialCall_0005
203 * @tc.name Test for SetClir function by cs
204 * @tc.desc Function test
205 */
206 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0005, Function | MediumTest | Level2)
207 {
208 if (HasSimCard(SIM1_SLOTID)) {
209 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#31#");
210 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
211 }
212 if (HasSimCard(SIM2_SLOTID)) {
213 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "#31#");
214 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
215 }
216 }
217
218 /**
219 * @tc.number cellular_call_DialCall_0006
220 * @tc.name Test for GetClir function by cs
221 * @tc.desc Function test
222 */
223 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0006, Function | MediumTest | Level2)
224 {
225 if (HasSimCard(SIM1_SLOTID)) {
226 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#31#");
227 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
228 }
229 if (HasSimCard(SIM2_SLOTID)) {
230 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*#31#");
231 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
232 }
233 }
234
235 /**
236 * @tc.number cellular_call_DialCall_0007
237 * @tc.name Test for SetCallTransfer function by cs
238 * @tc.desc Function test
239 */
240 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0007, Function | MediumTest | Level2)
241 {
242 if (HasSimCard(SIM1_SLOTID)) {
243 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*21#");
244 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
245 }
246 if (HasSimCard(SIM2_SLOTID)) {
247 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*21#");
248 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
249 }
250 }
251
252 /**
253 * @tc.number cellular_call_DialCall_0008
254 * @tc.name Test for SetCallTransfer function by cs
255 * @tc.desc Function test
256 */
257 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0008, Function | MediumTest | Level2)
258 {
259 if (HasSimCard(SIM1_SLOTID)) {
260 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#21#");
261 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
262 }
263 if (HasSimCard(SIM2_SLOTID)) {
264 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "#21#");
265 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
266 }
267 }
268
269 /**
270 * @tc.number cellular_call_DialCall_0009
271 * @tc.name Test for GetCallTransfer function by cs
272 * @tc.desc Function test
273 */
274 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0009, Function | MediumTest | Level2)
275 {
276 if (HasSimCard(SIM1_SLOTID)) {
277 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#21#");
278 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
279 }
280 if (HasSimCard(SIM2_SLOTID)) {
281 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*#21#");
282 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
283 }
284 }
285
286 /**
287 * @tc.number cellular_call_DialCall_0010
288 * @tc.name Test for SetCallRestriction function by cs
289 * @tc.desc Function test
290 */
291 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0010, Function | MediumTest | Level2)
292 {
293 if (HasSimCard(SIM1_SLOTID)) {
294 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*33#");
295 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
296 }
297 if (HasSimCard(SIM2_SLOTID)) {
298 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*33#");
299 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
300 }
301 }
302
303 /**
304 * @tc.number cellular_call_DialCall_0011
305 * @tc.name Test for SetCallRestriction function by cs
306 * @tc.desc Function test
307 */
308 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0011, Function | MediumTest | Level2)
309 {
310 if (HasSimCard(SIM1_SLOTID)) {
311 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#33#");
312 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
313 }
314 if (HasSimCard(SIM2_SLOTID)) {
315 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "#33#");
316 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
317 }
318 }
319
320 /**
321 * @tc.number cellular_call_DialCall_0012
322 * @tc.name Test for GetCallRestriction function by cs
323 * @tc.desc Function test
324 */
325 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0012, Function | MediumTest | Level2)
326 {
327 if (HasSimCard(SIM1_SLOTID)) {
328 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#33#");
329 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
330 }
331 if (HasSimCard(SIM2_SLOTID)) {
332 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*#33#");
333 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
334 }
335 }
336
337 /**
338 * @tc.number cellular_call_DialCall_0013
339 * @tc.name Test for SetCallWaiting function by cs
340 * @tc.desc Function test
341 */
342 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0013, Function | MediumTest | Level2)
343 {
344 if (HasSimCard(SIM1_SLOTID)) {
345 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*43#");
346 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
347 }
348 if (HasSimCard(SIM2_SLOTID)) {
349 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*43#");
350 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
351 }
352 }
353
354 /**
355 * @tc.number cellular_call_DialCall_0014
356 * @tc.name Test for SetCallWaiting function by cs
357 * @tc.desc Function test
358 */
359 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0014, Function | MediumTest | Level2)
360 {
361 if (HasSimCard(SIM1_SLOTID)) {
362 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "#43#");
363 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
364 }
365 if (HasSimCard(SIM2_SLOTID)) {
366 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "#43#");
367 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
368 }
369 }
370
371 /**
372 * @tc.number cellular_call_DialCall_0015
373 * @tc.name Test for GetCallWaiting function by cs
374 * @tc.desc Function test
375 */
376 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0015, Function | MediumTest | Level2)
377 {
378 if (HasSimCard(SIM1_SLOTID)) {
379 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*#43#");
380 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
381 }
382 if (HasSimCard(SIM2_SLOTID)) {
383 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*#43#");
384 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
385 }
386 }
387
388 /**
389 * @tc.number cellular_call_DialCall_0016
390 * @tc.name Test for AlterPinPassword function by cs
391 * @tc.desc Function test
392 */
393 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0016, Function | MediumTest | Level2)
394 {
395 if (HasSimCard(SIM1_SLOTID)) {
396 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*04#");
397 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
398 }
399 if (HasSimCard(SIM2_SLOTID)) {
400 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*04#");
401 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
402 }
403 }
404
405 /**
406 * @tc.number cellular_call_DialCall_0017
407 * @tc.name Test for UnlockPuk function by cs
408 * @tc.desc Function test
409 */
410 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0017, Function | MediumTest | Level2)
411 {
412 if (HasSimCard(SIM1_SLOTID)) {
413 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*05#");
414 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
415 }
416 if (HasSimCard(SIM2_SLOTID)) {
417 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*05#");
418 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
419 }
420 }
421
422 /**
423 * @tc.number cellular_call_DialCall_0018
424 * @tc.name Test for AlterPin2Password function by cs
425 * @tc.desc Function test
426 */
427 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0018, Function | MediumTest | Level2)
428 {
429 if (HasSimCard(SIM1_SLOTID)) {
430 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*042#");
431 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
432 }
433 if (HasSimCard(SIM2_SLOTID)) {
434 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*042#");
435 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
436 }
437 }
438
439 /**
440 * @tc.number cellular_call_DialCall_0019
441 * @tc.name Test for UnlockPuk2 function by cs
442 * @tc.desc Function test
443 */
444 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0019, Function | MediumTest | Level2)
445 {
446 if (HasSimCard(SIM1_SLOTID)) {
447 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*052#");
448 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
449 }
450 if (HasSimCard(SIM2_SLOTID)) {
451 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*052#");
452 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
453 }
454 }
455
456 /**
457 * @tc.number cellular_call_DialCall_0020
458 * @tc.name Test for SendUssd function by cs
459 * @tc.desc Function test
460 */
461 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0020, Function | MediumTest | Level2)
462 {
463 if (HasSimCard(SIM1_SLOTID)) {
464 int32_t ret = TestDialCallByCs(SIM1_SLOTID, "*4444#");
465 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
466 }
467 if (HasSimCard(SIM2_SLOTID)) {
468 int32_t ret = TestDialCallByCs(SIM2_SLOTID, "*4444#");
469 EXPECT_NE(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
470 }
471 }
472
473 /**
474 * @tc.number cellular_call_DialCall_0021
475 * @tc.name Test for dial function with invalid slot by cs
476 * @tc.desc Function test
477 */
478 HWTEST_F(CsCallOperationTest, cellular_call_DialCall_0021, Function | MediumTest | Level2)
479 {
480 if (HasSimCard(SIM1_SLOTID)) {
481 int32_t ret = TestDialCallByCs(INVALID_SLOTID, PHONE_NUMBER);
482 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
483 }
484 if (HasSimCard(SIM2_SLOTID)) {
485 int32_t ret = TestDialCallByCs(INVALID_SLOTID, PHONE_NUMBER);
486 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
487 }
488 }
489
490 /**
491 * @tc.number cellular_call_HangUpCall_0001
492 * @tc.name Test for HangUp function by cs
493 * @tc.desc Function test
494 */
495 HWTEST_F(CsCallOperationTest, cellular_call_HangUpCall_0001, Function | MediumTest | Level2)
496 {
497 AccessToken token;
498 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
499 ASSERT_TRUE(systemAbilityMgr != nullptr);
500 auto hangUpCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
501 ASSERT_TRUE(hangUpCallRemote != nullptr);
502 auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
503 ASSERT_TRUE(telephonyService != nullptr);
504 CellularCallInfo hangUpCallInfo;
505 if (HasSimCard(SIM1_SLOTID)) {
506 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, hangUpCallInfo);
507 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
508 ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
509 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
510 ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
511 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
512 }
513 if (HasSimCard(SIM2_SLOTID)) {
514 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, hangUpCallInfo);
515 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
516 ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
517 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
518 ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
519 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
520 }
521 }
522
523 /**
524 * @tc.number cellular_call_HangUpCall_0002
525 * @tc.name Test for HangUp function with invalid slot by cs
526 * @tc.desc Function test
527 */
528 HWTEST_F(CsCallOperationTest, cellular_call_HangUpCall_0002, Function | MediumTest | Level2)
529 {
530 AccessToken token;
531 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
532 ASSERT_TRUE(systemAbilityMgr != nullptr);
533 auto hangUpCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
534 ASSERT_TRUE(hangUpCallRemote != nullptr);
535 auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
536 ASSERT_TRUE(telephonyService != nullptr);
537 if (HasSimCard(SIM1_SLOTID)) {
538 CellularCallInfo hangUpCallInfo;
539 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, hangUpCallInfo);
540 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
541 ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
542 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
543 }
544 if (HasSimCard(SIM2_SLOTID)) {
545 CellularCallInfo hangUpCallInfo;
546 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, hangUpCallInfo);
547 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
548 ret = telephonyService->HangUp(hangUpCallInfo, CallSupplementType::TYPE_DEFAULT);
549 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
550 }
551 }
552
553 /**
554 * @tc.number cellular_call_AnswerCall_0001
555 * @tc.name Test for answer function by cs
556 * @tc.desc Function test
557 */
558 HWTEST_F(CsCallOperationTest, cellular_call_AnswerCall_0001, Function | MediumTest | Level2)
559 {
560 AccessToken token;
561 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
562 ASSERT_TRUE(systemAbilityMgr != nullptr);
563 auto answerCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
564 ASSERT_TRUE(answerCallRemote != nullptr);
565 auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
566 ASSERT_TRUE(telephonyService != nullptr);
567 if (HasSimCard(SIM1_SLOTID)) {
568 CellularCallInfo answerCallInfo;
569 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, answerCallInfo);
570 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
571 ret = telephonyService->Answer(answerCallInfo);
572 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
573 }
574 if (HasSimCard(SIM2_SLOTID)) {
575 CellularCallInfo answerCallInfo;
576 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, answerCallInfo);
577 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
578 ret = telephonyService->Answer(answerCallInfo);
579 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
580 }
581 }
582
583 /**
584 * @tc.number cellular_call_AnswerCall_0002
585 * @tc.name Test for answer function with invalid slot by cs
586 * @tc.desc Function test
587 */
588 HWTEST_F(CsCallOperationTest, cellular_call_AnswerCall_0002, Function | MediumTest | Level2)
589 {
590 AccessToken token;
591 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
592 ASSERT_TRUE(systemAbilityMgr != nullptr);
593 auto answerCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
594 ASSERT_TRUE(answerCallRemote != nullptr);
595 auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
596 ASSERT_TRUE(telephonyService != nullptr);
597 if (HasSimCard(SIM1_SLOTID)) {
598 CellularCallInfo answerCallInfo;
599 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, answerCallInfo);
600 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
601 ret = telephonyService->Answer(answerCallInfo);
602 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
603 }
604 if (HasSimCard(SIM2_SLOTID)) {
605 CellularCallInfo answerCallInfo;
606 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, answerCallInfo);
607 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
608 ret = telephonyService->Answer(answerCallInfo);
609 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
610 }
611 }
612
613 /**
614 * @tc.number cellular_call_RejectCall_0001
615 * @tc.name Test for reject function by cs
616 * @tc.desc Function test
617 */
618 HWTEST_F(CsCallOperationTest, cellular_call_RejectCall_0001, Function | MediumTest | Level2)
619 {
620 AccessToken token;
621 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
622 ASSERT_TRUE(systemAbilityMgr != nullptr);
623 auto rejectCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
624 ASSERT_TRUE(rejectCallRemote != nullptr);
625 auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
626 ASSERT_TRUE(telephonyService != nullptr);
627 if (HasSimCard(SIM1_SLOTID)) {
628 CellularCallInfo rejectCallInfo;
629 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, rejectCallInfo);
630 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
631 ret = telephonyService->Reject(rejectCallInfo);
632 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
633 }
634 if (HasSimCard(SIM2_SLOTID)) {
635 CellularCallInfo rejectCallInfo;
636 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, rejectCallInfo);
637 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
638 ret = telephonyService->Reject(rejectCallInfo);
639 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
640 }
641 }
642
643 /**
644 * @tc.number cellular_call_RejectCall_0002
645 * @tc.name Test for reject function with invalid slot by cs
646 * @tc.desc Function test
647 */
648 HWTEST_F(CsCallOperationTest, cellular_call_RejectCall_0002, Function | MediumTest | Level2)
649 {
650 AccessToken token;
651 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
652 ASSERT_TRUE(systemAbilityMgr != nullptr);
653 auto rejectCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
654 ASSERT_TRUE(rejectCallRemote != nullptr);
655 auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
656 ASSERT_TRUE(telephonyService != nullptr);
657 if (HasSimCard(SIM1_SLOTID)) {
658 CellularCallInfo rejectCallInfo;
659 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, rejectCallInfo);
660 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
661 ret = telephonyService->Reject(rejectCallInfo);
662 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
663 }
664 if (HasSimCard(SIM2_SLOTID)) {
665 CellularCallInfo rejectCallInfo;
666 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, rejectCallInfo);
667 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
668 ret = telephonyService->Reject(rejectCallInfo);
669 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
670 }
671 }
672
673 /**
674 * @tc.number cellular_call_HoldCall_0001
675 * @tc.name Test for hold call function by cs
676 * @tc.desc Function test
677 */
678 HWTEST_F(CsCallOperationTest, cellular_call_HoldCall_0001, Function | MediumTest | Level2)
679 {
680 AccessToken token;
681 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
682 ASSERT_TRUE(systemAbilityMgr != nullptr);
683 auto holdCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
684 ASSERT_TRUE(holdCallRemote != nullptr);
685 auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
686 ASSERT_TRUE(telephonyService != nullptr);
687 if (HasSimCard(SIM1_SLOTID)) {
688 CellularCallInfo holdCallInfo;
689 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, holdCallInfo);
690 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
691 ret = telephonyService->HoldCall(holdCallInfo);
692 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
693 }
694 if (HasSimCard(SIM2_SLOTID)) {
695 CellularCallInfo holdCallInfo;
696 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, holdCallInfo);
697 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
698 ret = telephonyService->HoldCall(holdCallInfo);
699 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
700 }
701 }
702
703 /**
704 * @tc.number cellular_call_HoldCall_0002
705 * @tc.name Test for hold function with invalid slot by cs
706 * @tc.desc Function test
707 */
708 HWTEST_F(CsCallOperationTest, cellular_call_HoldCall_0002, Function | MediumTest | Level2)
709 {
710 AccessToken token;
711 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
712 ASSERT_TRUE(systemAbilityMgr != nullptr);
713 auto holdCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
714 ASSERT_TRUE(holdCallRemote != nullptr);
715 auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
716 ASSERT_TRUE(telephonyService != nullptr);
717 if (HasSimCard(SIM1_SLOTID)) {
718 CellularCallInfo holdCallInfo;
719 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, holdCallInfo);
720 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
721 ret = telephonyService->HoldCall(holdCallInfo);
722 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
723 }
724 if (HasSimCard(SIM2_SLOTID)) {
725 CellularCallInfo holdCallInfo;
726 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, holdCallInfo);
727 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
728 ret = telephonyService->HoldCall(holdCallInfo);
729 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
730 }
731 }
732
733 /**
734 * @tc.number cellular_call_UnHoldCall_0001
735 * @tc.name Test for unhold call function by cs
736 * @tc.desc Function test
737 */
738 HWTEST_F(CsCallOperationTest, cellular_call_UnHoldCall_0001, Function | MediumTest | Level2)
739 {
740 AccessToken token;
741 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
742 ASSERT_TRUE(systemAbilityMgr != nullptr);
743 auto unHoldCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
744 ASSERT_TRUE(unHoldCallRemote != nullptr);
745 auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
746 ASSERT_TRUE(telephonyService != nullptr);
747 if (HasSimCard(SIM1_SLOTID)) {
748 CellularCallInfo unHoldCallInfo;
749 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, unHoldCallInfo);
750 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
751 ret = telephonyService->UnHoldCall(unHoldCallInfo);
752 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
753 }
754 if (HasSimCard(SIM2_SLOTID)) {
755 CellularCallInfo unHoldCallInfo;
756 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, unHoldCallInfo);
757 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
758 ret = telephonyService->UnHoldCall(unHoldCallInfo);
759 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
760 }
761 }
762
763 /**
764 * @tc.number cellular_call_UnHoldCall_0002
765 * @tc.name Test for unhold function with invalid slot by cs
766 * @tc.desc Function test
767 */
768 HWTEST_F(CsCallOperationTest, cellular_call_UnHoldCall_0002, Function | MediumTest | Level2)
769 {
770 AccessToken token;
771 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
772 ASSERT_TRUE(systemAbilityMgr != nullptr);
773 auto unHoldCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
774 ASSERT_TRUE(unHoldCallRemote != nullptr);
775 auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
776 ASSERT_TRUE(telephonyService != nullptr);
777 if (HasSimCard(SIM1_SLOTID)) {
778 CellularCallInfo unHoldCallInfo;
779 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, unHoldCallInfo);
780 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
781 ret = telephonyService->UnHoldCall(unHoldCallInfo);
782 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
783 }
784 if (HasSimCard(SIM2_SLOTID)) {
785 CellularCallInfo unHoldCallInfo;
786 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, unHoldCallInfo);
787 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
788 ret = telephonyService->UnHoldCall(unHoldCallInfo);
789 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
790 }
791 }
792
793 /**
794 * @tc.number cellular_call_SwitchCall_0001
795 * @tc.name Test for switch call function by cs
796 * @tc.desc Function test
797 */
798 HWTEST_F(CsCallOperationTest, cellular_call_SwitchCall_0001, Function | MediumTest | Level2)
799 {
800 AccessToken token;
801 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
802 ASSERT_TRUE(systemAbilityMgr != nullptr);
803 auto switchCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
804 ASSERT_TRUE(switchCallRemote != nullptr);
805 auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
806 ASSERT_TRUE(telephonyService != nullptr);
807 if (HasSimCard(SIM1_SLOTID)) {
808 CellularCallInfo switchCallInfo;
809 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, switchCallInfo);
810 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
811 ret = telephonyService->SwitchCall(switchCallInfo);
812 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
813 }
814 if (HasSimCard(SIM2_SLOTID)) {
815 CellularCallInfo switchCallInfo;
816 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, switchCallInfo);
817 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
818 ret = telephonyService->SwitchCall(switchCallInfo);
819 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
820 }
821 }
822
823 /**
824 * @tc.number cellular_call_SwitchCall_0002
825 * @tc.name Test for switch function with invalid slot by cs
826 * @tc.desc Function test
827 */
828 HWTEST_F(CsCallOperationTest, cellular_call_SwitchCall_0002, Function | MediumTest | Level2)
829 {
830 AccessToken token;
831 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
832 ASSERT_TRUE(systemAbilityMgr != nullptr);
833 auto switchCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
834 ASSERT_TRUE(switchCallRemote != nullptr);
835 auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
836 ASSERT_TRUE(telephonyService != nullptr);
837 if (HasSimCard(SIM1_SLOTID)) {
838 CellularCallInfo switchCallInfo;
839 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, switchCallInfo);
840 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
841 ret = telephonyService->SwitchCall(switchCallInfo);
842 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
843 }
844 if (HasSimCard(SIM2_SLOTID)) {
845 CellularCallInfo switchCallInfo;
846 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, switchCallInfo);
847 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
848 ret = telephonyService->SwitchCall(switchCallInfo);
849 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
850 }
851 }
852
853 /**
854 * @tc.number cellular_call_CombineConference_0001
855 * @tc.name Test for combineConference function by cs
856 * @tc.desc Function test
857 */
858 HWTEST_F(CsCallOperationTest, cellular_call_CombineConference_0001, Function | MediumTest | Level2)
859 {
860 AccessToken token;
861 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
862 ASSERT_TRUE(systemAbilityMgr != nullptr);
863 auto combineRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
864 ASSERT_TRUE(combineRemote != nullptr);
865 auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
866 ASSERT_TRUE(telephonyService != nullptr);
867 if (HasSimCard(SIM1_SLOTID)) {
868 CellularCallInfo conferenceCallInfo;
869 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, conferenceCallInfo);
870 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
871 ret = telephonyService->CombineConference(conferenceCallInfo);
872 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
873 }
874 if (HasSimCard(SIM2_SLOTID)) {
875 CellularCallInfo conferenceCallInfo;
876 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, conferenceCallInfo);
877 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
878 ret = telephonyService->CombineConference(conferenceCallInfo);
879 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
880 }
881 }
882
883 /**
884 * @tc.number cellular_call_CombineConference_0002
885 * @tc.name Test for combineConference function with invalid slot by cs
886 * @tc.desc Function test
887 */
888 HWTEST_F(CsCallOperationTest, cellular_call_CombineConference_0002, Function | MediumTest | Level2)
889 {
890 AccessToken token;
891 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
892 ASSERT_TRUE(systemAbilityMgr != nullptr);
893 auto combineRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
894 ASSERT_TRUE(combineRemote != nullptr);
895 auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
896 ASSERT_TRUE(telephonyService != nullptr);
897 if (HasSimCard(SIM1_SLOTID)) {
898 CellularCallInfo conferenceCallInfo;
899 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, conferenceCallInfo);
900 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
901 ret = telephonyService->CombineConference(conferenceCallInfo);
902 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
903 }
904 if (HasSimCard(SIM2_SLOTID)) {
905 CellularCallInfo conferenceCallInfo;
906 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, conferenceCallInfo);
907 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
908 ret = telephonyService->CombineConference(conferenceCallInfo);
909 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
910 }
911 }
912
913 /**
914 * @tc.number cellular_call_SeparateConference_0001
915 * @tc.name Test for separateConference function by cs
916 * @tc.desc Function test
917 */
918 HWTEST_F(CsCallOperationTest, cellular_call_SeparateConference_0001, Function | MediumTest | Level2)
919 {
920 AccessToken token;
921 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
922 ASSERT_TRUE(systemAbilityMgr != nullptr);
923 auto separateRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
924 ASSERT_TRUE(separateRemote != nullptr);
925 auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
926 ASSERT_TRUE(telephonyService != nullptr);
927 if (HasSimCard(SIM1_SLOTID)) {
928 CellularCallInfo callInfo;
929 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
930 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
931 ret = telephonyService->SeparateConference(callInfo);
932 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
933 }
934 if (HasSimCard(SIM2_SLOTID)) {
935 CellularCallInfo callInfo;
936 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
937 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
938 ret = telephonyService->SeparateConference(callInfo);
939 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
940 }
941 }
942
943 /**
944 * @tc.number cellular_call_SeparateConference_0002
945 * @tc.name Test for separateConference function with invalid slot by cs
946 * @tc.desc Function test
947 */
948 HWTEST_F(CsCallOperationTest, cellular_call_SeparateConference_0002, Function | MediumTest | Level2)
949 {
950 AccessToken token;
951 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
952 ASSERT_TRUE(systemAbilityMgr != nullptr);
953 auto separateRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
954 ASSERT_TRUE(separateRemote != nullptr);
955 auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
956 ASSERT_TRUE(telephonyService != nullptr);
957 if (HasSimCard(SIM1_SLOTID)) {
958 CellularCallInfo separateCallInfo;
959 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, separateCallInfo);
960 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
961 ret = telephonyService->SeparateConference(separateCallInfo);
962 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
963 }
964 if (HasSimCard(SIM2_SLOTID)) {
965 CellularCallInfo separateCallInfo;
966 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, separateCallInfo);
967 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
968 ret = telephonyService->SeparateConference(separateCallInfo);
969 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
970 }
971 }
972
973 /**
974 * @tc.number cellular_call_KickOutFromConference_0001
975 * @tc.name Test for separateConference function by cs
976 * @tc.desc Function test
977 */
978 HWTEST_F(CsCallOperationTest, cellular_call_KickOutFromConference_0001, Function | MediumTest | Level2)
979 {
980 AccessToken token;
981 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
982 ASSERT_TRUE(systemAbilityMgr != nullptr);
983 auto kickOutRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
984 ASSERT_TRUE(kickOutRemote != nullptr);
985 auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
986 ASSERT_TRUE(telephonyService != nullptr);
987 if (HasSimCard(SIM1_SLOTID)) {
988 CellularCallInfo kickOutCallInfo;
989 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, kickOutCallInfo);
990 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
991 ret = telephonyService->KickOutFromConference(kickOutCallInfo);
992 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
993 }
994 if (HasSimCard(SIM2_SLOTID)) {
995 CellularCallInfo kickOutCallInfo;
996 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, kickOutCallInfo);
997 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
998 ret = telephonyService->KickOutFromConference(kickOutCallInfo);
999 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
1000 }
1001 }
1002
1003 /**
1004 * @tc.number cellular_call_KickOutFromConference_0002
1005 * @tc.name Test for KickOutFromConference function with invalid slot by cs
1006 * @tc.desc Function test
1007 */
1008 HWTEST_F(CsCallOperationTest, cellular_call_KickOutFromConference_0002, Function | MediumTest | Level2)
1009 {
1010 AccessToken token;
1011 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1012 ASSERT_TRUE(systemAbilityMgr != nullptr);
1013 auto kickOutRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
1014 ASSERT_TRUE(kickOutRemote != nullptr);
1015 auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
1016 ASSERT_TRUE(telephonyService != nullptr);
1017 if (HasSimCard(SIM1_SLOTID)) {
1018 CellularCallInfo kickOutCallInfo;
1019 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, kickOutCallInfo);
1020 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1021 ret = telephonyService->KickOutFromConference(kickOutCallInfo);
1022 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
1023 }
1024 if (HasSimCard(SIM2_SLOTID)) {
1025 CellularCallInfo kickOutCallInfo;
1026 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, kickOutCallInfo);
1027 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1028 ret = telephonyService->KickOutFromConference(kickOutCallInfo);
1029 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
1030 }
1031 }
1032
1033 /**
1034 * @tc.number cellular_call_HangUpAllConnection_0001
1035 * @tc.name Test for hangup all connection function by cs
1036 * @tc.desc Function test
1037 */
1038 HWTEST_F(CsCallOperationTest, cellular_call_HangUpAllConnection_0001, Function | MediumTest | Level2)
1039 {
1040 AccessToken token;
1041 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1042 ASSERT_TRUE(systemAbilityMgr != nullptr);
1043 auto hangUpAllConRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
1044 ASSERT_TRUE(hangUpAllConRemote != nullptr);
1045 auto telephonyService = iface_cast<CellularCallInterface>(hangUpAllConRemote);
1046 ASSERT_TRUE(telephonyService != nullptr);
1047 if (HasSimCard(SIM1_SLOTID)) {
1048 int32_t ret = telephonyService->HangUpAllConnection();
1049 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1050 }
1051 if (HasSimCard(SIM2_SLOTID)) {
1052 int32_t ret = telephonyService->HangUpAllConnection();
1053 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1054 }
1055 }
1056
1057 /**
1058 * @tc.number cellular_call_StartDtmf_0001
1059 * @tc.name Test for startDtmf function by cs
1060 * @tc.desc Function test
1061 */
1062 HWTEST_F(CsCallOperationTest, cellular_call_StartDtmf_0001, Function | MediumTest | Level2)
1063 {
1064 AccessToken token;
1065 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1066 ASSERT_TRUE(systemAbilityMgr != nullptr);
1067 auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
1068 ASSERT_TRUE(startDtmfRemote != nullptr);
1069 auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
1070 ASSERT_TRUE(telephonyService != nullptr);
1071 if (HasSimCard(SIM1_SLOTID)) {
1072 CellularCallInfo callInfo;
1073 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
1074 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1075 char code = '1';
1076 ret = telephonyService->StartDtmf(code, callInfo);
1077 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
1078 }
1079 if (HasSimCard(SIM2_SLOTID)) {
1080 CellularCallInfo callInfo;
1081 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
1082 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1083 char code = '1';
1084 ret = telephonyService->StartDtmf(code, callInfo);
1085 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
1086 }
1087 }
1088
1089 /**
1090 * @tc.number cellular_call_StartDtmf_0002
1091 * @tc.name Test for startDtmf function with invalid slot by cs
1092 * @tc.desc Function test
1093 */
1094 HWTEST_F(CsCallOperationTest, cellular_call_StartDtmf_0002, Function | MediumTest | Level2)
1095 {
1096 AccessToken token;
1097 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1098 ASSERT_TRUE(systemAbilityMgr != nullptr);
1099 auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
1100 ASSERT_TRUE(startDtmfRemote != nullptr);
1101 auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
1102 ASSERT_TRUE(telephonyService != nullptr);
1103 CellularCallInfo callInfo;
1104 if (HasSimCard(SIM1_SLOTID)) {
1105 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
1106 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1107 char code = '1';
1108 ret = telephonyService->StartDtmf(code, callInfo);
1109 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
1110 }
1111 if (HasSimCard(SIM2_SLOTID)) {
1112 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
1113 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1114 char code = '1';
1115 ret = telephonyService->StartDtmf(code, callInfo);
1116 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
1117 }
1118 }
1119
1120 /**
1121 * @tc.number cellular_call_StopDtmf_0001
1122 * @tc.name Test for stopDtmf function by cs
1123 * @tc.desc Function test
1124 */
1125 HWTEST_F(CsCallOperationTest, cellular_call_StopDtmf_0001, Function | MediumTest | Level2)
1126 {
1127 AccessToken token;
1128 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1129 ASSERT_TRUE(systemAbilityMgr != nullptr);
1130 auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
1131 ASSERT_TRUE(stopDtmfRemote != nullptr);
1132 auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
1133 ASSERT_TRUE(telephonyService != nullptr);
1134 if (HasSimCard(SIM1_SLOTID)) {
1135 CellularCallInfo callInfo;
1136 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
1137 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1138 ret = telephonyService->StopDtmf(callInfo);
1139 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
1140 }
1141 if (HasSimCard(SIM2_SLOTID)) {
1142 CellularCallInfo callInfo;
1143 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
1144 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1145 ret = telephonyService->StopDtmf(callInfo);
1146 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
1147 }
1148 }
1149
1150 /**
1151 * @tc.number cellular_call_StopDtmf_0002
1152 * @tc.name Test for stopDtmf function with invalid slot by cs
1153 * @tc.desc Function test
1154 */
1155 HWTEST_F(CsCallOperationTest, cellular_call_StopDtmf_0002, Function | MediumTest | Level2)
1156 {
1157 AccessToken token;
1158 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1159 ASSERT_TRUE(systemAbilityMgr != nullptr);
1160 auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
1161 ASSERT_TRUE(stopDtmfRemote != nullptr);
1162 auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
1163 ASSERT_TRUE(telephonyService != nullptr);
1164 if (HasSimCard(SIM1_SLOTID)) {
1165 CellularCallInfo stopDtmfCallInfo;
1166 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
1167 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1168 ret = telephonyService->StopDtmf(stopDtmfCallInfo);
1169 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
1170 }
1171 if (HasSimCard(SIM2_SLOTID)) {
1172 CellularCallInfo stopDtmfCallInfo;
1173 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
1174 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1175 ret = telephonyService->StopDtmf(stopDtmfCallInfo);
1176 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
1177 }
1178 }
1179
1180 /**
1181 * @tc.number cellular_call_SendDtmf_0001
1182 * @tc.name Test for sendDtmf function by cs
1183 * @tc.desc Function test
1184 */
1185 HWTEST_F(CsCallOperationTest, cellular_call_SendDtmf_0001, Function | MediumTest | Level2)
1186 {
1187 AccessToken token;
1188 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1189 ASSERT_TRUE(systemAbilityMgr != nullptr);
1190 auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
1191 ASSERT_TRUE(sendDtmfRemote != nullptr);
1192 auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
1193 ASSERT_TRUE(telephonyService != nullptr);
1194 if (HasSimCard(SIM1_SLOTID)) {
1195 CellularCallInfo sendDtmfCallInfo;
1196 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
1197 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1198 char code = '1';
1199 ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
1200 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
1201 }
1202 if (HasSimCard(SIM2_SLOTID)) {
1203 CellularCallInfo sendDtmfCallInfo;
1204 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
1205 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1206 char code = '1';
1207 ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
1208 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
1209 }
1210 }
1211
1212 /**
1213 * @tc.number cellular_call_SendDtmf_0002
1214 * @tc.name Test for sendDtmf function with invalid slot by cs
1215 * @tc.desc Function test
1216 */
1217 HWTEST_F(CsCallOperationTest, cellular_call_SendDtmf_0002, Function | MediumTest | Level2)
1218 {
1219 AccessToken token;
1220 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1221 ASSERT_TRUE(systemAbilityMgr != nullptr);
1222 auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
1223 ASSERT_TRUE(sendDtmfRemote != nullptr);
1224 auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
1225 ASSERT_TRUE(telephonyService != nullptr);
1226 if (HasSimCard(SIM1_SLOTID)) {
1227 CellularCallInfo sendDtmfCallInfo;
1228 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
1229 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1230 char code = '1';
1231 ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
1232 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
1233 }
1234 if (HasSimCard(SIM2_SLOTID)) {
1235 CellularCallInfo sendDtmfCallInfo;
1236 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
1237 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
1238 char code = '1';
1239 ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
1240 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
1241 }
1242 }
1243 } // namespace Telephony
1244 } // namespace OHOS
1245