1 /*
2 * Copyright (c) 2025 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
16 #include <iostream>
17 #include <cstddef>
18 #include <cstdint>
19 #include <cstring>
20 #include "audio_info.h"
21 #include "audio_policy_server.h"
22 #include "audio_policy_service.h"
23 #include "audio_device_info.h"
24 #include "audio_utils.h"
25 #include "accesstoken_kit.h"
26 #include "nativetoken_kit.h"
27 #include "token_setproc.h"
28 #include "access_token.h"
29 #include "audio_channel_blend.h"
30 #include "volume_ramp.h"
31 #include "audio_speed.h"
32
33 #include "audio_policy_utils.h"
34 #include "audio_stream_descriptor.h"
35 #include "audio_limiter_manager.h"
36 #include "dfx_msg_manager.h"
37
38 #include "audio_source_clock.h"
39 #include "capturer_clock_manager.h"
40 #include "hpae_policy_manager.h"
41 #include "audio_policy_state_monitor.h"
42 #include "audio_device_info.h"
43 #include "audio_effect_volume.h"
44
45 namespace OHOS {
46 namespace AudioStandard {
47 using namespace std;
48
49 static const uint8_t* RAW_DATA = nullptr;
50 static size_t g_dataSize = 0;
51 static size_t g_pos;
52 const size_t THRESHOLD = 10;
53 const uint8_t TESTSIZE = 65;
54 static int32_t NUM_2 = 2;
55 const int32_t SESSIONID = 12345;
56
57 typedef void (*TestFuncs)();
58
59 template<class T>
GetData()60 T GetData()
61 {
62 T object {};
63 size_t objectSize = sizeof(object);
64 if (g_dataSize < g_pos) {
65 return object;
66 }
67 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
68 return object;
69 }
70 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
71 if (ret != EOK) {
72 return {};
73 }
74 g_pos += objectSize;
75 return object;
76 }
77
78 template<class T>
GetArrLength(T & arr)79 uint32_t GetArrLength(T& arr)
80 {
81 if (arr == nullptr) {
82 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
83 return 0;
84 }
85 return sizeof(arr) / sizeof(arr[0]);
86 }
87
88 vector<DeviceType> DeviceTypeVec = {
89 DEVICE_TYPE_NONE,
90 DEVICE_TYPE_INVALID,
91 DEVICE_TYPE_EARPIECE,
92 DEVICE_TYPE_SPEAKER,
93 DEVICE_TYPE_WIRED_HEADSET,
94 DEVICE_TYPE_WIRED_HEADPHONES,
95 DEVICE_TYPE_BLUETOOTH_SCO,
96 DEVICE_TYPE_BLUETOOTH_A2DP,
97 DEVICE_TYPE_BLUETOOTH_A2DP_IN,
98 DEVICE_TYPE_MIC,
99 DEVICE_TYPE_WAKEUP,
100 DEVICE_TYPE_USB_HEADSET,
101 DEVICE_TYPE_DP,
102 DEVICE_TYPE_REMOTE_CAST,
103 DEVICE_TYPE_USB_DEVICE,
104 DEVICE_TYPE_ACCESSORY,
105 DEVICE_TYPE_REMOTE_DAUDIO,
106 DEVICE_TYPE_HDMI,
107 DEVICE_TYPE_LINE_DIGITAL,
108 DEVICE_TYPE_NEARLINK,
109 DEVICE_TYPE_NEARLINK_IN,
110 DEVICE_TYPE_FILE_SINK,
111 DEVICE_TYPE_FILE_SOURCE,
112 DEVICE_TYPE_EXTERN_CABLE,
113 DEVICE_TYPE_DEFAULT,
114 DEVICE_TYPE_USB_ARM_HEADSET,
115 DEVICE_TYPE_MAX,
116 };
117
118 vector<StreamUsage> StreamUsageVec = {
119 STREAM_USAGE_INVALID,
120 STREAM_USAGE_UNKNOWN,
121 STREAM_USAGE_MEDIA,
122 STREAM_USAGE_MUSIC,
123 STREAM_USAGE_VOICE_COMMUNICATION,
124 STREAM_USAGE_VOICE_ASSISTANT,
125 STREAM_USAGE_ALARM,
126 STREAM_USAGE_VOICE_MESSAGE,
127 STREAM_USAGE_NOTIFICATION_RINGTONE,
128 STREAM_USAGE_RINGTONE,
129 STREAM_USAGE_NOTIFICATION,
130 STREAM_USAGE_ACCESSIBILITY,
131 STREAM_USAGE_SYSTEM,
132 STREAM_USAGE_MOVIE,
133 STREAM_USAGE_GAME,
134 STREAM_USAGE_AUDIOBOOK,
135 STREAM_USAGE_NAVIGATION,
136 STREAM_USAGE_DTMF,
137 STREAM_USAGE_ENFORCED_TONE,
138 STREAM_USAGE_ULTRASONIC,
139 STREAM_USAGE_VIDEO_COMMUNICATION,
140 STREAM_USAGE_RANGING,
141 STREAM_USAGE_VOICE_MODEM_COMMUNICATION,
142 STREAM_USAGE_VOICE_RINGTONE,
143 STREAM_USAGE_VOICE_CALL_ASSISTANT,
144 STREAM_USAGE_MAX,
145 };
146
147 vector<SourceType> SourceTypeVec = {
148 SOURCE_TYPE_INVALID,
149 SOURCE_TYPE_MIC,
150 SOURCE_TYPE_VOICE_RECOGNITION,
151 SOURCE_TYPE_PLAYBACK_CAPTURE,
152 SOURCE_TYPE_WAKEUP,
153 SOURCE_TYPE_VOICE_CALL,
154 SOURCE_TYPE_VOICE_COMMUNICATION,
155 SOURCE_TYPE_ULTRASONIC,
156 SOURCE_TYPE_VIRTUAL_CAPTURE,
157 SOURCE_TYPE_VOICE_MESSAGE,
158 SOURCE_TYPE_REMOTE_CAST,
159 SOURCE_TYPE_VOICE_TRANSCRIPTION,
160 SOURCE_TYPE_CAMCORDER,
161 SOURCE_TYPE_UNPROCESSED,
162 SOURCE_TYPE_EC,
163 SOURCE_TYPE_MIC_REF,
164 SOURCE_TYPE_LIVE,
165 SOURCE_TYPE_MAX,
166 };
167
168 vector<AudioSamplingRate> AudioSamplingRateVec = {
169 SAMPLE_RATE_8000,
170 SAMPLE_RATE_11025,
171 SAMPLE_RATE_12000,
172 SAMPLE_RATE_16000,
173 SAMPLE_RATE_22050,
174 SAMPLE_RATE_24000,
175 SAMPLE_RATE_32000,
176 SAMPLE_RATE_44100,
177 SAMPLE_RATE_48000,
178 SAMPLE_RATE_64000,
179 SAMPLE_RATE_88200,
180 SAMPLE_RATE_96000,
181 SAMPLE_RATE_176400,
182 SAMPLE_RATE_192000,
183 };
184
185 vector<DeviceRole> DeviceRoleVec = {
186 DEVICE_ROLE_NONE,
187 INPUT_DEVICE,
188 OUTPUT_DEVICE,
189 DEVICE_ROLE_MAX,
190 };
191
192 const vector<AudioStreamType> AudioStreamTypeVec = {
193 STREAM_DEFAULT,
194 STREAM_VOICE_CALL,
195 STREAM_MUSIC,
196 STREAM_RING,
197 STREAM_MEDIA,
198 STREAM_VOICE_ASSISTANT,
199 STREAM_SYSTEM,
200 STREAM_ALARM,
201 STREAM_NOTIFICATION,
202 STREAM_BLUETOOTH_SCO,
203 STREAM_ENFORCED_AUDIBLE,
204 STREAM_DTMF,
205 STREAM_TTS,
206 STREAM_ACCESSIBILITY,
207 STREAM_RECORDING,
208 STREAM_MOVIE,
209 STREAM_GAME,
210 STREAM_SPEECH,
211 STREAM_SYSTEM_ENFORCED,
212 STREAM_ULTRASONIC,
213 STREAM_WAKEUP,
214 STREAM_VOICE_MESSAGE,
215 STREAM_NAVIGATION,
216 STREAM_INTERNAL_FORCE_STOP,
217 STREAM_SOURCE_VOICE_CALL,
218 STREAM_VOICE_COMMUNICATION,
219 STREAM_VOICE_RING,
220 STREAM_VOICE_CALL_ASSISTANT,
221 STREAM_CAMCORDER,
222 STREAM_APP,
223 STREAM_TYPE_MAX,
224 STREAM_ALL,
225 };
226
FilterSourceOutputsFuzzTest()227 void FilterSourceOutputsFuzzTest()
228 {
229 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
230 int32_t sessionId = GetData<int32_t>();
231 audioDeviceCommon.FilterSourceOutputs(sessionId);
232 }
233
IsRingerOrAlarmerDualDevicesRangeFuzzTest()234 void IsRingerOrAlarmerDualDevicesRangeFuzzTest()
235 {
236 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
237 if (DeviceTypeVec.size() == 0) {
238 return;
239 }
240 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
241 InternalDeviceType deviceType = DeviceTypeVec[deviceTypeCount];
242 audioDeviceCommon.IsRingerOrAlarmerDualDevicesRange(deviceType);
243 }
244
IsRingOverPlaybackFuzzTest()245 void IsRingOverPlaybackFuzzTest()
246 {
247 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
248 int32_t modeCount = static_cast<int32_t>(AudioMode::AUDIO_MODE_RECORD) + 1;
249 AudioMode mode = static_cast<AudioMode>(GetData<uint8_t>() % modeCount);
250 int32_t rendererStateCount =
251 static_cast<int32_t>(RendererState::RENDERER_PAUSED - RendererState::RENDERER_INVALID) + 1;
252 RendererState state = static_cast<RendererState>(GetData<int32_t>() % rendererStateCount- 1);
253 audioDeviceCommon.IsRingOverPlayback(mode, state);
254 }
255
GetPreferredInputDeviceDescInnerFuzzTest()256 void GetPreferredInputDeviceDescInnerFuzzTest()
257 {
258 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
259 audioDeviceCommon.audioPolicyServerHandler_ = nullptr;
260 AudioDeviceDescriptor deviceDescriptor;
261 audioDeviceCommon.OnPreferredOutputDeviceUpdated(deviceDescriptor, AudioStreamDeviceChangeReason::UNKNOWN);
262 if (DeviceTypeVec.size() == 0 || StreamUsageVec.size() == 0 || SourceTypeVec.size() == 0) {
263 return;
264 }
265 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
266 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
267 shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler = std::make_shared<AudioPolicyServerHandler>();
268 audioDeviceCommon.Init(audioPolicyServerHandler);
269 audioDeviceCommon.OnPreferredInputDeviceUpdated(deviceType, "");
270
271 AudioRendererInfo rendererInfo;
272 uint32_t streamUsageCount = GetData<uint32_t>() % StreamUsageVec.size();
273 rendererInfo.streamUsage = StreamUsageVec[streamUsageCount];
274 audioDeviceCommon.GetPreferredOutputDeviceDescInner(rendererInfo, "");
275 AudioCapturerInfo captureInfo;
276 uint32_t sourceTypeCount = GetData<uint32_t>() % SourceTypeVec.size();
277 captureInfo.sourceType = SourceTypeVec[sourceTypeCount];
278 std::string networkId = "LocalDevice";
279 audioDeviceCommon.GetPreferredInputDeviceDescInner(captureInfo, networkId);
280 audioDeviceCommon.DeInit();
281 }
282
GetPreferredInputStreamTypeInnerFuzzTest()283 void GetPreferredInputStreamTypeInnerFuzzTest()
284 {
285 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
286 if (DeviceTypeVec.size() == 0 || AudioSamplingRateVec.size() == 0 || SourceTypeVec.size() == 0) {
287 return;
288 }
289 uint32_t sourceTypeCount = GetData<uint32_t>() % SourceTypeVec.size();
290 SourceType sourceType = SourceTypeVec[sourceTypeCount];
291 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
292 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
293 int32_t flags = GetData<int32_t>();
294 std::string networkId = "abc";
295 uint32_t samplingRateCount = GetData<uint32_t>() % AudioSamplingRateVec.size();
296 AudioSamplingRate samplingRate = AudioSamplingRateVec[samplingRateCount];
297 audioDeviceCommon.GetPreferredInputStreamTypeInner(sourceType, deviceType, flags, networkId, samplingRate);
298 }
299
UpdateDeviceInfoFuzzTest()300 void UpdateDeviceInfoFuzzTest()
301 {
302 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
303 AudioDeviceDescriptor deviceInfo;
304 deviceInfo.deviceType_ = GetData<DeviceType>();
305 bool hasBTPermission = GetData<uint32_t>() % NUM_2;
306 bool hasSystemPermission = GetData<uint32_t>() % NUM_2;
307 BluetoothOffloadState state = NO_A2DP_DEVICE;
308 audioDeviceCommon.audioA2dpOffloadFlag_.SetA2dpOffloadFlag(state);
309 audioDeviceCommon.UpdateDeviceInfo(deviceInfo, std::make_shared<AudioDeviceDescriptor>(),
310 hasBTPermission, hasSystemPermission);
311 }
312
UpdateConnectedDevicesWhenDisconnectingFuzzTest()313 void UpdateConnectedDevicesWhenDisconnectingFuzzTest()
314 {
315 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
316 AudioDeviceDescriptor updatedDesc;
317 if (DeviceTypeVec.size() == 0 || DeviceRoleVec.size() == 0) {
318 return;
319 }
320 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
321 updatedDesc.deviceType_ = DeviceTypeVec[deviceTypeCount];
322 uint32_t roleCount = GetData<uint32_t>() % DeviceRoleVec.size();
323 updatedDesc.deviceRole_ = DeviceRoleVec[roleCount];
324 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
325 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
326 audioDeviceDescriptorSptr->deviceType_ = DeviceTypeVec[deviceTypeCount];
327 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
328 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
329 audioDeviceCommon.UpdateConnectedDevicesWhenDisconnecting(updatedDesc, audioDeviceDescriptorSptrVector);
330 }
331
UpdateDualToneStateFuzzTest()332 void UpdateDualToneStateFuzzTest()
333 {
334 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
335 bool enable = GetData<uint32_t>() % NUM_2;
336 int32_t sessionId = GetData<int32_t>();
337 audioDeviceCommon.UpdateDualToneState(enable, sessionId);
338 }
339
IsFastFromA2dpToA2dpFuzzTest()340 void IsFastFromA2dpToA2dpFuzzTest()
341 {
342 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
343 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
344 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
345 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
346 if (rendererChangeInfo == nullptr || desc == nullptr || DeviceTypeVec.size() == 0) {
347 return;
348 }
349 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
350 rendererChangeInfo->outputDeviceInfo.deviceType_ = DeviceTypeVec[deviceTypeCount];
351 rendererChangeInfo->rendererInfo.originalFlag = AUDIO_FLAG_MMAP;
352 rendererChangeInfo->outputDeviceInfo.deviceId_ = 0;
353 desc->deviceId_ = GetData<uint32_t>() % NUM_2;
354 audioDeviceCommon.IsFastFromA2dpToA2dp(desc, rendererChangeInfo, reason);
355 }
356
SetDeviceConnectedFlagWhenFetchOutputDeviceFuzzTest()357 void SetDeviceConnectedFlagWhenFetchOutputDeviceFuzzTest()
358 {
359 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
360 audioDeviceCommon.SetDeviceConnectedFlagWhenFetchOutputDevice();
361 }
362
FetchOutputDeviceFuzzTest()363 void FetchOutputDeviceFuzzTest()
364 {
365 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
366 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
367 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
368 vector<std::shared_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
369 rendererChangeInfos.push_back(std::move(rendererChangeInfo));
370 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
371 audioDeviceCommon.FetchOutputDevice(rendererChangeInfos, reason);
372 }
373
GetDeviceDescriptorInnerFuzzTest()374 void GetDeviceDescriptorInnerFuzzTest()
375 {
376 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
377 VolumeUtils::SetPCVolumeEnable(true);
378 audioDeviceCommon.isFirstScreenOn_ = GetData<uint32_t>() % NUM_2;
379 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
380 vector<std::shared_ptr<AudioDeviceDescriptor>> descs =
381 audioDeviceCommon.GetDeviceDescriptorInner(rendererChangeInfo);
382 if (rendererChangeInfo == nullptr || StreamUsageVec.size() == 0) {
383 return;
384 }
385 uint32_t streamUsageCount = GetData<uint32_t>() % StreamUsageVec.size();
386 rendererChangeInfo->rendererInfo.streamUsage = StreamUsageVec[streamUsageCount];
387 rendererChangeInfo->clientUID = 0;
388 audioDeviceCommon.GetDeviceDescriptorInner(rendererChangeInfo);
389 }
390
FetchOutputEndFuzzTest()391 void FetchOutputEndFuzzTest()
392 {
393 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
394 bool isUpdateActiveDevice = GetData<uint32_t>() % NUM_2;
395 int32_t runningStreamCount = GetData<int32_t>();
396 audioDeviceCommon.FetchOutputEnd(isUpdateActiveDevice, runningStreamCount, AudioStreamDeviceChangeReason::UNKNOWN);
397 }
398
FetchOutputDeviceWhenNoRunningStreamFuzzTest()399 void FetchOutputDeviceWhenNoRunningStreamFuzzTest()
400 {
401 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
402 audioDeviceCommon.FetchOutputDeviceWhenNoRunningStream(AudioStreamDeviceChangeReason::UNKNOWN);
403 }
404
HandleDeviceChangeForFetchOutputDeviceFuzzTest()405 void HandleDeviceChangeForFetchOutputDeviceFuzzTest()
406 {
407 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
408 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
409 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
410 if (desc == nullptr || DeviceTypeVec.size() == 0 || rendererChangeInfo == nullptr) {
411 return;
412 }
413 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
414 desc->deviceType_ = DeviceTypeVec[deviceTypeCount];
415 desc->networkId_ = "LocalDevice";
416 desc->macAddress_ = "00:11:22:33:44:55";
417 desc->connectState_ = GetData<ConnectState>();
418 rendererChangeInfo->outputDeviceInfo.deviceType_ = desc->deviceType_;
419 rendererChangeInfo->outputDeviceInfo.networkId_ = desc->networkId_;
420 rendererChangeInfo->outputDeviceInfo.macAddress_ = desc->macAddress_;
421 rendererChangeInfo->outputDeviceInfo.connectState_ = desc->connectState_;
422 audioDeviceCommon.HandleDeviceChangeForFetchOutputDevice(desc, rendererChangeInfo,
423 AudioStreamDeviceChangeReason::UNKNOWN);
424 }
425
MuteSinkForSwitchGeneralDeviceFuzzTest()426 void MuteSinkForSwitchGeneralDeviceFuzzTest()
427 {
428 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
429 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
430 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
431 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorUniqueptr = std::make_shared<AudioDeviceDescriptor>();
432 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorUniqueptrVector;
433 if (audioDeviceDescriptorUniqueptr == nullptr || DeviceTypeVec.size() == 0) {
434 return;
435 }
436 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
437 audioDeviceDescriptorUniqueptr->deviceType_ = DeviceTypeVec[deviceTypeCount];
438 audioDeviceDescriptorUniqueptrVector.push_back(std::move(audioDeviceDescriptorUniqueptr));
439 audioDeviceCommon.MuteSinkForSwitchGeneralDevice(rendererChangeInfo, audioDeviceDescriptorUniqueptrVector, reason);
440 }
441
MuteSinkForSwitchBluetoothDeviceFuzzTest()442 void MuteSinkForSwitchBluetoothDeviceFuzzTest()
443 {
444 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
445 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
446 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
447 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorUniqueptr = std::make_shared<AudioDeviceDescriptor>();
448 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorUniqueptrVector;
449 if (audioDeviceDescriptorUniqueptr == nullptr || DeviceTypeVec.size() == 0) {
450 return;
451 }
452 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
453 audioDeviceDescriptorUniqueptr->deviceType_ = DeviceTypeVec[deviceTypeCount];
454 audioDeviceDescriptorUniqueptrVector.push_back(std::move(audioDeviceDescriptorUniqueptr));
455 audioDeviceCommon.MuteSinkForSwitchBluetoothDevice(rendererChangeInfo,
456 audioDeviceDescriptorUniqueptrVector, reason);
457 }
458
SetVoiceCallMuteForSwitchDeviceFuzzTest()459 void SetVoiceCallMuteForSwitchDeviceFuzzTest()
460 {
461 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
462 audioDeviceCommon.SetVoiceCallMuteForSwitchDevice();
463 }
464
IsRendererStreamRunningFuzzTest()465 void IsRendererStreamRunningFuzzTest()
466 {
467 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
468 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
469 if (StreamUsageVec.size() == 0) {
470 return;
471 }
472 uint32_t streamUsageCount = GetData<uint32_t>() % StreamUsageVec.size();
473 rendererChangeInfo->rendererInfo.streamUsage = StreamUsageVec[streamUsageCount];
474 int32_t audioSceneCount = static_cast<int32_t>(AudioScene::AUDIO_SCENE_MAX - AudioScene::AUDIO_SCENE_INVALID) + 1;
475 AudioScene audioScene = static_cast<AudioScene>(GetData<uint8_t>() % audioSceneCount - 1);
476 audioDeviceCommon.audioSceneManager_.SetAudioScenePre(audioScene);
477 audioDeviceCommon.IsRendererStreamRunning(rendererChangeInfo);
478 }
479
ActivateA2dpDeviceWhenDescEnabledFuzzTest()480 void ActivateA2dpDeviceWhenDescEnabledFuzzTest()
481 {
482 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
483 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
484 if (desc == nullptr) {
485 return;
486 }
487 desc->isEnable_ = GetData<uint32_t>() % NUM_2;
488 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
489 vector<std::shared_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
490 rendererChangeInfos.push_back(std::move(rendererChangeInfo));
491 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
492 audioDeviceCommon.ActivateA2dpDeviceWhenDescEnabled(desc, rendererChangeInfos, reason);
493 }
494
ActivateA2dpDeviceFuzzTest()495 void ActivateA2dpDeviceFuzzTest()
496 {
497 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
498 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
499 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
500 vector<std::shared_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
501 rendererChangeInfos.push_back(std::move(rendererChangeInfo));
502 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
503 audioDeviceCommon.ActivateA2dpDevice(desc, rendererChangeInfos, reason);
504 }
505
HandleScoOutputDeviceFetchedFuzzTest()506 void HandleScoOutputDeviceFetchedFuzzTest()
507 {
508 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
509 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
510 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
511 vector<std::shared_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
512 rendererChangeInfos.push_back(std::move(rendererChangeInfo));
513 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
514 audioDeviceCommon.HandleScoOutputDeviceFetched(desc, rendererChangeInfos, reason);
515 }
516
NotifyRecreateRendererStreamFuzzTest()517 void NotifyRecreateRendererStreamFuzzTest()
518 {
519 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
520 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
521 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
522 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
523 if (rendererChangeInfo == nullptr || desc == nullptr || DeviceTypeVec.size() == 0) {
524 return;
525 }
526 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
527 rendererChangeInfo->outputDeviceInfo.deviceType_ = DeviceTypeVec[deviceTypeCount];
528 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
529 desc->deviceType_ = DeviceTypeVec[deviceTypeCount];
530 rendererChangeInfo->rendererInfo.originalFlag = AUDIO_FLAG_MMAP;
531 rendererChangeInfo->rendererInfo.originalFlag = AUDIO_FLAG_VOIP_DIRECT;
532 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
533 rendererChangeInfo->outputDeviceInfo.deviceType_ = DeviceTypeVec[deviceTypeCount];
534 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
535 desc->deviceType_ = DeviceTypeVec[deviceTypeCount];
536 audioDeviceCommon.NotifyRecreateRendererStream(desc, rendererChangeInfo, reason);
537 }
538
NeedRehandleA2DPDeviceFuzzTest()539 void NeedRehandleA2DPDeviceFuzzTest()
540 {
541 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
542 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
543 if (desc == nullptr || DeviceTypeVec.size() == 0) {
544 return;
545 }
546 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
547 desc->deviceType_ = DeviceTypeVec[deviceTypeCount];
548 audioDeviceCommon.NeedRehandleA2DPDevice(desc);
549 }
550
MoveToNewOutputDeviceFuzzTest()551 void MoveToNewOutputDeviceFuzzTest()
552 {
553 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
554 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
555 if (rendererChangeInfo == nullptr || DeviceTypeVec.size() == 0 || DeviceRoleVec.size() == 0) {
556 return;
557 }
558 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
559 rendererChangeInfo->outputDeviceInfo.deviceType_ = DeviceTypeVec[deviceTypeCount];
560 rendererChangeInfo->outputDeviceInfo.macAddress_ = "";
561 rendererChangeInfo->outputDeviceInfo.networkId_ = "";
562 uint32_t roleCount = GetData<uint32_t>() % DeviceRoleVec.size();
563 rendererChangeInfo->outputDeviceInfo.deviceRole_ = DeviceRoleVec[roleCount];
564 std::shared_ptr<AudioDeviceDescriptor> outputdevice = std::make_shared<AudioDeviceDescriptor>();
565 if (outputdevice == nullptr) {
566 return;
567 }
568 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
569 outputdevice->deviceType_ = DeviceTypeVec[deviceTypeCount];
570 outputdevice->macAddress_ = "";
571 outputdevice->networkId_ = "";
572 roleCount = GetData<uint32_t>() % DeviceRoleVec.size();
573 outputdevice->deviceRole_ = DeviceRoleVec[roleCount];
574 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
575 outputDevices.push_back(std::move(outputdevice));
576 std::vector<SinkInput> sinkInputs;
577 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::OVERRODE;
578 audioDeviceCommon.audioConfigManager_.OnUpdateRouteSupport(true);
579 audioDeviceCommon.MoveToNewOutputDevice(rendererChangeInfo, outputDevices, sinkInputs, reason);
580 audioDeviceCommon.audioConfigManager_.GetUpdateRouteSupport();
581 }
582
MuteSinkPortFuzzTest()583 void MuteSinkPortFuzzTest()
584 {
585 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
586 std::vector<std::string> oldSinknameList = {"", "Offload_Speaker"};
587 if (oldSinknameList.size() == 0) {
588 return;
589 }
590 uint32_t oldSinknameCount = GetData<uint32_t>() % oldSinknameList.size();
591 std::string oldSinkname = oldSinknameList[oldSinknameCount];
592 std::vector<std::string> newSinkNameList = {"", "Offload_Speaker"};
593 if (newSinkNameList.size() == 0) {
594 return;
595 }
596 uint32_t newSinkNameCount = GetData<uint32_t>() % newSinkNameList.size();
597 std::string newSinkName = newSinkNameList[newSinkNameCount];
598 int32_t reasonCount = static_cast<int32_t>(AudioStreamDeviceChangeReason::OVERRODE) + 1;
599 AudioStreamDeviceChangeReasonExt reason =
600 static_cast<AudioStreamDeviceChangeReason>(GetData<uint8_t>() % reasonCount);
601 audioDeviceCommon.MuteSinkPort(oldSinkname, newSinkName, reason);
602 audioDeviceCommon.audioDeviceManager_.ExistsByType(DEVICE_TYPE_DP);
603 audioDeviceCommon.audioDeviceManager_.ExistsByTypeAndAddress(DEVICE_TYPE_DP, "card=0;port=0");
604 }
605
TriggerRecreateRendererStreamCallbackFuzzTest()606 void TriggerRecreateRendererStreamCallbackFuzzTest()
607 {
608 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
609 int32_t callerPid = 0;
610 int32_t sessionId = 0;
611 int32_t streamFlag = 0;
612 int32_t reasonCount = static_cast<int32_t>(AudioStreamDeviceChangeReason::OVERRODE) + 1;
613 AudioStreamDeviceChangeReasonExt reason =
614 static_cast<AudioStreamDeviceChangeReason>(GetData<uint8_t>() % reasonCount);
615 audioDeviceCommon.audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
616 audioDeviceCommon.TriggerRecreateRendererStreamCallback(callerPid, sessionId, streamFlag, reason);
617 }
618
IsDualStreamWhenRingDualFuzzTest()619 void IsDualStreamWhenRingDualFuzzTest()
620 {
621 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
622 if (AudioStreamTypeVec.size() == 0) {
623 return;
624 }
625 uint32_t index = GetData<uint32_t>() % AudioStreamTypeVec.size();
626 AudioStreamType streamType = AudioStreamTypeVec[index];
627 audioDeviceCommon.IsDualStreamWhenRingDual(streamType);
628 }
629
UpdateRouteFuzzTest()630 void UpdateRouteFuzzTest()
631 {
632 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
633 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
634 if (rendererChangeInfo == nullptr || DeviceTypeVec.size() == 0 || StreamUsageVec.size() == 0) {
635 return;
636 }
637 uint32_t streamUsageCount = GetData<uint32_t>() % StreamUsageVec.size();
638 rendererChangeInfo->rendererInfo.streamUsage = StreamUsageVec[streamUsageCount];
639
640 std::shared_ptr<AudioDeviceDescriptor> outputdevice = std::make_shared<AudioDeviceDescriptor>();
641 if (outputdevice == nullptr) {
642 return;
643 }
644 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
645 outputdevice->deviceType_ = DeviceTypeVec[deviceTypeCount];
646 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
647 outputDevices.push_back(std::move(outputdevice));
648 VolumeUtils::SetPCVolumeEnable(GetData<uint32_t>() % NUM_2);
649 audioDeviceCommon.UpdateRoute(rendererChangeInfo, outputDevices);
650 }
651
ResetOffloadAndMchModeFuzzTest()652 void ResetOffloadAndMchModeFuzzTest()
653 {
654 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
655 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
656 vector<std::shared_ptr<AudioDeviceDescriptor>> outputDevices;
657 std::shared_ptr<AudioDeviceDescriptor> outputDevice = std::make_shared<AudioDeviceDescriptor>();
658 std::vector<std::string> networkIdList = {"", "LocalDevice"};
659 if (outputDevice == nullptr || DeviceTypeVec.size() == 0 || networkIdList.size() == 0) {
660 return;
661 }
662 uint32_t networkIdCount = GetData<uint32_t>() % networkIdList.size();
663 outputDevice->networkId_ = networkIdList[networkIdCount];
664 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
665 outputDevice->deviceType_ = DeviceTypeVec[deviceTypeCount];
666 outputDevices.push_back(std::move(outputDevice));
667 audioDeviceCommon.ResetOffloadAndMchMode(rendererChangeInfo, outputDevices);
668 }
669
JudgeIfLoadMchModuleFuzzTest()670 void JudgeIfLoadMchModuleFuzzTest()
671 {
672 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
673 audioDeviceCommon.JudgeIfLoadMchModule();
674 AudioIOHandle moduleId = 0;
675 std::string moduleName = "MCH_Speaker";
676 audioDeviceCommon.audioIOHandleMap_.AddIOHandleInfo(moduleName, moduleId);
677 audioDeviceCommon.JudgeIfLoadMchModule();
678 }
679
FetchStreamForA2dpMchStreamFuzzTest()680 void FetchStreamForA2dpMchStreamFuzzTest()
681 {
682 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
683 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
684 vector<std::shared_ptr<AudioDeviceDescriptor>> descs;
685 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
686 descs.push_back(std::move(desc));
687 audioDeviceCommon.FetchStreamForA2dpMchStream(rendererChangeInfo, descs);
688 }
689
FetchStreamForSpkMchStreamFuzzTest()690 void FetchStreamForSpkMchStreamFuzzTest()
691 {
692 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
693 std::shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
694 vector<std::shared_ptr<AudioDeviceDescriptor>> descs;
695 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
696 descs.push_back(std::move(desc));
697 audioDeviceCommon.FetchStreamForSpkMchStream(rendererChangeInfo, descs);
698 }
699
IsRingDualToneOnPrimarySpeakerFuzzTest()700 void IsRingDualToneOnPrimarySpeakerFuzzTest()
701 {
702 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
703 vector<std::shared_ptr<AudioDeviceDescriptor>> descs;
704 audioDeviceCommon.IsRingDualToneOnPrimarySpeaker(descs, 1);
705 descs.push_back(std::make_shared<AudioDeviceDescriptor>());
706 descs.push_back(std::make_shared<AudioDeviceDescriptor>());
707 audioDeviceCommon.IsRingDualToneOnPrimarySpeaker(descs, 1);
708 if (DeviceTypeVec.size() == 0) {
709 return;
710 }
711 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
712 descs.front()->deviceType_ = DeviceTypeVec[deviceTypeCount];
713 audioDeviceCommon.IsRingDualToneOnPrimarySpeaker(descs, 1);
714 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
715 descs.back()->deviceType_ = DeviceTypeVec[deviceTypeCount];
716 audioDeviceCommon.IsRingDualToneOnPrimarySpeaker(descs, 1);
717 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
718 descs.front()->deviceType_ = DeviceTypeVec[deviceTypeCount];
719 audioDeviceCommon.IsRingDualToneOnPrimarySpeaker(descs, 1);
720 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
721 descs.back()->deviceType_ = DeviceTypeVec[deviceTypeCount];
722 audioDeviceCommon.IsRingDualToneOnPrimarySpeaker(descs, 1);
723 }
724
ClearRingMuteWhenCallStartFuzzTest()725 void ClearRingMuteWhenCallStartFuzzTest()
726 {
727 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
728 bool pre = GetData<uint32_t>() % NUM_2;
729 bool after = GetData<uint32_t>() % NUM_2;
730 audioDeviceCommon.ClearRingMuteWhenCallStart(pre, after);
731 }
732
HandleDeviceChangeForFetchInputDeviceFuzzTest()733 void HandleDeviceChangeForFetchInputDeviceFuzzTest()
734 {
735 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
736 std::shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
737 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
738 if (desc == nullptr || capturerChangeInfo == nullptr || DeviceTypeVec.size() == 0 || DeviceRoleVec.size() == 0) {
739 return;
740 }
741 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
742 desc->deviceType_ = DeviceTypeVec[deviceTypeCount];
743 audioDeviceCommon.HandleDeviceChangeForFetchInputDevice(desc, capturerChangeInfo);
744 desc->networkId_ = "";
745 capturerChangeInfo->inputDeviceInfo.networkId_ = "";
746 desc->macAddress_ = "";
747 capturerChangeInfo->inputDeviceInfo.macAddress_ = "";
748 int32_t connectStateCount = static_cast<int32_t>(ConnectState::DEACTIVE_CONNECTED) + 1;
749 desc->connectState_ = static_cast<ConnectState>(GetData<uint8_t>() % connectStateCount);
750 connectStateCount = static_cast<int32_t>(ConnectState::DEACTIVE_CONNECTED) + 1;
751 capturerChangeInfo->inputDeviceInfo.connectState_ =
752 static_cast<ConnectState>(GetData<uint8_t>() % connectStateCount);
753 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
754 desc->deviceType_ = DeviceTypeVec[deviceTypeCount];
755 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
756 capturerChangeInfo->inputDeviceInfo.deviceType_ = DeviceTypeVec[deviceTypeCount];
757 uint32_t roleCount = GetData<uint32_t>() % DeviceRoleVec.size();
758 desc->deviceRole_ = DeviceRoleVec[roleCount];
759 roleCount = GetData<uint32_t>() % DeviceRoleVec.size();
760 capturerChangeInfo->inputDeviceInfo.deviceRole_ = DeviceRoleVec[roleCount];
761 audioDeviceCommon.HandleDeviceChangeForFetchInputDevice(desc, capturerChangeInfo);
762 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
763 desc->deviceType_ = DeviceTypeVec[deviceTypeCount];
764 connectStateCount = static_cast<int32_t>(ConnectState::DEACTIVE_CONNECTED) + 1;
765 desc->connectState_ = static_cast<ConnectState>(GetData<uint8_t>() % connectStateCount);
766 audioDeviceCommon.HandleDeviceChangeForFetchInputDevice(desc, capturerChangeInfo);
767 }
768
HandleBluetoothInputDeviceFetchedFuzzTest()769 void HandleBluetoothInputDeviceFetchedFuzzTest()
770 {
771 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
772 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
773 if (desc == nullptr || DeviceTypeVec.size() == 0 || SourceTypeVec.size() == 0) {
774 return;
775 }
776 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
777 desc->deviceType_ = DeviceTypeVec[deviceTypeCount];
778 std::shared_ptr<AudioCapturerChangeInfo> captureChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
779 vector<std::shared_ptr<AudioCapturerChangeInfo>> captureChangeInfos;
780 captureChangeInfos.push_back(std::move(captureChangeInfo));
781 uint32_t sourceTypeCount = GetData<uint32_t>() % SourceTypeVec.size();
782 SourceType sourceType = SourceTypeVec[sourceTypeCount];
783 audioDeviceCommon.HandleBluetoothInputDeviceFetched(desc, captureChangeInfos, sourceType);
784 }
785
NotifyRecreateCapturerStreamFuzzTest()786 void NotifyRecreateCapturerStreamFuzzTest()
787 {
788 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
789 bool isUpdateActiveDevice = true;
790 std::shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
791 if (capturerChangeInfo == nullptr) {
792 return;
793 }
794 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
795 capturerChangeInfo->capturerInfo.originalFlag = AUDIO_FLAG_MMAP;
796 capturerChangeInfo->inputDeviceInfo.deviceType_ = DEVICE_TYPE_MIC;
797 AudioDeviceDescriptor deviceDescriptor;
798 deviceDescriptor.deviceType_ = DEVICE_TYPE_MIC;
799 audioDeviceCommon.audioActiveDevice_.SetCurrentInputDevice(deviceDescriptor);
800 std::vector<std::string> networkIdList = {"test", "LocalDevice"};
801 if (networkIdList.size() == 0) {
802 return;
803 }
804 uint32_t networkIdCount = GetData<uint32_t>() % networkIdList.size();
805 capturerChangeInfo->inputDeviceInfo.networkId_ = networkIdList[networkIdCount];
806 audioDeviceCommon.NotifyRecreateCapturerStream(isUpdateActiveDevice, capturerChangeInfo, reason);
807 }
808
MoveToRemoteInputDeviceFuzzTest()809 void MoveToRemoteInputDeviceFuzzTest()
810 {
811 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
812 SourceOutput sourceOutput;
813 std::vector<SourceOutput> sourceOutputs;
814 sourceOutputs.push_back(sourceOutput);
815 std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
816 audioDeviceCommon.isOpenRemoteDevice = GetData<uint32_t>() % NUM_2;
817 audioDeviceCommon.MoveToRemoteInputDevice(sourceOutputs, remoteDeviceDescriptor);
818 }
819
ScoInputDeviceFetchedForRecongnitionFuzzTest()820 void ScoInputDeviceFetchedForRecongnitionFuzzTest()
821 {
822 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
823 bool handleFlag = GetData<uint32_t>() % NUM_2;
824 std::string address = "";
825 int32_t connectStateCount = static_cast<int32_t>(ConnectState::DEACTIVE_CONNECTED) + 1;
826 ConnectState connectState = static_cast<ConnectState>(GetData<uint8_t>() % connectStateCount);
827 audioDeviceCommon.ScoInputDeviceFetchedForRecongnition(handleFlag, address, connectState);
828 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
829 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
830 audioDeviceCommon.ScoInputDeviceFetchedForRecongnition(handleFlag, address, connectState);
831 }
832
CheckAndNotifyUserSelectedDeviceFuzzTest()833 void CheckAndNotifyUserSelectedDeviceFuzzTest()
834 {
835 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
836 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
837 audioDeviceCommon.CheckAndNotifyUserSelectedDevice(desc);
838 audioDeviceCommon.audioActiveDevice_.CheckActiveOutputDeviceSupportOffload();
839 }
840
HasLowLatencyCapabilityFuzzTest()841 void HasLowLatencyCapabilityFuzzTest()
842 {
843 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
844 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
845 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
846 bool isRemote = GetData<uint32_t>() % NUM_2;
847 audioDeviceCommon.HasLowLatencyCapability(deviceType, isRemote);
848 }
849
GetSpatialDeviceTypeFuzzTest()850 void GetSpatialDeviceTypeFuzzTest()
851 {
852 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
853 std::string macAddress = "F0-FA-C7-8C-46-01";
854 audioDeviceCommon.GetSpatialDeviceType(macAddress);
855
856 AudioDeviceDescriptor deviceDescriptor;
857 deviceDescriptor.macAddress_ = "F0-FA-C7-8C-46-01";
858 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
859 deviceDescriptor.deviceType_ = DeviceTypeVec[deviceTypeCount];
860 shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler = std::make_shared<AudioPolicyServerHandler>();
861 audioDeviceCommon.Init(audioPolicyServerHandler);
862 audioDeviceCommon.OnPreferredOutputDeviceUpdated(deviceDescriptor, AudioStreamDeviceChangeReason::UNKNOWN);
863 audioDeviceCommon.GetSpatialDeviceType(macAddress);
864 audioDeviceCommon.DeInit();
865 }
866
IsDeviceConnectedFuzzTest()867 void IsDeviceConnectedFuzzTest()
868 {
869 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
870 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
871 audioDeviceCommon.IsDeviceConnected(audioDeviceDescriptorSptr);
872 }
873
IsSameDeviceFuzzTest()874 void IsSameDeviceFuzzTest()
875 {
876 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
877 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
878 AudioDeviceDescriptor deviceInfo;
879 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
880 desc->deviceType_ = DeviceTypeVec[deviceTypeCount];
881 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
882 deviceInfo.deviceType_ = DeviceTypeVec[deviceTypeCount];
883 audioDeviceCommon.IsSameDevice(desc, deviceInfo);
884 desc->networkId_ = "";
885 deviceInfo.networkId_ = "";
886 desc->macAddress_ = "";
887 deviceInfo.macAddress_ = "";
888 int32_t connectStateCount = static_cast<int32_t>(ConnectState::DEACTIVE_CONNECTED) + 1;
889 desc->connectState_ = static_cast<ConnectState>(GetData<uint8_t>() % connectStateCount);
890 connectStateCount = static_cast<int32_t>(ConnectState::DEACTIVE_CONNECTED) + 1;
891 deviceInfo.connectState_ = static_cast<ConnectState>(GetData<uint8_t>() % connectStateCount);
892 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
893 desc->deviceType_ = DeviceTypeVec[deviceTypeCount];
894 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
895 deviceInfo.deviceType_ = DeviceTypeVec[deviceTypeCount];
896 uint32_t roleCount = GetData<uint32_t>() % DeviceRoleVec.size();
897 desc->deviceRole_ = DeviceRoleVec[roleCount];
898 roleCount = GetData<uint32_t>() % DeviceRoleVec.size();
899 deviceInfo.deviceRole_ = DeviceRoleVec[roleCount];
900 audioDeviceCommon.IsSameDevice(desc, deviceInfo);
901 }
902
GetSourceOutputsFuzzTest()903 void GetSourceOutputsFuzzTest()
904 {
905 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
906 audioDeviceCommon.GetSourceOutputs();
907 }
908
ClientDiedDisconnectScoNormalFuzzTest()909 void ClientDiedDisconnectScoNormalFuzzTest()
910 {
911 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
912 audioDeviceCommon.ClientDiedDisconnectScoNormal();
913 }
914
ClientDiedDisconnectScoRecognitionFuzzTest()915 void ClientDiedDisconnectScoRecognitionFuzzTest()
916 {
917 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
918 audioDeviceCommon.ClientDiedDisconnectScoRecognition();
919 }
920
GetA2dpModuleInfoFuzzTest()921 void GetA2dpModuleInfoFuzzTest()
922 {
923 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
924 AudioModuleInfo moduleInfo;
925 AudioStreamInfo audioStreamInfo;
926 uint32_t sourceTypeCount = GetData<uint32_t>() % SourceTypeVec.size();
927 SourceType sourceType = SourceTypeVec[sourceTypeCount];
928 audioDeviceCommon.GetA2dpModuleInfo(moduleInfo, audioStreamInfo, sourceType);
929 }
930
LoadA2dpModuleFuzzTest()931 void LoadA2dpModuleFuzzTest()
932 {
933 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
934 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
935 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
936 AudioStreamInfo audioStreamInfo;
937 std::string networkID = "";
938 std::string sinkName = "";
939 uint32_t sourceTypeCount = GetData<uint32_t>() % SourceTypeVec.size();
940 SourceType sourceType = SourceTypeVec[sourceTypeCount];
941 ClassType classType = GetData<ClassType>();
942 AudioModuleInfo moduleInfo;
943 std::list<AudioModuleInfo> moduleInfoList;
944 moduleInfoList.push_back(moduleInfo);
945 audioDeviceCommon.audioConfigManager_.deviceClassInfo_.insert({classType, moduleInfoList});
946 audioDeviceCommon.LoadA2dpModule(deviceType, audioStreamInfo, networkID, sinkName, sourceType);
947 audioDeviceCommon.audioConfigManager_.deviceClassInfo_.clear();
948 }
949
ReloadA2dpAudioPortFuzzTest()950 void ReloadA2dpAudioPortFuzzTest()
951 {
952 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
953 AudioModuleInfo moduleInfo;
954 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
955 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
956 AudioStreamInfo audioStreamInfo;
957 std::string networkID = "";
958 std::string sinkName = "";
959 uint32_t sourceTypeCount = GetData<uint32_t>() % SourceTypeVec.size();
960 SourceType sourceType = SourceTypeVec[sourceTypeCount];
961 audioDeviceCommon.ReloadA2dpAudioPort(moduleInfo, deviceType, audioStreamInfo, networkID, sinkName, sourceType);
962 }
963
SwitchActiveA2dpDeviceFuzzTest()964 void SwitchActiveA2dpDeviceFuzzTest()
965 {
966 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
967 audioDeviceCommon.DeInit();
968
969 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
970 deviceDescriptor->macAddress_ = Bluetooth::AudioA2dpManager::GetActiveA2dpDevice();
971 deviceDescriptor->deviceName_ = "TestA2dpDevice";
972 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
973 deviceDescriptor->deviceType_ = DeviceTypeVec[deviceTypeCount];
974 audioDeviceCommon.audioA2dpDevice_.connectedA2dpDeviceMap_[deviceDescriptor->macAddress_] = A2dpDeviceConfigInfo();
975
976 audioDeviceCommon.audioIOHandleMap_.IOHandles_[BLUETOOTH_SPEAKER] = GetData<uint32_t>();
977 audioDeviceCommon.SwitchActiveA2dpDevice(deviceDescriptor);
978 }
979
RingToneVoiceControlFuzzTest()980 void RingToneVoiceControlFuzzTest()
981 {
982 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
983 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
984 InternalDeviceType deviceType = DeviceTypeVec[deviceTypeCount];
985 audioDeviceCommon.RingToneVoiceControl(deviceType);
986 }
987
SetFirstScreenOnFuzzTest()988 void SetFirstScreenOnFuzzTest()
989 {
990 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
991 audioDeviceCommon.SetFirstScreenOn();
992 }
993
SetVirtualCallFuzzTest()994 void SetVirtualCallFuzzTest()
995 {
996 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
997 pid_t uid = GetData<pid_t>();
998 bool isVirtual = GetData<uint32_t>() % NUM_2;
999 audioDeviceCommon.SetVirtualCall(uid, isVirtual);
1000 }
1001
SetHeadsetUnpluggedToSpkOrEpFlagFuzzTest()1002 void SetHeadsetUnpluggedToSpkOrEpFlagFuzzTest()
1003 {
1004 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1005 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
1006 InternalDeviceType oldDeviceType = DeviceTypeVec[deviceTypeCount];
1007 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
1008 InternalDeviceType newDeviceType = DeviceTypeVec[deviceTypeCount];
1009 audioDeviceCommon.SetHeadsetUnpluggedToSpkOrEpFlag(oldDeviceType, newDeviceType);
1010 }
1011
WriteInputRouteChangeEventFuzzTest()1012 void WriteInputRouteChangeEventFuzzTest()
1013 {
1014 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1015 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1016 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
1017 desc->deviceType_ = DeviceTypeVec[deviceTypeCount];
1018 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
1019 audioDeviceCommon.WriteInputRouteChangeEvent(desc, reason);
1020 }
1021
MoveToNewInputDeviceFuzzTest()1022 void MoveToNewInputDeviceFuzzTest()
1023 {
1024 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1025 audioDeviceCommon.DeInit();
1026
1027 std::shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
1028 if (capturerChangeInfo == nullptr) {
1029 return;
1030 }
1031 capturerChangeInfo->sessionId = SESSIONID;
1032 capturerChangeInfo->inputDeviceInfo.deviceType_ = DEVICE_TYPE_MIC;
1033 capturerChangeInfo->inputDeviceInfo.macAddress_ = "00:11:22:33:44:55";
1034 capturerChangeInfo->inputDeviceInfo.networkId_ = LOCAL_NETWORK_ID;
1035
1036 std::shared_ptr<AudioDeviceDescriptor> inputDevice = std::make_shared<AudioDeviceDescriptor>();
1037 if (inputDevice == nullptr) {
1038 return;
1039 }
1040 inputDevice->deviceType_ = DEVICE_TYPE_USB_HEADSET;
1041 inputDevice->macAddress_ = "66:77:88:99:AA:BB";
1042 inputDevice->networkId_ = GetData<int32_t>() % NUM_2 == 0 ? LOCAL_NETWORK_ID : REMOTE_NETWORK_ID;
1043
1044 audioDeviceCommon.audioConfigManager_.OnUpdateRouteSupport(GetData<uint32_t>() % NUM_2);
1045 audioDeviceCommon.MoveToNewInputDevice(capturerChangeInfo, inputDevice);
1046 }
1047
BluetoothScoFetchFuzzTest()1048 void BluetoothScoFetchFuzzTest()
1049 {
1050 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1051 audioDeviceCommon.DeInit();
1052
1053 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1054 if (desc == nullptr) {
1055 return;
1056 }
1057 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
1058 desc->deviceType_ = DeviceTypeVec[deviceTypeCount];
1059 desc->macAddress_ = "00:11:22:33:44:55";
1060 desc->networkId_ = GetData<uint32_t>() % NUM_2 == 0 ? LOCAL_NETWORK_ID : REMOTE_NETWORK_ID;
1061
1062 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> capturerChangeInfos;
1063 std::shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
1064 uint32_t sourceTypeCount = GetData<uint32_t>() % SourceTypeVec.size();
1065 capturerChangeInfo->capturerInfo.sourceType = SourceTypeVec[sourceTypeCount];
1066 capturerChangeInfos.push_back(capturerChangeInfo);
1067
1068 audioDeviceCommon.audioActiveDevice_.SetCurrentInputDevice(*desc);
1069 sourceTypeCount = GetData<uint32_t>() % SourceTypeVec.size();
1070 SourceType sourceType = SourceTypeVec[sourceTypeCount];
1071 audioDeviceCommon.BluetoothScoFetch(desc, capturerChangeInfos, sourceType);
1072 audioDeviceCommon.audioActiveDevice_.GetCurrentInputDevice();
1073 }
1074
HandleA2dpInputDeviceFetchedFuzzTest()1075 void HandleA2dpInputDeviceFetchedFuzzTest()
1076 {
1077 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1078 audioDeviceCommon.DeInit();
1079 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1080 uint32_t sourceTypeCount = GetData<uint32_t>() % SourceTypeVec.size();
1081 SourceType sourceType = SourceTypeVec[sourceTypeCount];
1082 audioDeviceCommon.HandleA2dpInputDeviceFetched(desc, sourceType);
1083 }
1084
TriggerRecreateCapturerStreamCallbackFuzzTest()1085 void TriggerRecreateCapturerStreamCallbackFuzzTest()
1086 {
1087 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1088 std::shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = std::make_shared<AudioCapturerChangeInfo>();
1089 int32_t streamFlag = GetData<int32_t>();
1090 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
1091 shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler = std::make_shared<AudioPolicyServerHandler>();
1092 audioDeviceCommon.Init(audioPolicyServerHandler);
1093 bool isDeInit = GetData<bool>();
1094 if (isDeInit) {
1095 audioDeviceCommon.DeInit();
1096 }
1097 audioDeviceCommon.TriggerRecreateCapturerStreamCallback(capturerChangeInfo, streamFlag, reason);
1098 audioDeviceCommon.DeInit();
1099 }
1100
HandleScoInputDeviceFetchedFuzzTest()1101 void HandleScoInputDeviceFetchedFuzzTest()
1102 {
1103 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1104 audioDeviceCommon.DeInit();
1105 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
1106 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> captureChangeInfos;
1107 audioDeviceCommon.HandleScoInputDeviceFetched(audioDeviceDescriptorSptr, captureChangeInfos);
1108 }
1109
AudioDeviceCommonOpenRemoteAudioDeviceFuzzTest()1110 void AudioDeviceCommonOpenRemoteAudioDeviceFuzzTest()
1111 {
1112 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1113 audioDeviceCommon.DeInit();
1114 std::string networkId = "testNetworkId";
1115 DeviceRole deviceRole = GetData<DeviceRole>();
1116 DeviceType deviceType = GetData<DeviceType>();
1117 std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
1118 audioDeviceCommon.OpenRemoteAudioDevice(networkId, deviceRole, deviceType, remoteDeviceDescriptor);
1119 }
1120
AudioDeviceCommonIsSameDeviceFuzzTest()1121 void AudioDeviceCommonIsSameDeviceFuzzTest()
1122 {
1123 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1124 audioDeviceCommon.DeInit();
1125 AudioDeviceDescriptor deviceDesc;
1126 deviceDesc.networkId_ = "testNetworkId";
1127 deviceDesc.deviceType_ = GetData<DeviceType>();
1128 deviceDesc.macAddress_ = "00:11:22:33:44:55";
1129 deviceDesc.connectState_ = GetData<ConnectState>();
1130 deviceDesc.deviceRole_ = GetData<DeviceRole>();
1131 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>(deviceDesc);
1132 if (desc == nullptr) {
1133 return;
1134 }
1135 bool isNoClear = GetData<bool>();
1136 if (!isNoClear) {
1137 desc->networkId_.clear();
1138 }
1139
1140 audioDeviceCommon.IsSameDevice(desc, deviceDesc);
1141 }
1142
AudioDeviceCommonDeviceParamsCheckFuzzTest()1143 void AudioDeviceCommonDeviceParamsCheckFuzzTest()
1144 {
1145 AudioDeviceCommon& audioDeviceCommon = AudioDeviceCommon::GetInstance();
1146 audioDeviceCommon.DeInit();
1147 DeviceRole targetRole = GetData<DeviceRole>();
1148 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
1149 if (audioDeviceDescriptor == nullptr) {
1150 return;
1151 }
1152 audioDeviceDescriptor->deviceType_ = GetData<DeviceType>();
1153 audioDeviceDescriptor->deviceRole_ = GetData<DeviceRole>();
1154 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
1155 audioDeviceDescriptors.push_back(audioDeviceDescriptor);
1156
1157 audioDeviceCommon.DeviceParamsCheck(targetRole, audioDeviceDescriptors);
1158 }
1159
1160 TestFuncs g_testFuncs[TESTSIZE] = {
1161 FilterSourceOutputsFuzzTest,
1162 IsRingerOrAlarmerDualDevicesRangeFuzzTest,
1163 IsRingOverPlaybackFuzzTest,
1164 GetPreferredInputDeviceDescInnerFuzzTest,
1165 GetPreferredInputStreamTypeInnerFuzzTest,
1166 UpdateDeviceInfoFuzzTest,
1167 UpdateConnectedDevicesWhenDisconnectingFuzzTest,
1168 UpdateDualToneStateFuzzTest,
1169 IsFastFromA2dpToA2dpFuzzTest,
1170 SetDeviceConnectedFlagWhenFetchOutputDeviceFuzzTest,
1171 FetchOutputDeviceFuzzTest,
1172 GetDeviceDescriptorInnerFuzzTest,
1173 FetchOutputEndFuzzTest,
1174 FetchOutputDeviceWhenNoRunningStreamFuzzTest,
1175 HandleDeviceChangeForFetchOutputDeviceFuzzTest,
1176 MuteSinkForSwitchGeneralDeviceFuzzTest,
1177 MuteSinkForSwitchBluetoothDeviceFuzzTest,
1178 SetVoiceCallMuteForSwitchDeviceFuzzTest,
1179 IsRendererStreamRunningFuzzTest,
1180 ActivateA2dpDeviceWhenDescEnabledFuzzTest,
1181 ActivateA2dpDeviceFuzzTest,
1182 HandleScoOutputDeviceFetchedFuzzTest,
1183 NotifyRecreateRendererStreamFuzzTest,
1184 NeedRehandleA2DPDeviceFuzzTest,
1185 MoveToNewOutputDeviceFuzzTest,
1186 MuteSinkPortFuzzTest,
1187 TriggerRecreateRendererStreamCallbackFuzzTest,
1188 IsDualStreamWhenRingDualFuzzTest,
1189 UpdateRouteFuzzTest,
1190 ResetOffloadAndMchModeFuzzTest,
1191 JudgeIfLoadMchModuleFuzzTest,
1192 FetchStreamForA2dpMchStreamFuzzTest,
1193 FetchStreamForSpkMchStreamFuzzTest,
1194 IsRingDualToneOnPrimarySpeakerFuzzTest,
1195 ClearRingMuteWhenCallStartFuzzTest,
1196 HandleDeviceChangeForFetchInputDeviceFuzzTest,
1197 HandleBluetoothInputDeviceFetchedFuzzTest,
1198 NotifyRecreateCapturerStreamFuzzTest,
1199 MoveToRemoteInputDeviceFuzzTest,
1200 ScoInputDeviceFetchedForRecongnitionFuzzTest,
1201 CheckAndNotifyUserSelectedDeviceFuzzTest,
1202 HasLowLatencyCapabilityFuzzTest,
1203 GetSpatialDeviceTypeFuzzTest,
1204 IsDeviceConnectedFuzzTest,
1205 IsSameDeviceFuzzTest,
1206 GetSourceOutputsFuzzTest,
1207 ClientDiedDisconnectScoNormalFuzzTest,
1208 ClientDiedDisconnectScoRecognitionFuzzTest,
1209 GetA2dpModuleInfoFuzzTest,
1210 LoadA2dpModuleFuzzTest,
1211 ReloadA2dpAudioPortFuzzTest,
1212 SwitchActiveA2dpDeviceFuzzTest,
1213 RingToneVoiceControlFuzzTest,
1214 SetFirstScreenOnFuzzTest,
1215 SetVirtualCallFuzzTest,
1216 SetHeadsetUnpluggedToSpkOrEpFlagFuzzTest,
1217 WriteInputRouteChangeEventFuzzTest,
1218 MoveToNewInputDeviceFuzzTest,
1219 BluetoothScoFetchFuzzTest,
1220 HandleA2dpInputDeviceFetchedFuzzTest,
1221 TriggerRecreateCapturerStreamCallbackFuzzTest,
1222 HandleScoInputDeviceFetchedFuzzTest,
1223 AudioDeviceCommonOpenRemoteAudioDeviceFuzzTest,
1224 AudioDeviceCommonIsSameDeviceFuzzTest,
1225 AudioDeviceCommonDeviceParamsCheckFuzzTest,
1226 };
1227
FuzzTest(const uint8_t * rawData,size_t size)1228 void FuzzTest(const uint8_t* rawData, size_t size)
1229 {
1230 if (rawData == nullptr) {
1231 return;
1232 }
1233
1234 // initialize data
1235 RAW_DATA = rawData;
1236 g_dataSize = size;
1237 g_pos = 0;
1238
1239 uint32_t code = GetData<uint32_t>();
1240 uint32_t len = GetArrLength(g_testFuncs);
1241 if (len > 0) {
1242 g_testFuncs[code % len]();
1243 } else {
1244 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
1245 }
1246
1247 return;
1248 }
1249 } // namespace AudioStandard
1250 } // namesapce OHOS
1251
1252 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1253 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
1254 {
1255 if (size < OHOS::AudioStandard::THRESHOLD) {
1256 return 0;
1257 }
1258
1259 OHOS::AudioStandard::FuzzTest(data, size);
1260 return 0;
1261 }
1262