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->SetAudioDeviceChangeCallback();
264 audioProxy->UnsetDeviceChangeCallback();
265
266 audioProxy->SetBluetoothDevActive();
267 audioProxy->SetBluetoothDevActive();
268 audioProxy->SetSpeakerDevActive(true);
269 audioProxy->SetSpeakerDevActive(true);
270 audioProxy->SetWiredHeadsetState(true);
271 ASSERT_FALSE(audioProxy->SetEarpieceDevActive());
272 audioProxy->SetWiredHeadsetState(false);
273 audioProxy->SetEarpieceDevActive();
274 audioProxy->SetEarpieceDevActive();
275 ASSERT_FALSE(audioProxy->SetWiredHeadsetDevActive());
276 audioProxy->SetWiredHeadsetState(true);
277 audioProxy->SetWiredHeadsetDevActive();
278 audioProxy->SetSpeakerDevActive(true);
279 audioProxy->SetWiredHeadsetDevActive();
280 audioProxy->SetEarpieceDevActive();
281 audioProxy->SetWiredHeadsetDevActive();
282 audioProxy->SetBluetoothDevActive();
283 audioProxy->SetWiredHeadsetDevActive();
284
285 int32_t volume = audioProxy->GetVolume(AudioStandard::AudioStreamType::STREAM_VOICE_CALL);
286 audioProxy->SetMaxVolume(AudioStandard::AudioStreamType::STREAM_VOICE_CALL);
287 audioProxy->SetVolumeAudible();
288 audioProxy->SetVolume(AudioStandard::AudioStreamType::STREAM_VOICE_CALL, volume);
289 audioProxy->IsStreamActive(AudioStandard::AudioStreamType::STREAM_VOICE_CALL);
290 audioProxy->IsStreamMute(AudioStandard::AudioStreamType::STREAM_VOICE_CALL);
291 audioProxy->GetMaxVolume(AudioStandard::AudioStreamType::STREAM_VOICE_CALL);
292 audioProxy->GetMinVolume(AudioStandard::AudioStreamType::STREAM_VOICE_CALL);
293 bool isMute = audioProxy->IsMicrophoneMute();
294 audioProxy->SetMicrophoneMute(!isMute);
295 audioProxy->SetMicrophoneMute(isMute);
296 ASSERT_TRUE(audioProxy->SetMicrophoneMute(isMute));
297 }
298
299 /**
300 * @tc.number Telephony_AudioProxy_002
301 * @tc.name test error branch
302 * @tc.desc Function test
303 */
304 HWTEST_F(CallStateTest, Telephony_AudioProxy_002, Function | MediumTest | Level3)
305 {
306 auto audioProxy = std::make_shared<AudioProxy>();
307 audioProxy->GetRingerMode();
308 AudioDevice device;
309 audioProxy->GetPreferredOutputAudioDevice(device);
310 audioProxy->SetAudioPreferDeviceChangeCallback();
311 audioProxy->UnsetAudioPreferDeviceChangeCallback();
312 ASSERT_FALSE(audioProxy->GetDefaultTonePath().empty());
313 ASSERT_FALSE(audioProxy->GetDefaultDtmfPath().empty());
314 }
315
316 /**
317 * @tc.number Telephony_AudioDeviceManager_001
318 * @tc.name test error branch
319 * @tc.desc Function test
320 */
321 HWTEST_F(CallStateTest, Telephony_AudioDeviceManager_001, Function | MediumTest | Level3)
322 {
323 auto audioDeviceManager = DelayedSingleton<AudioDeviceManager>::GetInstance();
324 audioDeviceManager->AddAudioDeviceList(NAME, AudioDeviceType::DEVICE_SPEAKER, NAME);
325 audioDeviceManager->AddAudioDeviceList(NAME, AudioDeviceType::DEVICE_WIRED_HEADSET, NAME);
326 audioDeviceManager->AddAudioDeviceList(NAME, AudioDeviceType::DEVICE_BLUETOOTH_SCO, NAME);
327 audioDeviceManager->RemoveAudioDeviceList(NAME, AudioDeviceType::DEVICE_WIRED_HEADSET);
328 audioDeviceManager->RemoveAudioDeviceList(NAME, AudioDeviceType::DEVICE_BLUETOOTH_SCO);
329 audioDeviceManager->ResetBtAudioDevicesList();
330 audioDeviceManager->ResetDistributedCallDevicesList();
331 audioDeviceManager->ProcessEvent(AudioEvent::WIRED_HEADSET_DISCONNECTED);
332 audioDeviceManager->SwitchDevice(AUDIO_DEACTIVATED);
333 audioDeviceManager->EnableBtSco();
334 audioDeviceManager->GetCurrentAudioDevice();
335 audioDeviceManager->IsEarpieceDevEnable();
336 audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_SPEAKER, false);
337 audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_EARPIECE, false);
338 audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_BLUETOOTH_SCO, false);
339 audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_WIRED_HEADSET, false);
340 audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_DISTRIBUTED_AUTOMOTIVE, false);
341 audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_DISTRIBUTED_PHONE, false);
342 audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_UNKNOWN, false);
343 ASSERT_FALSE(audioDeviceManager->IsWiredHeadsetDevEnable());
344 }
345
346 /**
347 * @tc.number Telephony_AudioDeviceManager_002
348 * @tc.name test error branch
349 * @tc.desc Function test
350 */
351 HWTEST_F(CallStateTest, Telephony_AudioDeviceManager_002, Function | MediumTest | Level3)
352 {
353 auto audioDeviceManager = DelayedSingleton<AudioDeviceManager>::GetInstance();
354 audioDeviceManager->AddAudioDeviceList(NAME, AudioDeviceType::DEVICE_SPEAKER, NAME);
355 audioDeviceManager->AddAudioDeviceList(NAME, AudioDeviceType::DEVICE_WIRED_HEADSET, NAME);
356 audioDeviceManager->AddAudioDeviceList(NAME, AudioDeviceType::DEVICE_BLUETOOTH_SCO, NAME);
357 audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_EARPIECE);
358 audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_SPEAKER);
359 audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_WIRED_HEADSET);
360 audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_BLUETOOTH_SCO);
361 audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_DISABLE);
362 audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_UNKNOWN);
363 audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_DISTRIBUTED_AUTOMOTIVE);
364 audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_DISTRIBUTED_PHONE);
365 audioDeviceManager->SwitchDevice(AudioDeviceType::DEVICE_DISTRIBUTED_PAD);
366 audioDeviceManager->isWiredHeadsetConnected_ = true;
367 audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_WIRED_HEADSET, true);
368 audioDeviceManager->EnableWiredHeadset();
369 audioDeviceManager->SetDeviceAvailable(AudioDeviceType::DEVICE_DISTRIBUTED_PAD, true);
370 audioDeviceManager->IsBtScoDevEnable();
371 audioDeviceManager->IsDCallDevEnable();
372 audioDeviceManager->IsSpeakerDevEnable();
373 ASSERT_FALSE(audioDeviceManager->IsSpeakerAvailable());
374 }
375
376 /**
377 * @tc.number Telephony_AudioPlayer_001
378 * @tc.name test error branch
379 * @tc.desc Function test
380 */
381 HWTEST_F(CallStateTest, Telephony_AudioPlayer_001, Function | MediumTest | Level3)
382 {
383 auto audioPlayer = DelayedSingleton<AudioPlayer>::GetInstance();
384 std::string profilePath = "";
385 std::string path = "";
386 audioPlayer->GetRealPath(profilePath, path);
387 ASSERT_FALSE(audioPlayer->IsStop(TYPE_RING));
388 ASSERT_FALSE(audioPlayer->IsStop(TYPE_TONE));
389 ASSERT_FALSE(audioPlayer->IsStop(TYPE_DTMF));
390 ASSERT_FALSE(audioPlayer->IsStop(TYPE_SOUND));
391 }
392
393 /**
394 * @tc.number Telephony_AudioSceneProcessor_001
395 * @tc.name test error branch
396 * @tc.desc Function test
397 */
398 HWTEST_F(CallStateTest, Telephony_AudioSceneProcessor_001, Function | MediumTest | Level3)
399 {
400 auto audioSceneProcessor = DelayedSingleton<AudioSceneProcessor>::GetInstance();
401 audioSceneProcessor->SwitchState(CallStateType::DIALING_STATE);
402 audioSceneProcessor->SwitchState(CallStateType::ALERTING_STATE);
403 audioSceneProcessor->SwitchState(CallStateType::INCOMING_STATE);
404 audioSceneProcessor->SwitchState(CallStateType::CS_CALL_STATE);
405 audioSceneProcessor->SwitchState(CallStateType::IMS_CALL_STATE);
406 audioSceneProcessor->SwitchState(CallStateType::HOLDING_STATE);
407 audioSceneProcessor->SwitchState(CallStateType::UNKNOWN_STATE);
408 audioSceneProcessor->SwitchState(CallStateType::INACTIVE_STATE);
409 ASSERT_TRUE(audioSceneProcessor->SwitchIncoming());
410 }
411
412 /**
413 * @tc.number Telephony_Ring_001
414 * @tc.name test error branch
415 * @tc.desc Function test
416 */
417 HWTEST_F(CallStateTest, Telephony_Ring_001, Function | MediumTest | Level3)
418 {
419 auto ring = std::make_shared<Ring>();
420 ring->Play(DEFAULT_SLOT_ID, "");
421 sleep(WAIT_TIME);
422 ring->Stop();
423 ring->ReleaseRenderer();
424 ring->Play(DEFAULT_SLOT_ID, "");
425 sleep(WAIT_TIME);
426 ASSERT_NE(ring->Stop(), TELEPHONY_ERR_LOCAL_PTR_NULL);
427 }
428
429 /**
430 * @tc.number Telephony_Tone_001
431 * @tc.name test error branch
432 * @tc.desc Function test
433 */
434 HWTEST_F(CallStateTest, Telephony_Tone_001, Function | MediumTest | Level3)
435 {
436 auto unknownTone = std::make_shared<Tone>(ToneDescriptor::TONE_UNKNOWN);
437 unknownTone->Init();
438 unknownTone->Play();
439 sleep(WAIT_TIME);
440 unknownTone->Stop();
441 unknownTone->ReleaseRenderer();
442
443 auto ringbackTone = std::make_shared<Tone>(ToneDescriptor::TONE_RINGBACK);
444 ringbackTone->Play();
445 sleep(WAIT_TIME);
446 ringbackTone->Stop();
447
448 auto tone = std::make_shared<Tone>(ToneDescriptor::TONE_DTMF_CHAR_1);
449 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_0));
450 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_1));
451 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_2));
452 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_3));
453 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_4));
454 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_5));
455 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_6));
456 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_7));
457 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_8));
458 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_9));
459 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_P));
460 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_DTMF_CHAR_W));
461 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_RINGBACK));
462 ASSERT_TRUE(tone->IsUseTonePlayer(ToneDescriptor::TONE_WAITING));
463 }
464
465 /**
466 * @tc.number Telephony_Tone_002
467 * @tc.name test error branch
468 * @tc.desc Function test
469 */
470 HWTEST_F(CallStateTest, Telephony_Tone_002, Function | MediumTest | Level3)
471 {
472 ASSERT_EQ(Tone::ConvertDigitToTone('0'), ToneDescriptor::TONE_DTMF_CHAR_0);
473 ASSERT_EQ(Tone::ConvertDigitToTone('1'), ToneDescriptor::TONE_DTMF_CHAR_1);
474 ASSERT_EQ(Tone::ConvertDigitToTone('2'), ToneDescriptor::TONE_DTMF_CHAR_2);
475 ASSERT_EQ(Tone::ConvertDigitToTone('3'), ToneDescriptor::TONE_DTMF_CHAR_3);
476 ASSERT_EQ(Tone::ConvertDigitToTone('4'), ToneDescriptor::TONE_DTMF_CHAR_4);
477 ASSERT_EQ(Tone::ConvertDigitToTone('5'), ToneDescriptor::TONE_DTMF_CHAR_5);
478 ASSERT_EQ(Tone::ConvertDigitToTone('6'), ToneDescriptor::TONE_DTMF_CHAR_6);
479 ASSERT_EQ(Tone::ConvertDigitToTone('7'), ToneDescriptor::TONE_DTMF_CHAR_7);
480 ASSERT_EQ(Tone::ConvertDigitToTone('8'), ToneDescriptor::TONE_DTMF_CHAR_8);
481 ASSERT_EQ(Tone::ConvertDigitToTone('9'), ToneDescriptor::TONE_DTMF_CHAR_9);
482 ASSERT_EQ(Tone::ConvertDigitToTone('*'), ToneDescriptor::TONE_DTMF_CHAR_P);
483 ASSERT_EQ(Tone::ConvertDigitToTone('#'), ToneDescriptor::TONE_DTMF_CHAR_W);
484 ASSERT_EQ(Tone::ConvertDigitToTone('a'), ToneDescriptor::TONE_UNKNOWN);
485 }
486
487 /**
488 * @tc.number Telephony_Tone_003
489 * @tc.name test error branch
490 * @tc.desc Function test
491 */
492 HWTEST_F(CallStateTest, Telephony_Tone_003, Function | MediumTest | Level3)
493 {
494 auto tone = std::make_shared<Tone>();
495 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_0),
496 AudioStandard::ToneType::TONE_TYPE_DIAL_0);
497 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_1),
498 AudioStandard::ToneType::TONE_TYPE_DIAL_1);
499 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_2),
500 AudioStandard::ToneType::TONE_TYPE_DIAL_2);
501 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_3),
502 AudioStandard::ToneType::TONE_TYPE_DIAL_3);
503 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_4),
504 AudioStandard::ToneType::TONE_TYPE_DIAL_4);
505 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_5),
506 AudioStandard::ToneType::TONE_TYPE_DIAL_5);
507 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_6),
508 AudioStandard::ToneType::TONE_TYPE_DIAL_6);
509 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_7),
510 AudioStandard::ToneType::TONE_TYPE_DIAL_7);
511 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_8),
512 AudioStandard::ToneType::TONE_TYPE_DIAL_8);
513 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_9),
514 AudioStandard::ToneType::TONE_TYPE_DIAL_9);
515 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_P),
516 AudioStandard::ToneType::TONE_TYPE_DIAL_S);
517 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_DTMF_CHAR_W),
518 AudioStandard::ToneType::TONE_TYPE_DIAL_P);
519 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_RINGBACK),
520 AudioStandard::ToneType::TONE_TYPE_COMMON_SUPERVISORY_RINGTONE);
521 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_WAITING),
522 AudioStandard::ToneType::TONE_TYPE_COMMON_SUPERVISORY_CALL_WAITING);
523 ASSERT_EQ(tone->ConvertToneDescriptorToToneType(ToneDescriptor::TONE_UNKNOWN), AudioStandard::ToneType::NUM_TONES);
524 }
525
526 /**
527 * @tc.number Telephony_Tone_004
528 * @tc.name test error branch
529 * @tc.desc Function test
530 */
531 HWTEST_F(CallStateTest, Telephony_Tone_004, Function | MediumTest | Level3)
532 {
533 auto tone = std::make_shared<Tone>();
534 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_0),
535 AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
536 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_1),
537 AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
538 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_2),
539 AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
540 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_3),
541 AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
542 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_4),
543 AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
544 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_5),
545 AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
546 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_6),
547 AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
548 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_7),
549 AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
550 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_8),
551 AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
552 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_9),
553 AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
554 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_P),
555 AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
556 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_DTMF_CHAR_W),
557 AudioStandard::StreamUsage::STREAM_USAGE_DTMF);
558 ASSERT_EQ(tone->GetStreamUsageByToneType(ToneDescriptor::TONE_RINGBACK),
559 AudioStandard::StreamUsage::STREAM_USAGE_VOICE_MODEM_COMMUNICATION);
560 tone->GetStreamUsageByToneType(ToneDescriptor::TONE_WAITING);
561 }
562
563 /**
564 * @tc.number Telephony_CallStatusCallbackProxy_001
565 * @tc.name test error branch
566 * @tc.desc Function test
567 */
568 HWTEST_F(CallStateTest, Telephony_CallStatusCallbackProxy_001, Function | MediumTest | Level3)
569 {
570 auto callStatusCallbackProxy = std::make_shared<CallStatusCallbackProxy>(nullptr);
571 CallReportInfo callReportInfo;
572 callStatusCallbackProxy->UpdateCallReportInfo(callReportInfo);
573 CallsReportInfo callsReportInfo;
574 callStatusCallbackProxy->UpdateCallsReportInfo(callsReportInfo);
575 DisconnectedDetails details;
576 callStatusCallbackProxy->UpdateDisconnectedCause(details);
577 CellularCallEventInfo eventInfo;
578 callStatusCallbackProxy->UpdateEventResultInfo(eventInfo);
579 RBTPlayInfo playInfo = RBTPlayInfo::LOCAL_ALERTING;
580 callStatusCallbackProxy->UpdateRBTPlayInfo(playInfo);
581 CallWaitResponse callWaitResponse;
582 callStatusCallbackProxy->UpdateGetWaitingResult(callWaitResponse);
583 int32_t result = 0;
584 callStatusCallbackProxy->UpdateSetWaitingResult(result);
585 CallRestrictionResponse callRestrictionResult;
586 callStatusCallbackProxy->UpdateGetRestrictionResult(callRestrictionResult);
587 callStatusCallbackProxy->UpdateSetRestrictionResult(result);
588 callStatusCallbackProxy->UpdateSetRestrictionPasswordResult(result);
589 CallTransferResponse callTransferResponse;
590 callStatusCallbackProxy->UpdateGetTransferResult(callTransferResponse);
591 callStatusCallbackProxy->UpdateSetTransferResult(result);
592 ClipResponse clipResponse;
593 callStatusCallbackProxy->UpdateGetCallClipResult(clipResponse);
594 ClirResponse clirResponse;
595 callStatusCallbackProxy->UpdateGetCallClirResult(clirResponse);
596 callStatusCallbackProxy->UpdateSetCallClirResult(result);
597 callStatusCallbackProxy->StartRttResult(result);
598 callStatusCallbackProxy->StopRttResult(result);
599 GetImsConfigResponse imsConfigResponse;
600 callStatusCallbackProxy->GetImsConfigResult(imsConfigResponse);
601 callStatusCallbackProxy->SetImsConfigResult(result);
602 GetImsFeatureValueResponse imsFeatureValueResponse;
603 callStatusCallbackProxy->GetImsFeatureValueResult(imsFeatureValueResponse);
604 callStatusCallbackProxy->SetImsFeatureValueResult(result);
605 callStatusCallbackProxy->InviteToConferenceResult(result);
606 callStatusCallbackProxy->StartDtmfResult(result);
607 callStatusCallbackProxy->StopDtmfResult(result);
608 callStatusCallbackProxy->SendUssdResult(result);
609 MmiCodeInfo mmiCodeInfo;
610 ASSERT_EQ(callStatusCallbackProxy->SendMmiCodeResult(mmiCodeInfo), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
611 ASSERT_EQ(callStatusCallbackProxy->GetImsCallDataResult(result), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
612 ASSERT_EQ(callStatusCallbackProxy->CloseUnFinishedUssdResult(result), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
613 }
614
615 /**
616 * @tc.number Telephony_CallStatusCallbackProxy_002
617 * @tc.name test error branch
618 * @tc.desc Function test
619 */
620 HWTEST_F(CallStateTest, Telephony_CallStatusCallbackProxy_002, Function | MediumTest | Level3)
621 {
622 sptr<ISystemAbilityManager> systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
623 if (systemAbilityMgr == nullptr) {
624 TELEPHONY_LOGE("Telephony_CallStatusCallbackProxy systemAbilityMgr is nullptr");
625 return;
626 }
627 sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
628 if (remote == nullptr) {
629 TELEPHONY_LOGE("Telephony_CallStatusCallbackProxy remote is nullptr");
630 return;
631 }
632 auto callStatusCallbackProxy = std::make_shared<CallStatusCallbackProxy>(remote);
633
634 CallReportInfo callReportInfo;
635 callStatusCallbackProxy->UpdateCallReportInfo(callReportInfo);
636 CallsReportInfo callsReportInfo;
637 callStatusCallbackProxy->UpdateCallsReportInfo(callsReportInfo);
638 DisconnectedDetails details;
639 callStatusCallbackProxy->UpdateDisconnectedCause(details);
640 CellularCallEventInfo eventInfo;
641 callStatusCallbackProxy->UpdateEventResultInfo(eventInfo);
642 RBTPlayInfo playInfo = RBTPlayInfo::LOCAL_ALERTING;
643 callStatusCallbackProxy->UpdateRBTPlayInfo(playInfo);
644 CallWaitResponse callWaitResponse;
645 callStatusCallbackProxy->UpdateGetWaitingResult(callWaitResponse);
646 CallRestrictionResponse callRestrictionResult;
647 callStatusCallbackProxy->UpdateGetRestrictionResult(callRestrictionResult);
648 CallTransferResponse callTransferResponse;
649 callStatusCallbackProxy->UpdateGetTransferResult(callTransferResponse);
650 ClipResponse clipResponse;
651 ASSERT_EQ(callStatusCallbackProxy->UpdateGetCallClipResult(clipResponse), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
652 ClirResponse clirResponse;
653 ASSERT_EQ(callStatusCallbackProxy->UpdateGetCallClirResult(clirResponse), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
654 }
655
656 /**
657 * @tc.number Telephony_CallStatusCallbackProxy_003
658 * @tc.name test error branch
659 * @tc.desc Function test
660 */
661 HWTEST_F(CallStateTest, Telephony_CallStatusCallbackProxy_003, Function | MediumTest | Level3)
662 {
663 sptr<ISystemAbilityManager> systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
664 if (systemAbilityMgr == nullptr) {
665 TELEPHONY_LOGE("Telephony_CallStatusCallbackProxy systemAbilityMgr is nullptr");
666 return;
667 }
668 sptr<IRemoteObject> remote = systemAbilityMgr->CheckSystemAbility(TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID);
669 if (remote == nullptr) {
670 TELEPHONY_LOGE("Telephony_CallStatusCallbackProxy remote is nullptr");
671 return;
672 }
673 auto callStatusCallbackProxy = std::make_shared<CallStatusCallbackProxy>(remote);
674
675 int32_t result = 0;
676 callStatusCallbackProxy->UpdateSetWaitingResult(result);
677 callStatusCallbackProxy->UpdateSetRestrictionResult(result);
678 callStatusCallbackProxy->UpdateSetRestrictionPasswordResult(result);
679 callStatusCallbackProxy->UpdateSetTransferResult(result);
680 callStatusCallbackProxy->UpdateSetCallClirResult(result);
681 callStatusCallbackProxy->StartRttResult(result);
682 callStatusCallbackProxy->StopRttResult(result);
683 GetImsConfigResponse imsConfigResponse;
684 callStatusCallbackProxy->GetImsConfigResult(imsConfigResponse);
685 callStatusCallbackProxy->SetImsConfigResult(result);
686 GetImsFeatureValueResponse imsFeatureValueResponse;
687 callStatusCallbackProxy->GetImsFeatureValueResult(imsFeatureValueResponse);
688 callStatusCallbackProxy->SetImsFeatureValueResult(result);
689 callStatusCallbackProxy->InviteToConferenceResult(result);
690 callStatusCallbackProxy->StartDtmfResult(result);
691 callStatusCallbackProxy->StopDtmfResult(result);
692 callStatusCallbackProxy->SendUssdResult(result);
693 MmiCodeInfo mmiCodeInfo;
694 CallModeReportInfo callModeRequestInfo;
695 callStatusCallbackProxy->ReceiveUpdateCallMediaModeRequest(callModeRequestInfo);
696 CallModeReportInfo callModeResponseInfo;
697 callStatusCallbackProxy->ReceiveUpdateCallMediaModeResponse(callModeResponseInfo);
698 CallSessionReportInfo sessionReportInfo;
699 callStatusCallbackProxy->HandleCallSessionEventChanged(sessionReportInfo);
700 PeerDimensionsReportInfo peerDimensionsReportInfo;
701 callStatusCallbackProxy->HandlePeerDimensionsChanged(peerDimensionsReportInfo);
702 callStatusCallbackProxy->HandleCallDataUsageChanged(static_cast<int64_t>(result));
703 CameraCapabilitiesReportInfo cameraCapabilitiesInfo;
704 callStatusCallbackProxy->HandleCameraCapabilitiesChanged(cameraCapabilitiesInfo);
705 ASSERT_EQ(callStatusCallbackProxy->SendMmiCodeResult(mmiCodeInfo), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
706 ASSERT_EQ(callStatusCallbackProxy->GetImsCallDataResult(result), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
707 ASSERT_EQ(callStatusCallbackProxy->CloseUnFinishedUssdResult(result), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
708 }
709
710 /**
711 * @tc.number Telephony_CallRequestProcess_002
712 * @tc.name test error branch
713 * @tc.desc Function test
714 */
715 HWTEST_F(CallStateTest, Telephony_CallRequestProcess_002, Function | MediumTest | Level3)
716 {
717 std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
718 DialParaInfo mDialParaInfo;
719 mDialParaInfo.accountId = 0;
720 sptr<OHOS::Telephony::CallBase> callBase1 = new IMSCall(mDialParaInfo);
721 callBase1->IsMuted();
722 callBase1->callState_ = TelCallState::CALL_STATUS_ACTIVE;
723 callBase1->callId_ = 1;
724 mDialParaInfo.accountId = 1;
725 sptr<OHOS::Telephony::CallBase> callBase2 = new IMSCall(mDialParaInfo);
726 callBase2->callState_ = TelCallState::CALL_STATUS_INCOMING;
727 callBase2->callId_ = 2;
728 bool enabled = false;
729 callRequestProcess->HandleCallWaitingNumZero(callBase2, callBase1, 1, 1, enabled);
730 mDialParaInfo.accountId = 0;
731 sptr<OHOS::Telephony::CallBase> callBase5 = new IMSCall(mDialParaInfo);
732 callBase5->callState_ = TelCallState::CALL_STATUS_HOLDING;
733 callBase5->callId_ = 1;
734 mDialParaInfo.accountId = 1;
735 sptr<OHOS::Telephony::CallBase> callBase6 = new IMSCall(mDialParaInfo);
736 callBase6->callState_ = TelCallState::CALL_STATUS_ACTIVE;
737 callBase6->callId_ = 2;
738 sptr<OHOS::Telephony::CallBase> callBase7 = new IMSCall(mDialParaInfo);
739 callBase7->callState_ = TelCallState::CALL_STATUS_INCOMING;
740 callBase7->callId_ = 3;
741 bool enabled1 = false;
742 callRequestProcess->HandleCallWaitingNumOne(callBase7, callBase5, 1, 1, enabled1);
743 mDialParaInfo.accountId = 0;
744 sptr<OHOS::Telephony::CallBase> callBase8 = new IMSCall(mDialParaInfo);
745 callBase8->callState_ = TelCallState::CALL_STATUS_HOLDING;
746 callBase8->callId_ = 1;
747 sptr<OHOS::Telephony::CallBase> callBase9 = new IMSCall(mDialParaInfo);
748 callBase9->callState_ = TelCallState::CALL_STATUS_WAITING;
749 callBase9->callId_ = 2;
750 mDialParaInfo.accountId = 1;
751 sptr<OHOS::Telephony::CallBase> callBase10 = new IMSCall(mDialParaInfo);
752 callBase10->callState_ = TelCallState::CALL_STATUS_ACTIVE;
753 callBase10->callId_ = 3;
754 sptr<OHOS::Telephony::CallBase> callBase11 = new IMSCall(mDialParaInfo);
755 callBase11->callState_ = TelCallState::CALL_STATUS_WAITING;
756 callBase11->callId_ = 4;
757 sptr<OHOS::Telephony::CallBase> callBase12 = new IMSCall(mDialParaInfo);
758 callBase12->callState_ = TelCallState::CALL_STATUS_INCOMING;
759 callBase12->callId_ = 5;
760 bool enabled2 = false;
761 callRequestProcess->HandleCallWaitingNumTwo(callBase12, callBase8, 1, 1, enabled2);
762 ASSERT_NE(callBase12, nullptr);
763 }
764
765 /**
766 * @tc.number Telephony_CallRequestProcess_003
767 * @tc.name test error branch
768 * @tc.desc Function test
769 */
770 HWTEST_F(CallStateTest, Telephony_CallRequestProcess_003, Function | MediumTest | Level3)
771 {
772 int32_t defaultCallId = 1;
773 std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
774 DialParaInfo mDialParaInfo;
775 mDialParaInfo.accountId = 0;
776 sptr<OHOS::Telephony::CallBase> callBase1 = new IMSCall(mDialParaInfo);
777 callBase1->callState_ = TelCallState::CALL_STATUS_HOLDING;
778 callBase1->callId_ = 1;
779 callBase1->callRunningState_ = CallRunningState::CALL_RUNNING_STATE_HOLD;
780 callBase1->videoState_ = VideoStateType::TYPE_SEND_ONLY;
781 mDialParaInfo.accountId = 1;
782 sptr<OHOS::Telephony::CallBase> callBase2 = new IMSCall(mDialParaInfo);
783 callBase2->callState_ = TelCallState::CALL_STATUS_ACTIVE;
784 callBase2->callId_ = 2;
785 callBase2->callRunningState_ = CallRunningState::CALL_RUNNING_STATE_ACTIVE;
786 callBase2->videoState_ = VideoStateType::TYPE_SEND_ONLY;
787 sptr<OHOS::Telephony::CallBase> callBase3 = new IMSCall(mDialParaInfo);
788 callBase3->callState_ = TelCallState::CALL_STATUS_INCOMING;
789 callBase3->callId_ = 3;
790 callRequestProcess->AddOneCallObject(callBase1);
791 callRequestProcess->AddOneCallObject(callBase2);
792 callRequestProcess->AddOneCallObject(callBase3);
793 bool enabled = false;
794 callRequestProcess->HandleCallWaitingNumOneNext(callBase3, callBase2, callBase1, 1, enabled);
795 ASSERT_FALSE(callRequestProcess->HasConnectingCall(false));
796 ASSERT_TRUE(callRequestProcess->HasActivedCall(false));
797 ASSERT_TRUE(callRequestProcess->NeedAnswerVTAndEndActiveVO(3, 1));
798 ASSERT_TRUE(callRequestProcess->NeedAnswerVOAndEndActiveVT(defaultCallId, 0));
799 }
800
801 /**
802 * @tc.number Telephony_CallRequestProcess_004
803 * @tc.name test error branch
804 * @tc.desc Function test
805 */
806 HWTEST_F(CallStateTest, Telephony_CallRequestProcess_004, Function | MediumTest | Level3)
807 {
808 int32_t defaultCallId = 1;
809 std::unique_ptr<CallRequestProcess> callRequestProcess = std::make_unique<CallRequestProcess>();
810 DialParaInfo mDialParaInfo;
811 mDialParaInfo.accountId = 0;
812 sptr<OHOS::Telephony::CallBase> call1 = new IMSCall(mDialParaInfo);
813 sptr<OHOS::Telephony::CallBase> call2 = new IMSCall(mDialParaInfo);
814 sptr<OHOS::Telephony::CallBase> call3 = new IMSCall(mDialParaInfo);
815 callRequestProcess->AddOneCallObject(call1);
816 callRequestProcess->AddOneCallObject(call2);
817 callRequestProcess->AddOneCallObject(call3);
818 sptr<OHOS::Telephony::CallBase> callBase = new IMSCall(mDialParaInfo);
819 callRequestProcess->AnswerRequestForDsda(callBase, 1, 0);
820 sptr<OHOS::Telephony::CallBase> callBase1 = new IMSCall(mDialParaInfo);
821 sptr<OHOS::Telephony::CallBase> incomingCall = new IMSCall(mDialParaInfo);
822 callRequestProcess->HandleDsdaIncomingCall(callBase1, 0, DEFAULT_SLOT_ID, 0, incomingCall);
823 sptr<OHOS::Telephony::CallBase> callBase2 = new IMSCall(mDialParaInfo);
824 callRequestProcess->HangUpForDsdaRequest(callBase2);
825 CellularCallInfo callInfo;
826 callRequestProcess->HandleStartDial(false, mDialParaInfo);
827 ASSERT_EQ(callRequestProcess->EccDialPolicy(), TELEPHONY_SUCCESS);
828 }
829
830 /**
831 * @tc.number Telephony_VoipCallConnection_001
832 * @tc.name test error nullptr branch with permission
833 * @tc.desc Function test
834 */
835 HWTEST_F(CallStateTest, Telephony_VoipCallConnection_001, Function | MediumTest | Level3)
836 {
837 std::shared_ptr<VoipCallConnection> voipCallConnection = std::make_shared<VoipCallConnection>();
838 int32_t systemAbilityId = 1;
839 voipCallConnection->Init(systemAbilityId);
840 voipCallConnection->UnInit();
841 voipCallConnection->GetCallManagerProxy();
842 VoipCallEventInfo voipCallEventInfo;
843 voipCallEventInfo.voipCallId = "123";
844 voipCallConnection->AnswerCall(voipCallEventInfo, static_cast<int32_t>(VideoStateType::TYPE_VOICE));
845 voipCallConnection->HangUpCall(voipCallEventInfo);
846 voipCallConnection->RejectCall(voipCallEventInfo);
847 sptr<ICallStatusCallback> callStatusCallback = nullptr;
848 voipCallConnection->RegisterCallManagerCallBack(callStatusCallback);
849 voipCallConnection->ClearVoipCall();
850 ASSERT_NE(voipCallConnection->UnRegisterCallManagerCallBack(), TELEPHONY_SUCCESS);
851 }
852
853 /**
854 * @tc.number Telephony_CallStateProcessor_001
855 * @tc.name test error nullptr branch with permission
856 * @tc.desc Function test
857 */
858 HWTEST_F(CallStateTest, Telephony_CallStateProcessor_001, Function | MediumTest | Level3)
859 {
860 auto callStateProcessor = DelayedSingleton<CallStateProcessor>::GetInstance();
861 TelCallState state = TelCallState::CALL_STATUS_ACTIVE;
862 callStateProcessor->AddCall(1, state);
863 bool result = callStateProcessor->UpdateCurrentCallState();
864 callStateProcessor->ShouldStopSoundtone();
865 callStateProcessor->GetCurrentActiveCall();
866 callStateProcessor->GetCallNumber(state);
867 callStateProcessor->ShouldSwitchState(state);
868 callStateProcessor->GetAudioForegroundLiveCall();
869 ASSERT_EQ(result, false);
870 }
871
872 /**
873 * @tc.number Telephony_CoreServiceConnection_001
874 * @tc.name test error nullptr branch with permission
875 * @tc.desc Function test
876 */
877 HWTEST_F(CallStateTest, Telephony_CoreServiceConnection_001, Function | MediumTest | Level3)
878 {
879 CoreServiceConnection coreServiceConnection;
880 coreServiceConnection.GetFdnNumberList(DEFAULT_SLOT_ID);
881 bool res = coreServiceConnection.IsFdnEnabled(DEFAULT_SLOT_ID);
882 ASSERT_FALSE(res);
883 }
884
885 } // namespace Telephony
886 } // namespace OHOS
887