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