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