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