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 "satellite_test.h"
17 
18 #define private public
19 #define protected public
20 #include "cellular_call_config.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 "tel_ril_call_parcel.h"
26 #include "satellite_call_client.h"
27 #include "securec.h"
28 
29 namespace OHOS {
30 namespace Telephony {
31 using namespace testing::ext;
32 const int32_t SIM1_SLOTID = 0;
33 const int32_t SIM2_SLOTID = 1;
34 const int32_t INVALID_SLOTID = 10;
35 const std::string PHONE_NUMBER = "0000000";
36 
SetUpTestCase(void)37 void SatelliteTest::SetUpTestCase(void)
38 {
39     // step 3: Set Up Test Case
40 }
41 
TearDownTestCase(void)42 void SatelliteTest::TearDownTestCase(void)
43 {
44     // step 3: Tear Down Test Case
45 }
46 
SetUp(void)47 void SatelliteTest::SetUp(void)
48 {
49     // step 3: input testcase setup step
50 }
51 
TearDown(void)52 void SatelliteTest::TearDown(void)
53 {
54     // step 3: input testcase teardown step
55 }
56 
57 /**
58  * @tc.number   Satellite_call_test_001
59  * @tc.name     Test the corresponding functions by entering commands, such as 300 -- SetCallPreferenceMode, 301 --
60  *              GetCallPreferenceMode, etc
61  * @tc.desc     Function test
62  */
63 HWTEST_F(SatelliteTest, Satellite_call_test_001, Function | MediumTest | Level0)
64 {
65     std::cout << "HWTEST_F Satellite_call_test_001";
66     AccessToken token;
67     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
68     ASSERT_TRUE(systemAbilityMgr != nullptr);
69     auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
70     ASSERT_TRUE(remote != nullptr);
71     auto telephonyService = iface_cast<CellularCallInterface>(remote);
72     ASSERT_TRUE(telephonyService != nullptr);
73 }
74 
75 /**
76  * @tc.number   Satellite_call_test_002
77  * @tc.name     Test the corresponding functions by entering commands, such as 300 -- SetCallPreferenceMode, 301 --
78  *              GetCallPreferenceMode, etc
79  * @tc.desc     Function test
80  */
81 HWTEST_F(SatelliteTest, Satellite_call_test_002, Function | MediumTest | Level1)
82 {
83     std::cout << "HWTEST_F Satellite_call_test_002";
84     AccessToken token;
85     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
86     ASSERT_TRUE(systemAbilityMgr != nullptr);
87     auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
88     ASSERT_TRUE(remote != nullptr);
89     auto telephonyService = iface_cast<CellularCallInterface>(remote);
90     ASSERT_TRUE(telephonyService != nullptr);
91 }
92 
93 /**
94  * @tc.number   Satellite_call_DialCall_0001
95  * @tc.name     Test for SetClip function by Satellite
96  * @tc.desc     Function test
97  */
98 HWTEST_F(SatelliteTest, Satellite_call_DialCall_0001, Function | MediumTest | Level2)
99 {
100     AccessToken token;
101     TELEPHONY_LOGI("Satellite_call_DialCall_0001 entry");
102     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
103     ASSERT_TRUE(systemAbilityMgr != nullptr);
104     auto hangUpCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
105     ASSERT_TRUE(hangUpCallRemote != nullptr);
106     auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
107     ASSERT_TRUE(telephonyService != nullptr);
108     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
109         return;
110     }
111     if (HasSimCard(SIM1_SLOTID)) {
112         int32_t ret = TestDialCallBySatellite(SIM1_SLOTID, PHONE_NUMBER);
113         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
114         ret = TestDialCallBySatellite(INVALID_SLOTID, PHONE_NUMBER);
115         EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
116     }
117     if (HasSimCard(SIM2_SLOTID)) {
118         int32_t ret = TestDialCallBySatellite(SIM2_SLOTID, PHONE_NUMBER);
119         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
120         ret = TestDialCallBySatellite(INVALID_SLOTID, PHONE_NUMBER);
121         EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
122     }
123 }
124 
125 /**
126  * @tc.number   Satellite_call_HangUpCall_0001
127  * @tc.name     Test for HangUp function by Satellite
128  * @tc.desc     Function test
129  */
130 HWTEST_F(SatelliteTest, Satellite_call_HangUpCall_0001, Function | MediumTest | Level2)
131 {
132     AccessToken token;
133     TELEPHONY_LOGI("Satellite_call_HangUpCall_0001 entry");
134     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
135     ASSERT_TRUE(systemAbilityMgr != nullptr);
136     auto hangUpCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
137     ASSERT_TRUE(hangUpCallRemote != nullptr);
138     auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
139     ASSERT_TRUE(telephonyService != nullptr);
140     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
141         return;
142     }
143     if (HasSimCard(SIM1_SLOTID)) {
144         CellularCallInfo callInfo;
145         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
146         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
147         ret = telephonyService->HangUp(callInfo, CallSupplementType::TYPE_DEFAULT);
148         EXPECT_GE(ret, TELEPHONY_SUCCESS);
149     }
150     if (HasSimCard(SIM2_SLOTID)) {
151         CellularCallInfo callInfo;
152         int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
153         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
154         ret = telephonyService->HangUp(callInfo, CallSupplementType::TYPE_DEFAULT);
155         EXPECT_GE(ret, TELEPHONY_SUCCESS);
156     }
157 }
158 
159 /**
160  * @tc.number   Satellite_call_AnswerCall_0001
161  * @tc.name     Test for answer function by Satellite
162  * @tc.desc     Function test
163  */
164 HWTEST_F(SatelliteTest, Satellite_call_AnswerCall_0001, Function | MediumTest | Level2)
165 {
166     AccessToken token;
167     TELEPHONY_LOGI("Satellite_call_AnswerCall_0001 entry");
168     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
169     ASSERT_TRUE(systemAbilityMgr != nullptr);
170     auto answerCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
171     ASSERT_TRUE(answerCallRemote != nullptr);
172     auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
173     ASSERT_TRUE(telephonyService != nullptr);
174     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
175         return;
176     }
177     if (HasSimCard(SIM1_SLOTID)) {
178         CellularCallInfo callInfo;
179         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
180         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
181         ret = telephonyService->Answer(callInfo);
182         EXPECT_GE(ret, TELEPHONY_SUCCESS);
183     }
184     if (HasSimCard(SIM2_SLOTID)) {
185         CellularCallInfo callInfo;
186         int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
187         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
188         ret = telephonyService->Answer(callInfo);
189         EXPECT_GE(ret, TELEPHONY_SUCCESS);
190     }
191 }
192 
193 /**
194  * @tc.number   Satellite_call_RejectCall_0001
195  * @tc.name     Test for reject function by tatellite
196  * @tc.desc     Function test
197  */
198 HWTEST_F(SatelliteTest, Satellite_call_RejectCall_0001, Function | MediumTest | Level2)
199 {
200     AccessToken token;
201     TELEPHONY_LOGI("Satellite_call_RejectCall_0001 entry");
202     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
203     ASSERT_TRUE(systemAbilityMgr != nullptr);
204     auto rejectCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
205     ASSERT_TRUE(rejectCallRemote != nullptr);
206     auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
207     ASSERT_TRUE(telephonyService != nullptr);
208     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
209         return;
210     }
211     if (HasSimCard(SIM1_SLOTID)) {
212         CellularCallInfo callInfo;
213         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
214         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
215         ret = telephonyService->Reject(callInfo);
216         EXPECT_GE(ret, TELEPHONY_SUCCESS);
217     }
218     if (HasSimCard(SIM2_SLOTID)) {
219         CellularCallInfo callInfo;
220         int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
221         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
222         ret = telephonyService->Reject(callInfo);
223         EXPECT_GE(ret, TELEPHONY_SUCCESS);
224     }
225 }
226 /**
227  * @tc.number   Satellite_call_StartDtmf_0001
228  * @tc.name     Test for startDtmf function by satellite
229  * @tc.desc     Function test
230  */
231 HWTEST_F(SatelliteTest, Satellite_call_StartDtmf_0001, Function | MediumTest | Level2)
232 {
233     AccessToken token;
234     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
235     ASSERT_TRUE(systemAbilityMgr != nullptr);
236     auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
237     ASSERT_TRUE(startDtmfRemote != nullptr);
238     auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
239     ASSERT_TRUE(telephonyService != nullptr);
240     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
241         return;
242     }
243     if (HasSimCard(SIM1_SLOTID)) {
244         CellularCallInfo callInfo;
245         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
246         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
247         char code = '1';
248         ret = telephonyService->StartDtmf(code, callInfo);
249         EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
250     }
251     if (HasSimCard(SIM2_SLOTID)) {
252         CellularCallInfo callInfo;
253         int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
254         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
255         char code = '1';
256         ret = telephonyService->StartDtmf(code, callInfo);
257         EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
258     }
259 }
260 
261 /**
262  * @tc.number   Satellite_call_StartDtmf_0002
263  * @tc.name     Test for startDtmf function with invalid slot by satellite
264  * @tc.desc     Function test
265  */
266 HWTEST_F(SatelliteTest, Satellite_call_StartDtmf_0002, Function | MediumTest | Level2)
267 {
268     AccessToken token;
269     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
270         return;
271     }
272     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
273     ASSERT_TRUE(systemAbilityMgr != nullptr);
274     auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
275     ASSERT_TRUE(startDtmfRemote != nullptr);
276     auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
277     ASSERT_TRUE(telephonyService != nullptr);
278     CellularCallInfo callInfo;
279     if (HasSimCard(SIM1_SLOTID)) {
280         int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
281         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
282         char code = '1';
283         ret = telephonyService->StartDtmf(code, callInfo);
284         EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
285     }
286     if (HasSimCard(SIM2_SLOTID)) {
287         int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
288         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
289         char code = '1';
290         ret = telephonyService->StartDtmf(code, callInfo);
291         EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
292     }
293 }
294 
295 /**
296  * @tc.number   Satellite_call_StopDtmf_0001
297  * @tc.name     Test for stopDtmf function by satellite
298  * @tc.desc     Function test
299  */
300 HWTEST_F(SatelliteTest, Satellite_call_StopDtmf_0001, Function | MediumTest | Level2)
301 {
302     AccessToken token;
303     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
304     ASSERT_TRUE(systemAbilityMgr != nullptr);
305     auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
306     ASSERT_TRUE(stopDtmfRemote != nullptr);
307     auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
308     ASSERT_TRUE(telephonyService != nullptr);
309     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
310         return;
311     }
312     if (HasSimCard(SIM1_SLOTID)) {
313         CellularCallInfo callInfo;
314         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
315         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
316         ret = telephonyService->StopDtmf(callInfo);
317         EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
318     }
319     if (HasSimCard(SIM2_SLOTID)) {
320         CellularCallInfo callInfo;
321         int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
322         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
323         ret = telephonyService->StopDtmf(callInfo);
324         EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
325     }
326 }
327 
328 /**
329  * @tc.number   Satellite_call_StopDtmf_0002
330  * @tc.name     Test for stopDtmf function with invalid slot by satellite
331  * @tc.desc     Function test
332  */
333 HWTEST_F(SatelliteTest, Satellite_call_StopDtmf_0002, Function | MediumTest | Level2)
334 {
335     AccessToken token;
336     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
337         return;
338     }
339     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
340     ASSERT_TRUE(systemAbilityMgr != nullptr);
341     auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
342     ASSERT_TRUE(stopDtmfRemote != nullptr);
343     auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
344     ASSERT_TRUE(telephonyService != nullptr);
345     if (HasSimCard(SIM1_SLOTID)) {
346         CellularCallInfo stopDtmfCallInfo;
347         int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
348         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
349         ret = telephonyService->StopDtmf(stopDtmfCallInfo);
350         EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
351     }
352     if (HasSimCard(SIM2_SLOTID)) {
353         CellularCallInfo stopDtmfCallInfo;
354         int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
355         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
356         ret = telephonyService->StopDtmf(stopDtmfCallInfo);
357         EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
358     }
359 }
360 
361 /**
362  * @tc.number   Satellite_call_SendDtmf_0001
363  * @tc.name     Test for sendDtmf function by satellite
364  * @tc.desc     Function test
365  */
366 HWTEST_F(SatelliteTest, Satellite_call_SendDtmf_0001, Function | MediumTest | Level2)
367 {
368     AccessToken token;
369     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
370     ASSERT_TRUE(systemAbilityMgr != nullptr);
371     auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
372     ASSERT_TRUE(sendDtmfRemote != nullptr);
373     auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
374     ASSERT_TRUE(telephonyService != nullptr);
375     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
376         return;
377     }
378     if (HasSimCard(SIM1_SLOTID)) {
379         CellularCallInfo sendDtmfCallInfo;
380         int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
381         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
382         char code = '1';
383         ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
384         EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
385     }
386     if (HasSimCard(SIM2_SLOTID)) {
387         CellularCallInfo sendDtmfCallInfo;
388         int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
389         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
390         char code = '1';
391         ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
392         EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
393     }
394 }
395 
396 /**
397  * @tc.number   Satellite_call_SendDtmf_0002
398  * @tc.name     Test for sendDtmf function with invalid slot by satellite
399  * @tc.desc     Function test
400  */
401 HWTEST_F(SatelliteTest, Satellite_call_SendDtmf_0002, Function | MediumTest | Level2)
402 {
403     AccessToken token;
404     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
405         return;
406     }
407     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
408     ASSERT_TRUE(systemAbilityMgr != nullptr);
409     auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
410     ASSERT_TRUE(sendDtmfRemote != nullptr);
411     auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
412     ASSERT_TRUE(telephonyService != nullptr);
413     if (HasSimCard(SIM1_SLOTID)) {
414         CellularCallInfo sendDtmfCallInfo;
415         int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
416         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
417         char code = '1';
418         ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
419         EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
420     }
421     if (HasSimCard(SIM2_SLOTID)) {
422         CellularCallInfo sendDtmfCallInfo;
423         int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
424         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
425         char code = '1';
426         ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
427         EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
428     }
429 }
430 } // namespace Telephony
431 } // namespace OHOS
432