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 "ims_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 "ims_call_callback_proxy.h"
27#include "ims_call_callback_stub.h"
28#include "ims_call_client.h"
29#include "ims_control.h"
30#include "ims_error.h"
31#include "securec.h"
32
33namespace OHOS {
34namespace Telephony {
35using namespace testing::ext;
36const int32_t SIM1_SLOTID = 0;
37const int32_t SIM2_SLOTID = 1;
38const std::string PHONE_NUMBER = "0000000";
39const std::string PHONE_NUMBER_SECOND = "1111111";
40const std::string PHONE_NUMBER_THIRD = "2222222";
41const std::string PHONE_NUMBER_FOUR = "3333333";
42
43/**
44 * @tc.number   cellular_call_ims_test_001
45 * @tc.name     Test the corresponding functions by entering commands, such as 300 -- SetCallPreferenceMode, 301 --
46 *              GetCallPreferenceMode, etc
47 * @tc.desc     Function test
48 */
49HWTEST_F(ImsTest, cellular_call_ims_test_001, Function | MediumTest | Level0)
50{
51    AccessToken token;
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_ims_test_001";
59}
60
61/**
62 * @tc.number   cellular_call_ims_test_002
63 * @tc.name     Test the corresponding functions by entering commands, such as 300 -- SetCallPreferenceMode, 301 --
64 *              GetCallPreferenceMode, etc
65 * @tc.desc     Function test
66 */
67HWTEST_F(ImsTest, cellular_call_ims_test_002, Function | MediumTest | Level1)
68{
69    AccessToken token;
70    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
71    ASSERT_TRUE(systemAbilityMgr != nullptr);
72    auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
73    ASSERT_TRUE(remote != nullptr);
74    auto telephonyService = iface_cast<CellularCallInterface>(remote);
75    ASSERT_TRUE(telephonyService != nullptr);
76    std::cout << "HWTEST_F cellular_call_ims_test_002";
77}
78
79/**
80 * @tc.number   cellular_call_DialCall_0001
81 * @tc.name     Test for SetClip function by ims
82 * @tc.desc     Function test
83 */
84HWTEST_F(ImsTest, cellular_call_DialCall_0001, Function | MediumTest | Level2)
85{
86    AccessToken token;
87    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
88        return;
89    }
90    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
91        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*30#");
92        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
93    }
94    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
95        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*30#");
96        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
97    }
98}
99
100/**
101 * @tc.number   cellular_call_DialCall_0002
102 * @tc.name     Test for SetClip function by ims
103 * @tc.desc     Function test
104 */
105HWTEST_F(ImsTest, cellular_call_DialCall_0002, Function | MediumTest | Level2)
106{
107    AccessToken token;
108    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
109        return;
110    }
111    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
112        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#30#");
113        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
114    }
115    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
116        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "#30#");
117        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
118    }
119}
120
121/**
122 * @tc.number   cellular_call_DialCall_0003
123 * @tc.name     Test for getClip function by ims
124 * @tc.desc     Function test
125 */
126HWTEST_F(ImsTest, cellular_call_DialCall_0003, Function | MediumTest | Level2)
127{
128    AccessToken token;
129    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
130        return;
131    }
132    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
133        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#30#");
134        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
135    }
136    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
137        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*#30#");
138        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
139    }
140}
141
142/**
143 * @tc.number   cellular_call_DialCall_0004
144 * @tc.name     Test for SetClir function by ims
145 * @tc.desc     Function test
146 */
147HWTEST_F(ImsTest, cellular_call_DialCall_0004, Function | MediumTest | Level2)
148{
149    AccessToken token;
150    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
151        return;
152    }
153    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
154        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*31#");
155        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
156    }
157    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
158        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*31#");
159        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
160    }
161}
162
163/**
164 * @tc.number   cellular_call_DialCall_0005
165 * @tc.name     Test for SetClir function by ims
166 * @tc.desc     Function test
167 */
168HWTEST_F(ImsTest, cellular_call_DialCall_0005, Function | MediumTest | Level2)
169{
170    AccessToken token;
171    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
172        return;
173    }
174    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
175        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#31#");
176        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
177    }
178    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
179        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "#31#");
180        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
181    }
182}
183
184/**
185 * @tc.number   cellular_call_DialCall_0006
186 * @tc.name     Test for GetClir function by ims
187 * @tc.desc     Function test
188 */
189HWTEST_F(ImsTest, cellular_call_DialCall_0006, Function | MediumTest | Level2)
190{
191    AccessToken token;
192    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
193        return;
194    }
195    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
196        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#31#");
197        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
198    }
199    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
200        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*#31#");
201        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
202    }
203}
204
205/**
206 * @tc.number   cellular_call_DialCall_0007
207 * @tc.name     Test for SetCallTransfer function by ims
208 * @tc.desc     Function test
209 */
210HWTEST_F(ImsTest, cellular_call_DialCall_0007, Function | MediumTest | Level2)
211{
212    AccessToken token;
213    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
214        return;
215    }
216    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
217        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*21#");
218        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
219    }
220    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
221        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*21#");
222        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
223    }
224}
225
226/**
227 * @tc.number   cellular_call_DialCall_0008
228 * @tc.name     Test for SetCallTransfer function by ims
229 * @tc.desc     Function test
230 */
231HWTEST_F(ImsTest, cellular_call_DialCall_0008, Function | MediumTest | Level2)
232{
233    AccessToken token;
234    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
235        return;
236    }
237    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
238        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#21#");
239        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
240    }
241    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
242        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "#21#");
243        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
244    }
245}
246
247/**
248 * @tc.number   cellular_call_DialCall_0009
249 * @tc.name     Test for GetCallTransfer function by ims
250 * @tc.desc     Function test
251 */
252HWTEST_F(ImsTest, cellular_call_DialCall_0009, Function | MediumTest | Level2)
253{
254    AccessToken token;
255    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
256        return;
257    }
258    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
259        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#21#");
260        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
261    }
262    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
263        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*#21#");
264        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
265    }
266}
267
268/**
269 * @tc.number   cellular_call_DialCall_0010
270 * @tc.name     Test for SetCallRestriction function by ims
271 * @tc.desc     Function test
272 */
273HWTEST_F(ImsTest, cellular_call_DialCall_0010, Function | MediumTest | Level2)
274{
275    AccessToken token;
276    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
277        return;
278    }
279    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
280        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*33#");
281        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
282    }
283    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
284        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*33#");
285        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
286    }
287}
288
289/**
290 * @tc.number   cellular_call_DialCall_0011
291 * @tc.name     Test for SetCallRestriction function by ims
292 * @tc.desc     Function test
293 */
294HWTEST_F(ImsTest, cellular_call_DialCall_0011, Function | MediumTest | Level2)
295{
296    AccessToken token;
297    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
298        return;
299    }
300    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
301        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#33#");
302        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
303    }
304    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
305        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "#33#");
306        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
307    }
308}
309
310/**
311 * @tc.number   cellular_call_DialCall_0012
312 * @tc.name     Test for GetCallRestriction function by ims
313 * @tc.desc     Function test
314 */
315HWTEST_F(ImsTest, cellular_call_DialCall_0012, Function | MediumTest | Level2)
316{
317    AccessToken token;
318    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
319        return;
320    }
321    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
322        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#33#");
323        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
324    }
325    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
326        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*#33#");
327        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
328    }
329}
330
331/**
332 * @tc.number   cellular_call_DialCall_0013
333 * @tc.name     Test for SetCallWaiting function by ims
334 * @tc.desc     Function test
335 */
336HWTEST_F(ImsTest, cellular_call_DialCall_0013, Function | MediumTest | Level2)
337{
338    AccessToken token;
339    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
340        return;
341    }
342    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
343        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*43#");
344        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
345    }
346    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
347        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*43#");
348        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
349    }
350}
351
352/**
353 * @tc.number   cellular_call_DialCall_0014
354 * @tc.name     Test for SetCallWaiting function by ims
355 * @tc.desc     Function test
356 */
357HWTEST_F(ImsTest, cellular_call_DialCall_0014, Function | MediumTest | Level2)
358{
359    AccessToken token;
360    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
361        return;
362    }
363    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
364        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "#43#");
365        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
366    }
367    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
368        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "#43#");
369        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
370    }
371}
372
373/**
374 * @tc.number   cellular_call_DialCall_0015
375 * @tc.name     Test for GetCallWaiting function by ims
376 * @tc.desc     Function test
377 */
378HWTEST_F(ImsTest, cellular_call_DialCall_0015, Function | MediumTest | Level2)
379{
380    AccessToken token;
381    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
382        return;
383    }
384    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
385        int32_t ret = TestDialCallByIms(SIM1_SLOTID, "*#43#");
386        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
387        ret = TestDialCallByIms(SIM1_SLOTID, "*#4@3#");
388        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
389    }
390    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
391        int32_t ret = TestDialCallByIms(SIM2_SLOTID, "*#43#");
392        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
393        ret = TestDialCallByIms(SIM2_SLOTID, "*#4@3#");
394        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
395    }
396}
397
398/**
399 * @tc.number   cellular_call_HangUpCall_0001
400 * @tc.name     Test for HangUp function by ims
401 * @tc.desc     Function test
402 */
403HWTEST_F(ImsTest, cellular_call_HangUpCall_0001, Function | MediumTest | Level2)
404{
405    AccessToken token;
406    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
407    ASSERT_TRUE(systemAbilityMgr != nullptr);
408    auto hangUpCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
409    ASSERT_TRUE(hangUpCallRemote != nullptr);
410    auto telephonyService = iface_cast<CellularCallInterface>(hangUpCallRemote);
411    ASSERT_TRUE(telephonyService != nullptr);
412    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
413        return;
414    }
415    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
416        CellularCallInfo callInfo;
417        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
418        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
419        ret = telephonyService->HangUp(callInfo, CallSupplementType::TYPE_DEFAULT);
420        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
421        ret = telephonyService->HangUp(callInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
422        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
423    }
424    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
425        CellularCallInfo callInfo;
426        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
427        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
428        ret = telephonyService->HangUp(callInfo, CallSupplementType::TYPE_DEFAULT);
429        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
430        ret = telephonyService->HangUp(callInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
431        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
432    }
433}
434
435/**
436 * @tc.number   cellular_call_AnswerCall_0001
437 * @tc.name     Test for answer function by ims
438 * @tc.desc     Function test
439 */
440HWTEST_F(ImsTest, cellular_call_AnswerCall_0001, Function | MediumTest | Level2)
441{
442    AccessToken token;
443    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
444    ASSERT_TRUE(systemAbilityMgr != nullptr);
445    auto answerCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
446    ASSERT_TRUE(answerCallRemote != nullptr);
447    auto telephonyService = iface_cast<CellularCallInterface>(answerCallRemote);
448    ASSERT_TRUE(telephonyService != nullptr);
449    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
450        return;
451    }
452    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
453        CellularCallInfo callInfo;
454        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
455        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
456        ret = telephonyService->Answer(callInfo);
457        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
458    }
459    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
460        CellularCallInfo callInfo;
461        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
462        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
463        ret = telephonyService->Answer(callInfo);
464        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
465    }
466}
467
468/**
469 * @tc.number   cellular_call_RejectCall_0001
470 * @tc.name     Test for reject function by ims
471 * @tc.desc     Function test
472 */
473HWTEST_F(ImsTest, cellular_call_RejectCall_0001, Function | MediumTest | Level2)
474{
475    AccessToken token;
476    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
477    ASSERT_TRUE(systemAbilityMgr != nullptr);
478    auto rejectCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
479    ASSERT_TRUE(rejectCallRemote != nullptr);
480    auto telephonyService = iface_cast<CellularCallInterface>(rejectCallRemote);
481    ASSERT_TRUE(telephonyService != nullptr);
482    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
483        return;
484    }
485    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
486        CellularCallInfo callInfo;
487        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
488        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
489        ret = telephonyService->Reject(callInfo);
490        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
491    }
492    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
493        CellularCallInfo callInfo;
494        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
495        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
496        ret = telephonyService->Reject(callInfo);
497        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
498    }
499}
500
501/**
502 * @tc.number   cellular_call_HoldCall_0001
503 * @tc.name     Test for hold call function by ims
504 * @tc.desc     Function test
505 */
506HWTEST_F(ImsTest, cellular_call_HoldCall_0001, Function | MediumTest | Level2)
507{
508    AccessToken token;
509    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
510    ASSERT_TRUE(systemAbilityMgr != nullptr);
511    auto holdCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
512    ASSERT_TRUE(holdCallRemote != nullptr);
513    auto telephonyService = iface_cast<CellularCallInterface>(holdCallRemote);
514    ASSERT_TRUE(telephonyService != nullptr);
515    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
516        return;
517    }
518    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
519        CellularCallInfo callInfo;
520        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
521        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
522        ret = telephonyService->HoldCall(callInfo);
523        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
524    }
525    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
526        CellularCallInfo callInfo;
527        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
528        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
529        ret = telephonyService->HoldCall(callInfo);
530        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
531    }
532}
533
534/**
535 * @tc.number   cellular_call_UnHoldCall_0001
536 * @tc.name     Test for unhold call function by ims
537 * @tc.desc     Function test
538 */
539HWTEST_F(ImsTest, cellular_call_UnHoldCall_0001, Function | MediumTest | Level2)
540{
541    AccessToken token;
542    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
543    ASSERT_TRUE(systemAbilityMgr != nullptr);
544    auto unHoldCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
545    ASSERT_TRUE(unHoldCallRemote != nullptr);
546    auto telephonyService = iface_cast<CellularCallInterface>(unHoldCallRemote);
547    ASSERT_TRUE(telephonyService != nullptr);
548    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
549        return;
550    }
551    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
552        CellularCallInfo callInfo;
553        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
554        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
555        ret = telephonyService->UnHoldCall(callInfo);
556        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
557    }
558    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
559        CellularCallInfo callInfo;
560        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
561        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
562        ret = telephonyService->UnHoldCall(callInfo);
563        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
564    }
565}
566
567/**
568 * @tc.number   cellular_call_SwitchCall_0001
569 * @tc.name     Test for switch call function by ims
570 * @tc.desc     Function test
571 */
572HWTEST_F(ImsTest, cellular_call_SwitchCall_0001, Function | MediumTest | Level2)
573{
574    AccessToken token;
575    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
576    ASSERT_TRUE(systemAbilityMgr != nullptr);
577    auto switchCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
578    ASSERT_TRUE(switchCallRemote != nullptr);
579    auto telephonyService = iface_cast<CellularCallInterface>(switchCallRemote);
580    ASSERT_TRUE(telephonyService != nullptr);
581    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
582        return;
583    }
584    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
585        CellularCallInfo callInfo;
586        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
587        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
588        ret = telephonyService->SwitchCall(callInfo);
589        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
590    }
591    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
592        CellularCallInfo callInfo;
593        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
594        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
595        ret = telephonyService->SwitchCall(callInfo);
596        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
597    }
598}
599
600/**
601 * @tc.number   cellular_call_CombineConference_0001
602 * @tc.name     Test for combineConference function by ims
603 * @tc.desc     Function test
604 */
605HWTEST_F(ImsTest, cellular_call_CombineConference_0001, Function | MediumTest | Level2)
606{
607    AccessToken token;
608    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
609    ASSERT_TRUE(systemAbilityMgr != nullptr);
610    auto combineRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
611    ASSERT_TRUE(combineRemote != nullptr);
612    auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
613    ASSERT_TRUE(telephonyService != nullptr);
614    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
615        return;
616    }
617    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
618        CellularCallInfo callInfo;
619        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
620        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
621        ret = telephonyService->CombineConference(callInfo);
622        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
623    }
624    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
625        CellularCallInfo callInfo;
626        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
627        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
628        ret = telephonyService->CombineConference(callInfo);
629        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
630    }
631}
632
633/**
634 * @tc.number   cellular_call_SeparateConference_0001
635 * @tc.name     Test for separateConference function by ims
636 * @tc.desc     Function test
637 */
638HWTEST_F(ImsTest, cellular_call_SeparateConference_0001, Function | MediumTest | Level2)
639{
640    AccessToken token;
641    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
642    ASSERT_TRUE(systemAbilityMgr != nullptr);
643    auto separateRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
644    ASSERT_TRUE(separateRemote != nullptr);
645    auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
646    ASSERT_TRUE(telephonyService != nullptr);
647    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
648        return;
649    }
650    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
651        CellularCallInfo callInfo;
652        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
653        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
654        ret = telephonyService->SeparateConference(callInfo);
655        EXPECT_EQ(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
656    }
657    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
658        CellularCallInfo callInfo;
659        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
660        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
661        ret = telephonyService->SeparateConference(callInfo);
662        EXPECT_EQ(ret, TELEPHONY_ERR_ARGUMENT_INVALID);
663    }
664}
665
666/**
667 * @tc.number   cellular_call_KickOutFromConference_0001
668 * @tc.name     Test for KickOutFromConference function by ims
669 * @tc.desc     Function test
670 */
671HWTEST_F(ImsTest, cellular_call_KickOutFromConference_0001, Function | MediumTest | Level2)
672{
673    AccessToken token;
674    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
675    ASSERT_TRUE(systemAbilityMgr != nullptr);
676    auto kickOutRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
677    ASSERT_TRUE(kickOutRemote != nullptr);
678    auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
679    ASSERT_TRUE(telephonyService != nullptr);
680    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
681        return;
682    }
683    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
684        CellularCallInfo callInfo;
685        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
686        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
687        ret = telephonyService->KickOutFromConference(callInfo);
688        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
689    }
690    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
691        CellularCallInfo callInfo;
692        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
693        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
694        ret = telephonyService->KickOutFromConference(callInfo);
695        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
696    }
697}
698
699/**
700 * @tc.number   cellular_call_StartDtmf_0001
701 * @tc.name     Test for startDtmf function by ims
702 * @tc.desc     Function test
703 */
704HWTEST_F(ImsTest, cellular_call_StartDtmf_0001, Function | MediumTest | Level2)
705{
706    AccessToken token;
707    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
708    ASSERT_TRUE(systemAbilityMgr != nullptr);
709    auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
710    ASSERT_TRUE(startDtmfRemote != nullptr);
711    auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
712    ASSERT_TRUE(telephonyService != nullptr);
713    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
714        return;
715    }
716    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
717        CellularCallInfo callInfo;
718        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
719        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
720        char code = '1';
721        ret = telephonyService->StartDtmf(code, callInfo);
722        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
723    }
724    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
725        CellularCallInfo callInfo;
726        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
727        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
728        char code = '1';
729        ret = telephonyService->StartDtmf(code, callInfo);
730        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
731    }
732}
733
734/**
735 * @tc.number   cellular_call_StopDtmf_0001
736 * @tc.name     Test for stopDtmf function by ims
737 * @tc.desc     Function test
738 */
739HWTEST_F(ImsTest, cellular_call_StopDtmf_0001, Function | MediumTest | Level2)
740{
741    AccessToken token;
742    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
743    ASSERT_TRUE(systemAbilityMgr != nullptr);
744    auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
745    ASSERT_TRUE(stopDtmfRemote != nullptr);
746    auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
747    ASSERT_TRUE(telephonyService != nullptr);
748    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
749        return;
750    }
751    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
752        CellularCallInfo callInfo;
753        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
754        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
755        ret = telephonyService->StopDtmf(callInfo);
756        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
757    }
758    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
759        CellularCallInfo callInfo;
760        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
761        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
762        ret = telephonyService->StopDtmf(callInfo);
763        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
764    }
765}
766
767/**
768 * @tc.number   cellular_call_SendDtmf_0001
769 * @tc.name     Test for sendDtmf function by ims
770 * @tc.desc     Function test
771 */
772HWTEST_F(ImsTest, cellular_call_SendDtmf_0001, Function | MediumTest | Level2)
773{
774    AccessToken token;
775    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
776    ASSERT_TRUE(systemAbilityMgr != nullptr);
777    auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
778    ASSERT_TRUE(sendDtmfRemote != nullptr);
779    auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
780    ASSERT_TRUE(telephonyService != nullptr);
781    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
782        return;
783    }
784    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_VOICE)) {
785        CellularCallInfo callInfo;
786        int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
787        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
788        char code = '1';
789        ret = telephonyService->SendDtmf(code, callInfo);
790        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
791    }
792    if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
793        CellularCallInfo callInfo;
794        int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
795        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
796        char code = '1';
797        ret = telephonyService->SendDtmf(code, callInfo);
798        EXPECT_EQ(ret, CALL_ERR_CALL_CONNECTION_NOT_EXIST);
799    }
800}
801
802/**
803 * @tc.number   cellular_call_CanSetCallTransferTime_0001
804 * @tc.name     Test for CanSetCallTransferTime function by ims
805 * @tc.desc     Function test
806 */
807HWTEST_F(ImsTest, cellular_call_CanSetCallTransferTime_0001, Function | MediumTest | Level2)
808{
809    AccessToken token;
810    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
811    ASSERT_TRUE(systemAbilityMgr != nullptr);
812    auto transferRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
813    ASSERT_TRUE(transferRemote != nullptr);
814    auto telephonyService = iface_cast<CellularCallInterface>(transferRemote);
815    ASSERT_TRUE(telephonyService != nullptr);
816    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
817        return;
818    }
819    if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM1_SLOTID, ImsServiceType::TYPE_UT)) {
820        bool result;
821        int32_t ret = telephonyService->CanSetCallTransferTime(SIM1_SLOTID, result);
822        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
823    }
824    if (HasSimCard(SIM2_SLOTID)) {
825        bool result;
826        int32_t ret = telephonyService->CanSetCallTransferTime(SIM2_SLOTID, result);
827        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
828    }
829}
830
831
832/**
833 * @tc.number   cellular_call_SetVoNRState_0001
834 * @tc.name     Test for SetVoNRState function
835 * @tc.desc     Function test
836 */
837HWTEST_F(ImsTest, cellular_call_SetVoNRState_0001, Function | MediumTest | Level2)
838{
839    AccessToken token;
840    auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
841    ASSERT_TRUE(systemAbilityMgr != nullptr);
842    auto setVoNRRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
843    ASSERT_TRUE(setVoNRRemote != nullptr);
844    auto telephonyService = iface_cast<CellularCallInterface>(setVoNRRemote);
845    ASSERT_TRUE(telephonyService != nullptr);
846    if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
847        return;
848    }
849    if (HasSimCard(SIM1_SLOTID)) {
850        int32_t ret = telephonyService->SetVoNRState(SIM1_SLOTID, 1);
851        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
852    }
853    if (HasSimCard(SIM2_SLOTID)) {
854        int32_t ret = telephonyService->SetVoNRState(SIM2_SLOTID, 1);
855        EXPECT_EQ(ret, TELEPHONY_SUCCESS);
856    }
857}
858} // namespace Telephony
859} // namespace OHOS
860