1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define private public
16 #define protected public
17
18 #include "cellular_call_config.h"
19 #include "cellular_call_connection_ims.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 "cellular_call_supplement.h"
25 #include "config_request.h"
26 #include "control_base.h"
27 #include "cs_control.h"
28 #include "gtest/gtest.h"
29 #include "tel_ril_call_parcel.h"
30 #include "ims_call_callback_proxy.h"
31 #include "ims_call_callback_stub.h"
32 #include "ims_call_client.h"
33 #include "ims_control.h"
34 #include "ims_error.h"
35 #include "token.h"
36 #include "securec.h"
37 #include "cellular_call_hisysevent.h"
38 #include "standardize_utils.h"
39 #include "cellular_call_rdb_helper.h"
40 #include "cellular_call_dump_helper.h"
41 #include "emergency_utils.h"
42 #include "satellite_call_client.h"
43 #include "telephony_ext_wrapper.h"
44
45 namespace OHOS {
46 namespace Telephony {
47 using namespace testing::ext;
48
49 #ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
50 static const int32_t INVALID_VALUE = -1;
51 #endif
52
53 namespace {
54 const int32_t INVALID_SLOTID = 2;
55 const int32_t SIM1_SLOTID = 0;
56 const int32_t SIM2_SLOTID = 1;
57 const int32_t ACTIVATE_ACTION = 1;
58 const std::string PHONE_NUMBER = "00000000";
59 const int32_t DEFAULT_INDEX = 1;
60 const int32_t FIVE_MINUTES = 5;
61 } // namespace
62
63 class DemoHandler : public AppExecFwk::EventHandler {
64 public:
DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> & runner)65 explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &runner) : AppExecFwk::EventHandler(runner) {}
~DemoHandler()66 virtual ~DemoHandler() {}
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)67 void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
68 };
69
70 class ZeroBranch1Test : public testing::Test {
71 public:
72 static void SetUpTestCase();
73 static void TearDownTestCase();
74 void SetUp();
75 void TearDown();
76 int32_t InitCellularCallInfo(int32_t accountId, std::string phonenumber, CellularCallInfo &callInfo);
77 void InitImsCallInfoList(ImsCurrentCallList &callInfoList, int32_t num);
78 void InitCsCallInfoList(CallInfoList &callInfoList, int32_t num);
79 void MakeCallInfoParcelData(bool isError, MessageParcel &data);
80 };
81
SetUpTestCase()82 void ZeroBranch1Test::SetUpTestCase()
83 {
84 std::cout << "---------- CellularCallService start ------------" << std::endl;
85 DelayedSingleton<CellularCallService>::GetInstance()->Init();
86 DelayedSingleton<ImsCallClient>::GetInstance()->Init();
87 }
88
TearDownTestCase()89 void ZeroBranch1Test::TearDownTestCase() {}
90
SetUp()91 void ZeroBranch1Test::SetUp() {}
92
TearDown()93 void ZeroBranch1Test::TearDown()
94 {
95 std::this_thread::sleep_for(std::chrono::seconds(FIVE_MINUTES));
96 }
97
IsMmiCodeMockTrue(int32_t slotId,std::string & number)98 bool IsMmiCodeMockTrue(int32_t slotId, std::string &number)
99 {
100 return true;
101 }
102
IsMmiCodeMockFalse(int32_t slotId,std::string & number)103 bool IsMmiCodeMockFalse(int32_t slotId, std::string &number)
104 {
105 return false;
106 }
107
InitCellularCallInfo(int32_t accountId,std::string phonenumber,CellularCallInfo & callInfo)108 int32_t ZeroBranch1Test::InitCellularCallInfo(int32_t accountId, std::string phonenumber, CellularCallInfo &callInfo)
109 {
110 callInfo.accountId = accountId;
111 callInfo.slotId = accountId;
112 callInfo.index = accountId;
113 callInfo.callType = CallType::TYPE_IMS;
114 callInfo.videoState = 0; // 0 means audio
115 if (memset_s(callInfo.phoneNum, kMaxNumberLen, 0, kMaxNumberLen) != EOK) {
116 return TELEPHONY_ERR_MEMSET_FAIL;
117 }
118 if (phonenumber.length() > static_cast<size_t>(kMaxNumberLen)) {
119 return CALL_ERR_NUMBER_OUT_OF_RANGE;
120 }
121 if (memcpy_s(callInfo.phoneNum, kMaxNumberLen, phonenumber.c_str(), phonenumber.length()) != EOK) {
122 return TELEPHONY_ERR_MEMCPY_FAIL;
123 }
124 return TELEPHONY_SUCCESS;
125 }
126
InitImsCallInfoList(ImsCurrentCallList & callInfoList,int32_t num)127 void ZeroBranch1Test::InitImsCallInfoList(ImsCurrentCallList &callInfoList, int32_t num)
128 {
129 callInfoList.callSize = num;
130 ImsCurrentCall call;
131 int32_t callStateSum = 6;
132 for (int32_t i = 0; i < num; ++i) {
133 call.index = i;
134 call.state = i % callStateSum;
135 callInfoList.calls.push_back(call);
136 }
137 }
138
MakeCallInfoParcelData(bool isError,MessageParcel & data)139 void ZeroBranch1Test::MakeCallInfoParcelData(bool isError, MessageParcel &data)
140 {
141 if (isError) {
142 int32_t errorSize = 0;
143 data.WriteInt32(errorSize);
144 } else {
145 CellularCallInfo callInfo;
146 callInfo.slotId = -1;
147 int32_t size = 1;
148 data.WriteInt32(size);
149 data.WriteRawData(static_cast<const void *>(&callInfo), sizeof(CellularCallInfo));
150 }
151 }
152
InitCsCallInfoList(CallInfoList & callInfoList,int32_t num)153 void ZeroBranch1Test::InitCsCallInfoList(CallInfoList &callInfoList, int32_t num)
154 {
155 callInfoList.callSize = num;
156 CallInfo call;
157 int32_t callStateSum = 9;
158 for (int32_t i = 0; i < num; ++i) {
159 call.index = i;
160 call.state = i % callStateSum;
161 callInfoList.calls.push_back(call);
162 }
163 }
164
165 /**
166 * @tc.number Telephony_CellularCallStub_001
167 * @tc.name Test error branch
168 * @tc.desc Function test
169 */
170 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_001, Function | MediumTest | Level3)
171 {
172 AccessToken token;
173 CellularCallService callStub;
174 MessageParcel reply;
175
176 MessageParcel dialErrorData;
177 MakeCallInfoParcelData(true, dialErrorData);
178 callStub.OnDialInner(dialErrorData, reply);
179 MessageParcel dialData;
180 MakeCallInfoParcelData(false, dialData);
181 callStub.OnDialInner(dialData, reply);
182
183 MessageParcel hangUpErrorData;
184 MakeCallInfoParcelData(true, hangUpErrorData);
185 callStub.OnHangUpInner(hangUpErrorData, reply);
186 MessageParcel hangUpData;
187 MakeCallInfoParcelData(false, hangUpData);
188 hangUpData.WriteInt32(1);
189 callStub.OnHangUpInner(hangUpData, reply);
190
191 MessageParcel rejectErrorData;
192 MakeCallInfoParcelData(true, rejectErrorData);
193 callStub.OnRejectInner(rejectErrorData, reply);
194 MessageParcel rejectData;
195 MakeCallInfoParcelData(false, rejectData);
196 callStub.OnRejectInner(rejectData, reply);
197
198 MessageParcel answerErrorData;
199 MakeCallInfoParcelData(true, answerErrorData);
200 callStub.OnAnswerInner(answerErrorData, reply);
201 MessageParcel answerData;
202 MakeCallInfoParcelData(false, answerData);
203 callStub.OnAnswerInner(answerData, reply);
204
205 MessageParcel holdErrorData;
206 MakeCallInfoParcelData(true, holdErrorData);
207 callStub.OnHoldCallInner(holdErrorData, reply);
208 MessageParcel holdData;
209 MakeCallInfoParcelData(false, answerData);
210 callStub.OnHoldCallInner(holdData, reply);
211
212 MessageParcel unholdErrorData;
213 MakeCallInfoParcelData(true, unholdErrorData);
214 callStub.OnUnHoldCallInner(unholdErrorData, reply);
215 MessageParcel unholdData;
216 MakeCallInfoParcelData(false, unholdData);
217 callStub.OnUnHoldCallInner(unholdData, reply);
218
219 MessageParcel switchCallErrorData;
220 MakeCallInfoParcelData(true, switchCallErrorData);
221 callStub.OnSwitchCallInner(switchCallErrorData, reply);
222 MessageParcel switchCallData;
223 MakeCallInfoParcelData(false, switchCallData);
224 ASSERT_EQ(callStub.OnSwitchCallInner(switchCallData, reply), TELEPHONY_SUCCESS);
225 }
226
227 /**
228 * @tc.number Telephony_CellularCallStub_002
229 * @tc.name Test error branch
230 * @tc.desc Function test
231 */
232 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_002, Function | MediumTest | Level3)
233 {
234 AccessToken token;
235 CellularCallService callStub;
236 MessageParcel reply;
237 int32_t size = 1;
238
239 MessageParcel combineErrorData;
240 MakeCallInfoParcelData(true, combineErrorData);
241 callStub.OnCombineConferenceInner(combineErrorData, reply);
242 MessageParcel combineData;
243 MakeCallInfoParcelData(false, combineData);
244 callStub.OnCombineConferenceInner(combineData, reply);
245
246 MessageParcel separateErrorData;
247 MakeCallInfoParcelData(true, separateErrorData);
248 callStub.OnSeparateConferenceInner(separateErrorData, reply);
249 MessageParcel separateData;
250 MakeCallInfoParcelData(false, separateData);
251 callStub.OnSeparateConferenceInner(separateData, reply);
252
253 MessageParcel kickOutErrorData;
254 MakeCallInfoParcelData(true, kickOutErrorData);
255 callStub.OnKickOutFromConferenceInner(kickOutErrorData, reply);
256 MessageParcel kickOutData;
257 MakeCallInfoParcelData(false, kickOutData);
258 callStub.OnKickOutFromConferenceInner(kickOutData, reply);
259
260 MessageParcel stopDtmfErrorData;
261 MakeCallInfoParcelData(true, stopDtmfErrorData);
262 callStub.OnStopDtmfInner(stopDtmfErrorData, reply);
263 MessageParcel stopDtmfData;
264 MakeCallInfoParcelData(false, stopDtmfData);
265 callStub.OnStopDtmfInner(stopDtmfData, reply);
266
267 MessageParcel postDialErrorData;
268 MakeCallInfoParcelData(true, postDialErrorData);
269 callStub.OnPostDialProceedInner(postDialErrorData, reply);
270 MessageParcel postDialData;
271 MakeCallInfoParcelData(false, postDialData);
272 postDialData.WriteBool(false);
273 callStub.OnPostDialProceedInner(postDialData, reply);
274
275 MessageParcel cameraData;
276 cameraData.WriteInt32(size);
277 ASSERT_EQ(callStub.OnControlCameraInner(cameraData, reply), TELEPHONY_SUCCESS);
278 }
279
280 /**
281 * @tc.number Telephony_CellularCallStub_003
282 * @tc.name Test error branch
283 * @tc.desc Function test
284 */
285 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_003, Function | MediumTest | Level3)
286 {
287 AccessToken token;
288 CellularCallService callStub;
289 CellularCallInfo callInfo;
290 callInfo.slotId = -1;
291 int32_t errorSize = -1;
292 int32_t size = 1;
293 MessageParcel reply;
294
295 MessageParcel hangUpAllData;
296 hangUpAllData.WriteInt32(size);
297 callStub.OnHangUpAllConnectionInner(hangUpAllData, reply);
298 MessageParcel startDtmfData;
299 startDtmfData.WriteInt32(size);
300 startDtmfData.WriteInt8('1');
301 startDtmfData.WriteRawData((const void *)&callInfo, sizeof(CellularCallInfo));
302 callStub.OnStartDtmfInner(startDtmfData, reply);
303 MessageParcel sendDtmfData;
304 sendDtmfData.WriteInt32(size);
305 sendDtmfData.WriteInt8('1');
306 sendDtmfData.WriteRawData((const void *)&callInfo, sizeof(CellularCallInfo));
307 callStub.OnSendDtmfInner(sendDtmfData, reply);
308 MessageParcel emergencyData;
309 emergencyData.WriteInt32(size);
310 emergencyData.WriteInt32(errorSize);
311 callStub.OnIsEmergencyPhoneNumberInner(emergencyData, reply);
312 MessageParcel setReadyData;
313 setReadyData.WriteInt32(errorSize);
314 callStub.OnSetReadyToCallInner(setReadyData, reply);
315 MessageParcel setCallTransferData;
316 setCallTransferData.WriteInt32(size);
317 setCallTransferData.WriteInt32(errorSize);
318 callStub.OnSetCallTransferInner(setCallTransferData, reply);
319 MessageParcel canSetTimerData;
320 canSetTimerData.WriteInt32(size);
321 canSetTimerData.WriteInt32(errorSize);
322 callStub.OnCanSetCallTransferTimeInner(canSetTimerData, reply);
323 MessageParcel getCallTransferData;
324 getCallTransferData.WriteInt32(size);
325 getCallTransferData.WriteInt32(errorSize);
326 callStub.OnGetCallTransferInner(getCallTransferData, reply);
327 MessageParcel setCallWaitData;
328 setCallWaitData.WriteInt32(size);
329 setCallWaitData.WriteInt32(errorSize);
330 callStub.OnSetCallWaitingInner(setCallWaitData, reply);
331 MessageParcel getCallWaitData;
332 getCallWaitData.WriteInt32(size);
333 getCallWaitData.WriteInt32(errorSize);
334 ASSERT_EQ(callStub.OnGetCallWaitingInner(getCallWaitData, reply), TELEPHONY_SUCCESS);
335 }
336
337 /**
338 * @tc.number Telephony_CellularCallStub_004
339 * @tc.name Test error branch
340 * @tc.desc Function test
341 */
342 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_004, Function | MediumTest | Level3)
343 {
344 AccessToken token;
345 CellularCallService callStub;
346 int32_t errorSize = -1;
347 int32_t size = 1;
348 MessageParcel reply;
349
350 MessageParcel setCallRestData;
351 setCallRestData.WriteInt32(size);
352 setCallRestData.WriteInt32(errorSize);
353 callStub.OnSetCallRestrictionInner(setCallRestData, reply);
354 MessageParcel getCallRestData;
355 getCallRestData.WriteInt32(size);
356 getCallRestData.WriteInt32(errorSize);
357 callStub.OnGetCallRestrictionInner(getCallRestData, reply);
358 MessageParcel setCallRestPwdData;
359 setCallRestPwdData.WriteInt32(size);
360 setCallRestPwdData.WriteInt32(errorSize);
361 callStub.OnSetCallRestrictionPasswordInner(setCallRestPwdData, reply);
362 MessageParcel setDomainData;
363 setDomainData.WriteInt32(size);
364 setDomainData.WriteInt32(errorSize);
365 callStub.OnSetDomainPreferenceModeInner(setDomainData, reply);
366 MessageParcel getDomainData;
367 getDomainData.WriteInt32(size);
368 getDomainData.WriteInt32(errorSize);
369 callStub.OnGetDomainPreferenceModeInner(getDomainData, reply);
370 MessageParcel setImsSwitchData;
371 setImsSwitchData.WriteInt32(size);
372 setImsSwitchData.WriteInt32(errorSize);
373 callStub.OnSetImsSwitchStatusInner(setImsSwitchData, reply);
374 MessageParcel getImsSwitchData;
375 getImsSwitchData.WriteInt32(size);
376 getImsSwitchData.WriteInt32(errorSize);
377 callStub.OnGetImsSwitchStatusInner(getImsSwitchData, reply);
378 MessageParcel setVonrData;
379 setVonrData.WriteInt32(size);
380 setVonrData.WriteInt32(errorSize);
381 callStub.OnSetVoNRStateInner(setVonrData, reply);
382 MessageParcel getVonrData;
383 getVonrData.WriteInt32(size);
384 getVonrData.WriteInt32(errorSize);
385 callStub.OnGetVoNRStateInner(getVonrData, reply);
386 MessageParcel setconfigData;
387 setconfigData.WriteInt32(size);
388 setconfigData.WriteInt32(errorSize);
389 ASSERT_EQ(callStub.OnSetImsConfigStringInner(setconfigData, reply), TELEPHONY_SUCCESS);
390 }
391
392 /**
393 * @tc.number Telephony_CellularCallStub_005
394 * @tc.name Test error branch
395 * @tc.desc Function test
396 */
397 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_005, Function | MediumTest | Level3)
398 {
399 AccessToken token;
400 CellularCallService callStub;
401 int32_t errorSize = -1;
402 int32_t size = 1;
403 MessageParcel reply;
404
405 MessageParcel setconfigData;
406 setconfigData.WriteInt32(size);
407 setconfigData.WriteInt32(errorSize);
408 callStub.OnSetImsConfigIntInner(setconfigData, reply);
409 MessageParcel getconfigData;
410 getconfigData.WriteInt32(size);
411 getconfigData.WriteInt32(errorSize);
412 callStub.OnGetImsConfigInner(getconfigData, reply);
413 MessageParcel setFeatureData;
414 setFeatureData.WriteInt32(size);
415 setFeatureData.WriteInt32(errorSize);
416 callStub.OnSetImsFeatureValueInner(setFeatureData, reply);
417 MessageParcel getFeatureData;
418 getFeatureData.WriteInt32(size);
419 getFeatureData.WriteInt32(errorSize);
420 callStub.OnGetImsFeatureValueInner(getFeatureData, reply);
421 MessageParcel setMuteData;
422 setMuteData.WriteInt32(size);
423 setMuteData.WriteInt32(errorSize);
424 callStub.OnSetMuteInner(setMuteData, reply);
425 MessageParcel getMuteData;
426 getMuteData.WriteInt32(size);
427 getMuteData.WriteInt32(errorSize);
428 callStub.OnGetMuteInner(getMuteData, reply);
429 MessageParcel closeUssdData;
430 closeUssdData.WriteInt32(size);
431 closeUssdData.WriteInt32(errorSize);
432 callStub.OnCloseUnFinishedUssdInner(closeUssdData, reply);
433 MessageParcel clearCallsData;
434 MakeCallInfoParcelData(false, clearCallsData);
435 ASSERT_EQ(callStub.OnClearAllCallsInner(clearCallsData, reply), TELEPHONY_SUCCESS);
436 MessageParcel ussdData;
437 ussdData.WriteInt32(0);
438 ussdData.WriteString("1");
439 ASSERT_NE(callStub.OnSendUssdResponse(ussdData, reply), TELEPHONY_SUCCESS);
440 }
441
442 /**
443 * @tc.number Telephony_CellularCallStub_006
444 * @tc.name Test error branch
445 * @tc.desc Function test
446 */
447 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_006, Function | MediumTest | Level3)
448 {
449 AccessToken token;
450 CellularCallService callStub;
451 int32_t errorSize = -1;
452 int32_t size = 1;
453 MessageParcel reply;
454 MessageParcel setPreviewData;
455 setPreviewData.WriteInt32(errorSize);
456 callStub.OnSetPreviewWindowInner(setPreviewData, reply);
457 MessageParcel setDisplayData;
458 setDisplayData.WriteInt32(errorSize);
459 callStub.OnSetDisplayWindowInner(setDisplayData, reply);
460 MessageParcel setCameraData;
461 setCameraData.WriteInt32(errorSize);
462 callStub.OnSetCameraZoomInner(setCameraData, reply);
463 MessageParcel setImageData;
464 setImageData.WriteInt32(errorSize);
465 callStub.OnSetPausePictureInner(setImageData, reply);
466 MessageParcel setDirectionData;
467 setDirectionData.WriteInt32(errorSize);
468 callStub.OnSetDeviceDirectionInner(setDirectionData, reply);
469
470 MessageParcel setEmergencyData;
471 setEmergencyData.WriteInt32(size);
472 setEmergencyData.WriteInt32(errorSize);
473 setEmergencyData.WriteInt32(size);
474 if (setEmergencyData.WriteString("123") && setEmergencyData.WriteString("456") &&
475 setEmergencyData.WriteInt32(size) && setEmergencyData.WriteInt32(size) && setEmergencyData.WriteInt32(size)) {
476 callStub.OnSetEmergencyCallList(setEmergencyData, reply);
477 }
478
479 MessageParcel registerData;
480 registerData.WriteInt32(size);
481 callStub.OnRegisterCallBackInner(registerData, reply);
482 MessageParcel unRegisterData;
483 unRegisterData.WriteInt32(errorSize);
484 callStub.OnUnRegisterCallBackInner(unRegisterData, reply);
485 MessageParcel inviteData;
486 registerData.WriteInt32(size);
487 inviteData.WriteInt32(errorSize);
488 callStub.OnInviteToConferenceInner(inviteData, reply);
489 MessageParcel startRttData;
490 startRttData.WriteInt32(size);
491 startRttData.WriteInt32(errorSize);
492 startRttData.WriteString("1");
493 callStub.OnStartRttInner(startRttData, reply);
494 MessageParcel stopRttData;
495 stopRttData.WriteInt32(size);
496 stopRttData.WriteInt32(errorSize);
497 ASSERT_EQ(callStub.OnStopRttInner(stopRttData, reply), TELEPHONY_SUCCESS);
498 }
499
500 /**
501 * @tc.number Telephony_CellularCallStub_007
502 * @tc.name Test error branch
503 * @tc.desc Function test
504 */
505 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_007, Function | MediumTest | Level3)
506 {
507 AccessToken token;
508 CellularCallService callStub;
509 int32_t size = 1;
510 MessageParcel reply;
511 MessageParcel callMediaModeRequestData;
512 MakeCallInfoParcelData(false, callMediaModeRequestData);
513 ImsCallMode requestMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
514 callMediaModeRequestData.WriteInt32(static_cast<int32_t>(requestMode));
515 callStub.OnSendUpdateCallMediaModeRequestInner(callMediaModeRequestData, reply);
516
517 MessageParcel callMediaModeResponseData;
518 MakeCallInfoParcelData(false, callMediaModeResponseData);
519 ImsCallMode responseMode = ImsCallMode::CALL_MODE_AUDIO_ONLY;
520 callMediaModeResponseData.WriteInt32(static_cast<int32_t>(responseMode));
521 callStub.OnSendUpdateCallMediaModeResponseInner(callMediaModeResponseData, reply);
522
523 MessageParcel callUpgradeData;
524 callUpgradeData.WriteInt32(size);
525 callUpgradeData.WriteInt32(SIM1_SLOTID);
526 callUpgradeData.WriteInt32(DEFAULT_INDEX);
527 callStub.OnCancelCallUpgradeInner(callUpgradeData, reply);
528
529 MessageParcel cameraCapabilitiesData;
530 cameraCapabilitiesData.WriteInt32(size);
531 cameraCapabilitiesData.WriteInt32(SIM1_SLOTID);
532 cameraCapabilitiesData.WriteInt32(DEFAULT_INDEX);
533 ASSERT_EQ(callStub.OnRequestCameraCapabilitiesInner(cameraCapabilitiesData, reply), TELEPHONY_SUCCESS);
534 }
535
536 /**
537 * @tc.number Telephony_CellularCallStub_008
538 * @tc.name Test OnIsMmiCodeInner
539 * @tc.desc Function test
540 */
541 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_008, Function | MediumTest | Level3)
542 {
543 AccessToken token;
544 CellularCallService callStub;
545 int32_t size = 1;
546 MessageParcel reply;
547
548 MessageParcel mmiCodeData;
549 mmiCodeData.WriteInt32(size);
550 mmiCodeData.WriteInt32(SIM1_SLOTID);
551 mmiCodeData.WriteString("*100#");
552 ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData, reply), TELEPHONY_SUCCESS);
553
554 MessageParcel mmiCodeDataInvalid;
555 mmiCodeDataInvalid.WriteInt32(size);
556 mmiCodeDataInvalid.WriteInt32(-1);
557 mmiCodeDataInvalid.WriteString("*100#");
558 ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeDataInvalid, reply), TELEPHONY_SUCCESS);
559
560 MessageParcel mmiCodeErrData;
561 mmiCodeErrData.WriteInt32(-1);
562 mmiCodeErrData.WriteInt32(SIM1_SLOTID);
563 mmiCodeErrData.WriteString("*100#");
564 ASSERT_NE(callStub.OnIsMmiCodeInner(mmiCodeErrData, reply), TELEPHONY_SUCCESS);
565
566 TELEPHONY_EXT_WRAPPER.isMmiCode_ = IsMmiCodeMockTrue;
567 MessageParcel mmiCodeData1;
568 mmiCodeData1.WriteInt32(size);
569 mmiCodeData1.WriteInt32(SIM1_SLOTID);
570 mmiCodeData1.WriteString("*100#");
571 ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData1, reply), TELEPHONY_SUCCESS);
572
573 TELEPHONY_EXT_WRAPPER.isMmiCode_ = IsMmiCodeMockFalse;
574 MessageParcel mmiCodeData2;
575 mmiCodeData2.WriteInt32(size);
576 mmiCodeData2.WriteInt32(SIM1_SLOTID);
577 mmiCodeData2.WriteString("*100#");
578 ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData2, reply), TELEPHONY_SUCCESS);
579
580 TELEPHONY_EXT_WRAPPER.isMmiCode_ = nullptr;
581 MessageParcel mmiCodeData3;
582 mmiCodeData3.WriteInt32(size);
583 mmiCodeData3.WriteInt32(SIM1_SLOTID);
584 mmiCodeData3.WriteString("*100#");
585 ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData3, reply), TELEPHONY_SUCCESS);
586
587 TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
588 }
589
590 /**
591 * @tc.number Telephony_CellularCallStub_009
592 * @tc.name Test OnIsMmiCodeInner
593 * @tc.desc Function test
594 */
595 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallStub_009, Function | MediumTest | Level3)
596 {
597 AccessToken token;
598 CellularCallService callStub;
599 int32_t size = 1;
600 MessageParcel reply;
601
602 TELEPHONY_EXT_WRAPPER.isMmiCode_ = IsMmiCodeMockTrue;
603 MessageParcel mmiCodeData1;
604 mmiCodeData1.WriteInt32(size);
605 mmiCodeData1.WriteInt32(SIM1_SLOTID);
606 mmiCodeData1.WriteString("*31#1234567");
607 ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData1, reply), TELEPHONY_SUCCESS);
608
609 MessageParcel mmiCodeData2;
610 mmiCodeData2.WriteInt32(size);
611 mmiCodeData2.WriteInt32(SIM1_SLOTID);
612 mmiCodeData2.WriteString("#31#1234567");
613 ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData2, reply), TELEPHONY_SUCCESS);
614
615 MessageParcel mmiCodeData3;
616 mmiCodeData3.WriteInt32(size);
617 mmiCodeData3.WriteInt32(SIM1_SLOTID);
618 mmiCodeData3.WriteString("*#31#1234567");
619 ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData3, reply), TELEPHONY_SUCCESS);
620
621 MessageParcel mmiCodeData4;
622 mmiCodeData4.WriteInt32(size);
623 mmiCodeData4.WriteInt32(SIM1_SLOTID);
624 mmiCodeData4.WriteString("1234567");
625 ASSERT_EQ(callStub.OnIsMmiCodeInner(mmiCodeData4, reply), TELEPHONY_SUCCESS);
626
627 TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
628 }
629
630 /**
631 * @tc.number Telephony_CellularCallService_001
632 * @tc.name Test error branch
633 * @tc.desc Function test
634 */
635 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallService_001, Function | MediumTest | Level3)
636 {
637 // AccessToken token;
638 CellularCallService cellularCall;
639 std::vector<std::u16string> args = { u"1", u"2" };
640 cellularCall.Dump(-1, args);
641 cellularCall.Dump(1, args);
642 cellularCall.GetServiceRunningState();
643 cellularCall.GetBindTime();
644 cellularCall.GetEndTime();
645 cellularCall.GetSpendTime();
646
647 CellularCallInfo csCallInfo = { .callType = CallType::TYPE_CS };
648 CellularCallInfo imsCallInfo = { .callType = CallType::TYPE_IMS };
649 CellularCallInfo errCallInfo = { .callType = CallType::TYPE_ERR_CALL };
650 cellularCall.Dial(csCallInfo);
651 cellularCall.Dial(imsCallInfo);
652 cellularCall.Dial(errCallInfo);
653
654 cellularCall.HangUp(csCallInfo, CallSupplementType::TYPE_HANG_UP_HOLD_WAIT);
655 cellularCall.HangUp(imsCallInfo, CallSupplementType::TYPE_HANG_UP_HOLD_WAIT);
656 cellularCall.HangUp(errCallInfo, CallSupplementType::TYPE_HANG_UP_HOLD_WAIT);
657
658 cellularCall.Reject(csCallInfo);
659 cellularCall.Reject(imsCallInfo);
660 cellularCall.Reject(errCallInfo);
661
662 cellularCall.Answer(csCallInfo);
663 cellularCall.Answer(imsCallInfo);
664 cellularCall.Answer(errCallInfo);
665
666 cellularCall.HoldCall(csCallInfo);
667 cellularCall.HoldCall(imsCallInfo);
668 cellularCall.HoldCall(errCallInfo);
669
670 cellularCall.UnHoldCall(csCallInfo);
671 cellularCall.UnHoldCall(imsCallInfo);
672 cellularCall.UnHoldCall(errCallInfo);
673
674 cellularCall.SwitchCall(csCallInfo);
675 cellularCall.SwitchCall(imsCallInfo);
676 cellularCall.SwitchCall(errCallInfo);
677
678 bool enabled = false;
679 std::string phoneNum = "000";
680 cellularCall.IsEmergencyPhoneNumber(INVALID_SLOTID, phoneNum, enabled);
681 ASSERT_EQ(cellularCall.IsEmergencyPhoneNumber(SIM1_SLOTID, phoneNum, enabled), TELEPHONY_SUCCESS);
682 }
683
684 /**
685 * @tc.number Telephony_CellularCallService_002
686 * @tc.name Test error branch
687 * @tc.desc Function test
688 */
689 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallService_002, Function | MediumTest | Level3)
690 {
691 // AccessToken token;
692 CellularCallService cellularCall;
693 CellularCallInfo csCallInfo = { .callType = CallType::TYPE_CS };
694 CellularCallInfo imsCallInfo = { .callType = CallType::TYPE_IMS };
695 CellularCallInfo errCallInfo = { .callType = CallType::TYPE_ERR_CALL };
696 EmergencyCall ecc;
697 std::vector<EmergencyCall> eccVec;
698 eccVec.push_back(ecc);
699 cellularCall.SetEmergencyCallList(SIM1_SLOTID, eccVec);
700 cellularCall.CombineConference(csCallInfo);
701 cellularCall.CombineConference(imsCallInfo);
702 cellularCall.CombineConference(errCallInfo);
703
704 cellularCall.SeparateConference(csCallInfo);
705 cellularCall.SeparateConference(imsCallInfo);
706 cellularCall.SeparateConference(errCallInfo);
707
708 std::vector<std::string> numberList = { "111", "222" };
709 cellularCall.InviteToConference(SIM1_SLOTID, numberList);
710 cellularCall.KickOutFromConference(csCallInfo);
711 cellularCall.KickOutFromConference(imsCallInfo);
712 cellularCall.KickOutFromConference(errCallInfo);
713 cellularCall.HangUpAllConnection();
714 cellularCall.HangUpAllConnection(SIM1_SLOTID);
715
716 cellularCall.SetReadyToCall(SIM1_SLOTID, 0, true);
717 cellularCall.SetReadyToCall(SIM1_SLOTID, 1, true);
718 cellularCall.SetReadyToCall(SIM1_SLOTID, 3, true);
719 cellularCall.StartDtmf('*', csCallInfo);
720 cellularCall.StartDtmf('*', imsCallInfo);
721 cellularCall.StartDtmf('*', errCallInfo);
722 cellularCall.StopDtmf(csCallInfo);
723 cellularCall.StopDtmf(imsCallInfo);
724 cellularCall.StopDtmf(errCallInfo);
725
726 cellularCall.PostDialProceed(csCallInfo, true);
727 cellularCall.PostDialProceed(imsCallInfo, true);
728 cellularCall.PostDialProceed(errCallInfo, true);
729 cellularCall.SendDtmf('*', csCallInfo);
730 cellularCall.SendDtmf('*', imsCallInfo);
731 cellularCall.SendDtmf('*', errCallInfo);
732 std::string msg = "";
733 cellularCall.StartRtt(SIM1_SLOTID, msg);
734 ASSERT_NE(cellularCall.StopRtt(SIM1_SLOTID), TELEPHONY_SUCCESS);
735 }
736
737 /**
738 * @tc.number Telephony_CellularCallService_003
739 * @tc.name Test error branch
740 * @tc.desc Function test
741 */
742 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallService_003, Function | MediumTest | Level3)
743 {
744 AccessToken token;
745 CellularCallService cellularCall;
746 CallTransferInfo cTInfoDisable = { .settingType = CallTransferSettingType::CALL_TRANSFER_DISABLE };
747 CallTransferInfo cTInfoEnable = { .settingType = CallTransferSettingType::CALL_TRANSFER_ENABLE };
748 cellularCall.SetCallTransferInfo(SIM1_SLOTID, cTInfoDisable);
749 cellularCall.SetCallTransferInfo(SIM1_SLOTID, cTInfoEnable);
750 bool result = false;
751 cellularCall.CanSetCallTransferTime(SIM1_SLOTID, result);
752 cellularCall.GetCallTransferInfo(SIM1_SLOTID, CallTransferType::TRANSFER_TYPE_UNCONDITIONAL);
753 cellularCall.SetCallWaiting(SIM1_SLOTID, true);
754 cellularCall.GetCallWaiting(SIM1_SLOTID);
755 CallRestrictionInfo crInfo;
756 cellularCall.SetCallRestriction(SIM1_SLOTID, crInfo);
757 cellularCall.GetCallRestriction(SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING);
758 std::string password = "1111";
759 cellularCall.SetCallRestrictionPassword(
760 SIM1_SLOTID, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING, password.c_str(), password.c_str());
761 cellularCall.SetDomainPreferenceMode(SIM1_SLOTID, 1);
762 cellularCall.GetDomainPreferenceMode(SIM1_SLOTID);
763 cellularCall.SetImsSwitchStatus(SIM1_SLOTID, true);
764 bool enabled = false;
765 cellularCall.GetImsSwitchStatus(SIM1_SLOTID, enabled);
766 std::string value = "";
767 cellularCall.SetImsConfig(SIM1_SLOTID, ImsConfigItem::ITEM_VIDEO_QUALITY, value);
768 int32_t state = 0;
769 cellularCall.SetVoNRState(SIM1_SLOTID, state);
770 cellularCall.GetVoNRState(SIM1_SLOTID, state);
771 cellularCall.SetImsConfig(SIM1_SLOTID, ImsConfigItem::ITEM_VIDEO_QUALITY, 1);
772 cellularCall.GetImsConfig(SIM1_SLOTID, ImsConfigItem::ITEM_VIDEO_QUALITY);
773 cellularCall.SetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_VOICE_OVER_LTE, 1);
774 cellularCall.GetImsFeatureValue(SIM1_SLOTID, FeatureType::TYPE_VOICE_OVER_LTE);
775 std::string cameraId = "";
776 cellularCall.ControlCamera(SIM1_SLOTID, DEFAULT_INDEX, cameraId);
777 std::string surfaceId = "";
778 cellularCall.SetPreviewWindow(SIM1_SLOTID, DEFAULT_INDEX, surfaceId, nullptr);
779 cellularCall.SetDisplayWindow(SIM1_SLOTID, DEFAULT_INDEX, surfaceId, nullptr);
780 cellularCall.SetCameraZoom(1.0);
781 std::string path = "";
782 cellularCall.SetPausePicture(SIM1_SLOTID, DEFAULT_INDEX, path);
783 cellularCall.SetDeviceDirection(SIM1_SLOTID, DEFAULT_INDEX, 0);
784 CellularCallInfo cellularCallInfo;
785 InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, cellularCallInfo);
786 cellularCall.SendUpdateCallMediaModeRequest(cellularCallInfo, ImsCallMode::CALL_MODE_AUDIO_ONLY);
787 cellularCall.SendUpdateCallMediaModeResponse(cellularCallInfo, ImsCallMode::CALL_MODE_AUDIO_ONLY);
788 cellularCall.CancelCallUpgrade(SIM1_SLOTID, DEFAULT_INDEX);
789 }
790
791 /**
792 * @tc.number Telephony_CellularCallService_004
793 * @tc.name Test error branch
794 * @tc.desc Function test
795 */
796 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallService_004, Function | MediumTest | Level3)
797 {
798 AccessToken token;
799 CellularCallService cellularCall;
800 cellularCall.SetMute(SIM1_SLOTID, 0);
801 cellularCall.GetMute(SIM1_SLOTID);
802 cellularCall.CloseUnFinishedUssd(SIM1_SLOTID);
803 std::vector<CellularCallInfo> infos = {};
804 cellularCall.ClearAllCalls(infos);
805 cellularCall.IsNeedIms(SIM1_SLOTID);
806 cellularCall.IsNeedIms(SIM2_SLOTID);
807 cellularCall.GetCsControl(SIM1_SLOTID);
808 cellularCall.GetImsControl(SIM1_SLOTID);
809 std::shared_ptr<CSControl> csControl;
810 cellularCall.SetCsControl(SIM1_SLOTID, csControl);
811 std::shared_ptr<IMSControl> imsControl;
812 cellularCall.SetImsControl(SIM1_SLOTID, imsControl);
813 cellularCall.GetHandler(SIM1_SLOTID);
814 cellularCall.SetSrvccState(SrvccState::SRVCC_NONE);
815 cellularCall.GetSrvccState();
816 cellularCall.RegisterHandler();
817 #ifdef CALL_MANAGER_AUTO_START_OPTIMIZE
818 cellularCall.StartCallManagerService();
819 ASSERT_EQ(cellularCall.RequestCameraCapabilities(SIM1_SLOTID, DEFAULT_INDEX), INVALID_VALUE);
820 #else
821 ASSERT_EQ(cellularCall.RequestCameraCapabilities(SIM1_SLOTID, DEFAULT_INDEX), TELEPHONY_SUCCESS);
822 #endif
823 cellularCall.Init();
824 cellularCall.RegisterCoreServiceHandler();
825 cellularCall.CreateHandler();
826 cellularCall.SendEventRegisterHandler();
827 cellularCall.IsValidSlotId(SIM1_SLOTID);
828 CellularCallInfo imsCallInfo = { .callType = CallType::TYPE_IMS };
829 CellularCallInfo csCallInfo = { .callType = CallType::TYPE_CS };
830 cellularCall.UseImsForEmergency(imsCallInfo, true);
831 cellularCall.HandleCallManagerException();
832 cellularCall.HandleCellularControlException(imsCallInfo);
833 cellularCall.HandleCellularControlException(csCallInfo);
834 cellularCall.HangUpWithCellularCallRestart(infos);
835 cellularCall.SetControl(imsCallInfo);
836 cellularCall.SetControl(csCallInfo);
837 sptr<ICallStatusCallback> callback;
838 cellularCall.RegisterCallManagerCallBack(callback);
839 cellularCall.UnRegisterCallManagerCallBack();
840 cellularCall.HandlerResetUnRegister();
841 cellularCall.OnStop();
842 cellularCall.SendUssdResponse(0, "1");
843 ASSERT_EQ(callback, nullptr);
844 }
845
846 /**
847 * @tc.number Telephony_CellularCallSupplementRequestIms_001
848 * @tc.name Test error branch
849 * @tc.desc Function test
850 */
851 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallSupplementRequestIms_001, Function | MediumTest | Level3)
852 {
853 SupplementRequestIms SRequestIms;
854 CallTransferInfo CTransferInfo;
855 std::string fac = "";
856 SRequestIms.SetClipRequest(SIM1_SLOTID, ACTIVATE_ACTION, 0);
857 SRequestIms.GetClipRequest(SIM1_SLOTID, 0);
858 SRequestIms.SetClirRequest(SIM1_SLOTID, ACTIVATE_ACTION, 0);
859 SRequestIms.GetClirRequest(SIM1_SLOTID, 0);
860 SRequestIms.GetCallTransferRequest(SIM1_SLOTID, 0, 0);
861 SRequestIms.SetCallTransferRequest(SIM1_SLOTID, CTransferInfo, ACTIVATE_ACTION, 0);
862 bool enable = false;
863 SRequestIms.CanSetCallTransferTime(SIM1_SLOTID, enable);
864 SRequestIms.GetCallRestrictionRequest(SIM1_SLOTID, fac, 0);
865 std::string pw = "";
866 SRequestIms.SetCallRestrictionRequest(SIM1_SLOTID, fac, 0, pw, 0);
867 SRequestIms.SetCallWaitingRequest(SIM1_SLOTID, true, 0, 0);
868 SRequestIms.GetCallWaitingRequest(SIM1_SLOTID, 0);
869 SRequestIms.SetColrRequest(SIM1_SLOTID, 0, 0);
870 SRequestIms.GetColrRequest(SIM1_SLOTID, 0);
871 SRequestIms.SetColpRequest(SIM1_SLOTID, 0, 0);
872 SRequestIms.GetMMIHandler(SIM1_SLOTID);
873 ASSERT_NE(SRequestIms.GetColpRequest(SIM1_SLOTID, 0), TELEPHONY_SUCCESS);
874 }
875
876 /**
877 * @tc.number Telephony_CellularCallbaseconnection_001
878 * @tc.name Test error branch
879 * @tc.desc Function test
880 */
881 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallbaseconnection_001, Function | MediumTest | Level3)
882 {
883 BaseConnection BConnection;
884 char c = ' ';
885 BConnection.postDialCalltate_ = PostDialCallState::POST_DIAL_CALL_CANCELED;
886 EXPECT_EQ(BConnection.ProcessNextChar(SIM1_SLOTID, c), 5);
887 EXPECT_EQ(BConnection.GetLeftPostDialCallString(), "");
888 BConnection.postDialCallString_ = "111111";
889 EXPECT_EQ(BConnection.ProcessNextChar(SIM1_SLOTID, c), 5);
890 BConnection.postDialCalltate_ = PostDialCallState::POST_DIAL_CALL_NOT_STARTED;
891 EXPECT_NE(BConnection.ProcessNextChar(SIM1_SLOTID, c), 5);
892 EXPECT_NE(BConnection.GetLeftPostDialCallString(), "");
893 }
894 /**
895 * @tc.number Telephony_CellularCallHiSysEvent_001
896 * @tc.name Test error branch
897 * @tc.desc Function test
898 */
899 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallHiSysEvent_001, Function | MediumTest | Level3)
900 {
901 // AccessToken token;
902 std::shared_ptr<CellularCallHiSysEvent> cellularCallHiSysEvent = std::make_shared<CellularCallHiSysEvent>();
903 std::string desc;
904 cellularCallHiSysEvent->WriteFoundationRestartFaultEvent(2);
905 CallBehaviorParameterInfo Info = { .callType = 1 };
906 CallResponseResult result = CallResponseResult::COMMAND_FAILURE;
907 cellularCallHiSysEvent->WriteDialCallBehaviorEvent(Info, result);
908 result = CallResponseResult::COMMAND_SUCCESS;
909 cellularCallHiSysEvent->WriteDialCallBehaviorEvent(Info, result);
910 Info = { .callType = 0 };
911 cellularCallHiSysEvent->WriteDialCallBehaviorEvent(Info, result);
912 Info = { .callType = 1 };
913 result = CallResponseResult::COMMAND_FAILURE;
914 cellularCallHiSysEvent->WriteHangUpCallBehaviorEvent(Info, result);
915 result = CallResponseResult::COMMAND_SUCCESS;
916 cellularCallHiSysEvent->WriteHangUpCallBehaviorEvent(Info, result);
917 Info = { .callType = 0 };
918 cellularCallHiSysEvent->WriteHangUpCallBehaviorEvent(Info, result);
919 cellularCallHiSysEvent->WriteIncomingCallFaultEvent(
920 0, 0, 0, static_cast<int32_t>(TELEPHONY_ERR_MEMCPY_FAIL), desc);
921 cellularCallHiSysEvent->WriteIncomingCallFaultEvent(0, 0, 0, -1, desc);
922 cellularCallHiSysEvent->JudgingIncomingTimeOut(0, 0, 0);
923 CallForwardingInfo cfInfo;
924 cellularCallHiSysEvent->GetCallForwardingInfo(cfInfo);
925 ASSERT_TRUE(desc.empty());
926 }
927
928 /**
929 * @tc.number Telephony_CellularCallHiSysEvent_002
930 * @tc.name Test error branch
931 * @tc.desc Function test
932 */
933 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallHiSysEvent_002, Function | MediumTest | Level3)
934 {
935 // AccessToken token;
936 std::shared_ptr<CellularCallHiSysEvent> cellularCallHiSysEvent = std::make_shared<CellularCallHiSysEvent>();
937 CallErrorCode eventValue;
938 cellularCallHiSysEvent->TelephonyErrorCodeConversion(-1, eventValue);
939 cellularCallHiSysEvent->TelephonyErrorCodeConversion(
940 static_cast<int32_t>(TELEPHONY_ERR_LOCAL_PTR_NULL), eventValue);
941 cellularCallHiSysEvent->TelephonyErrorCodeConversion(
942 static_cast<int32_t>(TELEPHONY_ERR_ARGUMENT_INVALID), eventValue);
943 cellularCallHiSysEvent->TelephonyErrorCodeConversion(
944 static_cast<int32_t>(TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL), eventValue);
945 cellularCallHiSysEvent->TelephonyErrorCodeConversion(
946 static_cast<int32_t>(TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL), eventValue);
947 cellularCallHiSysEvent->TelephonyErrorCodeConversion(
948 static_cast<int32_t>(TELEPHONY_ERR_WRITE_DATA_FAIL), eventValue);
949 cellularCallHiSysEvent->TelephonyErrorCodeConversion(
950 static_cast<int32_t>(TELEPHONY_ERR_PERMISSION_ERR), eventValue);
951 cellularCallHiSysEvent->TelephonyErrorCodeConversion(static_cast<int32_t>(TELEPHONY_ERR_MEMSET_FAIL), eventValue);
952 cellularCallHiSysEvent->TelephonyErrorCodeConversion(static_cast<int32_t>(TELEPHONY_ERR_MEMCPY_FAIL), eventValue);
953 cellularCallHiSysEvent->CallDataErrorCodeConversion(-1, eventValue);
954 cellularCallHiSysEvent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_SLOT_ID), eventValue);
955 cellularCallHiSysEvent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_CALLID), eventValue);
956 cellularCallHiSysEvent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_PHONE_NUMBER_EMPTY), eventValue);
957 cellularCallHiSysEvent->CallDataErrorCodeConversion(
958 static_cast<int32_t>(CALL_ERR_NUMBER_OUT_OF_RANGE), eventValue);
959 cellularCallHiSysEvent->CallDataErrorCodeConversion(
960 static_cast<int32_t>(CALL_ERR_UNSUPPORTED_NETWORK_TYPE), eventValue);
961 cellularCallHiSysEvent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_INVALID_DIAL_SCENE), eventValue);
962 cellularCallHiSysEvent->CallDataErrorCodeConversion(
963 static_cast<int32_t>(CALL_ERR_INVALID_VIDEO_STATE), eventValue);
964 cellularCallHiSysEvent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_UNKNOW_DIAL_TYPE), eventValue);
965 cellularCallHiSysEvent->CallDataErrorCodeConversion(static_cast<int32_t>(CALL_ERR_UNKNOW_CALL_TYPE), eventValue);
966 cellularCallHiSysEvent->CallDataErrorCodeConversion(
967 static_cast<int32_t>(CALL_ERR_CALL_OBJECT_IS_NULL), eventValue);
968 cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(-1, eventValue);
969 cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(static_cast<int32_t>(CALL_ERR_DIAL_IS_BUSY), eventValue);
970 cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(
971 static_cast<int32_t>(CALL_ERR_ILLEGAL_CALL_OPERATION), eventValue);
972 cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(
973 static_cast<int32_t>(CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED), eventValue);
974 cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(
975 static_cast<int32_t>(CALL_ERR_SYSTEM_EVENT_HANDLE_FAILURE), eventValue);
976 cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(
977 static_cast<int32_t>(CALL_ERR_CALL_COUNTS_EXCEED_LIMIT), eventValue);
978 ASSERT_NE(cellularCallHiSysEvent->CallInterfaceErrorCodeConversion(
979 static_cast<int32_t>(CALL_ERR_GET_RADIO_STATE_FAILED), eventValue), 0);
980 }
981
982 /**
983 * @tc.number Telephony_CellularCallConnectionCs_001
984 * @tc.name Test error branch
985 * @tc.desc Function test
986 */
987 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallConnectionCs_001, Function | MediumTest | Level3)
988 {
989 CellularCallConnectionCS cellularCallConnectionCS;
990 DialRequestStruct dialRequestStruct;
991 cellularCallConnectionCS.DialRequest(SIM2_SLOTID, dialRequestStruct);
992 cellularCallConnectionCS.HangUpRequest(SIM2_SLOTID);
993 cellularCallConnectionCS.AnswerRequest(SIM2_SLOTID);
994 cellularCallConnectionCS.AnswerRequest(SIM1_SLOTID);
995 cellularCallConnectionCS.RejectRequest(SIM2_SLOTID);
996 cellularCallConnectionCS.HoldRequest(SIM2_SLOTID);
997 cellularCallConnectionCS.UnHoldCallRequest(SIM2_SLOTID);
998 cellularCallConnectionCS.SwitchCallRequest(SIM2_SLOTID);
999 cellularCallConnectionCS.CombineConferenceRequest(SIM2_SLOTID, 0);
1000 cellularCallConnectionCS.SeparateConferenceRequest(SIM2_SLOTID, 0, 0);
1001 cellularCallConnectionCS.CallSupplementRequest(SIM2_SLOTID, CallSupplementType::TYPE_DEFAULT);
1002 char cDtmfCode = ' ';
1003 cellularCallConnectionCS.SendDtmfRequest(SIM2_SLOTID, cDtmfCode, 0);
1004 cellularCallConnectionCS.StartDtmfRequest(SIM2_SLOTID, cDtmfCode, 0);
1005 cellularCallConnectionCS.StopDtmfRequest(SIM2_SLOTID, 0);
1006 cellularCallConnectionCS.GetCsCallsDataRequest(SIM2_SLOTID, 0);
1007 cellularCallConnectionCS.GetCallFailReasonRequest(SIM2_SLOTID);
1008 ASSERT_EQ(cellularCallConnectionCS.ProcessPostDialCallChar(SIM1_SLOTID, cDtmfCode), TELEPHONY_SUCCESS);
1009 }
1010
1011 /**
1012 * @tc.number Telephony_SupplementRequestCs_001
1013 * @tc.name Test error branch
1014 * @tc.desc Function test
1015 */
1016 HWTEST_F(ZeroBranch1Test, Telephony_SupplementRequestCs_001, Function | MediumTest | Level3)
1017 {
1018 SupplementRequestCs supplementRequestCs;
1019 std::string msg = "11111";
1020 std::string fac = "";
1021 std::string pw = "";
1022 std::string oldPin = "123456";
1023 std::string newPin = "789101";
1024 std::string puk = "22222";
1025 CallTransferParam callTransferParam;
1026 ASSERT_EQ(supplementRequestCs.SendUssdRequest(SIM1_SLOTID, msg), TELEPHONY_ERR_LOCAL_PTR_NULL);
1027 ASSERT_EQ(supplementRequestCs.CloseUnFinishedUssdRequest(SIM1_SLOTID), TELEPHONY_ERR_LOCAL_PTR_NULL);
1028 ASSERT_EQ(supplementRequestCs.SetClirRequest(SIM1_SLOTID, ACTIVATE_ACTION, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
1029 ASSERT_EQ(supplementRequestCs.GetClipRequest(SIM1_SLOTID, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
1030 ASSERT_EQ(supplementRequestCs.GetClirRequest(SIM1_SLOTID, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
1031 ASSERT_EQ(supplementRequestCs.SetCallTransferRequest(SIM1_SLOTID, callTransferParam, 0),
1032 TELEPHONY_ERR_LOCAL_PTR_NULL);
1033 ASSERT_EQ(supplementRequestCs.GetCallTransferRequest(SIM1_SLOTID, 0, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
1034 ASSERT_EQ(supplementRequestCs.GetCallRestrictionRequest(SIM1_SLOTID, fac, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
1035 ASSERT_EQ(supplementRequestCs.SetCallRestrictionRequest(SIM1_SLOTID, fac, 0, pw, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
1036 ASSERT_EQ(supplementRequestCs.SetBarringPasswordRequest(SIM1_SLOTID, msg, 0, oldPin.c_str(), newPin.c_str()),
1037 TELEPHONY_ERR_LOCAL_PTR_NULL);
1038 ASSERT_EQ(supplementRequestCs.SetCallWaitingRequest(SIM1_SLOTID, true, 0, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
1039 ASSERT_EQ(supplementRequestCs.AlterPinPassword(SIM1_SLOTID, newPin, oldPin), TELEPHONY_ERROR);
1040 ASSERT_EQ(supplementRequestCs.UnlockPuk(SIM1_SLOTID, newPin, puk), TELEPHONY_ERROR);
1041 ASSERT_EQ(supplementRequestCs.AlterPin2Password(SIM1_SLOTID, newPin, oldPin), TELEPHONY_ERROR);
1042 ASSERT_EQ(supplementRequestCs.UnlockPuk2(SIM1_SLOTID, newPin, puk), TELEPHONY_ERROR);
1043 ASSERT_EQ(supplementRequestCs.GetCallWaitingRequest(SIM1_SLOTID, 0), TELEPHONY_ERR_LOCAL_PTR_NULL);
1044 }
1045
1046 /**
1047 * @tc.number Telephony_StandardizeUtils_001
1048 * @tc.name Test error branch
1049 * @tc.desc Function test
1050 */
1051 HWTEST_F(ZeroBranch1Test, Telephony_StandardizeUtils_001, Function | MediumTest | Level3)
1052 {
1053 StandardizeUtils standardizeUtils;
1054 std::string phoneString = {0};
1055 std::string networkAddress = "1111111";
1056 std::string postDial = "11111111";
1057 ASSERT_EQ(standardizeUtils.RemoveSeparatorsPhoneNumber(phoneString), "");
1058 phoneString = "1111111,123321";
1059 standardizeUtils.ExtractAddressAndPostDial(phoneString, networkAddress, postDial);
1060 ASSERT_EQ(postDial, "11111111,123321");
1061 std::vector<std::string> split = standardizeUtils.Split(phoneString, ",");
1062 ASSERT_FALSE(split.empty());
1063 }
1064
1065 /**
1066 * @tc.number Telephony_MmiCodeUtils_001
1067 * @tc.name Test error branch
1068 * @tc.desc Function test
1069 */
1070 HWTEST_F(ZeroBranch1Test, Telephony_MmiCodeUtils_001, Function | MediumTest | Level3)
1071 {
1072 MMICodeUtils mmiCodeUtils;
1073 bool enable = false;
1074 ASSERT_FALSE(mmiCodeUtils.IsNeedExecuteMmi("111111#", enable));
1075 mmiCodeUtils.isNeedUseIms_ = true;
1076 ASSERT_FALSE(mmiCodeUtils.ExecuteMmiCode(SIM1_SLOTID));
1077 mmiCodeUtils.isNeedUseIms_ = false;
1078 mmiCodeUtils.mmiData_.serviceCode = "11111";
1079 ASSERT_FALSE(mmiCodeUtils.ExecuteMmiCode(SIM1_SLOTID));
1080 mmiCodeUtils.mmiData_.serviceCode.clear();
1081 mmiCodeUtils.mmiData_.fullString = "11111";
1082 ASSERT_TRUE(mmiCodeUtils.ExecuteMmiCode(SIM1_SLOTID));
1083 mmiCodeUtils.mmiData_.fullString.clear();
1084 mmiCodeUtils.mmiData_.dialString = "11111#";
1085 ASSERT_FALSE(mmiCodeUtils.RegexMatchMmi("111111#"));
1086 std::string dialStr = "";
1087 ASSERT_FALSE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
1088 dialStr = "12";
1089 ASSERT_FALSE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
1090 dialStr = "33";
1091 ASSERT_TRUE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
1092 dialStr = "*21*10086#";
1093 ASSERT_TRUE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
1094 dialStr = "10086";
1095 ASSERT_FALSE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
1096 dialStr = "*30#10086";
1097 ASSERT_TRUE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
1098 dialStr = "*33##123#";
1099 ASSERT_TRUE(mmiCodeUtils.IsNeedExecuteMmi(dialStr, enable));
1100 }
1101
1102 /**
1103 * @tc.number Telephony_CellularCallRdbHelper_001
1104 * @tc.name Test error branch
1105 * @tc.desc Function test
1106 */
1107 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallRdbHelper_001, Function | MediumTest | Level3)
1108 {
1109 std::u16string u16Hplmn = u"";
1110 CoreManagerInner::GetInstance().GetSimOperatorNumeric(SIM1_SLOTID, u16Hplmn);
1111 std::string hplmn = Str16ToStr8(u16Hplmn);
1112 std::vector<EccNum> eccVec;
1113 ASSERT_NE(DelayedSingleton<CellularCallRdbHelper>::GetInstance()->QueryEccList(hplmn, eccVec), TELEPHONY_SUCCESS);
1114 }
1115
1116 /**
1117 * @tc.number Telephony_CellularCallDumpHelper_001
1118 * @tc.name Test error branch
1119 * @tc.desc Function test
1120 */
1121 HWTEST_F(ZeroBranch1Test, Telephony_CellularCallDumpHelper_001, Function | MediumTest | Level3)
1122 {
1123 CellularCallDumpHelper cellularCallDumpHelper;
1124 std::vector<std::string> args = { "123456", "234567" };
1125 std::string result;
1126 cellularCallDumpHelper.WhetherHasSimCard(SIM1_SLOTID);
1127 ASSERT_NE(cellularCallDumpHelper.Dump(args, result), TELEPHONY_SUCCESS);
1128 }
1129
1130 /**
1131 * @tc.number Telephony_EmergencyUtils_001
1132 * @tc.name Test error branch
1133 * @tc.desc Function test
1134 */
1135 HWTEST_F(ZeroBranch1Test, Telephony_EmergencyUtils_001, Function | MediumTest | Level3)
1136 {
1137 EmergencyUtils emergencyUtils;
1138 std::string phoneNum = "1234567";
1139 bool enabled = false;
1140 ASSERT_EQ(emergencyUtils.IsEmergencyCall(SIM1_SLOTID, phoneNum, enabled), TELEPHONY_SUCCESS);
1141 }
1142
1143 } // namespace Telephony
1144 } // namespace OHOS