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