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 
33 namespace OHOS {
34 namespace Telephony {
35 using namespace testing::ext;
36 const int32_t SIM1_SLOTID = 0;
37 const int32_t SIM2_SLOTID = 1;
38 const int32_t SLOT_COUNT = 2;
39 const int32_t INVALID_SLOTID = -1;
40 const int32_t INVALID_HANG_UP_TYPE = -1;
41 const int32_t RESULT = 1;
42 const std::string PHONE_NUMBER = "0000000";
43 const std::string PHONE_NUMBER_SECOND = "1111111";
44 const std::string PHONE_NUMBER_THIRD = "2222222";
45 const std::string PHONE_NUMBER_FOUR = "3333333";
46 
47 /**
48  * @tc.number   cellular_call_SetVoNRState_0002
49  * @tc.name     Test for SetVoNRState function
50  * @tc.desc     Function test
51  */
HWTEST_F(ImsTest, cellular_call_SetVoNRState_0002, Function | MediumTest | Level2)52 HWTEST_F(ImsTest, cellular_call_SetVoNRState_0002, Function | MediumTest | Level2)
53 {
54     AccessToken token;
55     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
56         return;
57     }
58     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
59     ASSERT_TRUE(systemAbilityMgr != nullptr);
60     auto setVoNRRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
61     ASSERT_TRUE(setVoNRRemote != nullptr);
62     auto telephonyService = iface_cast<CellularCallInterface>(setVoNRRemote);
63     ASSERT_TRUE(telephonyService != nullptr);
64     if (HasSimCard(SIM1_SLOTID)) {
65         int32_t ret = telephonyService->SetVoNRState(SIM1_SLOTID, 0);
66         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
67     }
68     if (HasSimCard(SIM2_SLOTID)) {
69         int32_t ret = telephonyService->SetVoNRState(SIM2_SLOTID, 0);
70         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
71     }
72 }
73 
74 /**
75  * @tc.number   cellular_call_GetVoNRState_0001
76  * @tc.name     Test for GetVoNRState function
77  * @tc.desc     Function test
78  */
HWTEST_F(ImsTest, cellular_call_GetVoNRState_0001, Function | MediumTest | Level2)79 HWTEST_F(ImsTest, cellular_call_GetVoNRState_0001, Function | MediumTest | Level2)
80 {
81     AccessToken token;
82     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
83     ASSERT_TRUE(systemAbilityMgr != nullptr);
84     auto getVoNRRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
85     ASSERT_TRUE(getVoNRRemote != nullptr);
86     auto telephonyService = iface_cast<CellularCallInterface>(getVoNRRemote);
87     ASSERT_TRUE(telephonyService != nullptr);
88     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
89         return;
90     }
91     if (HasSimCard(SIM1_SLOTID)) {
92         int32_t result;
93         int32_t ret = telephonyService->GetVoNRState(SIM1_SLOTID, result);
94         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
95     }
96     if (HasSimCard(SIM2_SLOTID)) {
97         int32_t result;
98         int32_t ret = telephonyService->GetVoNRState(SIM2_SLOTID, result);
99         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
100     }
101 }
102 
103 /**
104  * @tc.number   cellular_call_StartRtt_0001
105  * @tc.name     Test for StartRtt function
106  * @tc.desc     Function test
107  */
HWTEST_F(ImsTest, cellular_call_StartRtt_0001, Function | MediumTest | Level2)108 HWTEST_F(ImsTest, cellular_call_StartRtt_0001, Function | MediumTest | Level2)
109 {
110     AccessToken token;
111     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
112     ASSERT_TRUE(systemAbilityMgr != nullptr);
113     auto startRttRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
114     ASSERT_TRUE(startRttRemote != nullptr);
115     auto telephonyService = iface_cast<CellularCallInterface>(startRttRemote);
116     ASSERT_TRUE(telephonyService != nullptr);
117     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
118         return;
119     }
120     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
121         int32_t ret = telephonyService->StartRtt(SIM1_SLOTID, PHONE_NUMBER);
122         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
123     }
124     if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
125         int32_t ret = telephonyService->StartRtt(SIM2_SLOTID, PHONE_NUMBER);
126         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
127     }
128 }
129 
130 /**
131  * @tc.number   cellular_call_StopRtt_0001
132  * @tc.name     Test for StopRtt function
133  * @tc.desc     Function test
134  */
HWTEST_F(ImsTest, cellular_call_StopRtt_0001, Function | MediumTest | Level2)135 HWTEST_F(ImsTest, cellular_call_StopRtt_0001, Function | MediumTest | Level2)
136 {
137     AccessToken token;
138     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
139     ASSERT_TRUE(systemAbilityMgr != nullptr);
140     auto stopRttRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
141     ASSERT_TRUE(stopRttRemote != nullptr);
142     auto telephonyService = iface_cast<CellularCallInterface>(stopRttRemote);
143     ASSERT_TRUE(telephonyService != nullptr);
144     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
145         return;
146     }
147     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
148         int32_t ret = telephonyService->StopRtt(SIM1_SLOTID);
149         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
150     }
151     if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
152         int32_t ret = telephonyService->StopRtt(SIM2_SLOTID);
153         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
154     }
155 }
156 
157 /**
158  * @tc.number   cellular_call_SetDomainPreferenceMode_0001
159  * @tc.name     Test for SetDomainPreferenceMode function
160  * @tc.desc     Function test
161  */
HWTEST_F(ImsTest, cellular_call_SetDomainPreferenceMode_0001, Function | MediumTest | Level2)162 HWTEST_F(ImsTest, cellular_call_SetDomainPreferenceMode_0001, Function | MediumTest | Level2)
163 {
164     AccessToken token;
165     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
166     ASSERT_TRUE(systemAbilityMgr != nullptr);
167     auto domainPrefModeRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
168     ASSERT_TRUE(domainPrefModeRemote != nullptr);
169     auto telephonyService = iface_cast<CellularCallInterface>(domainPrefModeRemote);
170     ASSERT_TRUE(telephonyService != nullptr);
171     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
172         return;
173     }
174     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
175         int32_t mode = -1;
176         int32_t ret = telephonyService->SetDomainPreferenceMode(SIM1_SLOTID, mode);
177         EXPECT_EQ(ret, CALL_ERR_PARAMETER_OUT_OF_RANGE);
178     }
179     if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
180         int32_t mode = -1;
181         int32_t ret = telephonyService->SetDomainPreferenceMode(SIM2_SLOTID, mode);
182         EXPECT_EQ(ret, CALL_ERR_PARAMETER_OUT_OF_RANGE);
183     }
184 }
185 
186 /**
187  * @tc.number   cellular_call_GetImsConfig_0001
188  * @tc.name     Test for GetImsConfig function
189  * @tc.desc     Function test
190  */
HWTEST_F(ImsTest, cellular_call_GetImsConfig_0001, Function | MediumTest | Level2)191 HWTEST_F(ImsTest, cellular_call_GetImsConfig_0001, Function | MediumTest | Level2)
192 {
193     AccessToken token;
194     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
195     ASSERT_TRUE(systemAbilityMgr != nullptr);
196     auto getImsConfigRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
197     ASSERT_TRUE(getImsConfigRemote != nullptr);
198     auto telephonyService = iface_cast<CellularCallInterface>(getImsConfigRemote);
199     ASSERT_TRUE(telephonyService != nullptr);
200     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
201         return;
202     }
203     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
204         ImsConfigItem mode = ITEM_IMS_SWITCH_STATUS;
205         int32_t ret = telephonyService->GetImsConfig(SIM1_SLOTID, mode);
206         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
207     }
208     if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
209         ImsConfigItem mode = ITEM_IMS_SWITCH_STATUS;
210         int32_t ret = telephonyService->GetImsConfig(SIM2_SLOTID, mode);
211         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
212     }
213 }
214 
215 /**
216  * @tc.number   cellular_call_GetImsFeatureValue_0001
217  * @tc.name     Test for GetImsFeatureValue function
218  * @tc.desc     Function test
219  */
HWTEST_F(ImsTest, cellular_call_GetImsFeatureValue_0001, Function | MediumTest | Level2)220 HWTEST_F(ImsTest, cellular_call_GetImsFeatureValue_0001, Function | MediumTest | Level2)
221 {
222     AccessToken token;
223     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
224     ASSERT_TRUE(systemAbilityMgr != nullptr);
225     auto getImsFeatureRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
226     ASSERT_TRUE(getImsFeatureRemote != nullptr);
227     auto telephonyService = iface_cast<CellularCallInterface>(getImsFeatureRemote);
228     ASSERT_TRUE(telephonyService != nullptr);
229     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
230         return;
231     }
232     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
233         FeatureType mode = TYPE_VOICE_OVER_LTE;
234         int32_t ret = telephonyService->GetImsFeatureValue(SIM1_SLOTID, mode);
235         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
236     }
237     if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
238         FeatureType mode = TYPE_VOICE_OVER_LTE;
239         int32_t ret = telephonyService->GetImsFeatureValue(SIM2_SLOTID, mode);
240         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
241     }
242 }
243 
244 /**
245  * @tc.number   cellular_call_SetMute_0001
246  * @tc.name     Test for SetMute function
247  * @tc.desc     Function test
248  */
HWTEST_F(ImsTest, cellular_call_SetMute_0001, Function | MediumTest | Level2)249 HWTEST_F(ImsTest, cellular_call_SetMute_0001, Function | MediumTest | Level2)
250 {
251     AccessToken token;
252     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
253     ASSERT_TRUE(systemAbilityMgr != nullptr);
254     auto setMuteRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
255     ASSERT_TRUE(setMuteRemote != nullptr);
256     auto telephonyService = iface_cast<CellularCallInterface>(setMuteRemote);
257     ASSERT_TRUE(telephonyService != nullptr);
258     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
259         return;
260     }
261     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
262         int32_t mode = 0;
263         int32_t ret = telephonyService->SetMute(SIM1_SLOTID, mode);
264         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
265     }
266     if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_VOICE)) {
267         int32_t mode = 0;
268         int32_t ret = telephonyService->SetMute(SIM2_SLOTID, mode);
269         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
270     }
271 }
272 
273 /**
274  * @tc.number   cellular_call_SetCallWaiting_0001
275  * @tc.name     Test for SetCallWaiting function
276  * @tc.desc     Function test
277  */
HWTEST_F(ImsTest, cellular_call_SetCallWaiting_0001, Function | MediumTest | Level2)278 HWTEST_F(ImsTest, cellular_call_SetCallWaiting_0001, Function | MediumTest | Level2)
279 {
280     AccessToken token;
281     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
282     ASSERT_TRUE(systemAbilityMgr != nullptr);
283     auto SetCWRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
284     ASSERT_TRUE(SetCWRemote != nullptr);
285     auto telephonyService = iface_cast<CellularCallInterface>(SetCWRemote);
286     ASSERT_TRUE(telephonyService != nullptr);
287     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
288         return;
289     }
290     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
291         bool act = true;
292         int32_t ret = telephonyService->SetCallWaiting(SIM1_SLOTID, act);
293         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
294     }
295     if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
296         bool act = true;
297         int32_t ret = telephonyService->SetCallWaiting(SIM2_SLOTID, act);
298         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
299     }
300 }
301 
302 /**
303  * @tc.number   cellular_call_GetCallWaiting_0001
304  * @tc.name     Test for GetCallWaiting function
305  * @tc.desc     Function test
306  */
HWTEST_F(ImsTest, cellular_call_GetCallWaiting_0001, Function | MediumTest | Level2)307 HWTEST_F(ImsTest, cellular_call_GetCallWaiting_0001, Function | MediumTest | Level2)
308 {
309     AccessToken token;
310     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
311     ASSERT_TRUE(systemAbilityMgr != nullptr);
312     auto getCWRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
313     ASSERT_TRUE(getCWRemote != nullptr);
314     auto telephonyService = iface_cast<CellularCallInterface>(getCWRemote);
315     ASSERT_TRUE(telephonyService != nullptr);
316     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
317         return;
318     }
319     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
320         int32_t ret = telephonyService->GetCallWaiting(SIM1_SLOTID);
321         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
322     }
323     if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
324         int32_t ret = telephonyService->GetCallWaiting(SIM2_SLOTID);
325         EXPECT_EQ(ret, TELEPHONY_SUCCESS);
326     }
327 }
328 
329 /**
330  * @tc.number   cellular_call_SetCallRestriction_0001
331  * @tc.name     Test for SetCallRestriction function
332  * @tc.desc     Function test
333  */
HWTEST_F(ImsTest, cellular_call_SetCallRestriction_0001, Function | MediumTest | Level2)334 HWTEST_F(ImsTest, cellular_call_SetCallRestriction_0001, Function | MediumTest | Level2)
335 {
336     AccessToken token;
337     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
338     ASSERT_TRUE(systemAbilityMgr != nullptr);
339     auto setCRRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
340     ASSERT_TRUE(setCRRemote != nullptr);
341     auto telephonyService = iface_cast<CellularCallInterface>(setCRRemote);
342     ASSERT_TRUE(telephonyService != nullptr);
343     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
344         return;
345     }
346     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
347         CallRestrictionInfo crInfo;
348         int32_t ret = telephonyService->SetCallRestriction(SIM1_SLOTID, crInfo);
349         EXPECT_NE(ret, TELEPHONY_SUCCESS);
350     }
351     if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
352         CallRestrictionInfo crInfo;
353         int32_t ret = telephonyService->SetCallRestriction(SIM2_SLOTID, crInfo);
354         EXPECT_NE(ret, TELEPHONY_SUCCESS);
355     }
356 }
357 
358 /**
359  * @tc.number   cellular_call_GetCallRestriction_0001
360  * @tc.name     Test for GetCallRestriction function
361  * @tc.desc     Function test
362  */
HWTEST_F(ImsTest, cellular_call_GetCallRestriction_0001, Function | MediumTest | Level2)363 HWTEST_F(ImsTest, cellular_call_GetCallRestriction_0001, Function | MediumTest | Level2)
364 {
365     AccessToken token;
366     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
367     ASSERT_TRUE(systemAbilityMgr != nullptr);
368     auto getCRRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
369     ASSERT_TRUE(getCRRemote != nullptr);
370     auto telephonyService = iface_cast<CellularCallInterface>(getCRRemote);
371     ASSERT_TRUE(telephonyService != nullptr);
372     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
373         return;
374     }
375     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
376         CallRestrictionType facType = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING;
377         int32_t ret = telephonyService->GetCallRestriction(SIM1_SLOTID, facType);
378         EXPECT_NE(ret, TELEPHONY_SUCCESS);
379     }
380     if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
381         CallRestrictionType facType = CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING;
382         int32_t ret = telephonyService->GetCallRestriction(SIM2_SLOTID, facType);
383         EXPECT_NE(ret, TELEPHONY_SUCCESS);
384     }
385 }
386 
387 /**
388  * @tc.number   cellular_call_SetCallTransferInfo_0001
389  * @tc.name     Test for SetCallTransferInfo function
390  * @tc.desc     Function test
391  */
HWTEST_F(ImsTest, cellular_call_SetCallTransferInfo_0001, Function | MediumTest | Level2)392 HWTEST_F(ImsTest, cellular_call_SetCallTransferInfo_0001, Function | MediumTest | Level2)
393 {
394     AccessToken token;
395     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
396     ASSERT_TRUE(systemAbilityMgr != nullptr);
397     auto setTransferRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
398     ASSERT_TRUE(setTransferRemote != nullptr);
399     auto telephonyService = iface_cast<CellularCallInterface>(setTransferRemote);
400     ASSERT_TRUE(telephonyService != nullptr);
401     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
402         return;
403     }
404     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
405         CallTransferInfo ctInfo;
406         int32_t ret = telephonyService->SetCallTransferInfo(SIM1_SLOTID, ctInfo);
407         EXPECT_NE(ret, TELEPHONY_SUCCESS);
408     }
409     if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
410         CallTransferInfo ctInfo;
411         int32_t ret = telephonyService->SetCallTransferInfo(SIM2_SLOTID, ctInfo);
412         EXPECT_NE(ret, TELEPHONY_SUCCESS);
413     }
414 }
415 
416 /**
417  * @tc.number   cellular_call_GetCallTransferInfo_0001
418  * @tc.name     Test for GetCallTransferInfo function
419  * @tc.desc     Function test
420  */
HWTEST_F(ImsTest, cellular_call_GetCallTransferInfo_0001, Function | MediumTest | Level2)421 HWTEST_F(ImsTest, cellular_call_GetCallTransferInfo_0001, Function | MediumTest | Level2)
422 {
423     AccessToken token;
424     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
425     ASSERT_TRUE(systemAbilityMgr != nullptr);
426     auto getTransferRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
427     ASSERT_TRUE(getTransferRemote != nullptr);
428     auto telephonyService = iface_cast<CellularCallInterface>(getTransferRemote);
429     ASSERT_TRUE(telephonyService != nullptr);
430     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
431         return;
432     }
433     if (HasSimCard(SIM1_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
434         CallTransferType type = CallTransferType::TRANSFER_TYPE_UNCONDITIONAL;
435         int32_t ret = telephonyService->GetCallTransferInfo(SIM1_SLOTID, type);
436         EXPECT_NE(ret, TELEPHONY_SUCCESS);
437     }
438     if (HasSimCard(SIM2_SLOTID) && CanUseImsService(SIM2_SLOTID, ImsServiceType::TYPE_UT)) {
439         CallTransferType type = CallTransferType::TRANSFER_TYPE_UNCONDITIONAL;
440         int32_t ret = telephonyService->GetCallTransferInfo(SIM2_SLOTID, type);
441         EXPECT_NE(ret, TELEPHONY_SUCCESS);
442     }
443 }
444 
445 /**
446  * @tc.number   cellular_call_ImsControl_0001
447  * @tc.name     Test for ImsControl
448  * @tc.desc     Function test
449  */
HWTEST_F(ImsTest, cellular_call_ImsControl_0001, Function | MediumTest | Level3)450 HWTEST_F(ImsTest, cellular_call_ImsControl_0001, Function | MediumTest | Level3)
451 {
452     AccessToken token;
453     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
454     ASSERT_TRUE(systemAbilityMgr != nullptr);
455     auto imsControlRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
456     ASSERT_TRUE(imsControlRemote != nullptr);
457     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
458         return;
459     }
460     auto imsControl = std::make_shared<IMSControl>();
461     CellularCallInfo cellularCallInfo;
462     for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
463         if (!HasSimCard(slotId) || !CanUseImsService(slotId, ImsServiceType::TYPE_VOICE)) {
464             continue;
465         }
466         EXPECT_NE(imsControl->Answer(cellularCallInfo), TELEPHONY_SUCCESS);
467         EXPECT_NE(imsControl->Reject(cellularCallInfo), TELEPHONY_SUCCESS);
468         EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER, cellularCallInfo), TELEPHONY_SUCCESS);
469         bool enabled = false;
470         EXPECT_EQ(imsControl->Dial(cellularCallInfo, enabled), CALL_ERR_GET_RADIO_STATE_FAILED);
471         CLIRMode mode = CLIRMode::DEFAULT;
472         EXPECT_EQ(imsControl->DialJudgment(slotId, PHONE_NUMBER_SECOND, mode, 0), TELEPHONY_SUCCESS);
473         EXPECT_EQ(imsControl->DialJudgment(slotId, PHONE_NUMBER_THIRD, mode, 0), TELEPHONY_SUCCESS);
474         EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_SECOND, cellularCallInfo), TELEPHONY_SUCCESS);
475         EXPECT_NE(imsControl->Answer(cellularCallInfo), TELEPHONY_SUCCESS);
476         EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_THIRD, cellularCallInfo), TELEPHONY_SUCCESS);
477         EXPECT_NE(imsControl->Answer(cellularCallInfo), TELEPHONY_SUCCESS);
478         EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_FOUR, cellularCallInfo), TELEPHONY_SUCCESS);
479         EXPECT_NE(imsControl->Answer(cellularCallInfo), TELEPHONY_SUCCESS);
480         EXPECT_NE(imsControl->Reject(cellularCallInfo), TELEPHONY_SUCCESS);
481         EXPECT_EQ(imsControl->HoldCall(slotId), TELEPHONY_SUCCESS);
482         std::vector<std::string> numberList;
483         EXPECT_EQ(imsControl->KickOutFromConference(slotId, PHONE_NUMBER, cellularCallInfo.index), TELEPHONY_SUCCESS);
484         EXPECT_EQ(imsControl->InviteToConference(slotId, numberList), TELEPHONY_SUCCESS);
485         EXPECT_EQ(imsControl->StartRtt(slotId, PHONE_NUMBER), TELEPHONY_SUCCESS);
486         EXPECT_EQ(imsControl->StopRtt(slotId), TELEPHONY_SUCCESS);
487         EXPECT_NE(imsControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_DEFAULT), TELEPHONY_SUCCESS);
488         EXPECT_EQ(imsControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE),
489             CALL_ERR_RESOURCE_UNAVAILABLE);
490         EXPECT_EQ(imsControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ALL), TELEPHONY_SUCCESS);
491         EXPECT_EQ(imsControl->HangUp(cellularCallInfo, static_cast<CallSupplementType>(INVALID_HANG_UP_TYPE)),
492             TELEPHONY_ERR_ARGUMENT_INVALID);
493     }
494 }
495 
496 /**
497  * @tc.number   cellular_call_ImsControl_0002
498  * @tc.name     Test for ImsControl
499  * @tc.desc     Function test
500  */
HWTEST_F(ImsTest, cellular_call_ImsControl_0002, Function | MediumTest | Level3)501 HWTEST_F(ImsTest, cellular_call_ImsControl_0002, Function | MediumTest | Level3)
502 {
503     AccessToken token;
504     auto imsControl = std::make_shared<IMSControl>();
505     for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
506         if (!HasSimCard(slotId) || !CanUseImsService(slotId, ImsServiceType::TYPE_VOICE)) {
507             continue;
508         }
509         ImsCurrentCallList callList;
510         callList.callSize = 0;
511         CallInfoList callInfoList;
512         EXPECT_EQ(imsControl->ReportCallsData(slotId, callInfoList), TELEPHONY_ERROR);
513         EXPECT_EQ(imsControl->ReportImsCallsData(slotId, callList), TELEPHONY_ERROR);
514         EXPECT_NE(imsControl->ReportUpdateInfo(slotId, callList), TELEPHONY_SUCCESS);
515         ImsCurrentCall callInfo;
516         callList.callSize = 1;
517         callInfo.number = PHONE_NUMBER;
518         callInfo.index = 1;
519         callInfo.state = static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING);
520         callList.calls.push_back(callInfo);
521         EXPECT_EQ(imsControl->ReportImsCallsData(slotId, callList), TELEPHONY_SUCCESS);
522         EXPECT_EQ(imsControl->HangUpAllConnection(slotId), TELEPHONY_SUCCESS);
523         callList.callSize = 2;
524         callInfo.index = 2;
525         callInfo.state = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
526         callInfo.number = PHONE_NUMBER_SECOND;
527         callList.calls.push_back(callInfo);
528         callList.callSize = 3;
529         callInfo.index = 3;
530         callInfo.state = static_cast<int32_t>(TelCallState::CALL_STATUS_WAITING);
531         callInfo.number = PHONE_NUMBER_THIRD;
532         callList.calls.push_back(callInfo);
533         callList.callSize = 4;
534         callInfo.index = 4;
535         callInfo.state = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
536         callInfo.number = PHONE_NUMBER_FOUR;
537         callList.calls.push_back(callInfo);
538         EXPECT_EQ(imsControl->ReportImsCallsData(slotId, callList), TELEPHONY_SUCCESS);
539         callList.callSize = 0;
540         EXPECT_EQ(imsControl->ReportImsCallsData(slotId, callList), TELEPHONY_SUCCESS);
541     }
542 }
543 
544 /**
545  * @tc.number   cellular_call_CellularCallConnectionIMS_0001
546  * @tc.name     Test for CellularCallConnectionIMS
547  * @tc.desc     Function test
548  */
HWTEST_F(ImsTest, cellular_call_CellularCallConnectionIMS_0001, Function | MediumTest | Level3)549 HWTEST_F(ImsTest, cellular_call_CellularCallConnectionIMS_0001, Function | MediumTest | Level3)
550 {
551     AccessToken token;
552     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
553     ASSERT_TRUE(systemAbilityMgr != nullptr);
554     auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
555     ASSERT_TRUE(remote != nullptr);
556     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
557         return;
558     }
559     for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
560         if (!HasSimCard(slotId) || !CanUseImsService(slotId, ImsServiceType::TYPE_VOICE)) {
561             continue;
562         }
563         CellularCallConnectionIMS imsConnection;
564         EXPECT_EQ(imsConnection.SendDtmfRequest(slotId, '1', 1), TELEPHONY_SUCCESS);
565         EXPECT_EQ(imsConnection.StartDtmfRequest(slotId, '1', 1), TELEPHONY_SUCCESS);
566         EXPECT_EQ(imsConnection.StopDtmfRequest(slotId, 1), TELEPHONY_SUCCESS);
567         EXPECT_EQ(imsConnection.GetImsCallsDataRequest(slotId, 1), TELEPHONY_SUCCESS);
568         EXPECT_EQ(imsConnection.GetCallFailReasonRequest(slotId), TELEPHONY_SUCCESS);
569         EXPECT_EQ(imsConnection.AnswerRequest(slotId, PHONE_NUMBER, 0, slotId), TELEPHONY_SUCCESS);
570         ImsDialInfoStruct imsDialInfo;
571         imsDialInfo.phoneNum = PHONE_NUMBER_SECOND;
572         EXPECT_EQ(imsConnection.DialRequest(slotId, imsDialInfo), TELEPHONY_SUCCESS);
573         EXPECT_EQ(imsConnection.HangUpRequest(slotId, PHONE_NUMBER_SECOND, slotId), TELEPHONY_SUCCESS);
574         EXPECT_EQ(imsConnection.StartRttRequest(slotId, PHONE_NUMBER_THIRD), TELEPHONY_SUCCESS);
575         EXPECT_EQ(imsConnection.StopRttRequest(slotId), TELEPHONY_SUCCESS);
576     }
577 }
578 
579 /**
580  * @tc.number   cellular_call_CellularCallRegister_0001
581  * @tc.name     Test for CellularCallRegister
582  * @tc.desc     Function test
583  */
HWTEST_F(ImsTest, cellular_call_CellularCallRegister_0001, Function | MediumTest | Level3)584 HWTEST_F(ImsTest, cellular_call_CellularCallRegister_0001, Function | MediumTest | Level3)
585 {
586     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
587     ASSERT_TRUE(systemAbilityMgr != nullptr);
588     auto registerRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
589     ASSERT_TRUE(registerRemote != nullptr);
590     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
591         return;
592     }
593     auto callRegister = DelayedSingleton<CellularCallRegister>::GetInstance();
594     ASSERT_TRUE(callRegister != nullptr);
595     GetImsConfigResponse imsConfigResponse;
596     callRegister->ReportGetImsConfigResult(imsConfigResponse);
597     callRegister->ReportSetImsConfigResult(RESULT);
598     GetImsFeatureValueResponse imsFeatureValueResponse;
599     callRegister->ReportGetImsFeatureResult(imsFeatureValueResponse);
600     callRegister->ReportSetImsFeatureResult(RESULT);
601     ImsCallModeReceiveInfo callModeInfo;
602     callRegister->ReceiveUpdateCallMediaModeRequest(-1, callModeInfo);
603     callRegister->ReceiveUpdateCallMediaModeResponse(-1, callModeInfo);
604     ImsCallSessionEventInfo callSessionEventInfo;
605     callRegister->HandleCallSessionEventChanged(callSessionEventInfo);
606     ImsCallPeerDimensionsInfo callPeerDimensionsInfo;
607     callRegister->HandlePeerDimensionsChanged(callPeerDimensionsInfo);
608     ImsCallDataUsageInfo callDataUsageInfo;
609     callRegister->HandleCallDataUsageChanged(callDataUsageInfo);
610     CameraCapabilitiesInfo cameraCapabilitiesInfo;
611     callRegister->HandleCameraCapabilitiesChanged(cameraCapabilitiesInfo);
612 }
613 
614 /**
615  * @tc.number   cellular_call_CellularCallRegister_0002
616  * @tc.name     Test for CellularCallRegister
617  * @tc.desc     Function test
618  */
HWTEST_F(ImsTest, cellular_call_CellularCallRegister_0002, Function | MediumTest | Level3)619 HWTEST_F(ImsTest, cellular_call_CellularCallRegister_0002, Function | MediumTest | Level3)
620 {
621     auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
622     ASSERT_TRUE(systemAbilityMgr != nullptr);
623     auto registerRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
624     ASSERT_TRUE(registerRemote != nullptr);
625     auto callRegister = DelayedSingleton<CellularCallRegister>::GetInstance();
626     ASSERT_TRUE(callRegister != nullptr);
627     GetImsConfigResponse imsConfigResponse;
628     callRegister->ReportGetImsConfigResult(imsConfigResponse);
629     callRegister->ReportSetImsConfigResult(RESULT);
630     GetImsFeatureValueResponse imsFeatureValueResponse;
631     callRegister->ReportGetImsFeatureResult(imsFeatureValueResponse);
632     callRegister->ReportSetImsFeatureResult(RESULT);
633     ImsCallModeReceiveInfo callModeInfo;
634     callRegister->ReceiveUpdateCallMediaModeRequest(-1, callModeInfo);
635     callRegister->ReceiveUpdateCallMediaModeResponse(-1, callModeInfo);
636     ImsCallSessionEventInfo callSessionEventInfo;
637     callRegister->HandleCallSessionEventChanged(callSessionEventInfo);
638     ImsCallPeerDimensionsInfo callPeerDimensionsInfo;
639     callRegister->HandlePeerDimensionsChanged(callPeerDimensionsInfo);
640     ImsCallDataUsageInfo callDataUsageInfo;
641     callRegister->HandleCallDataUsageChanged(callDataUsageInfo);
642     CameraCapabilitiesInfo cameraCapabilitiesInfo;
643     callRegister->HandleCameraCapabilitiesChanged(cameraCapabilitiesInfo);
644 }
645 
646 /**
647  * @tc.number   cellular_call_CellularCallConfig_0001
648  * @tc.name     Test for CellularCallConfig
649  * @tc.desc     Function test
650  */
HWTEST_F(ImsTest, cellular_call_CellularCallConfig_0001, Function | MediumTest | Level3)651 HWTEST_F(ImsTest, cellular_call_CellularCallConfig_0001, Function | MediumTest | Level3)
652 {
653     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
654         return;
655     }
656 
657     for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
658         if (!HasSimCard(slotId)) {
659             continue;
660         }
661         CellularCallConfig cellularCallConfig;
662         ASSERT_TRUE(cellularCallConfig.GetImsSwitchOnByDefaultConfig(INVALID_SLOTID));
663         ASSERT_TRUE(cellularCallConfig.GetImsSwitchOnByDefaultConfig(slotId));
664         ASSERT_FALSE(cellularCallConfig.GethideImsSwitchConfig(INVALID_SLOTID));
665         ASSERT_FALSE(cellularCallConfig.GethideImsSwitchConfig(slotId));
666         ASSERT_FALSE(cellularCallConfig.GetvolteSupportedConfig(INVALID_SLOTID));
667         ASSERT_FALSE(cellularCallConfig.GetvolteSupportedConfig(slotId));
668         cellularCallConfig.GetNrModeSupportedListConfig(INVALID_SLOTID);
669         cellularCallConfig.GetNrModeSupportedListConfig(slotId);
670         ASSERT_FALSE(cellularCallConfig.GetVolteProvisioningSupportedConfig(INVALID_SLOTID));
671         ASSERT_FALSE(cellularCallConfig.GetVolteProvisioningSupportedConfig(slotId));
672         ASSERT_FALSE(cellularCallConfig.GetSsOverUtSupportedConfig(INVALID_SLOTID));
673         ASSERT_FALSE(cellularCallConfig.GetSsOverUtSupportedConfig(slotId));
674         ASSERT_FALSE(cellularCallConfig.GetImsGbaRequiredConfig(INVALID_SLOTID));
675         ASSERT_FALSE(cellularCallConfig.GetImsGbaRequiredConfig(slotId));
676         ASSERT_FALSE(cellularCallConfig.GetUtProvisioningSupportedConfig(INVALID_SLOTID));
677         ASSERT_FALSE(cellularCallConfig.GetUtProvisioningSupportedConfig(slotId));
678         ASSERT_TRUE(cellularCallConfig.GetImsPreferForEmergencyConfig(INVALID_SLOTID));
679         ASSERT_TRUE(cellularCallConfig.GetImsPreferForEmergencyConfig(slotId));
680         cellularCallConfig.GetCallWaitingServiceClassConfig(INVALID_SLOTID);
681         cellularCallConfig.GetCallWaitingServiceClassConfig(slotId);
682         cellularCallConfig.GetImsCallDisconnectResoninfoMappingConfig(INVALID_SLOTID);
683         cellularCallConfig.GetImsCallDisconnectResoninfoMappingConfig(slotId);
684         ASSERT_FALSE(cellularCallConfig.GetForceVolteSwitchOnConfig(INVALID_SLOTID));
685         ASSERT_FALSE(cellularCallConfig.GetForceVolteSwitchOnConfig(slotId));
686     }
687 }
688 
689 /**
690  * @tc.number   cellular_call_CellularCallConfig_0002
691  * @tc.name     Test for CellularCallConfig
692  * @tc.desc     Function test
693  */
HWTEST_F(ImsTest, cellular_call_CellularCallConfig_0002, Function | MediumTest | Level3)694 HWTEST_F(ImsTest, cellular_call_CellularCallConfig_0002, Function | MediumTest | Level3)
695 {
696     for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
697         CellularCallConfig cellularCallConfig;
698         ASSERT_TRUE(cellularCallConfig.GetImsSwitchOnByDefaultConfig(INVALID_SLOTID));
699         ASSERT_TRUE(cellularCallConfig.GetImsSwitchOnByDefaultConfig(slotId));
700         ASSERT_FALSE(cellularCallConfig.GethideImsSwitchConfig(INVALID_SLOTID));
701         ASSERT_FALSE(cellularCallConfig.GethideImsSwitchConfig(slotId));
702         ASSERT_FALSE(cellularCallConfig.GetvolteSupportedConfig(INVALID_SLOTID));
703         ASSERT_FALSE(cellularCallConfig.GetvolteSupportedConfig(slotId));
704         cellularCallConfig.GetNrModeSupportedListConfig(INVALID_SLOTID);
705         cellularCallConfig.GetNrModeSupportedListConfig(slotId);
706         ASSERT_FALSE(cellularCallConfig.GetVolteProvisioningSupportedConfig(INVALID_SLOTID));
707         ASSERT_FALSE(cellularCallConfig.GetVolteProvisioningSupportedConfig(slotId));
708         ASSERT_FALSE(cellularCallConfig.GetSsOverUtSupportedConfig(INVALID_SLOTID));
709         ASSERT_FALSE(cellularCallConfig.GetSsOverUtSupportedConfig(slotId));
710         ASSERT_FALSE(cellularCallConfig.GetImsGbaRequiredConfig(INVALID_SLOTID));
711         ASSERT_FALSE(cellularCallConfig.GetImsGbaRequiredConfig(slotId));
712         ASSERT_FALSE(cellularCallConfig.GetUtProvisioningSupportedConfig(INVALID_SLOTID));
713         ASSERT_FALSE(cellularCallConfig.GetUtProvisioningSupportedConfig(slotId));
714         ASSERT_TRUE(cellularCallConfig.GetImsPreferForEmergencyConfig(INVALID_SLOTID));
715         ASSERT_TRUE(cellularCallConfig.GetImsPreferForEmergencyConfig(slotId));
716         cellularCallConfig.GetCallWaitingServiceClassConfig(INVALID_SLOTID);
717         cellularCallConfig.GetCallWaitingServiceClassConfig(slotId);
718         cellularCallConfig.GetImsCallDisconnectResoninfoMappingConfig(INVALID_SLOTID);
719         cellularCallConfig.GetImsCallDisconnectResoninfoMappingConfig(slotId);
720         ASSERT_FALSE(cellularCallConfig.GetForceVolteSwitchOnConfig(INVALID_SLOTID));
721         ASSERT_FALSE(cellularCallConfig.GetForceVolteSwitchOnConfig(slotId));
722     }
723 }
724 
725 /**
726  * @tc.number   cellular_call_CellularCallHandler_0001
727  * @tc.name     Test for CellularCallHandler
728  * @tc.desc     Function test
729  */
HWTEST_F(ImsTest, cellular_call_CellularCallHandler_0001, Function | MediumTest | Level3)730 HWTEST_F(ImsTest, cellular_call_CellularCallHandler_0001, Function | MediumTest | Level3)
731 {
732     EventFwk::MatchingSkills matchingSkills;
733     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
734     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
735     CellularCallHandler handler { subscriberInfo };
736     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
737         return;
738     }
739     for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
740         if (!HasSimCard(slotId)) {
741             continue;
742         }
743         handler.SetSlotId(slotId);
744         auto event = AppExecFwk::InnerEvent::Get(0);
745         handler.GetImsCallsDataResponse(event);
746         handler.GetImsCallsDataRequest(event);
747         auto rilRadioResponse = std::make_shared<RadioResponseInfo>();
748         rilRadioResponse->error = ErrType::ERR_GENERIC_FAILURE;
749         auto responseEvent = AppExecFwk::InnerEvent::Get(0, rilRadioResponse);
750         handler.SetDomainPreferenceModeResponse(responseEvent);
751         handler.GetDomainPreferenceModeResponse(event);
752         handler.SetDomainPreferenceModeResponse(event);
753         handler.SetVoNRSwitchStatusResponse(responseEvent);
754         ASSERT_EQ(handler.GetSlotId(), slotId);
755         handler.OnRilAdapterHostDied(event);
756         auto serviceInstance = DelayedSingleton<CellularCallService>::GetInstance();
757         if (serviceInstance != nullptr) {
758             std::shared_ptr<CSControl> csControl;
759             serviceInstance->SetCsControl(slotId, csControl);
760             std::shared_ptr<IMSControl> imsControl;
761             serviceInstance->SetImsControl(slotId, imsControl);
762             handler.OnRilAdapterHostDied(event);
763             ASSERT_TRUE(serviceInstance->GetCsControl(slotId) == nullptr);
764             ASSERT_TRUE(serviceInstance->GetCsControl(slotId) == nullptr);
765         }
766     }
767 }
768 
769 /**
770  * @tc.number   cellular_call_CellularCallHandler_0002
771  * @tc.name     Test for CellularCallHandler
772  * @tc.desc     Function test
773  */
HWTEST_F(ImsTest, cellular_call_CellularCallHandler_0002, Function | MediumTest | Level3)774 HWTEST_F(ImsTest, cellular_call_CellularCallHandler_0002, Function | MediumTest | Level3)
775 {
776     EventFwk::MatchingSkills matchingSkills;
777     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
778     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
779     CellularCallHandler handler { subscriberInfo };
780     if (!HasSimCard(SIM1_SLOTID) && !HasSimCard(SIM2_SLOTID)) {
781         return;
782     }
783     for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
784         if (!HasSimCard(slotId)) {
785             continue;
786         }
787         handler.SetSlotId(slotId);
788         auto event = AppExecFwk::InnerEvent::Get(0);
789         handler.ReceiveUpdateCallMediaModeRequest(event);
790         handler.ReceiveUpdateCallMediaModeResponse(event);
791         handler.HandleCallSessionEventChanged(event);
792         handler.HandlePeerDimensionsChanged(event);
793         handler.HandleCallDataUsageChanged(event);
794         handler.HandleCameraCapabilitiesChanged(event);
795     }
796 }
797 
798 /**
799  * @tc.number   cellular_call_CellularCallHandler_0003
800  * @tc.name     Test for CellularCallHandler
801  * @tc.desc     Function test
802  */
HWTEST_F(ImsTest, cellular_call_CellularCallHandler_0003, Function | MediumTest | Level3)803 HWTEST_F(ImsTest, cellular_call_CellularCallHandler_0003, Function | MediumTest | Level3)
804 {
805     EventFwk::MatchingSkills matchingSkills;
806     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
807     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
808     CellularCallHandler handler { subscriberInfo };
809     for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
810         handler.SetSlotId(slotId);
811         auto event = AppExecFwk::InnerEvent::Get(0);
812         handler.GetImsCallsDataResponse(event);
813         handler.GetImsCallsDataRequest(event);
814         auto rilRadioResponse = std::make_shared<RadioResponseInfo>();
815         rilRadioResponse->error = ErrType::ERR_GENERIC_FAILURE;
816         auto responseEvent = AppExecFwk::InnerEvent::Get(0, rilRadioResponse);
817         handler.SetDomainPreferenceModeResponse(responseEvent);
818         handler.GetDomainPreferenceModeResponse(event);
819         handler.SetDomainPreferenceModeResponse(event);
820         handler.SetVoNRSwitchStatusResponse(responseEvent);
821         ASSERT_EQ(handler.GetSlotId(), slotId);
822         handler.OnRilAdapterHostDied(event);
823         auto serviceInstance = DelayedSingleton<CellularCallService>::GetInstance();
824         if (serviceInstance != nullptr) {
825             std::shared_ptr<CSControl> csControl;
826             serviceInstance->SetCsControl(slotId, csControl);
827             std::shared_ptr<IMSControl> imsControl;
828             serviceInstance->SetImsControl(slotId, imsControl);
829             handler.OnRilAdapterHostDied(event);
830             ASSERT_TRUE(serviceInstance->GetCsControl(slotId) == nullptr);
831             ASSERT_TRUE(serviceInstance->GetCsControl(slotId) == nullptr);
832         }
833     }
834 }
835 
836 /**
837  * @tc.number   cellular_call_CellularCallHandler_0004
838  * @tc.name     Test for CellularCallHandler
839  * @tc.desc     Function test
840  */
HWTEST_F(ImsTest, cellular_call_CellularCallHandler_0004, Function | MediumTest | Level3)841 HWTEST_F(ImsTest, cellular_call_CellularCallHandler_0004, Function | MediumTest | Level3)
842 {
843     EventFwk::MatchingSkills matchingSkills;
844     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
845     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
846     CellularCallHandler handler { subscriberInfo };
847     for (int32_t slotId = 0; slotId < SLOT_COUNT; slotId++) {
848         handler.SetSlotId(slotId);
849         auto event = AppExecFwk::InnerEvent::Get(0);
850         handler.ReceiveUpdateCallMediaModeRequest(event);
851         handler.ReceiveUpdateCallMediaModeResponse(event);
852         handler.HandleCallSessionEventChanged(event);
853         handler.HandlePeerDimensionsChanged(event);
854         handler.HandleCallDataUsageChanged(event);
855         handler.HandleCameraCapabilitiesChanged(event);
856         ASSERT_EQ(handler.GetSlotId(), slotId);
857     }
858 }
859 
860 /**
861  * @tc.number   cellular_call_CellularCallHandler_0005
862  * @tc.name     Test for CellularCallHandler
863  * @tc.desc     Function test
864  */
HWTEST_F(ImsTest, cellular_call_CellularCallHandler_0005, Function | MediumTest | Level3)865 HWTEST_F(ImsTest, cellular_call_CellularCallHandler_0005, Function | MediumTest | Level3)
866 {
867     EventFwk::MatchingSkills matchingSkills;
868     matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
869     EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
870     CellularCallHandler handler { subscriberInfo };
871     auto imsCurrentCallList = std::make_shared<ImsCurrentCallList>();
872     imsCurrentCallList->callSize = 0;
873     handler.ProcessImsPhoneNumber(*imsCurrentCallList);
874     EXPECT_EQ(imsCurrentCallList->callSize, 0);
875     imsCurrentCallList->callSize = 1;
876     handler.ProcessImsPhoneNumber(*imsCurrentCallList);
877     EXPECT_EQ(imsCurrentCallList->callSize, 1);
878     imsCurrentCallList->callSize = 1;
879     ImsCurrentCall imsCurrent;
880     std::string phoneNumber = "123";
881     imsCurrent.number = phoneNumber;
882     imsCurrentCallList->calls.push_back(imsCurrent);
883     handler.ProcessImsPhoneNumber(*imsCurrentCallList);
884     EXPECT_EQ(imsCurrentCallList->calls[0].number, phoneNumber);
885     imsCurrentCallList->calls.clear();
886     std::string unexpected = "00861565910xxxx";
887     std::string expected = "+861565910xxxx";
888     imsCurrent.number = unexpected;
889     imsCurrentCallList->calls.push_back(imsCurrent);
890     handler.ProcessImsPhoneNumber(*imsCurrentCallList);
891     EXPECT_EQ(imsCurrentCallList->calls[0].number, expected);
892     imsCurrentCallList->calls.clear();
893     unexpected = "0861565910xxxx";
894     imsCurrent.number = unexpected;
895     imsCurrentCallList->calls.push_back(imsCurrent);
896     handler.ProcessImsPhoneNumber(*imsCurrentCallList);
897     EXPECT_EQ(imsCurrentCallList->calls[0].number, unexpected);
898 }
899 
900 /**
901  * @tc.number   cellular_call_ImsCallClient_0001
902  * @tc.name     test for ImsCallClient
903  * @tc.desc     Function test
904  */
HWTEST_F(ImsTest, cellular_call_ImsCallClient_0001, Function | MediumTest | Level3)905 HWTEST_F(ImsTest, cellular_call_ImsCallClient_0001, Function | MediumTest | Level3)
906 {
907     ImsCallClient::SystemAbilityListener listen;
908     int32_t systemAbilityId = 1;
909     std::string deviceId = "123";
910     listen.OnAddSystemAbility(systemAbilityId, deviceId);
911     listen.OnRemoveSystemAbility(systemAbilityId, deviceId);
912     listen.OnAddSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
913     listen.OnRemoveSystemAbility(COMMON_EVENT_SERVICE_ID, deviceId);
914 }
915 } // namespace Telephony
916 } // namespace OHOS
917