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 #include "alerting_state.h"
18 #include "audio_proxy.h"
19 #include "audio_control_manager.h"
20 #include "bluetooth_device_state.h"
21 #include "call_ability_callback_stub.h"
22 #include "call_policy.h"
23 #include "call_request_process.h"
24 #include "call_state_processor.h"
25 #include "call_status_callback_proxy.h"
26 #include "cs_call_state.h"
27 #include "dialing_state.h"
28 #include "earpiece_device_state.h"
29 #include "holding_state.h"
30 #include "ims_call.h"
31 #include "ims_call_state.h"
32 #include "inactive_device_state.h"
33 #include "inactive_state.h"
34 #include "incoming_state.h"
35 #include "iservice_registry.h"
36 #include "ott_call_state.h"
37 #include "ring.h"
38 #include "speaker_device_state.h"
39 #include "system_ability_definition.h"
40 #include "telephony_log_wrapper.h"
41 #include "tone.h"
42 #include "voip_call_connection.h"
43 #include "voip_call.h"
44 #include "wired_headset_device_state.h"
45 #include "gtest/gtest.h"
46 #include "audio_scene_processor.h"
47 #include "core_service_connection.h"
48 
49 namespace OHOS {
50 namespace Telephony {
51 using namespace testing::ext;
52 constexpr int WAIT_TIME = 3;
53 constexpr int DEFAULT_SLOT_ID = 0;
54 constexpr int VALID_CALL_ID = 1;
55 constexpr const char* NUMBER = "10086";
56 constexpr const char* NAME = "test";
57 
58 class CallStateTest : public testing::Test {
59 public:
60     static void SetUpTestCase();
61     static void TearDownTestCase();
62     void SetUp();
63     void TearDown();
64 };
SetUpTestCase()65 void CallStateTest::SetUpTestCase() {}
66 
TearDownTestCase()67 void CallStateTest::TearDownTestCase() {}
68 
SetUp()69 void CallStateTest::SetUp() {}
70 
TearDown()71 void CallStateTest::TearDown() {}
72 
73 /**
74  * @tc.number   Telephony_CSCallState_001
75  * @tc.name     test error branch
76  * @tc.desc     Function test
77  */
78 HWTEST_F(CallStateTest, Telephony_CSCallState_001, Function | MediumTest | Level3)
79 {
80     auto csCallState = std::make_shared<CSCallState>();
81     csCallState->ProcessEvent(AudioEvent::NO_MORE_ACTIVE_CALL);
82     csCallState->ProcessEvent(AudioEvent::NEW_INCOMING_CALL);
83     csCallState->ProcessEvent(AudioEvent::CALL_TYPE_CS_CHANGE_IMS);
84     ASSERT_FALSE(csCallState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
85 }
86 
87 /**
88  * @tc.number   Telephony_IMSCallState_001
89  * @tc.name     test error branch
90  * @tc.desc     Function test
91  */
92 HWTEST_F(CallStateTest, Telephony_IMSCallState_001, Function | MediumTest | Level3)
93 {
94     auto imsCallState = std::make_shared<IMSCallState>();
95     imsCallState->ProcessEvent(AudioEvent::NO_MORE_ACTIVE_CALL);
96     imsCallState->ProcessEvent(AudioEvent::NEW_INCOMING_CALL);
97     imsCallState->ProcessEvent(AudioEvent::CALL_TYPE_IMS_CHANGE_CS);
98     ASSERT_FALSE(imsCallState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
99 }
100 
101 /**
102  * @tc.number   Telephony_OTTCallState_001
103  * @tc.name     test error branch
104  * @tc.desc     Function test
105  */
106 HWTEST_F(CallStateTest, Telephony_OTTCallState_001, Function | MediumTest | Level3)
107 {
108     auto ottCallState = std::make_shared<OTTCallState>();
109     ASSERT_FALSE(ottCallState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
110 }
111 
112 /**
113  * @tc.number   Telephony_HoldingState_001
114  * @tc.name     test error branch
115  * @tc.desc     Function test
116  */
117 HWTEST_F(CallStateTest, Telephony_HoldingState_001, Function | MediumTest | Level3)
118 {
119     auto holdingState = std::make_shared<HoldingState>();
120     holdingState->ProcessEvent(AudioEvent::NEW_ACTIVE_CS_CALL);
121     holdingState->ProcessEvent(AudioEvent::NEW_ACTIVE_IMS_CALL);
122     holdingState->ProcessEvent(AudioEvent::NEW_INCOMING_CALL);
123     ASSERT_FALSE(holdingState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
124 }
125 
126 /**
127  * @tc.number   Telephony_AlertingState_001
128  * @tc.name     test error branch
129  * @tc.desc     Function test
130  */
131 HWTEST_F(CallStateTest, Telephony_AlertingState_001, Function | MediumTest | Level3)
132 {
133     auto alertingState = std::make_shared<AlertingState>();
134     alertingState->ProcessEvent(AudioEvent::NO_MORE_ALERTING_CALL);
135     alertingState->ProcessEvent(AudioEvent::NEW_ACTIVE_CS_CALL);
136     alertingState->ProcessEvent(AudioEvent::NEW_ACTIVE_IMS_CALL);
137     ASSERT_FALSE(alertingState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
138 }
139 
140 /**
141  * @tc.number   Telephony_IncomingState_001
142  * @tc.name     test error branch
143  * @tc.desc     Function test
144  */
145 HWTEST_F(CallStateTest, Telephony_IncomingState_001, Function | MediumTest | Level3)
146 {
147     auto incomingState = std::make_shared<IncomingState>();
148     incomingState->ProcessEvent(AudioEvent::NO_MORE_INCOMING_CALL);
149     incomingState->ProcessEvent(AudioEvent::NEW_ACTIVE_CS_CALL);
150     incomingState->ProcessEvent(AudioEvent::NEW_ACTIVE_IMS_CALL);
151     ASSERT_FALSE(incomingState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
152 }
153 
154 /**
155  * @tc.number   Telephony_InActiveState_001
156  * @tc.name     test error branch
157  * @tc.desc     Function test
158  */
159 HWTEST_F(CallStateTest, Telephony_InActiveState_001, Function | MediumTest | Level3)
160 {
161     auto inActiveState = std::make_shared<InActiveState>();
162     inActiveState->ProcessEvent(AudioEvent::NEW_DIALING_CALL);
163     inActiveState->ProcessEvent(AudioEvent::NEW_ACTIVE_CS_CALL);
164     inActiveState->ProcessEvent(AudioEvent::NEW_ACTIVE_IMS_CALL);
165     inActiveState->ProcessEvent(AudioEvent::NEW_ALERTING_CALL);
166     inActiveState->ProcessEvent(AudioEvent::NEW_INCOMING_CALL);
167     ASSERT_FALSE(inActiveState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
168 }
169 
170 /**
171  * @tc.number   Telephony_DialingState_001
172  * @tc.name     test error branch
173  * @tc.desc     Function test
174  */
175 HWTEST_F(CallStateTest, Telephony_DialingState_001, Function | MediumTest | Level3)
176 {
177     auto dialingState = std::make_shared<DialingState>();
178     dialingState->ProcessEvent(AudioEvent::NO_MORE_DIALING_CALL);
179     dialingState->ProcessEvent(AudioEvent::NEW_ACTIVE_CS_CALL);
180     dialingState->ProcessEvent(AudioEvent::NEW_ACTIVE_IMS_CALL);
181     dialingState->ProcessEvent(AudioEvent::NEW_ALERTING_CALL);
182     ASSERT_FALSE(dialingState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
183 }
184 
185 /**
186  * @tc.number   Telephony_WiredHeadsetDeviceState_001
187  * @tc.name     test error branch
188  * @tc.desc     Function test
189  */
190 HWTEST_F(CallStateTest, Telephony_WiredHeadsetDeviceState_001, Function | MediumTest | Level3)
191 {
192     auto wiredHeadsetDeviceState = std::make_shared<WiredHeadsetDeviceState>();
193     wiredHeadsetDeviceState->ProcessEvent(AudioEvent::WIRED_HEADSET_DISCONNECTED);
194     wiredHeadsetDeviceState->ProcessEvent(AudioEvent::BLUETOOTH_SCO_CONNECTED);
195     ASSERT_FALSE(wiredHeadsetDeviceState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
196 }
197 
198 /**
199  * @tc.number   Telephony_BluetoothDeviceState_001
200  * @tc.name     test error branch
201  * @tc.desc     Function test
202  */
203 HWTEST_F(CallStateTest, Telephony_BluetoothDeviceState_001, Function | MediumTest | Level3)
204 {
205     auto bluetoothDeviceState = std::make_shared<BluetoothDeviceState>();
206     bluetoothDeviceState->ProcessEvent(AudioEvent::BLUETOOTH_SCO_CONNECTED);
207     bluetoothDeviceState->ProcessEvent(AudioEvent::AUDIO_ACTIVATED);
208     bluetoothDeviceState->ProcessEvent(AudioEvent::AUDIO_RINGING);
209     bluetoothDeviceState->ProcessEvent(AudioEvent::BLUETOOTH_SCO_DISCONNECTED);
210     bluetoothDeviceState->ProcessEvent(AudioEvent::AUDIO_DEACTIVATED);
211     ASSERT_FALSE(bluetoothDeviceState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
212 }
213 
214 /**
215  * @tc.number   Telephony_EarpieceDeviceState_001
216  * @tc.name     test error branch
217  * @tc.desc     Function test
218  */
219 HWTEST_F(CallStateTest, Telephony_EarpieceDeviceState_001, Function | MediumTest | Level3)
220 {
221     auto earpieceDeviceState = std::make_shared<EarpieceDeviceState>();
222     earpieceDeviceState->ProcessEvent(AudioEvent::WIRED_HEADSET_CONNECTED);
223     earpieceDeviceState->ProcessEvent(AudioEvent::BLUETOOTH_SCO_CONNECTED);
224     ASSERT_FALSE(earpieceDeviceState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
225 }
226 
227 /**
228  * @tc.number   Telephony_SpeakerDeviceState_001
229  * @tc.name     test error branch
230  * @tc.desc     Function test
231  */
232 HWTEST_F(CallStateTest, Telephony_SpeakerDeviceState_001, Function | MediumTest | Level3)
233 {
234     auto speakerDeviceState = std::make_shared<SpeakerDeviceState>();
235     speakerDeviceState->ProcessEvent(AudioEvent::WIRED_HEADSET_CONNECTED);
236     speakerDeviceState->ProcessEvent(AudioEvent::BLUETOOTH_SCO_CONNECTED);
237     speakerDeviceState->ProcessEvent(AudioEvent::AUDIO_ACTIVATED);
238     ASSERT_FALSE(speakerDeviceState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
239 }
240 
241 /**
242  * @tc.number   Telephony_InactiveDeviceState_001
243  * @tc.name     test error branch
244  * @tc.desc     Function test
245  */
246 HWTEST_F(CallStateTest, Telephony_InactiveDeviceState_001, Function | MediumTest | Level3)
247 {
248     auto inactiveDeviceState = std::make_shared<InactiveDeviceState>();
249     inactiveDeviceState->ProcessEvent(AudioEvent::AUDIO_ACTIVATED);
250     inactiveDeviceState->ProcessEvent(AudioEvent::AUDIO_RINGING);
251     inactiveDeviceState->ProcessEvent(AudioEvent::AUDIO_DEACTIVATED);
252     ASSERT_FALSE(inactiveDeviceState->ProcessEvent(AudioEvent::UNKNOWN_EVENT));
253 }
254 
255 /**
256  * @tc.number   Telephony_AudioProxy_001
257  * @tc.name     test error branch
258  * @tc.desc     Function test
259  */
260 HWTEST_F(CallStateTest, Telephony_AudioProxy_001, Function | MediumTest | Level3)
261 {
262     auto audioProxy = std::make_shared<AudioProxy>();
263     audioProxy->SetAudioScene(AudioStandard::AudioScene::AUDIO_SCENE_DEFAULT);
264     audioProxy->SetAudioDeviceChangeCallback();
265     audioProxy->UnsetDeviceChangeCallback();
266 
267     audioProxy->SetBluetoothDevActive();
268     audioProxy->SetBluetoothDevActive();
269     audioProxy->SetSpeakerDevActive();
270     audioProxy->SetSpeakerDevActive();
271     audioProxy->SetWiredHeadsetState(true);
272     ASSERT_FALSE(audioProxy->SetEarpieceDevActive());
273     audioProxy->SetWiredHeadsetState(false);
274     audioProxy->SetEarpieceDevActive();
275     audioProxy->SetEarpieceDevActive();
276     ASSERT_FALSE(audioProxy->SetWiredHeadsetDevActive());
277     audioProxy->SetWiredHeadsetState(true);
278     audioProxy->SetWiredHeadsetDevActive();
279     audioProxy->SetSpeakerDevActive();
280     audioProxy->SetWiredHeadsetDevActive();
281     audioProxy->SetEarpieceDevActive();
282     audioProxy->SetWiredHeadsetDevActive();
283     audioProxy->SetBluetoothDevActive();
284     audioProxy->SetWiredHeadsetDevActive();
285 
286     int32_t volume = audioProxy->GetVolume(AudioStandard::AudioStreamType::STREAM_VOICE_CALL);
287     audioProxy->SetMaxVolume(AudioStandard::AudioStreamType::STREAM_VOICE_CALL);
288     audioProxy->SetVolumeAudible();
289     audioProxy->SetVolume(AudioStandard::AudioStreamType::STREAM_VOICE_CALL, volume);
290     audioProxy->IsStreamActive(AudioStandard::AudioStreamType::STREAM_VOICE_CALL);
291     audioProxy->IsStreamMute(AudioStandard::AudioStreamType::STREAM_VOICE_CALL);
292     audioProxy->GetMaxVolume(AudioStandard::AudioStreamType::STREAM_VOICE_CALL);
293     audioProxy->GetMinVolume(AudioStandard::AudioStreamType::STREAM_VOICE_CALL);
294     bool isMute = audioProxy->IsMicrophoneMute();
295     audioProxy->SetMicrophoneMute(!isMute);
296     audioProxy->SetMicrophoneMute(isMute);
297     ASSERT_TRUE(audioProxy->SetMicrophoneMute(isMute));
298 }
299 
300 /**
301  * @tc.number   Telephony_AudioProxy_002
302  * @tc.name     test error branch
303  * @tc.desc     Function test
304  */
305 HWTEST_F(CallStateTest, Telephony_AudioProxy_002, Function | MediumTest | Level3)
306 {
307     auto audioProxy = std::make_shared<AudioProxy>();
308     audioProxy->GetRingerMode();
309     AudioDevice device;
310     audioProxy->GetPreferredOutputAudioDevice(device);
311     audioProxy->SetAudioPreferDeviceChangeCallback();
312     audioProxy->UnsetAudioPreferDeviceChangeCallback();
313     ASSERT_FALSE(audioProxy->GetDefaultTonePath().empty());
314     ASSERT_FALSE(audioProxy->GetDefaultDtmfPath().empty());
315 }
316 
317 /**
318  * @tc.number   Telephony_AudioDeviceManager_001
319  * @tc.name     test error branch
320  * @tc.desc     Function test
321  */
322 HWTEST_F(CallStateTest, Telephony_AudioDeviceManager_001, Function | MediumTest | Level3)
323 {
324     auto audioDeviceManager = DelayedSingleton<AudioDeviceManager>::GetInstance();
325     audioDeviceManager->AddAudioDeviceList(NAME, AudioDeviceType::DEVICE_SPEAKER, NAME);
326     audioDeviceManager->AddAudioDeviceList(NAME, AudioDeviceType::DEVICE_WIRED_HEADSET, NAME);
327     audioDeviceManager->AddAudioDeviceList(NAME, AudioDeviceType::DEVICE_BLUETOOTH_SCO, NAME);
328     audioDeviceManager->RemoveAudioDeviceList(NAME, AudioDeviceType::DEVICE_WIRED_HEADSET);
329     audioDeviceManager->RemoveAudioDeviceList(NAME, AudioDeviceType::DEVICE_BLUETOOTH_SCO);
330     audioDeviceManager->ResetBtAudioDevicesList();
331     audioDeviceManager->ResetDistributedCallDevicesList();
332     audioDeviceManager->ProcessEvent(AudioEvent::WIRED_HEADSET_DISCONNECTED);
333     audioDeviceManager->SwitchDevice(AUDIO_DEACTIVATED);
334     audioDeviceManager->EnableBtSco();
335     audioDeviceManager->EnableDistributedCall();
336     audioDeviceManager->GetCurrentAudioDevice();
337     audioDeviceManager->IsEarpieceDevEnable();
338     audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_SPEAKER, false);
339     audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_EARPIECE, false);
340     audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_BLUETOOTH_SCO, false);
341     audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_WIRED_HEADSET, false);
342     audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_DISTRIBUTED_AUTOMOTIVE, false);
343     audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_DISTRIBUTED_PHONE, false);
344     audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_UNKNOWN, false);
345     ASSERT_FALSE(audioDeviceManager->IsWiredHeadsetDevEnable());
346 }
347 
348 /**
349  * @tc.number   Telephony_AudioDeviceManager_002
350  * @tc.name     test error branch
351  * @tc.desc     Function test
352  */
353 HWTEST_F(CallStateTest, Telephony_AudioDeviceManager_002, Function | MediumTest | Level3)
354 {
355     auto audioDeviceManager = DelayedSingleton<AudioDeviceManager>::GetInstance();
356     audioDeviceManager->AddAudioDeviceList(NAME, AudioDeviceType::DEVICE_SPEAKER, NAME);
357     audioDeviceManager->AddAudioDeviceList(NAME, AudioDeviceType::DEVICE_WIRED_HEADSET, NAME);
358     audioDeviceManager->AddAudioDeviceList(NAME, AudioDeviceType::DEVICE_BLUETOOTH_SCO, NAME);
359     audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_EARPIECE);
360     audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_SPEAKER);
361     audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_WIRED_HEADSET);
362     audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_BLUETOOTH_SCO);
363     audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_DISABLE);
364     audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_UNKNOWN);
365     audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_DISTRIBUTED_AUTOMOTIVE);
366     audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_DISTRIBUTED_PHONE);
367     audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_DISTRIBUTED_PAD);
368     audioDeviceManager->isWiredHeadsetConnected_ = true;
369     audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_WIRED_HEADSET, true);
370     audioDeviceManager->EnableWiredHeadset();
371     audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_DISTRIBUTED_PAD, true);
372     audioDeviceManager->EnableDistributedCall();
373     audioDeviceManager->IsBtScoDevEnable();
374     audioDeviceManager->IsDCallDevEnable();
375     audioDeviceManager->IsSpeakerDevEnable();
376     ASSERT_FALSE(audioDeviceManager->IsSpeakerAvailable());
377 }
378 
379 /**
380  * @tc.number   Telephony_AudioPlayer_001
381  * @tc.name     test error branch
382  * @tc.desc     Function test
383  */
384 HWTEST_F(CallStateTest, Telephony_AudioPlayer_001, Function | MediumTest | Level3)
385 {
386     auto audioPlayer = DelayedSingleton<AudioPlayer>::GetInstance();
387     std::string profilePath = "";
388     std::string path = "";
389     audioPlayer->GetRealPath(profilePath, path);
390     ASSERT_FALSE(audioPlayer->IsStop(TYPE_RING));
391     ASSERT_FALSE(audioPlayer->IsStop(TYPE_TONE));
392     ASSERT_FALSE(audioPlayer->IsStop(TYPE_DTMF));
393     ASSERT_FALSE(audioPlayer->IsStop(TYPE_SOUND));
394 }
395 
396 /**
397  * @tc.number   Telephony_AudioSceneProcessor_001
398  * @tc.name     test error branch
399  * @tc.desc     Function test
400  */
401 HWTEST_F(CallStateTest, Telephony_AudioSceneProcessor_001, Function | MediumTest | Level3)
402 {
403     auto audioSceneProcessor = DelayedSingleton<AudioSceneProcessor>::GetInstance();
404     audioSceneProcessor->SwitchState(CallStateType::DIALING_STATE);
405     audioSceneProcessor->SwitchState(CallStateType::ALERTING_STATE);
406     audioSceneProcessor->SwitchState(CallStateType::INCOMING_STATE);
407     audioSceneProcessor->SwitchState(CallStateType::CS_CALL_STATE);
408     audioSceneProcessor->SwitchState(CallStateType::IMS_CALL_STATE);
409     audioSceneProcessor->SwitchState(CallStateType::HOLDING_STATE);
410     audioSceneProcessor->SwitchState(CallStateType::UNKNOWN_STATE);
411     audioSceneProcessor->SwitchState(CallStateType::INACTIVE_STATE);
412     ASSERT_TRUE(audioSceneProcessor->SwitchIncoming());
413 }
414 
415 /**
416  * @tc.number   Telephony_Ring_001
417  * @tc.name     test error branch
418  * @tc.desc     Function test
419  */
420 HWTEST_F(CallStateTest, Telephony_Ring_001, Function | MediumTest | Level3)
421 {
422     auto ring = std::make_shared<Ring>();
423     ring->Play(DEFAULT_SLOT_ID);
424     sleep(WAIT_TIME);
425     ring->Stop();
426     ring->ReleaseRenderer();
427     ring->Play(DEFAULT_SLOT_ID);
428     sleep(WAIT_TIME);
429     ASSERT_NE(ring->Stop(), TELEPHONY_ERR_LOCAL_PTR_NULL);
430 }
431 
432 /**
433  * @tc.number   Telephony_Tone_001
434  * @tc.name     test error branch
435  * @tc.desc     Function test
436  */
437 HWTEST_F(CallStateTest, Telephony_Tone_001, Function | MediumTest | Level3)
438 {
439     auto unknownTone = std::make_shared<Tone>(ToneDescriptor::TONE_UNKNOWN);
440     unknownTone->Init();
441     unknownTone->Play();
442     sleep(WAIT_TIME);
443     unknownTone->Stop();
444     unknownTone->ReleaseRenderer();
445 
446     auto ringbackTone = std::make_shared<Tone>(ToneDescriptor::TONE_RINGBACK);
447     ringbackTone->Play();
448     sleep(WAIT_TIME);
449     ringbackTone->Stop();
450 
451     auto tone = std::make_shared<Tone>(ToneDescriptor::TONE_DTMF_CHAR_1);
452     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_0));
453     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_1));
454     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_2));
455     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_3));
456     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_4));
457     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_5));
458     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_6));
459     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_7));
460     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_8));
461     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_9));
462     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_P));
463     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_W));
464     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_RINGBACK));
465     ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_WAITING));
466 }
467 
468 /**
469  * @tc.number   Telephony_Tone_002
470  * @tc.name     test error branch
471  * @tc.desc     Function test
472  */
473 HWTEST_F(CallStateTest, Telephony_Tone_002, Function | MediumTest | Level3)
474 {
475     ASSERT_EQ(Tone::ConvertDigitToTone('0'), ToneDescriptor::TONE_DTMF_CHAR_0);
476     ASSERT_EQ(Tone::ConvertDigitToTone('1'), ToneDescriptor::TONE_DTMF_CHAR_1);
477     ASSERT_EQ(Tone::ConvertDigitToTone('2'), ToneDescriptor::TONE_DTMF_CHAR_2);
478     ASSERT_EQ(Tone::ConvertDigitToTone('3'), ToneDescriptor::TONE_DTMF_CHAR_3);
479     ASSERT_EQ(Tone::ConvertDigitToTone('4'), ToneDescriptor::TONE_DTMF_CHAR_4);
480     ASSERT_EQ(Tone::ConvertDigitToTone('5'), ToneDescriptor::TONE_DTMF_CHAR_5);
481     ASSERT_EQ(Tone::ConvertDigitToTone('6'), ToneDescriptor::TONE_DTMF_CHAR_6);
482     ASSERT_EQ(Tone::ConvertDigitToTone('7'), ToneDescriptor::TONE_DTMF_CHAR_7);
483     ASSERT_EQ(Tone::ConvertDigitToTone('8'), ToneDescriptor::TONE_DTMF_CHAR_8);
484     ASSERT_EQ(Tone::ConvertDigitToTone('9'), ToneDescriptor::TONE_DTMF_CHAR_9);
485     ASSERT_EQ(Tone::ConvertDigitToTone('*'), ToneDescriptor::TONE_DTMF_CHAR_P);
486     ASSERT_EQ(Tone::ConvertDigitToTone('#'), ToneDescriptor::TONE_DTMF_CHAR_W);
487     ASSERT_EQ(Tone::ConvertDigitToTone('a'), ToneDescriptor::TONE_UNKNOWN);
488 }
489 
490 /**
491  * @tc.number   Telephony_Tone_003
492  * @tc.name     test error branch
493  * @tc.desc     Function test
494  */
495 HWTEST_F(CallStateTest, Telephony_Tone_003, Function | MediumTest | Level3)
496 {
497     auto tone = std::make_shared<Tone>();
498     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_0),
499         AudioStandard::ToneType::TONE_TYPE_DIAL_0);
500     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_1),
501         AudioStandard::ToneType::TONE_TYPE_DIAL_1);
502     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_2),
503         AudioStandard::ToneType::TONE_TYPE_DIAL_2);
504     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_3),
505         AudioStandard::ToneType::TONE_TYPE_DIAL_3);
506     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_4),
507         AudioStandard::ToneType::TONE_TYPE_DIAL_4);
508     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_5),
509         AudioStandard::ToneType::TONE_TYPE_DIAL_5);
510     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_6),
511         AudioStandard::ToneType::TONE_TYPE_DIAL_6);
512     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_7),
513         AudioStandard::ToneType::TONE_TYPE_DIAL_7);
514     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_8),
515         AudioStandard::ToneType::TONE_TYPE_DIAL_8);
516     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_9),
517         AudioStandard::ToneType::TONE_TYPE_DIAL_9);
518     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_P),
519         AudioStandard::ToneType::TONE_TYPE_DIAL_S);
520     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_W),
521         AudioStandard::ToneType::TONE_TYPE_DIAL_P);
522     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_RINGBACK),
523         AudioStandard::ToneType::TONE_TYPE_COMMON_SUPERVISORY_RINGTONE);
524     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_WAITING),
525         AudioStandard::ToneType::TONE_TYPE_COMMON_SUPERVISORY_CALL_WAITING);
526     ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_UNKNOWN), AudioStandard::ToneType::NUM_TONES);
527 }
528 
529 /**
530  * @tc.number   Telephony_Tone_004
531  * @tc.name     test error branch
532  * @tc.desc     Function test
533  */
534 HWTEST_F(CallStateTest, Telephony_Tone_004, Function | MediumTest | Level3)
535 {
536     auto tone = std::make_shared<Tone>();
537     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_0),
538         AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
539     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_1),
540         AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
541     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_2),
542         AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
543     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_3),
544         AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
545     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_4),
546         AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
547     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_5),
548         AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
549     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_6),
550         AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
551     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_7),
552         AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
553     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_8),
554         AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
555     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_9),
556         AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
557     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_P),
558         AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
559     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_W),
560         AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
561     ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_RINGBACK),
562         AudioStandard::StreamUsage::STREAM_USAGE_VOICE_MODEM_COMMUNICATION);
563     tone->GetStreamUsageByToneType(ToneDescriptor::TONE_WAITING);
564 }
565 
566 /**
567  * @tc.number   Telephony_CallStatusCallbackProxy_001
568  * @tc.name     test error branch
569  * @tc.desc     Function test
570  */
571 HWTEST_F(CallStateTest, Telephony_CallStatusCallbackProxy_001, Function | MediumTest | Level3)
572 {
573     auto callStatusCallbackProxy = std::make_shared<CallStatusCallbackProxy>(nullptr);
574     CallReportInfo callReportInfo;
575     callStatusCallbackProxy->UpdateCallReportInfo(callReportInfo);
576     CallsReportInfo callsReportInfo;
577     callStatusCallbackProxy->UpdateCallsReportInfo(callsReportInfo);
578     DisconnectedDetails details;
579     callStatusCallbackProxy->UpdateDisconnectedCause(details);
580     CellularCallEventInfo eventInfo;
581     callStatusCallbackProxy->UpdateEventResultInfo(eventInfo);
582     RBTPlayInfo playInfo = RBTPlayInfo::LOCAL_ALERTING;
583     callStatusCallbackProxy->UpdateRBTPlayInfo(playInfo);
584     CallWaitResponse callWaitResponse;
585     callStatusCallbackProxy->UpdateGetWaitingResult(callWaitResponse);
586     int32_t result = 0;
587     callStatusCallbackProxy->UpdateSetWaitingResult(result);
588     CallRestrictionResponse callRestrictionResult;
589     callStatusCallbackProxy->UpdateGetRestrictionResult(callRestrictionResult);
590     callStatusCallbackProxy->UpdateSetRestrictionResult(result);
591     callStatusCallbackProxy->UpdateSetRestrictionPasswordResult(result);
592     CallTransferResponse callTransferResponse;
593     callStatusCallbackProxy->UpdateGetTransferResult(callTransferResponse);
594     callStatusCallbackProxy->UpdateSetTransferResult(result);
595     ClipResponse clipResponse;
596     callStatusCallbackProxy->UpdateGetCallClipResult(clipResponse);
597     ClirResponse clirResponse;
598     callStatusCallbackProxy->UpdateGetCallClirResult(clirResponse);
599     callStatusCallbackProxy->UpdateSetCallClirResult(result);
600     callStatusCallbackProxy->StartRttResult(result);
601     callStatusCallbackProxy->StopRttResult(result);
602     GetImsConfigResponse imsConfigResponse;
603     callStatusCallbackProxy->GetImsConfigResult(imsConfigResponse);
604     callStatusCallbackProxy->SetImsConfigResult(result);
605     GetImsFeatureValueResponse imsFeatureValueResponse;
606     callStatusCallbackProxy->GetImsFeatureValueResult(imsFeatureValueResponse);
607     callStatusCallbackProxy->SetImsFeatureValueResult(result);
608     callStatusCallbackProxy->InviteToConferenceResult(result);
609     callStatusCallbackProxy->StartDtmfResult(result);
610     callStatusCallbackProxy->StopDtmfResult(result);
611     callStatusCallbackProxy->SendUssdResult(result);
612     MmiCodeInfo mmiCodeInfo;
613     ASSERT_EQ(callStatusCallbackProxy->SendMmiCodeResult(mmiCodeInfo), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
614     ASSERT_EQ(callStatusCallbackProxy->GetImsCallDataResult(result), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
615     ASSERT_EQ(callStatusCallbackProxy->CloseUnFinishedUssdResult(result), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
616 }
617 
618 /**
619  * @tc.number   Telephony_CallStatusCallbackProxy_002
620  * @tc.name     test error branch
621  * @tc.desc     Function test
622  */
623 HWTEST_F(CallStateTest, Telephony_CallStatusCallbackProxy_002, Function | MediumTest | Level3)
624 {
625     sptr<ISystemAbilityManager> systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
626     if (systemAbilityMgr == nullptr) {
627         TELEPHONY_LOGE("Telephony_CallStatusCallbackProxy systemAbilityMgr is nullptr");
628         return;
629     }
630     sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
631     if (remote == nullptr) {
632         TELEPHONY_LOGE("Telephony_CallStatusCallbackProxy remote is nullptr");
633         return;
634     }
635     auto callStatusCallbackProxy = std::make_shared<CallStatusCallbackProxy>(remote);
636 
637     CallReportInfo callReportInfo;
638     callStatusCallbackProxy->UpdateCallReportInfo(callReportInfo);
639     CallsReportInfo callsReportInfo;
640     callStatusCallbackProxy->UpdateCallsReportInfo(callsReportInfo);
641     DisconnectedDetails details;
642     callStatusCallbackProxy->UpdateDisconnectedCause(details);
643     CellularCallEventInfo eventInfo;
644     callStatusCallbackProxy->UpdateEventResultInfo(eventInfo);
645     RBTPlayInfo playInfo = RBTPlayInfo::LOCAL_ALERTING;
646     callStatusCallbackProxy->UpdateRBTPlayInfo(playInfo);
647     CallWaitResponse callWaitResponse;
648     callStatusCallbackProxy->UpdateGetWaitingResult(callWaitResponse);
649     CallRestrictionResponse callRestrictionResult;
650     callStatusCallbackProxy->UpdateGetRestrictionResult(callRestrictionResult);
651     CallTransferResponse callTransferResponse;
652     callStatusCallbackProxy->UpdateGetTransferResult(callTransferResponse);
653     ClipResponse clipResponse;
654     ASSERT_EQ(callStatusCallbackProxy->UpdateGetCallClipResult(clipResponse), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
655     ClirResponse clirResponse;
656     ASSERT_EQ(callStatusCallbackProxy->UpdateGetCallClirResult(clirResponse), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
657 }
658 
659 /**
660  * @tc.number   Telephony_CallStatusCallbackProxy_003
661  * @tc.name     test error branch
662  * @tc.desc     Function test
663  */
664 HWTEST_F(CallStateTest, Telephony_CallStatusCallbackProxy_003, Function | MediumTest | Level3)
665 {
666     sptr<ISystemAbilityManager> systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
667     if (systemAbilityMgr == nullptr) {
668         TELEPHONY_LOGE("Telephony_CallStatusCallbackProxy systemAbilityMgr is nullptr");
669         return;
670     }
671     sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
672     if (remote == nullptr) {
673         TELEPHONY_LOGE("Telephony_CallStatusCallbackProxy remote is nullptr");
674         return;
675     }
676     auto callStatusCallbackProxy = std::make_shared<CallStatusCallbackProxy>(remote);
677 
678     int32_t result = 0;
679     callStatusCallbackProxy->UpdateSetWaitingResult(result);
680     callStatusCallbackProxy->UpdateSetRestrictionResult(result);
681     callStatusCallbackProxy->UpdateSetRestrictionPasswordResult(result);
682     callStatusCallbackProxy->UpdateSetTransferResult(result);
683     callStatusCallbackProxy->UpdateSetCallClirResult(result);
684     callStatusCallbackProxy->StartRttResult(result);
685     callStatusCallbackProxy->StopRttResult(result);
686     GetImsConfigResponse imsConfigResponse;
687     callStatusCallbackProxy->GetImsConfigResult(imsConfigResponse);
688     callStatusCallbackProxy->SetImsConfigResult(result);
689     GetImsFeatureValueResponse imsFeatureValueResponse;
690     callStatusCallbackProxy->GetImsFeatureValueResult(imsFeatureValueResponse);
691     callStatusCallbackProxy->SetImsFeatureValueResult(result);
692     callStatusCallbackProxy->InviteToConferenceResult(result);
693     callStatusCallbackProxy->StartDtmfResult(result);
694     callStatusCallbackProxy->StopDtmfResult(result);
695     callStatusCallbackProxy->SendUssdResult(result);
696     MmiCodeInfo mmiCodeInfo;
697     CallModeReportInfo callModeRequestInfo;
698     callStatusCallbackProxy->ReceiveUpdateCallMediaModeRequest(callModeRequestInfo);
699     CallModeReportInfo callModeResponseInfo;
700     callStatusCallbackProxy->ReceiveUpdateCallMediaModeResponse(callModeResponseInfo);
701     CallSessionReportInfo sessionReportInfo;
702     callStatusCallbackProxy->HandleCallSessionEventChanged(sessionReportInfo);
703     PeerDimensionsReportInfo peerDimensionsReportInfo;
704     callStatusCallbackProxy->HandlePeerDimensionsChanged(peerDimensionsReportInfo);
705     callStatusCallbackProxy->HandleCallDataUsageChanged(static_cast<int64_t>(result));
706     CameraCapabilitiesReportInfo cameraCapabilitiesInfo;
707     callStatusCallbackProxy->HandleCameraCapabilitiesChanged(cameraCapabilitiesInfo);
708     ASSERT_EQ(callStatusCallbackProxy->SendMmiCodeResult(mmiCodeInfo), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
709     ASSERT_EQ(callStatusCallbackProxy->GetImsCallDataResult(result), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
710     ASSERT_EQ(callStatusCallbackProxy->CloseUnFinishedUssdResult(result), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
711 }
712 
713 /**
714  * @tc.number   Telephony_CallRequestProcess_002
715  * @tc.name     test error branch
716  * @tc.desc     Function test
717  */
718 HWTEST_F(CallStateTest, Telephony_CallRequestProcess_002, Function | MediumTest | Level3)
719 {
720     std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
721     DialParaInfo mDialParaInfo;
722     mDialParaInfo.accountId = 0;
723     sptr<OHOS::Telephony::CallBase> callBase1 = new IMSCall(mDialParaInfo);
724     callBase1->IsMuted();
725     callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
726     callBase1->callId_ = 1;
727     mDialParaInfo.accountId = 1;
728     sptr<OHOS::Telephony::CallBase> callBase2 = new IMSCall(mDialParaInfo);
729     callBase2->callState_ = TelCallState::CALL_STATUS_INCOMING;
730     callBase2->callId_ = 2;
731     bool enabled = false;
732     callRequestProcess->HandleCallWaitingNumZero(callBase2, callBase1, 1, 1, enabled);
733     mDialParaInfo.accountId = 0;
734     sptr<OHOS::Telephony::CallBase> callBase5 = new IMSCall(mDialParaInfo);
735     callBase5->callState_ = TelCallState::CALL_STATUS_HOLDING;
736     callBase5->callId_ = 1;
737     mDialParaInfo.accountId = 1;
738     sptr<OHOS::Telephony::CallBase> callBase6 = new IMSCall(mDialParaInfo);
739     callBase6->callState_ = TelCallState::CALL_STATUS_ACTIVE;
740     callBase6->callId_ = 2;
741     sptr<OHOS::Telephony::CallBase> callBase7 = new IMSCall(mDialParaInfo);
742     callBase7->callState_ = TelCallState::CALL_STATUS_INCOMING;
743     callBase7->callId_ = 3;
744     bool enabled1 = false;
745     callRequestProcess->HandleCallWaitingNumOne(callBase7, callBase5, 1, 1, enabled1);
746     mDialParaInfo.accountId = 0;
747     sptr<OHOS::Telephony::CallBase> callBase8 = new IMSCall(mDialParaInfo);
748     callBase8->callState_ = TelCallState::CALL_STATUS_HOLDING;
749     callBase8->callId_ = 1;
750     sptr<OHOS::Telephony::CallBase> callBase9 = new IMSCall(mDialParaInfo);
751     callBase9->callState_ = TelCallState::CALL_STATUS_WAITING;
752     callBase9->callId_ = 2;
753     mDialParaInfo.accountId = 1;
754     sptr<OHOS::Telephony::CallBase> callBase10 = new IMSCall(mDialParaInfo);
755     callBase10->callState_ = TelCallState::CALL_STATUS_ACTIVE;
756     callBase10->callId_ = 3;
757     sptr<OHOS::Telephony::CallBase> callBase11 = new IMSCall(mDialParaInfo);
758     callBase11->callState_ = TelCallState::CALL_STATUS_WAITING;
759     callBase11->callId_ = 4;
760     sptr<OHOS::Telephony::CallBase> callBase12 = new IMSCall(mDialParaInfo);
761     callBase12->callState_ = TelCallState::CALL_STATUS_INCOMING;
762     callBase12->callId_ = 5;
763     bool enabled2 = false;
764     callRequestProcess->HandleCallWaitingNumTwo(callBase12, callBase8, 1, 1, enabled2);
765     ASSERT_NE(callBase12, nullptr);
766 }
767 
768 /**
769  * @tc.number   Telephony_CallRequestProcess_003
770  * @tc.name     test error branch
771  * @tc.desc     Function test
772  */
773 HWTEST_F(CallStateTest, Telephony_CallRequestProcess_003, Function | MediumTest | Level3)
774 {
775     int32_t defaultCallId = 1;
776     std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
777     DialParaInfo mDialParaInfo;
778     mDialParaInfo.accountId = 0;
779     sptr<OHOS::Telephony::CallBase> callBase1 = new IMSCall(mDialParaInfo);
780     callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
781     callBase1->callId_ = 1;
782     mDialParaInfo.accountId = 1;
783     sptr<OHOS::Telephony::CallBase> callBase2 = new IMSCall(mDialParaInfo);
784     callBase2->callState_ = TelCallState::CALL_STATUS_ACTIVE;
785     callBase2->callId_ = 2;
786     sptr<OHOS::Telephony::CallBase> callBase3 = new IMSCall(mDialParaInfo);
787     callBase3->callState_ = TelCallState::CALL_STATUS_INCOMING;
788     callBase3->callId_ = 3;
789     bool enabled = false;
790     callRequestProcess->HandleCallWaitingNumOneNext(callBase3, callBase2, callBase1, 1, enabled);
791     callRequestProcess->HasActiveCall();
792     callRequestProcess->HasDialingCall();
793     callRequestProcess->NeedAnswerVTAndEndActiveVO(defaultCallId, 0);
794     ASSERT_FALSE(callRequestProcess->NeedAnswerVOAndEndActiveVT(defaultCallId, 0));
795 }
796 
797 /**
798  * @tc.number   Telephony_CallRequestProcess_004
799  * @tc.name     test error branch
800  * @tc.desc     Function test
801  */
802 HWTEST_F(CallStateTest, Telephony_CallRequestProcess_004, Function | MediumTest | Level3)
803 {
804     int32_t defaultCallId = 1;
805     std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
806     DialParaInfo mDialParaInfo;
807     mDialParaInfo.accountId = 0;
808     sptr<OHOS::Telephony::CallBase> call1 = new IMSCall(mDialParaInfo);
809     sptr<OHOS::Telephony::CallBase> call2 = new IMSCall(mDialParaInfo);
810     sptr<OHOS::Telephony::CallBase> call3 = new IMSCall(mDialParaInfo);
811     callRequestProcess->AddOneCallObject(call1);
812     callRequestProcess->AddOneCallObject(call2);
813     callRequestProcess->AddOneCallObject(call3);
814     sptr<OHOS::Telephony::CallBase> callBase = new IMSCall(mDialParaInfo);
815     callRequestProcess->AnswerRequestForDsda(callBase, 1, 0);
816     sptr<OHOS::Telephony::CallBase> callBase1 = new IMSCall(mDialParaInfo);
817     sptr<OHOS::Telephony::CallBase> incomingCall = new IMSCall(mDialParaInfo);
818     callRequestProcess->HandleDsdaIncomingCall(callBase1, 0, DEFAULT_SLOT_ID, 0, incomingCall);
819     sptr<OHOS::Telephony::CallBase> callBase2 = new IMSCall(mDialParaInfo);
820     callRequestProcess->HangUpForDsdaRequest(callBase2);
821     CellularCallInfo callInfo;
822     callRequestProcess->HandleStartDial(false, callInfo);
823     ASSERT_EQ(callRequestProcess->EccDialPolicy(), TELEPHONY_SUCCESS);
824 }
825 
826 /**
827  * @tc.number   Telephony_VoipCallConnection_001
828  * @tc.name     test error nullptr branch with permission
829  * @tc.desc     Function test
830  */
831 HWTEST_F(CallStateTest, Telephony_VoipCallConnection_001, Function | MediumTest | Level3)
832 {
833     std::shared_ptr<VoipCallConnection> voipCallConnection = std::make_shared<VoipCallConnection>();
834     int32_t systemAbilityId = 1;
835     voipCallConnection->Init(systemAbilityId);
836     voipCallConnection->UnInit();
837     voipCallConnection->GetCallManagerProxy();
838     VoipCallEventInfo voipCallEventInfo;
839     voipCallEventInfo.voipCallId = "123";
840     voipCallConnection->AnswerCall(voipCallEventInfo, static_cast<int32_t>(VideoStateType::TYPE_VOICE));
841     voipCallConnection->HangUpCall(voipCallEventInfo);
842     voipCallConnection->RejectCall(voipCallEventInfo);
843     sptr<ICallStatusCallback> callStatusCallback = nullptr;
844     voipCallConnection->RegisterCallManagerCallBack(callStatusCallback);
845     voipCallConnection->ClearVoipCall();
846     ASSERT_NE(voipCallConnection->UnRegisterCallManagerCallBack(), TELEPHONY_SUCCESS);
847 }
848 
849 /**
850  * @tc.number   Telephony_CallStateProcessor_001
851  * @tc.name     test error nullptr branch with permission
852  * @tc.desc     Function test
853  */
854 HWTEST_F(CallStateTest, Telephony_CallStateProcessor_001, Function | MediumTest | Level3)
855 {
856     auto callStateProcessor = DelayedSingleton<CallStateProcessor>::GetInstance();
857     TelCallState state = TelCallState::CALL_STATUS_ACTIVE;
858     callStateProcessor->AddCall(1, state);
859     bool result = callStateProcessor->UpdateCurrentCallState();
860     callStateProcessor->ShouldStopSoundtone();
861     callStateProcessor->GetCurrentActiveCall();
862     callStateProcessor->GetCallNumber(state);
863     callStateProcessor->ShouldSwitchState(state);
864     callStateProcessor->GetAudioForegroundLiveCall();
865     ASSERT_EQ(result, false);
866 }
867 
868 /**
869  * @tc.number   Telephony_CoreServiceConnection_001
870  * @tc.name     test error nullptr branch with permission
871  * @tc.desc     Function test
872  */
873 HWTEST_F(CallStateTest, Telephony_CoreServiceConnection_001, Function | MediumTest | Level3)
874 {
875     CoreServiceConnection coreServiceConnection;
876     coreServiceConnection.GetFdnNumberList(DEFAULT_SLOT_ID);
877     bool res = coreServiceConnection.IsFdnEnabled(DEFAULT_SLOT_ID);
878     ASSERT_FALSE(res);
879 }
880 
881 } // namespace Telephony
882 } // namespace OHOS
883