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 "gtest/gtest.h"
17 #include <random>
18
19 #define private public
20 #define protected public
21 #include "cellular_call_callback.h"
22 #include "cellular_call_handler.h"
23 #include "cellular_call_proxy.h"
24 #include "cellular_call_register.h"
25 #include "cellular_call_service.h"
26 #include "cellular_call_supplement.h"
27 #include "config_request.h"
28 #include "core_service_client.h"
29 #include "cs_control.h"
30 #include "tel_ril_call_parcel.h"
31 #include "operator_config_types.h"
32 #include "radio_event.h"
33 #include "securec.h"
34 #include "sim_state_type.h"
35 #include "system_ability_definition.h"
36 #include "token.h"
37
38 namespace OHOS {
39 namespace Telephony {
40 using namespace testing::ext;
41 const int32_t SIM1_SLOTID = 0;
42 const int32_t SIM2_SLOTID = 1;
43 const int32_t INVALID_SLOTID = 0xFF;
44 const int32_t INVALID_HANG_UP_TYPE = -1;
45 const int32_t SUCCESS_RESULT = 0;
46 const int32_t ERROR_RESULT = 1;
47 const int32_t USSD_MODE_NOTIFY = 0;
48 const std::string PHONE_NUMBER = "0000000";
49 const std::string PHONE_NUMBER_SECOND = "1111111";
50 const std::string PHONE_NUMBER_THIRD = "2222222";
51
52 class Cs2Test : public testing::Test {
53 public:
54 static void SetUpTestCase();
55 static void TearDownTestCase();
56 void SetUp();
57 void TearDown();
58 int32_t TestDialCallByCs(int32_t slotId, std::string code);
HasSimCard(int32_t slotId)59 bool HasSimCard(int32_t slotId)
60 {
61 bool hasSimCard = false;
62 DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(slotId, hasSimCard);
63 return hasSimCard;
64 }
65 int32_t InitCellularCallInfo(int32_t accountId, std::string phonenumber, CellularCallInfo &callInfo);
66 };
67
TestDialCallByCs(int32_t slotId,std::string code)68 int32_t Cs2Test::TestDialCallByCs(int32_t slotId, std::string code)
69 {
70 AccessToken token;
71 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
72 if (systemAbilityMgr == nullptr) {
73 return TELEPHONY_ERR_FAIL;
74 }
75 auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
76 if (remote == nullptr) {
77 return TELEPHONY_ERR_FAIL;
78 }
79 auto telephonyService = iface_cast<CellularCallInterface>(remote);
80 if (telephonyService == nullptr) {
81 return TELEPHONY_ERR_FAIL;
82 }
83 CellularCallInfo callInfo;
84 int32_t ret = TELEPHONY_SUCCESS;
85 ret = InitCellularCallInfo(slotId, code, callInfo);
86 if (ret != TELEPHONY_SUCCESS) {
87 return ret;
88 }
89 // close ims, make this time use cs to test
90 ret = telephonyService->SetImsSwitchStatus(slotId, false);
91 if (ret != TELEPHONY_SUCCESS) {
92 return ret;
93 }
94 ret = telephonyService->Dial(callInfo);
95 return ret;
96 };
97
InitCellularCallInfo(int32_t accountId,std::string phonenumber,CellularCallInfo & callInfo)98 int32_t Cs2Test::InitCellularCallInfo(int32_t accountId, std::string phonenumber,
99 CellularCallInfo &callInfo)
100 {
101 callInfo.accountId = accountId;
102 callInfo.slotId = accountId;
103 callInfo.index = accountId;
104 callInfo.callType = CallType::TYPE_CS;
105 callInfo.videoState = 0; // 0 means audio
106 if (memset_s(callInfo.phoneNum, kMaxNumberLen, 0, kMaxNumberLen) != EOK) {
107 return TELEPHONY_ERR_MEMSET_FAIL;
108 }
109 if (phonenumber.length() > static_cast<size_t>(kMaxNumberLen)) {
110 return CALL_ERR_NUMBER_OUT_OF_RANGE;
111 }
112 if (memcpy_s(callInfo.phoneNum, kMaxNumberLen, phonenumber.c_str(), phonenumber.length()) != EOK) {
113 return TELEPHONY_ERR_MEMCPY_FAIL;
114 }
115 return TELEPHONY_SUCCESS;
116 };
117
SetUpTestCase(void)118 void Cs2Test::SetUpTestCase(void)
119 {
120 // step 3: Set Up Test Case
121 }
122
TearDownTestCase(void)123 void Cs2Test::TearDownTestCase(void)
124 {
125 // step 3: Tear Down Test Case
126 }
127
SetUp(void)128 void Cs2Test::SetUp(void)
129 {
130 // step 3: input testcase setup step
131 }
132
TearDown(void)133 void Cs2Test::TearDown(void)
134 {
135 // step 3: input testcase teardown step
136 }
137
138 /**
139 * @tc.number cellular_call_CombineConference_0001
140 * @tc.name Test for combineConference function by cs
141 * @tc.desc Function test
142 */
143 HWTEST_F(Cs2Test, cellular_call_CombineConference_0001, Function | MediumTest | Level2)
144 {
145 AccessToken token;
146 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
147 ASSERT_TRUE(systemAbilityMgr != nullptr);
148 auto combineRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
149 ASSERT_TRUE(combineRemote != nullptr);
150 auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
151 ASSERT_TRUE(telephonyService != nullptr);
152 if (HasSimCard(SIM1_SLOTID)) {
153 CellularCallInfo conferenceCallInfo;
154 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, conferenceCallInfo);
155 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
156 ret = telephonyService->CombineConference(conferenceCallInfo);
157 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
158 }
159 if (HasSimCard(SIM2_SLOTID)) {
160 CellularCallInfo conferenceCallInfo;
161 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, conferenceCallInfo);
162 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
163 ret = telephonyService->CombineConference(conferenceCallInfo);
164 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
165 }
166 }
167
168 /**
169 * @tc.number cellular_call_CombineConference_0002
170 * @tc.name Test for combineConference function with invalid slot by cs
171 * @tc.desc Function test
172 */
173 HWTEST_F(Cs2Test, cellular_call_CombineConference_0002, Function | MediumTest | Level2)
174 {
175 AccessToken token;
176 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
177 ASSERT_TRUE(systemAbilityMgr != nullptr);
178 auto combineRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
179 ASSERT_TRUE(combineRemote != nullptr);
180 auto telephonyService = iface_cast<CellularCallInterface>(combineRemote);
181 ASSERT_TRUE(telephonyService != nullptr);
182 if (HasSimCard(SIM1_SLOTID)) {
183 CellularCallInfo conferenceCallInfo;
184 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, conferenceCallInfo);
185 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
186 ret = telephonyService->CombineConference(conferenceCallInfo);
187 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
188 }
189 if (HasSimCard(SIM2_SLOTID)) {
190 CellularCallInfo conferenceCallInfo;
191 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, conferenceCallInfo);
192 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
193 ret = telephonyService->CombineConference(conferenceCallInfo);
194 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
195 }
196 }
197
198 /**
199 * @tc.number cellular_call_SeparateConference_0001
200 * @tc.name Test for separateConference function by cs
201 * @tc.desc Function test
202 */
203 HWTEST_F(Cs2Test, cellular_call_SeparateConference_0001, Function | MediumTest | Level2)
204 {
205 AccessToken token;
206 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
207 ASSERT_TRUE(systemAbilityMgr != nullptr);
208 auto separateRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
209 ASSERT_TRUE(separateRemote != nullptr);
210 auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
211 ASSERT_TRUE(telephonyService != nullptr);
212 if (HasSimCard(SIM1_SLOTID)) {
213 CellularCallInfo callInfo;
214 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
215 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
216 ret = telephonyService->SeparateConference(callInfo);
217 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
218 }
219 if (HasSimCard(SIM2_SLOTID)) {
220 CellularCallInfo callInfo;
221 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
222 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
223 ret = telephonyService->SeparateConference(callInfo);
224 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
225 }
226 }
227
228 /**
229 * @tc.number cellular_call_SeparateConference_0002
230 * @tc.name Test for separateConference function with invalid slot by cs
231 * @tc.desc Function test
232 */
233 HWTEST_F(Cs2Test, cellular_call_SeparateConference_0002, Function | MediumTest | Level2)
234 {
235 AccessToken token;
236 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
237 ASSERT_TRUE(systemAbilityMgr != nullptr);
238 auto separateRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
239 ASSERT_TRUE(separateRemote != nullptr);
240 auto telephonyService = iface_cast<CellularCallInterface>(separateRemote);
241 ASSERT_TRUE(telephonyService != nullptr);
242 if (HasSimCard(SIM1_SLOTID)) {
243 CellularCallInfo separateCallInfo;
244 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, separateCallInfo);
245 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
246 ret = telephonyService->SeparateConference(separateCallInfo);
247 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
248 }
249 if (HasSimCard(SIM2_SLOTID)) {
250 CellularCallInfo separateCallInfo;
251 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, separateCallInfo);
252 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
253 ret = telephonyService->SeparateConference(separateCallInfo);
254 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
255 }
256 }
257
258 /**
259 * @tc.number cellular_call_KickOutFromConference_0001
260 * @tc.name Test for separateConference function by cs
261 * @tc.desc Function test
262 */
263 HWTEST_F(Cs2Test, cellular_call_KickOutFromConference_0001, Function | MediumTest | Level2)
264 {
265 AccessToken token;
266 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
267 ASSERT_TRUE(systemAbilityMgr != nullptr);
268 auto kickOutRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
269 ASSERT_TRUE(kickOutRemote != nullptr);
270 auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
271 ASSERT_TRUE(telephonyService != nullptr);
272 if (HasSimCard(SIM1_SLOTID)) {
273 CellularCallInfo kickOutCallInfo;
274 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, kickOutCallInfo);
275 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
276 ret = telephonyService->KickOutFromConference(kickOutCallInfo);
277 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
278 }
279 if (HasSimCard(SIM2_SLOTID)) {
280 CellularCallInfo kickOutCallInfo;
281 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, kickOutCallInfo);
282 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
283 ret = telephonyService->KickOutFromConference(kickOutCallInfo);
284 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
285 }
286 }
287
288 /**
289 * @tc.number cellular_call_KickOutFromConference_0002
290 * @tc.name Test for KickOutFromConference function with invalid slot by cs
291 * @tc.desc Function test
292 */
293 HWTEST_F(Cs2Test, cellular_call_KickOutFromConference_0002, Function | MediumTest | Level2)
294 {
295 AccessToken token;
296 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
297 ASSERT_TRUE(systemAbilityMgr != nullptr);
298 auto kickOutRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
299 ASSERT_TRUE(kickOutRemote != nullptr);
300 auto telephonyService = iface_cast<CellularCallInterface>(kickOutRemote);
301 ASSERT_TRUE(telephonyService != nullptr);
302 if (HasSimCard(SIM1_SLOTID)) {
303 CellularCallInfo kickOutCallInfo;
304 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, kickOutCallInfo);
305 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
306 ret = telephonyService->KickOutFromConference(kickOutCallInfo);
307 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
308 }
309 if (HasSimCard(SIM2_SLOTID)) {
310 CellularCallInfo kickOutCallInfo;
311 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, kickOutCallInfo);
312 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
313 ret = telephonyService->KickOutFromConference(kickOutCallInfo);
314 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
315 }
316 }
317
318 /**
319 * @tc.number cellular_call_HangUpAllConnection_0001
320 * @tc.name Test for hangup all connection function by cs
321 * @tc.desc Function test
322 */
323 HWTEST_F(Cs2Test, cellular_call_HangUpAllConnection_0001, Function | MediumTest | Level2)
324 {
325 AccessToken token;
326 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
327 ASSERT_TRUE(systemAbilityMgr != nullptr);
328 auto hangUpAllConRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
329 ASSERT_TRUE(hangUpAllConRemote != nullptr);
330 auto telephonyService = iface_cast<CellularCallInterface>(hangUpAllConRemote);
331 ASSERT_TRUE(telephonyService != nullptr);
332 if (HasSimCard(SIM1_SLOTID)) {
333 int32_t ret = telephonyService->HangUpAllConnection();
334 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
335 }
336 if (HasSimCard(SIM2_SLOTID)) {
337 int32_t ret = telephonyService->HangUpAllConnection();
338 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
339 }
340 }
341
342 /**
343 * @tc.number cellular_call_StartDtmf_0001
344 * @tc.name Test for startDtmf function by cs
345 * @tc.desc Function test
346 */
347 HWTEST_F(Cs2Test, cellular_call_StartDtmf_0001, Function | MediumTest | Level2)
348 {
349 AccessToken token;
350 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
351 ASSERT_TRUE(systemAbilityMgr != nullptr);
352 auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
353 ASSERT_TRUE(startDtmfRemote != nullptr);
354 auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
355 ASSERT_TRUE(telephonyService != nullptr);
356 if (HasSimCard(SIM1_SLOTID)) {
357 CellularCallInfo callInfo;
358 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
359 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
360 char code = '1';
361 ret = telephonyService->StartDtmf(code, callInfo);
362 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
363 }
364 if (HasSimCard(SIM2_SLOTID)) {
365 CellularCallInfo callInfo;
366 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
367 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
368 char code = '1';
369 ret = telephonyService->StartDtmf(code, callInfo);
370 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
371 }
372 }
373
374 /**
375 * @tc.number cellular_call_StartDtmf_0002
376 * @tc.name Test for startDtmf function with invalid slot by cs
377 * @tc.desc Function test
378 */
379 HWTEST_F(Cs2Test, cellular_call_StartDtmf_0002, Function | MediumTest | Level2)
380 {
381 AccessToken token;
382 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
383 ASSERT_TRUE(systemAbilityMgr != nullptr);
384 auto startDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
385 ASSERT_TRUE(startDtmfRemote != nullptr);
386 auto telephonyService = iface_cast<CellularCallInterface>(startDtmfRemote);
387 ASSERT_TRUE(telephonyService != nullptr);
388 CellularCallInfo callInfo;
389 if (HasSimCard(SIM1_SLOTID)) {
390 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
391 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
392 char code = '1';
393 ret = telephonyService->StartDtmf(code, callInfo);
394 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
395 }
396 if (HasSimCard(SIM2_SLOTID)) {
397 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, callInfo);
398 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
399 char code = '1';
400 ret = telephonyService->StartDtmf(code, callInfo);
401 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
402 }
403 }
404
405 /**
406 * @tc.number cellular_call_StopDtmf_0001
407 * @tc.name Test for stopDtmf function by cs
408 * @tc.desc Function test
409 */
410 HWTEST_F(Cs2Test, cellular_call_StopDtmf_0001, Function | MediumTest | Level2)
411 {
412 AccessToken token;
413 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
414 ASSERT_TRUE(systemAbilityMgr != nullptr);
415 auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
416 ASSERT_TRUE(stopDtmfRemote != nullptr);
417 auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
418 ASSERT_TRUE(telephonyService != nullptr);
419 if (HasSimCard(SIM1_SLOTID)) {
420 CellularCallInfo callInfo;
421 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, callInfo);
422 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
423 ret = telephonyService->StopDtmf(callInfo);
424 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
425 }
426 if (HasSimCard(SIM2_SLOTID)) {
427 CellularCallInfo callInfo;
428 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, callInfo);
429 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
430 ret = telephonyService->StopDtmf(callInfo);
431 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
432 }
433 }
434
435 /**
436 * @tc.number cellular_call_StopDtmf_0002
437 * @tc.name Test for stopDtmf function with invalid slot by cs
438 * @tc.desc Function test
439 */
440 HWTEST_F(Cs2Test, cellular_call_StopDtmf_0002, Function | MediumTest | Level2)
441 {
442 AccessToken token;
443 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
444 ASSERT_TRUE(systemAbilityMgr != nullptr);
445 auto stopDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
446 ASSERT_TRUE(stopDtmfRemote != nullptr);
447 auto telephonyService = iface_cast<CellularCallInterface>(stopDtmfRemote);
448 ASSERT_TRUE(telephonyService != nullptr);
449 if (HasSimCard(SIM1_SLOTID)) {
450 CellularCallInfo stopDtmfCallInfo;
451 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
452 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
453 ret = telephonyService->StopDtmf(stopDtmfCallInfo);
454 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
455 }
456 if (HasSimCard(SIM2_SLOTID)) {
457 CellularCallInfo stopDtmfCallInfo;
458 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, stopDtmfCallInfo);
459 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
460 ret = telephonyService->StopDtmf(stopDtmfCallInfo);
461 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
462 }
463 }
464
465 /**
466 * @tc.number cellular_call_SendDtmf_0001
467 * @tc.name Test for sendDtmf function by cs
468 * @tc.desc Function test
469 */
470 HWTEST_F(Cs2Test, cellular_call_SendDtmf_0001, Function | MediumTest | Level2)
471 {
472 AccessToken token;
473 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
474 ASSERT_TRUE(systemAbilityMgr != nullptr);
475 auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
476 ASSERT_TRUE(sendDtmfRemote != nullptr);
477 auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
478 ASSERT_TRUE(telephonyService != nullptr);
479 if (HasSimCard(SIM1_SLOTID)) {
480 CellularCallInfo sendDtmfCallInfo;
481 int32_t ret = InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
482 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
483 char code = '1';
484 ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
485 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
486 }
487 if (HasSimCard(SIM2_SLOTID)) {
488 CellularCallInfo sendDtmfCallInfo;
489 int32_t ret = InitCellularCallInfo(SIM2_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
490 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
491 char code = '1';
492 ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
493 EXPECT_EQ(ret, TELEPHONY_ERR_LOCAL_PTR_NULL);
494 }
495 }
496
497 /**
498 * @tc.number cellular_call_SendDtmf_0002
499 * @tc.name Test for sendDtmf function with invalid slot by cs
500 * @tc.desc Function test
501 */
502 HWTEST_F(Cs2Test, cellular_call_SendDtmf_0002, Function | MediumTest | Level2)
503 {
504 AccessToken token;
505 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
506 ASSERT_TRUE(systemAbilityMgr != nullptr);
507 auto sendDtmfRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
508 ASSERT_TRUE(sendDtmfRemote != nullptr);
509 auto telephonyService = iface_cast<CellularCallInterface>(sendDtmfRemote);
510 ASSERT_TRUE(telephonyService != nullptr);
511 if (HasSimCard(SIM1_SLOTID)) {
512 CellularCallInfo sendDtmfCallInfo;
513 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
514 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
515 char code = '1';
516 ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
517 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
518 }
519 if (HasSimCard(SIM2_SLOTID)) {
520 CellularCallInfo sendDtmfCallInfo;
521 int32_t ret = InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, sendDtmfCallInfo);
522 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
523 char code = '1';
524 ret = telephonyService->SendDtmf(code, sendDtmfCallInfo);
525 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
526 }
527 }
528
529 /**
530 * @tc.number cellular_call_GetDomainPreferenceMode_0001
531 * @tc.name Test for GetDomainPreferenceMode function by invalid slotId
532 * @tc.desc Function test
533 */
534 HWTEST_F(Cs2Test, cellular_call_GetDomainPreferenceMode_0001, Function | MediumTest | Level3)
535 {
536 AccessToken token;
537 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
538 ASSERT_TRUE(systemAbilityMgr != nullptr);
539 auto domainPrefModeRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
540 ASSERT_TRUE(domainPrefModeRemote != nullptr);
541 auto telephonyService = iface_cast<CellularCallInterface>(domainPrefModeRemote);
542 ASSERT_TRUE(telephonyService != nullptr);
543 if (HasSimCard(SIM1_SLOTID)) {
544 int32_t ret = telephonyService->GetDomainPreferenceMode(INVALID_SLOTID);
545 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
546 }
547 if (HasSimCard(SIM2_SLOTID)) {
548 int32_t ret = telephonyService->GetDomainPreferenceMode(INVALID_SLOTID);
549 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
550 }
551 }
552
553 /**
554 * @tc.number cellular_call_GetDomainPreferenceMode_0002
555 * @tc.name Test for GetDomainPreferenceMode function by valid slotId
556 * @tc.desc Function test
557 */
558 HWTEST_F(Cs2Test, cellular_call_GetDomainPreferenceMode_0002, Function | MediumTest | Level3)
559 {
560 AccessToken token;
561 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
562 ASSERT_TRUE(systemAbilityMgr != nullptr);
563 auto domainPrefModeRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
564 ASSERT_TRUE(domainPrefModeRemote != nullptr);
565 auto telephonyService = iface_cast<CellularCallInterface>(domainPrefModeRemote);
566 ASSERT_TRUE(telephonyService != nullptr);
567 if (HasSimCard(SIM1_SLOTID)) {
568 int32_t ret = telephonyService->GetDomainPreferenceMode(SIM1_SLOTID);
569 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
570 }
571 if (HasSimCard(SIM2_SLOTID)) {
572 int32_t ret = telephonyService->GetDomainPreferenceMode(SIM2_SLOTID);
573 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
574 }
575 }
576
577 /**
578 * @tc.number cellular_call_GetMute_0001
579 * @tc.name Test for GetMute function by invalid slotId
580 * @tc.desc Function test
581 */
582 HWTEST_F(Cs2Test, cellular_call_GetMute_0001, Function | MediumTest | Level3)
583 {
584 AccessToken token;
585 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
586 ASSERT_TRUE(systemAbilityMgr != nullptr);
587 auto getMuteRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
588 ASSERT_TRUE(getMuteRemote != nullptr);
589 auto telephonyService = iface_cast<CellularCallInterface>(getMuteRemote);
590 ASSERT_TRUE(telephonyService != nullptr);
591 if (HasSimCard(SIM1_SLOTID)) {
592 int32_t ret = telephonyService->GetMute(INVALID_SLOTID);
593 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
594 }
595 if (HasSimCard(SIM2_SLOTID)) {
596 int32_t ret = telephonyService->GetMute(INVALID_SLOTID);
597 EXPECT_EQ(ret, CALL_ERR_INVALID_SLOT_ID);
598 }
599 }
600
601 /**
602 * @tc.number cellular_call_GetMute_0002
603 * @tc.name Test for GetMute function by valid slotId
604 * @tc.desc Function test
605 */
606 HWTEST_F(Cs2Test, cellular_call_GetMute_0002, Function | MediumTest | Level3)
607 {
608 AccessToken token;
609 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
610 ASSERT_TRUE(systemAbilityMgr != nullptr);
611 auto getMuteRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
612 ASSERT_TRUE(getMuteRemote != nullptr);
613 auto telephonyService = iface_cast<CellularCallInterface>(getMuteRemote);
614 ASSERT_TRUE(telephonyService != nullptr);
615 if (HasSimCard(SIM1_SLOTID)) {
616 int32_t ret = telephonyService->GetMute(SIM1_SLOTID);
617 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
618 }
619 if (HasSimCard(SIM2_SLOTID)) {
620 int32_t ret = telephonyService->GetMute(SIM2_SLOTID);
621 EXPECT_EQ(ret, TELEPHONY_SUCCESS);
622 }
623 }
624
625 /**
626 * @tc.number cellular_call_CsControl_0001
627 * @tc.name Test for CsControl
628 * @tc.desc Function test
629 */
630 HWTEST_F(Cs2Test, cellular_call_CsControl_0001, Function | MediumTest | Level3)
631 {
632 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
633 ASSERT_TRUE(systemAbilityMgr != nullptr);
634 auto csControlRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
635 ASSERT_TRUE(csControlRemote != nullptr);
636 auto csControl = std::make_shared<CSControl>();
637 CellularCallInfo cellularCallInfo;
638 bool enabled = false;
639 EXPECT_EQ(InitCellularCallInfo(INVALID_SLOTID, PHONE_NUMBER, cellularCallInfo), TELEPHONY_SUCCESS);
640 EXPECT_EQ(csControl->Dial(cellularCallInfo, enabled), CALL_ERR_GET_RADIO_STATE_FAILED);
641 EXPECT_EQ(InitCellularCallInfo(INVALID_SLOTID, "", cellularCallInfo), TELEPHONY_SUCCESS);
642 EXPECT_EQ(csControl->Dial(cellularCallInfo, enabled), CALL_ERR_PHONE_NUMBER_EMPTY);
643 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
644 if (!HasSimCard(slotId)) {
645 continue;
646 }
647 EXPECT_EQ(InitCellularCallInfo(slotId, "*30#", cellularCallInfo), TELEPHONY_SUCCESS);
648 EXPECT_EQ(csControl->DialCdma(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
649 EXPECT_EQ(csControl->DialGsm(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
650 EXPECT_EQ(InitCellularCallInfo(slotId, "#30#", cellularCallInfo), TELEPHONY_SUCCESS);
651 EXPECT_EQ(csControl->DialGsm(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
652 EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER, cellularCallInfo), TELEPHONY_SUCCESS);
653 EXPECT_EQ(csControl->DialCdma(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
654 EXPECT_EQ(csControl->Dial(cellularCallInfo, enabled), CALL_ERR_GET_RADIO_STATE_FAILED);
655 ASSERT_FALSE(csControl->CalculateInternationalRoaming(slotId));
656 EXPECT_NE(csControl->DialCdma(cellularCallInfo), TELEPHONY_SUCCESS);
657 EXPECT_EQ(csControl->DialGsm(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
658 EXPECT_NE(csControl->Answer(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
659 EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_SECOND, cellularCallInfo), TELEPHONY_SUCCESS);
660 EXPECT_NE(csControl->Answer(cellularCallInfo), CALL_ERR_CALL_STATE);
661 EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER_THIRD, cellularCallInfo), TELEPHONY_SUCCESS);
662 EXPECT_NE(csControl->Answer(cellularCallInfo), CALL_ERR_CALL_STATE);
663 EXPECT_NE(csControl->Reject(cellularCallInfo), CALL_ERR_CALL_STATE);
664 EXPECT_EQ(InitCellularCallInfo(slotId, PHONE_NUMBER, cellularCallInfo), TELEPHONY_SUCCESS);
665 EXPECT_EQ(csControl->SeparateConference(slotId, PHONE_NUMBER, 1), CALL_ERR_RESOURCE_UNAVAILABLE);
666 EXPECT_EQ(csControl->SeparateConference(slotId, "", 1), CALL_ERR_RESOURCE_UNAVAILABLE);
667 EXPECT_NE(csControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_DEFAULT), CALL_ERR_RESOURCE_UNAVAILABLE);
668 EXPECT_EQ(csControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE),
669 CALL_ERR_RESOURCE_UNAVAILABLE);
670 EXPECT_EQ(
671 csControl->HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ALL), CALL_ERR_RESOURCE_UNAVAILABLE);
672 EXPECT_EQ(csControl->HangUp(cellularCallInfo, static_cast<CallSupplementType>(INVALID_HANG_UP_TYPE)),
673 TELEPHONY_ERR_ARGUMENT_INVALID);
674 }
675 }
676
677 /**
678 * @tc.number cellular_call_CsControl_0002
679 * @tc.name Test for CsControl
680 * @tc.desc Function test
681 */
682 HWTEST_F(Cs2Test, cellular_call_CsControl_0002, Function | MediumTest | Level3)
683 {
684 auto csControl = std::make_shared<CSControl>();
685 CellularCallInfo cellularCallInfo;
686 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
687 if (!HasSimCard(slotId)) {
688 continue;
689 }
690 CallInfoList callList;
691 callList.callSize = 0;
692 EXPECT_EQ(csControl->ReportCsCallsData(slotId, callList), TELEPHONY_SUCCESS);
693 EXPECT_EQ(csControl->ReportUpdateInfo(slotId, callList), TELEPHONY_SUCCESS);
694 CallInfo callInfo;
695 callList.callSize = 1;
696 callInfo.number = PHONE_NUMBER;
697 callInfo.index = 1;
698 callInfo.state = static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING);
699 callList.calls.push_back(callInfo);
700 EXPECT_EQ(csControl->ReportCsCallsData(slotId, callList), TELEPHONY_SUCCESS);
701 callList.callSize = 2;
702 callInfo.state = static_cast<int32_t>(TelCallState::CALL_STATUS_ACTIVE);
703 callInfo.number = PHONE_NUMBER_SECOND;
704 callInfo.index = 2;
705 callList.calls.push_back(callInfo);
706 callList.callSize = 3;
707 callInfo.state = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
708 callInfo.number = PHONE_NUMBER_THIRD;
709 callInfo.index = 3;
710 callList.calls.push_back(callInfo);
711 callList.callSize = 0;
712 EXPECT_EQ(csControl->ReportCsCallsData(slotId, callList), TELEPHONY_SUCCESS);
713 EXPECT_NE(csControl->Reject(cellularCallInfo), CALL_ERR_RESOURCE_UNAVAILABLE);
714 EXPECT_NE(csControl->HoldCall(slotId), CALL_ERR_CALL_STATE);
715 EXPECT_NE(csControl->UnHoldCall(slotId), CALL_ERR_CALL_STATE);
716 EXPECT_NE(csControl->SwitchCall(slotId), CALL_ERR_CALL_STATE);
717 }
718 }
719
720 /**
721 * @tc.number cellular_call_CellularCallConnectionCS_0001
722 * @tc.name Test for CellularCallConnectionCS
723 * @tc.desc Function test
724 */
725 HWTEST_F(Cs2Test, cellular_call_CellularCallConnectionCS_0001, Function | MediumTest | Level3)
726 {
727 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
728 ASSERT_TRUE(systemAbilityMgr != nullptr);
729 auto remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
730 ASSERT_TRUE(remote != nullptr);
731
732 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
733 if (!HasSimCard(slotId)) {
734 continue;
735 }
736 CellularCallConnectionCS csConnection;
737 EXPECT_EQ(csConnection.SendDtmfRequest(slotId, '1', 1), CALL_ERR_RESOURCE_UNAVAILABLE);
738 EXPECT_EQ(csConnection.StartDtmfRequest(slotId, '1', 1), CALL_ERR_RESOURCE_UNAVAILABLE);
739 EXPECT_EQ(csConnection.StopDtmfRequest(slotId, 1), CALL_ERR_RESOURCE_UNAVAILABLE);
740 EXPECT_EQ(csConnection.GetCsCallsDataRequest(slotId, 1), CALL_ERR_RESOURCE_UNAVAILABLE);
741 EXPECT_EQ(csConnection.GetCallFailReasonRequest(slotId), CALL_ERR_RESOURCE_UNAVAILABLE);
742 MMICodeUtils utils;
743 ASSERT_FALSE(utils.IsNeedExecuteMmi("", false));
744 ASSERT_FALSE(utils.ExecuteMmiCode(slotId));
745 }
746 }
747
748 /**
749 * @tc.number cellular_call_CellularCallRegister_0001
750 * @tc.name Test for CellularCallRegister
751 * @tc.desc Function test
752 */
753 HWTEST_F(Cs2Test, cellular_call_CellularCallRegister_0001, Function | MediumTest | Level3)
754 {
755 auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
756 ASSERT_TRUE(systemAbilityMgr != nullptr);
757 auto cellularCallRemote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID);
758 ASSERT_TRUE(cellularCallRemote != nullptr);
759 auto callRegister = DelayedSingleton<CellularCallRegister>::GetInstance();
760 ASSERT_TRUE(callRegister != nullptr);
761 CellularCallEventInfo callEvent;
762 callRegister->ReportEventResultInfo(callEvent);
763 CallWaitResponse waitResponse;
764 callRegister->ReportGetWaitingResult(waitResponse);
765 callRegister->ReportSetWaitingResult(ERROR_RESULT);
766 CallRestrictionResponse restrictionResponse;
767 callRegister->ReportGetRestrictionResult(restrictionResponse);
768 callRegister->ReportSetRestrictionResult(ERROR_RESULT);
769 callRegister->ReportSetBarringPasswordResult(ERROR_RESULT);
770 CallTransferResponse transferResponse;
771 callRegister->ReportGetTransferResult(transferResponse);
772 callRegister->ReportSetTransferResult(ERROR_RESULT);
773 ClipResponse clipResponse;
774 callRegister->ReportGetClipResult(clipResponse);
775 ClirResponse clirResponse;
776 callRegister->ReportGetClirResult(clirResponse);
777 callRegister->ReportSetClirResult(ERROR_RESULT);
778 callRegister->ReportCallRingBackResult(ERROR_RESULT);
779 DisconnectedDetails details;
780 callRegister->ReportCallFailReason(details);
781 MuteControlResponse muteResponse;
782 callRegister->ReportSetMuteResult(muteResponse);
783 callRegister->ReportGetMuteResult(muteResponse);
784 callRegister->ReportInviteToConferenceResult(ERROR_RESULT);
785 callRegister->ReportGetCallDataResult(ERROR_RESULT);
786 callRegister->ReportStartDtmfResult(ERROR_RESULT);
787 callRegister->ReportStopDtmfResult(ERROR_RESULT);
788 callRegister->ReportStartRttResult(ERROR_RESULT);
789 callRegister->ReportStopRttResult(ERROR_RESULT);
790 callRegister->ReportSendUssdResult(ERROR_RESULT);
791 SetEccListResponse eccListResponse;
792 callRegister->ReportSetEmergencyCallListResponse(eccListResponse);
793 MmiCodeInfo mmiInfo;
794 callRegister->ReportMmiCodeResult(mmiInfo);
795 ASSERT_FALSE(callRegister->IsCallManagerCallBackRegistered());
796 }
797
798 /**
799 * @tc.number cellular_call_CellularCallRegister_0002
800 * @tc.name Test for CellularCallRegister
801 * @tc.desc Function test
802 */
803 HWTEST_F(Cs2Test, cellular_call_CellularCallRegister_0002, Function | MediumTest | Level3)
804 {
805 auto callRegister = DelayedSingleton<CellularCallRegister>::GetInstance();
806 CallReportInfo callRepotInfo;
807 callRepotInfo.callType = CallType::TYPE_CS;
808 callRepotInfo.accountId = INVALID_SLOTID;
809 callRepotInfo.state = TelCallState::CALL_STATUS_INCOMING;
810 callRepotInfo.callMode = VideoStateType::TYPE_VOICE;
811 CallsReportInfo calls;
812 calls.slotId = INVALID_SLOTID;
813 calls.callVec.push_back(callRepotInfo);
814 callRegister->ReportCallsInfo(calls);
815 callRegister->ReportSingleCallInfo(callRepotInfo, TelCallState::CALL_STATUS_INCOMING);
816 EXPECT_EQ(callRegister->RegisterCallManagerCallBack(nullptr), TELEPHONY_SUCCESS);
817 EXPECT_EQ(callRegister->UnRegisterCallManagerCallBack(), TELEPHONY_SUCCESS);
818 }
819
820 /**
821 * @tc.number cellular_call_SupplementRequestCs_0001
822 * @tc.name Test for SupplementRequestCs
823 * @tc.desc Function test
824 */
825 HWTEST_F(Cs2Test, cellular_call_SupplementRequestCs_0001, Function | MediumTest | Level3)
826 {
827 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
828 if (!HasSimCard(slotId)) {
829 continue;
830 }
831 SupplementRequestCs request;
832 std::string fac = "fac";
833 std::string pw = "test";
834 int32_t index = 1;
835 int32_t mode = 1;
836 int32_t classType = 1;
837 const char *oldPassword = "oldpwd";
838 const char *newPassword = "newpwd";
839 bool active = true;
840 CallTransferParam param;
841 EXPECT_NE(request.GetCallRestrictionRequest(slotId, fac, index), TELEPHONY_SUCCESS);
842 EXPECT_NE(request.SetCallRestrictionRequest(slotId, fac, mode, pw, index), TELEPHONY_SUCCESS);
843 EXPECT_NE(request.SetBarringPasswordRequest(slotId, fac, index, oldPassword, newPassword), TELEPHONY_SUCCESS);
844 EXPECT_NE(request.GetCallWaitingRequest(slotId, index), TELEPHONY_SUCCESS);
845 EXPECT_NE(request.SetCallWaitingRequest(slotId, active, classType, index), TELEPHONY_SUCCESS);
846 EXPECT_NE(request.GetClipRequest(slotId, index), TELEPHONY_SUCCESS);
847 EXPECT_NE(request.GetClirRequest(slotId, index), TELEPHONY_SUCCESS);
848 EXPECT_NE(request.SetClirRequest(slotId, mode, index), TELEPHONY_SUCCESS);
849 EXPECT_NE(request.GetCallTransferRequest(slotId, mode, index), TELEPHONY_SUCCESS);
850 EXPECT_NE(request.SetCallTransferRequest(slotId, param, index), TELEPHONY_SUCCESS);
851 }
852 }
853
854 /**
855 * @tc.number cellular_call_ConfigRequest_0001
856 * @tc.name Test for ConfigRequest
857 * @tc.desc Function test
858 */
859 HWTEST_F(Cs2Test, cellular_call_ConfigRequest_0001, Function | MediumTest | Level3)
860 {
861 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
862 if (!HasSimCard(slotId)) {
863 continue;
864 }
865 ConfigRequest config;
866 int32_t mode = 1;
867 EXPECT_NE(config.SetDomainPreferenceModeRequest(slotId, mode), TELEPHONY_SUCCESS);
868 EXPECT_NE(config.GetDomainPreferenceModeRequest(slotId), TELEPHONY_SUCCESS);
869 EXPECT_NE(config.SetMuteRequest(slotId, mode), TELEPHONY_SUCCESS);
870 EXPECT_NE(config.GetMuteRequest(slotId), TELEPHONY_SUCCESS);
871 }
872 }
873
874 /**
875 * @tc.number cellular_call_CellularCallSupplement_0001
876 * @tc.name Test for CellularCallSupplement
877 * @tc.desc Function test
878 */
879 HWTEST_F(Cs2Test, cellular_call_CellularCallSupplement_0001, Function | MediumTest | Level3)
880 {
881 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
882 if (!HasSimCard(slotId)) {
883 continue;
884 }
885 MMIData mmiData;
886 CellularCallSupplement supplement;
887 mmiData.actionString = "";
888 supplement.AlterPinPassword(slotId, mmiData);
889 supplement.AlterPin2Password(slotId, mmiData);
890 supplement.UnlockPuk(slotId, mmiData);
891 supplement.UnlockPuk2(slotId, mmiData);
892 mmiData.actionString = "test";
893 mmiData.serviceInfoA = "infoA";
894 mmiData.serviceInfoB = "infoB";
895 mmiData.serviceInfoC = "infoC";
896 supplement.AlterPinPassword(slotId, mmiData);
897 supplement.AlterPin2Password(slotId, mmiData);
898 supplement.UnlockPuk(slotId, mmiData);
899 supplement.UnlockPuk2(slotId, mmiData);
900 mmiData.serviceInfoC = "infoB";
901 supplement.AlterPinPassword(slotId, mmiData);
902 supplement.AlterPin2Password(slotId, mmiData);
903 supplement.UnlockPuk(slotId, mmiData);
904 supplement.UnlockPuk2(slotId, mmiData);
905 ASSERT_FALSE(supplement.IsVaildPinOrPuk("B", "B"));
906 EXPECT_NE(supplement.SendUssd(slotId, "test"), TELEPHONY_SUCCESS);
907 }
908 }
909
910 /**
911 * @tc.number cellular_call_CellularCallSupplement_0002
912 * @tc.name Test for CellularCallSupplement
913 * @tc.desc Function test
914 */
915 HWTEST_F(Cs2Test, cellular_call_CellularCallSupplement_0002, Function | MediumTest | Level3)
916 {
917 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
918 if (!HasSimCard(slotId)) {
919 continue;
920 }
921 CellularCallSupplement supplement;
922 supplement.ObtainBarringInstallation("33");
923 supplement.ObtainBarringInstallation("331");
924 supplement.ObtainBarringInstallation("332");
925 supplement.ObtainBarringInstallation("351");
926 supplement.ObtainBarringInstallation("35");
927 supplement.ObtainBarringInstallation("330");
928 supplement.ObtainBarringInstallation("333");
929 supplement.ObtainBarringInstallation("353");
930 supplement.ObtainBarringInstallation("1000");
931
932 EXPECT_NE(supplement.ObtainServiceCode("10"), TELEPHONY_SUCCESS);
933 EXPECT_NE(supplement.ObtainServiceCode("11"), TELEPHONY_SUCCESS);
934 EXPECT_NE(supplement.ObtainServiceCode("12"), TELEPHONY_SUCCESS);
935 EXPECT_NE(supplement.ObtainServiceCode("13"), TELEPHONY_SUCCESS);
936 EXPECT_NE(supplement.ObtainServiceCode("16"), TELEPHONY_SUCCESS);
937 EXPECT_NE(supplement.ObtainServiceCode("19"), TELEPHONY_SUCCESS);
938 EXPECT_NE(supplement.ObtainServiceCode("20"), TELEPHONY_SUCCESS);
939 EXPECT_NE(supplement.ObtainServiceCode("21"), TELEPHONY_SUCCESS);
940 EXPECT_NE(supplement.ObtainServiceCode("22"), TELEPHONY_SUCCESS);
941 EXPECT_NE(supplement.ObtainServiceCode("24"), TELEPHONY_SUCCESS);
942 EXPECT_NE(supplement.ObtainServiceCode("25"), TELEPHONY_SUCCESS);
943 EXPECT_NE(supplement.ObtainServiceCode("99"), TELEPHONY_SUCCESS);
944 EXPECT_EQ(supplement.ObtainServiceCode("100"), TELEPHONY_SUCCESS);
945
946 EXPECT_EQ(supplement.ObtainCause("21"), TELEPHONY_SUCCESS);
947 EXPECT_NE(supplement.ObtainCause("61"), TELEPHONY_SUCCESS);
948 EXPECT_NE(supplement.ObtainCause("62"), TELEPHONY_SUCCESS);
949 EXPECT_NE(supplement.ObtainCause("67"), TELEPHONY_SUCCESS);
950 EXPECT_EQ(supplement.ObtainCause("99"), TELEPHONY_ERROR);
951 }
952 }
953
954 /**
955 * @tc.number cellular_call_CellularCallSupplement_0003
956 * @tc.name Test for CellularCallSupplement
957 * @tc.desc Function test
958 */
959 HWTEST_F(Cs2Test, cellular_call_CellularCallSupplement_0003, Function | MediumTest | Level3)
960 {
961 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
962 if (!HasSimCard(slotId)) {
963 continue;
964 }
965 CellularCallSupplement supplement;
966 std::string action = "*";
967 std::string number = "";
968 CallTransferSettingType type;
969 EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
970 EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), PHONE_NUMBER, type), TELEPHONY_SUCCESS);
971 action = "#";
972 EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
973 action = "**";
974 EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
975 action = "##";
976 EXPECT_EQ(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
977 action = "*#";
978 EXPECT_NE(supplement.ObtainCallTrasferAction(action.c_str(), number, type), TELEPHONY_SUCCESS);
979 }
980 }
981
982 /**
983 * @tc.number cellular_call_CellularCallHandler_0001
984 * @tc.name Test for CellularCallHandler
985 * @tc.desc Function test
986 */
987 HWTEST_F(Cs2Test, cellular_call_CellularCallHandler_0001, Function | MediumTest | Level3)
988 {
989 EventFwk::MatchingSkills matchingSkills;
990 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
991 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
992 CellularCallHandler firstHandler { subscriberInfo };
993 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
994 if (!HasSimCard(slotId)) {
995 continue;
996 }
997 firstHandler.SetSlotId(slotId);
998 auto event = AppExecFwk::InnerEvent::Get(0);
999 auto rilRadioResponse = std::make_shared<RadioResponseInfo>();
1000 rilRadioResponse->error = ErrType::ERR_GENERIC_FAILURE;
1001 firstHandler.CellularCallIncomingStartTrace(static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING));
1002 firstHandler.CellularCallIncomingFinishTrace(static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING));
1003 firstHandler.GetCsCallsDataResponse(event);
1004 firstHandler.GetCsCallsDataRequest(event);
1005 firstHandler.GetMMIResponse(event);
1006 auto ringbackResponse = std::make_shared<RingbackVoice>();
1007 ringbackResponse->status = ERROR_RESULT;
1008 auto ringbackEvent = AppExecFwk::InnerEvent::Get(0, ringbackResponse);
1009 firstHandler.CallRingBackVoiceResponse(event);
1010 firstHandler.CallRingBackVoiceResponse(ringbackEvent);
1011 auto srvccStatus = std::make_shared<SrvccStatus>();
1012 srvccStatus->status = SrvccState::SRVCC_NONE;
1013 auto srvccEvent1 = AppExecFwk::InnerEvent::Get(0, srvccStatus);
1014 firstHandler.UpdateSrvccStateReport(event);
1015 firstHandler.UpdateSrvccStateReport(srvccEvent1);
1016 srvccStatus->status = SrvccState::COMPLETED;
1017 auto srvccEvent2 = AppExecFwk::InnerEvent::Get(0, srvccStatus);
1018 firstHandler.UpdateSrvccStateReport(srvccEvent2);
1019 firstHandler.UpdateRsrvccStateReport(event);
1020 firstHandler.GetCallFailReasonResponse(event);
1021 firstHandler.GetEmergencyCallListResponse(event);
1022 firstHandler.ReportEccChanged(event);
1023 firstHandler.SetEmergencyCallListResponse(event);
1024 firstHandler.SendUssdResponse(event);
1025 ASSERT_EQ(firstHandler.GetSlotId(), slotId);
1026 }
1027 }
1028
1029 /**
1030 * @tc.number cellular_call_CellularCallHandler_0002
1031 * @tc.name Test for CellularCallHandler
1032 * @tc.desc Function test
1033 */
1034 HWTEST_F(Cs2Test, cellular_call_CellularCallHandler_0002, Function | MediumTest | Level3)
1035 {
1036 EventFwk::MatchingSkills matchingSkills;
1037 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
1038 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1039 CellularCallHandler secondHandler { subscriberInfo };
1040 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
1041 if (!HasSimCard(slotId)) {
1042 continue;
1043 }
1044 secondHandler.SetSlotId(slotId);
1045 auto event = AppExecFwk::InnerEvent::Get(0);
1046 auto rilRadioResponse = std::make_shared<RadioResponseInfo>();
1047 rilRadioResponse->error = ErrType::ERR_GENERIC_FAILURE;
1048 secondHandler.CommonResultResponse(event);
1049 auto rejectEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_REJECT_CALL, rilRadioResponse);
1050 secondHandler.CommonResultResponse(rejectEvent);
1051 auto supplementEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CALL_SUPPLEMENT, rilRadioResponse);
1052 secondHandler.CommonResultResponse(supplementEvent);
1053
1054 rilRadioResponse->error = ErrType::NONE;
1055 auto hangupConnectEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_HANGUP_CONNECT, rilRadioResponse);
1056 secondHandler.CommonResultResponse(hangupConnectEvent);
1057 auto acceptEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_ACCEPT_CALL, rilRadioResponse);
1058 secondHandler.CommonResultResponse(acceptEvent);
1059 auto splitNoErrorEvent = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SPLIT_CALL, rilRadioResponse);
1060 secondHandler.CommonResultResponse(splitNoErrorEvent);
1061
1062 auto ssResult = std::make_shared<SsBaseResult>();
1063 ssResult->index = INVALID_INDEX;
1064 ssResult->result = SUCCESS_RESULT;
1065 auto errorEvent = AppExecFwk::InnerEvent::Get(0, ssResult);
1066 secondHandler.SetCallRestrictionResponse(event);
1067 secondHandler.SetCallRestrictionResponse(errorEvent);
1068 secondHandler.SetBarringPasswordResponse(event);
1069 secondHandler.SetCallTransferInfoResponse(event);
1070 secondHandler.SetCallWaitingResponse(event);
1071 secondHandler.SetClipResponse(event);
1072 secondHandler.SetClirResponse(event);
1073 secondHandler.SetColpResponse(event);
1074 secondHandler.SetColrResponse(event);
1075
1076 auto responseEvent = AppExecFwk::InnerEvent::Get(0, rilRadioResponse);
1077 secondHandler.SetMuteResponse(event);
1078 secondHandler.SetMuteResponse(responseEvent);
1079 secondHandler.GetMuteResponse(event);
1080 secondHandler.GetMuteResponse(responseEvent);
1081 ASSERT_EQ(secondHandler.GetSlotId(), slotId);
1082 }
1083 }
1084
1085 /**
1086 * @tc.number cellular_call_CellularCallHandler_0003
1087 * @tc.name Test for CellularCallHandler
1088 * @tc.desc Function test
1089 */
1090 HWTEST_F(Cs2Test, cellular_call_CellularCallHandler_0003, Function | MediumTest | Level3)
1091 {
1092 EventFwk::MatchingSkills matchingSkills;
1093 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
1094 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1095 CellularCallHandler thirdhandler { subscriberInfo };
1096 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
1097 if (!HasSimCard(slotId)) {
1098 continue;
1099 }
1100 thirdhandler.SetSlotId(slotId);
1101 auto event = AppExecFwk::InnerEvent::Get(0);
1102 auto ussdNoticeResponse = std::make_shared<UssdNoticeInfo>();
1103 ussdNoticeResponse->m = USSD_MODE_NOTIFY;
1104 ussdNoticeResponse->str = "tdd test";
1105 auto successEvent = AppExecFwk::InnerEvent::Get(0, ussdNoticeResponse);
1106 thirdhandler.UssdNotifyResponse(event);
1107 thirdhandler.UssdNotifyResponse(successEvent);
1108 ussdNoticeResponse->str = "";
1109 auto errorEvent = AppExecFwk::InnerEvent::Get(0, ussdNoticeResponse);
1110 thirdhandler.UssdNotifyResponse(errorEvent);
1111
1112 auto ssNoticeResponse = std::make_shared<SsNoticeInfo>();
1113 ssNoticeResponse->result = ERROR_RESULT;
1114 auto defaultEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
1115 thirdhandler.SsNotifyResponse(event);
1116 thirdhandler.SsNotifyResponse(defaultEvent);
1117 ssNoticeResponse->requestType = SUCCESS_RESULT;
1118 auto noticeErrorEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
1119 thirdhandler.SsNotifyResponse(noticeErrorEvent);
1120 ssNoticeResponse->result = SUCCESS_RESULT;
1121 auto noticeDefaultEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
1122 thirdhandler.SsNotifyResponse(noticeDefaultEvent);
1123 ssNoticeResponse->serviceType = static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_UNCONDITIONAL);
1124 auto noticeUnconditinalEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
1125 thirdhandler.SsNotifyResponse(noticeUnconditinalEvent);
1126 ssNoticeResponse->serviceType = static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_BUSY);
1127 auto noticeBusyEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
1128 thirdhandler.SsNotifyResponse(noticeBusyEvent);
1129 ssNoticeResponse->serviceType = static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_NO_REPLY);
1130 auto noticeNoReplyEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
1131 thirdhandler.SsNotifyResponse(noticeNoReplyEvent);
1132 ssNoticeResponse->serviceType = static_cast<int32_t>(CallTransferType::TRANSFER_TYPE_NOT_REACHABLE);
1133 auto noticeNotReachableEvent = AppExecFwk::InnerEvent::Get(0, ssNoticeResponse);
1134 thirdhandler.SsNotifyResponse(noticeNotReachableEvent);
1135 ASSERT_EQ(thirdhandler.GetSlotId(), slotId);
1136 }
1137 }
1138
1139 /**
1140 * @tc.number cellular_call_CellularCallHandler_0004
1141 * @tc.name Test for CellularCallHandler
1142 * @tc.desc Function test
1143 */
1144 HWTEST_F(Cs2Test, cellular_call_CellularCallHandler_0004, Function | MediumTest | Level3)
1145 {
1146 EventFwk::MatchingSkills matchingSkills;
1147 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
1148 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1149 CellularCallHandler fourthHandler { subscriberInfo };
1150 auto callInfoList = std::make_shared<CallInfoList>();
1151 callInfoList->callSize = 1;
1152 std::string expectedPhoneNumber = "+861565910xxxx";
1153 std::string unexpectedPhoneNumber = "00861565910xxxx";
1154 std::vector<CallInfo> callInfoLists;
1155 CallInfo callInfo;
1156 callInfo.number = unexpectedPhoneNumber;
1157 callInfoLists.push_back(callInfo);
1158 callInfoList->calls = callInfoLists;
1159 fourthHandler.ProcessCsPhoneNumber(*callInfoList);
1160 auto callInfoListFirst = std::make_shared<CallInfoList>();
1161 callInfoListFirst->callSize = 0;
1162 callInfoLists.clear();
1163 callInfo.number = unexpectedPhoneNumber;
1164 callInfoLists.push_back(callInfo);
1165 callInfoListFirst->calls = callInfoLists;
1166 fourthHandler.ProcessCsPhoneNumber(*callInfoListFirst);
1167 EXPECT_EQ(callInfoListFirst->calls[0].number, unexpectedPhoneNumber);
1168 auto callInfoListSecond = std::make_shared<CallInfoList>();
1169 callInfoListSecond->callSize = 1;
1170 fourthHandler.ProcessCsPhoneNumber(*callInfoListSecond);
1171 EXPECT_EQ(callInfoListSecond->callSize, 1);
1172 }
1173
1174 /**
1175 * @tc.number cellular_call_CellularCallHandler_0005
1176 * @tc.name Test for CellularCallHandler
1177 * @tc.desc Function test
1178 */
1179 HWTEST_F(Cs2Test, cellular_call_CellularCallHandler_0005, Function | MediumTest | Level3)
1180 {
1181 EventFwk::MatchingSkills matchingSkills;
1182 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
1183 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1184 CellularCallHandler fifthHandler { subscriberInfo };
1185 auto callInfoList = std::make_shared<CallInfoList>();
1186 callInfoList->callSize = 1;
1187 std::random_device rd;
1188 std::mt19937 gen(rd());
1189 std::uniform_int_distribution<> distrib(0, 9);
1190 int randomNumber = 0;
1191 int phonenumberLength = 8;
1192 for (int i = 0; i < phonenumberLength; i++) {
1193 randomNumber = randomNumber * 10 + distrib(gen);
1194 }
1195 std::string expectedPhoneNumber = "+86156" + std::to_string(randomNumber);
1196 std::string unexpectedPhoneNumber = "+8686156" + std::to_string(randomNumber);
1197 CallInfo callInfo;
1198 callInfo.number = unexpectedPhoneNumber;
1199 callInfo.type = 145;
1200 callInfoList->calls.push_back(callInfo);
1201 fifthHandler.ProcessRedundantCode(*callInfoList);
1202 EXPECT_EQ(callInfoList->calls[0].number, expectedPhoneNumber);
1203 callInfoList->calls[0].number = unexpectedPhoneNumber;
1204 callInfoList->callSize = 0;
1205 fifthHandler.ProcessRedundantCode(*callInfoList);
1206 EXPECT_EQ(callInfoList->calls[0].number, unexpectedPhoneNumber);
1207 callInfoList->callSize = 1;
1208 callInfoList->calls.clear();
1209 fifthHandler.ProcessRedundantCode(*callInfoList);
1210 EXPECT_EQ(callInfoList->callSize, 1);
1211 callInfo.number = unexpectedPhoneNumber;
1212 callInfo.type = 136;
1213 callInfoList->calls.push_back(callInfo);
1214 fifthHandler.ProcessRedundantCode(*callInfoList);
1215 EXPECT_EQ(callInfoList->calls[0].number, unexpectedPhoneNumber);
1216 unexpectedPhoneNumber = "+561565910xxxx";
1217 callInfo.number = unexpectedPhoneNumber;
1218 callInfo.type = 145;
1219 callInfoList->calls.clear();
1220 callInfoList->calls.push_back(callInfo);
1221 fifthHandler.ProcessRedundantCode(*callInfoList);
1222 EXPECT_EQ(callInfoList->calls[0].number, unexpectedPhoneNumber);
1223 unexpectedPhoneNumber = "+861565910";
1224 callInfo.number = unexpectedPhoneNumber;
1225 callInfoList->calls.clear();
1226 callInfoList->calls.push_back(callInfo);
1227 fifthHandler.ProcessRedundantCode(*callInfoList);
1228 EXPECT_EQ(callInfoList->calls[0].number, unexpectedPhoneNumber);
1229 }
1230
1231 /**
1232 * @tc.number cellular_call_CellularCallHandler_0006
1233 * @tc.name Test for CellularCallHandler
1234 * @tc.desc Function test
1235 */
1236 HWTEST_F(Cs2Test, cellular_call_CellularCallHandler_0006, Function | MediumTest | Level3)
1237 {
1238 EventFwk::MatchingSkills matchingSkills;
1239 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
1240 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1241 CellularCallHandler sixthHandler { subscriberInfo };
1242 sixthHandler.SetSlotId(DEFAULT_SIM_SLOT_ID);
1243 auto callInfoList = std::make_shared<CallInfoList>();
1244 callInfoList->callSize = 0;
1245 sixthHandler.ReportCsCallsData(*callInfoList);
1246 int32_t slotId = sixthHandler.GetSlotId();
1247 auto csControl = std::make_shared<CSControl>();
1248 EXPECT_EQ(csControl->ReportCsCallsData(slotId, *callInfoList), TELEPHONY_SUCCESS);
1249 callInfoList->callSize = 1;
1250 CallInfo call;
1251 call.number = PHONE_NUMBER;
1252 call.index = 1;
1253 call.state = 4;
1254 callInfoList->calls.push_back(call);
1255 sixthHandler.isInCsRedial_ = false;
1256 sixthHandler.ReportCsCallsData(*callInfoList);
1257 EXPECT_EQ(csControl->ReportCsCallsData(slotId, *callInfoList), TELEPHONY_SUCCESS);
1258 }
1259
1260 /**
1261 * @tc.number cellular_call_CellularCallHandler_0007
1262 * @tc.name Test for CellularCallHandler
1263 * @tc.desc Function test
1264 */
1265 HWTEST_F(Cs2Test, cellular_call_CellularCallHandler_0007, Function | MediumTest | Level3)
1266 {
1267 EventFwk::MatchingSkills matchingSkills;
1268 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
1269 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1270 CellularCallHandler seventhHandler { subscriberInfo };
1271 seventhHandler.HandleCallDisconnectReason(RilDisconnectedReason::DISCONNECTED_REASON_NORMAL, "");
1272 auto serviceInstance = DelayedSingleton<CellularCallService>::GetInstance();
1273 seventhHandler.SetSlotId(DEFAULT_SIM_SLOT_ID);
1274 int32_t slotId = seventhHandler.GetSlotId();
1275 auto csControl = std::make_shared<CSControl>();
1276 serviceInstance->SetCsControl(slotId, csControl);
1277 EXPECT_TRUE(serviceInstance->GetCsControl(slotId) != nullptr);
1278 seventhHandler.HandleCallDisconnectReason(RilDisconnectedReason::DISCONNECTED_REASON_NORMAL, "");
1279 CellularCallConnectionCS csConnection;
1280 RilDisconnectedReason reason = RilDisconnectedReason::DISCONNECTED_REASON_NORMAL;
1281 csConnection.SetDisconnectReason(reason);
1282 EXPECT_EQ(csConnection.GetDisconnectReason(), RilDisconnectedReason::DISCONNECTED_REASON_NORMAL);
1283 auto imsControl = std::make_shared<IMSControl>();
1284 serviceInstance->SetImsControl(slotId, imsControl);
1285 EXPECT_TRUE(serviceInstance->GetImsControl(slotId) != nullptr);
1286 seventhHandler.HandleCallDisconnectReason(RilDisconnectedReason::DISCONNECTED_REASON_NORMAL, "");
1287 CellularCallConnectionIMS imsConnection;
1288 reason = RilDisconnectedReason::DISCONNECTED_REASON_NORMAL;
1289 imsConnection.SetDisconnectReason(reason);
1290 EXPECT_EQ(imsConnection.GetDisconnectReason(), RilDisconnectedReason::DISCONNECTED_REASON_NORMAL);
1291 }
1292
1293 /**
1294 * @tc.number cellular_call_TestDump_0001
1295 * @tc.name TestDump
1296 * @tc.desc Function test
1297 */
1298 HWTEST_F(Cs2Test, cellular_call_TestDump_0001, Function | MediumTest | Level3)
1299 {
1300 std::vector<std::u16string> emptyArgs = {};
1301 std::vector<std::u16string> args = { u"test", u"test1" };
1302 EXPECT_GE(DelayedSingleton<CellularCallService>::GetInstance()->Dump(-1, args), 0);
1303 EXPECT_GE(DelayedSingleton<CellularCallService>::GetInstance()->Dump(0, emptyArgs), 0);
1304 EXPECT_GE(DelayedSingleton<CellularCallService>::GetInstance()->Dump(0, args), 0);
1305 }
1306
1307 /**
1308 * @tc.number cellular_call_ModuleServiceUtils_0001
1309 * @tc.name ModuleServiceUtils
1310 * @tc.desc Function test
1311 */
1312 HWTEST_F(Cs2Test, cellular_call_ModuleServiceUtils_0001, Function | MediumTest | Level3)
1313 {
1314 ModuleServiceUtils moduleServiceUtils;
1315 bool airplaneModeOn = false;
1316 moduleServiceUtils.GetCsRegState(SIM1_SLOTID);
1317 moduleServiceUtils.GetPsRegState(SIM1_SLOTID);
1318 moduleServiceUtils.GetRadioState(SIM1_SLOTID);
1319 moduleServiceUtils.GetNetworkStatus(SIM1_SLOTID);
1320 moduleServiceUtils.GetIsoCountryCode(SIM1_SLOTID);
1321 moduleServiceUtils.GetNetworkCountryCode(SIM1_SLOTID);
1322 moduleServiceUtils.GetImsRegistrationState(SIM1_SLOTID);
1323 moduleServiceUtils.GetSatelliteStatus();
1324 moduleServiceUtils.GetSlotInfo();
1325 moduleServiceUtils.NeedCallImsService();
1326 moduleServiceUtils.GetImsServiceRemoteObject();
1327 EXPECT_NE(moduleServiceUtils.GetAirplaneMode(airplaneModeOn), TELEPHONY_SUCCESS);
1328 EXPECT_NE(moduleServiceUtils.UpdateRadioOn(SIM1_SLOTID), TELEPHONY_SUCCESS);
1329 }
1330
1331 /**
1332 * @tc.number cellular_call_CellularCallConfig_0001
1333 * @tc.name CellularCallConfig
1334 * @tc.desc Function test
1335 */
1336 HWTEST_F(Cs2Test, cellular_call_CellularCallConfig_0001, Function | MediumTest | Level3)
1337 {
1338 CellularCallConfig CellularCallConfig;
1339 bool isReadyToCall = false;
1340 bool csType = 0;
1341 CellularCallConfig.SetReadyToCall(SIM1_SLOTID, isReadyToCall);
1342 CellularCallCallback cellularCallCallback;
1343 cellularCallCallback.SetReadyToCall(SIM1_SLOTID, csType, isReadyToCall);
1344 EXPECT_EQ(CellularCallConfig.IsReadyToCall(SIM1_SLOTID), TELEPHONY_SUCCESS);
1345 }
1346
1347 /**
1348 * @tc.number EncapsulationCallReportInfo_0001
1349 * @tc.name CsControl
1350 * @tc.desc Function test
1351 */
1352 HWTEST_F(Cs2Test, EncapsulationCallReportInfo_0001, Function | MediumTest | Level3)
1353 {
1354 auto csControl = std::make_shared<CSControl>();
1355 CallInfo callInfo;
1356 callInfo.number = "";
1357 callInfo.name = "aaa";
1358 CallReportInfo reportInfo = csControl->EncapsulationCallReportInfo(SIM1_SLOTID, callInfo);
1359 EXPECT_EQ("", reportInfo.name);
1360 }
1361
1362 /**
1363 * @tc.number EncapsulationCallReportInfo_0002
1364 * @tc.name CsControl
1365 * @tc.desc Function test
1366 */
1367 HWTEST_F(Cs2Test, EncapsulationCallReportInfo_0002, Function | MediumTest | Level3)
1368 {
1369 auto csControl = std::make_shared<CSControl>();
1370 CallInfo callInfo;
1371 callInfo.number = "1234567";
1372 callInfo.name = "aaa";
1373 CallReportInfo reportInfo = csControl->EncapsulationCallReportInfo(SIM1_SLOTID, callInfo);
1374 EXPECT_EQ("aaa", reportInfo.name);
1375 }
1376 } // namespace Telephony
1377 } // namespace OHOS
1378