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 #include "hpae_manager.h"
38 #include "audio_info.h"
39
40 namespace OHOS {
41 namespace AudioStandard {
42 using namespace std;
43
44 static const uint8_t* RAW_DATA = nullptr;
45 static size_t g_dataSize = 0;
46 static size_t g_pos;
47 const size_t THRESHOLD = 10;
48 const uint8_t TESTSIZE = 20;
49 static int32_t NUM_2 = 2;
50
51 typedef void (*TestFuncs)();
52
53 template<class T>
GetData()54 T GetData()
55 {
56 T object {};
57 size_t objectSize = sizeof(object);
58 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
59 return object;
60 }
61 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
62 if (ret != EOK) {
63 return {};
64 }
65 g_pos += objectSize;
66 return object;
67 }
68
69 template<class T>
GetArrLength(T & arr)70 uint32_t GetArrLength(T& arr)
71 {
72 if (arr == nullptr) {
73 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
74 return 0;
75 }
76 return sizeof(arr) / sizeof(arr[0]);
77 }
78
79 vector<DeviceType> DeviceTypeVec = {
80 DEVICE_TYPE_NONE,
81 DEVICE_TYPE_INVALID,
82 DEVICE_TYPE_EARPIECE,
83 DEVICE_TYPE_SPEAKER,
84 DEVICE_TYPE_WIRED_HEADSET,
85 DEVICE_TYPE_WIRED_HEADPHONES,
86 DEVICE_TYPE_BLUETOOTH_SCO,
87 DEVICE_TYPE_BLUETOOTH_A2DP,
88 DEVICE_TYPE_BLUETOOTH_A2DP_IN,
89 DEVICE_TYPE_MIC,
90 DEVICE_TYPE_WAKEUP,
91 DEVICE_TYPE_USB_HEADSET,
92 DEVICE_TYPE_DP,
93 DEVICE_TYPE_REMOTE_CAST,
94 DEVICE_TYPE_USB_DEVICE,
95 DEVICE_TYPE_ACCESSORY,
96 DEVICE_TYPE_REMOTE_DAUDIO,
97 DEVICE_TYPE_HDMI,
98 DEVICE_TYPE_LINE_DIGITAL,
99 DEVICE_TYPE_NEARLINK,
100 DEVICE_TYPE_NEARLINK_IN,
101 DEVICE_TYPE_FILE_SINK,
102 DEVICE_TYPE_FILE_SOURCE,
103 DEVICE_TYPE_EXTERN_CABLE,
104 DEVICE_TYPE_DEFAULT,
105 DEVICE_TYPE_USB_ARM_HEADSET,
106 DEVICE_TYPE_MAX,
107 };
108
109 vector<DeviceRole> DeviceRoleVec = {
110 DEVICE_ROLE_NONE,
111 INPUT_DEVICE,
112 OUTPUT_DEVICE,
113 DEVICE_ROLE_MAX,
114 };
115
116 const vector<DeviceFlag> DeviceFlagVec = {
117 NONE_DEVICES_FLAG,
118 OUTPUT_DEVICES_FLAG,
119 INPUT_DEVICES_FLAG,
120 ALL_DEVICES_FLAG,
121 DISTRIBUTED_OUTPUT_DEVICES_FLAG,
122 DISTRIBUTED_INPUT_DEVICES_FLAG,
123 ALL_DISTRIBUTED_DEVICES_FLAG,
124 ALL_L_D_DEVICES_FLAG,
125 DEVICE_FLAG_MAX,
126 };
127
IsConnectedOutputDeviceFuzzTest()128 void IsConnectedOutputDeviceFuzzTest()
129 {
130 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
131 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
132 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
133 DeviceRole deviceRole = DeviceRoleVec[deviceRoleCount];
134 auto desc = make_shared<AudioDeviceDescriptor>(deviceType, deviceRole);
135 AudioConnectedDevice::GetInstance().connectedDevices_.push_back(desc);
136 AudioConnectedDevice::GetInstance().IsConnectedOutputDevice(desc);
137 }
138
CheckExistOutputDeviceFuzzTest()139 void CheckExistOutputDeviceFuzzTest()
140 {
141 std::string macAddress = "test";
142 auto audioConnectedDevice = std::make_shared<AudioConnectedDevice>();
143 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
144 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
145 auto desc = make_shared<AudioDeviceDescriptor>(DeviceTypeVec[deviceTypeCount], DeviceRoleVec[deviceRoleCount]);
146 audioConnectedDevice->connectedDevices_.push_back(desc);
147 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
148 audioConnectedDevice->CheckExistOutputDevice(DeviceTypeVec[deviceTypeCount], macAddress);
149 }
150
CheckExistInputDeviceFuzzTest()151 void CheckExistInputDeviceFuzzTest()
152 {
153 auto audioConnectedDevice = std::make_shared<AudioConnectedDevice>();
154 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
155 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
156 auto desc = make_shared<AudioDeviceDescriptor>(DeviceTypeVec[deviceTypeCount], DeviceRoleVec[deviceRoleCount]);
157 audioConnectedDevice->connectedDevices_.push_back(desc);
158 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
159 audioConnectedDevice->CheckExistInputDevice(DeviceTypeVec[deviceTypeCount]);
160 }
161
GetConnectedDeviceByTypeFuzzTest()162 void GetConnectedDeviceByTypeFuzzTest()
163 {
164 string networkId = "test";
165 auto audioConnectedDevice = std::make_shared<AudioConnectedDevice>();
166 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
167 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
168 auto desc = make_shared<AudioDeviceDescriptor>(DeviceTypeVec[deviceTypeCount], DeviceRoleVec[deviceRoleCount]);
169 desc->networkId_ = networkId;
170 audioConnectedDevice->connectedDevices_.push_back(desc);
171 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
172 audioConnectedDevice->GetConnectedDeviceByType(networkId, DeviceTypeVec[deviceTypeCount]);
173 }
174
UpdateConnectDeviceFuzzTest()175 void UpdateConnectDeviceFuzzTest()
176 {
177 string macAddress = "macAddress";
178 string deviceName = "deviceName";
179 AudioStreamInfo streamInfo;
180 auto audioConnectedDevice = std::make_shared<AudioConnectedDevice>();
181 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
182 audioConnectedDevice->UpdateConnectDevice(DeviceTypeVec[deviceTypeCount], macAddress, deviceName, streamInfo);
183 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
184 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
185 auto desc = make_shared<AudioDeviceDescriptor>(DeviceTypeVec[deviceTypeCount], DeviceRoleVec[deviceRoleCount]);
186 desc->macAddress_ = macAddress;
187 audioConnectedDevice->connectedDevices_.push_back(desc);
188 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
189 audioConnectedDevice->UpdateConnectDevice(DeviceTypeVec[deviceTypeCount], macAddress, deviceName, streamInfo);
190 }
191
GetUsbDeviceDescriptorFuzzTest()192 void GetUsbDeviceDescriptorFuzzTest()
193 {
194 std::string address = "test";
195 auto audioConnectedDevice = std::make_shared<AudioConnectedDevice>();
196 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
197 audioConnectedDevice->GetUsbDeviceDescriptor(address, DeviceRoleVec[deviceRoleCount]);
198 }
199
UpdateSpatializationSupportedFuzzTest()200 void UpdateSpatializationSupportedFuzzTest()
201 {
202 string macAddress = "test";
203 bool spatializationSupported = GetData<uint8_t>() % NUM_2;
204 auto audioConnectedDevice = std::make_shared<AudioConnectedDevice>();
205 string encryAddress =
206 AudioSpatializationService::GetAudioSpatializationService().GetSha256EncryptAddress(macAddress);
207 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
208 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
209 auto desc1 = make_shared<AudioDeviceDescriptor>(DeviceTypeVec[deviceTypeCount], DeviceRoleVec[deviceRoleCount]);
210 desc1->macAddress_ = macAddress;
211 desc1->spatializationSupported_ = spatializationSupported;
212 audioConnectedDevice->connectedDevices_.push_back(desc1);
213 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
214 deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
215 auto desc2 = make_shared<AudioDeviceDescriptor>(DeviceTypeVec[deviceTypeCount], DeviceRoleVec[deviceRoleCount]);
216 desc2->macAddress_ = macAddress;
217 audioConnectedDevice->connectedDevices_.push_back(desc2);
218 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
219 deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
220 auto desc3 = make_shared<AudioDeviceDescriptor>(DeviceTypeVec[deviceTypeCount], DeviceRoleVec[deviceRoleCount]);
221 desc3->macAddress_ = macAddress;
222 desc3->spatializationSupported_ = spatializationSupported;
223 audioConnectedDevice->connectedDevices_.push_back(desc3);
224 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
225 deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
226 auto desc4 = make_shared<AudioDeviceDescriptor>(DeviceTypeVec[deviceTypeCount], DeviceRoleVec[deviceRoleCount]);
227 desc4->macAddress_ = macAddress;
228 audioConnectedDevice->connectedDevices_.push_back(desc4);
229 audioConnectedDevice->UpdateSpatializationSupported(encryAddress, spatializationSupported);
230 }
231
CheckDeviceConnectedFuzzTest()232 void CheckDeviceConnectedFuzzTest()
233 {
234 std::string selectedDevice = "test";
235 auto audioConnectedDevice = std::make_shared<AudioConnectedDevice>();
236 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
237 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
238 auto desc = make_shared<AudioDeviceDescriptor>(DeviceTypeVec[deviceTypeCount], DeviceRoleVec[deviceRoleCount]);
239 desc->networkId_ = selectedDevice;
240 audioConnectedDevice->connectedDevices_.push_back(desc);
241 audioConnectedDevice->CheckDeviceConnected(selectedDevice);
242 }
243
HasArmFuzzTest()244 void HasArmFuzzTest()
245 {
246 auto audioConnectedDevice = std::make_shared<AudioConnectedDevice>();
247 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
248 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
249 auto desc = make_shared<AudioDeviceDescriptor>(DeviceTypeVec[deviceTypeCount], DeviceRoleVec[deviceRoleCount]);
250 audioConnectedDevice->connectedDevices_.push_back(desc);
251 deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
252 audioConnectedDevice->HasArm(DeviceRoleVec[deviceRoleCount]);
253 }
254
HasHifiFuzzTest()255 void HasHifiFuzzTest()
256 {
257 auto audioConnectedDevice = std::make_shared<AudioConnectedDevice>();
258 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
259 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
260 auto desc = make_shared<AudioDeviceDescriptor>(DeviceTypeVec[deviceTypeCount], DeviceRoleVec[deviceRoleCount]);
261 audioConnectedDevice->connectedDevices_.push_back(desc);
262 deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
263 bool result = audioConnectedDevice->HasHifi(DeviceRoleVec[deviceRoleCount]);
264 }
265
IsArmDeviceFuzzTest()266 void IsArmDeviceFuzzTest()
267 {
268 string address = "test";
269 auto audioConnectedDevice = make_shared<AudioConnectedDevice>();
270 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
271 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
272 auto desc = make_shared<AudioDeviceDescriptor>(DeviceTypeVec[deviceTypeCount], DeviceRoleVec[deviceRoleCount]);
273 desc->macAddress_ = address;
274 audioConnectedDevice->connectedDevices_.push_back(desc);
275 deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
276 bool result = audioConnectedDevice->IsArmDevice(address, DeviceRoleVec[deviceRoleCount]);
277 }
278
AudioConnectedDeviceGetAllConnectedDeviceByTypeFuzzTest()279 void AudioConnectedDeviceGetAllConnectedDeviceByTypeFuzzTest()
280 {
281 auto audioConnectedDevice = make_shared<AudioConnectedDevice>();
282 if (audioConnectedDevice == nullptr || DeviceTypeVec.size() == 0 || DeviceRoleVec.size() == 0) {
283 return;
284 }
285 std::string networkId = "testNetworkId";
286 std::string macAddress = "testMacAddress";
287 DeviceType deviceType = DeviceTypeVec[GetData<uint32_t>() % DeviceTypeVec.size()];
288 DeviceRole deviceRole = DeviceRoleVec[GetData<uint32_t>() % DeviceRoleVec.size()];
289 std::vector<std::shared_ptr<AudioDeviceDescriptor>> descForCb;
290 std::shared_ptr<AudioDeviceDescriptor> deviceDesc = make_shared<AudioDeviceDescriptor>();
291 descForCb.push_back(deviceDesc);
292 audioConnectedDevice->GetAllConnectedDeviceByType(networkId, deviceType, macAddress, deviceRole, descForCb);
293 }
294
AudioConnectedDeviceDelConnectedDeviceFuzzTest()295 void AudioConnectedDeviceDelConnectedDeviceFuzzTest()
296 {
297 auto audioConnectedDevice = make_shared<AudioConnectedDevice>();
298 if (audioConnectedDevice == nullptr || DeviceTypeVec.size() == 0) {
299 return;
300 }
301 std::string networkId = "testNetworkId";
302 DeviceType deviceType = DeviceTypeVec[GetData<uint32_t>() % DeviceTypeVec.size()];
303 std::string macAddress = "testMacAddress";
304 audioConnectedDevice->DelConnectedDevice(networkId, deviceType, macAddress);
305 audioConnectedDevice->DelConnectedDevice(networkId, deviceType);
306 }
307
AudioConnectedDeviceSetDisplayNameFuzzTest()308 void AudioConnectedDeviceSetDisplayNameFuzzTest()
309 {
310 auto audioConnectedDevice = make_shared<AudioConnectedDevice>();
311 if (audioConnectedDevice == nullptr) {
312 return;
313 }
314
315 std::string deviceName = "testDeviceName";
316 bool isLocalDevice = GetData<uint32_t>() % NUM_2;
317 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
318 desc->networkId_ = "testNetworkId";
319 if (isLocalDevice) {
320 desc->networkId_ = "LocalDevice";
321 }
322 audioConnectedDevice->connectedDevices_.push_back(desc);
323 audioConnectedDevice->SetDisplayName(deviceName, isLocalDevice);
324 std::string macAddress = "testMacAddress";
325 audioConnectedDevice->SetDisplayName(macAddress, deviceName);
326 }
327
AudioConnectedDeviceUpdateDmDeviceMapFuzzTest()328 void AudioConnectedDeviceUpdateDmDeviceMapFuzzTest()
329 {
330 auto audioConnectedDevice = make_shared<AudioConnectedDevice>();
331 if (audioConnectedDevice == nullptr) {
332 return;
333 }
334
335 DmDevice dmDevice;
336 dmDevice.deviceName_ = "testDeviceName";
337 dmDevice.networkId_ = "testNetworkId";
338 bool isConnect = GetData<uint32_t>() % NUM_2;
339 audioConnectedDevice->UpdateDmDeviceMap(std::move(dmDevice), isConnect);
340 }
341
AudioConnectedDeviceUpdateDeviceDesc4DmDeviceFuzzTest()342 void AudioConnectedDeviceUpdateDeviceDesc4DmDeviceFuzzTest()
343 {
344 auto audioConnectedDevice = make_shared<AudioConnectedDevice>();
345 if (audioConnectedDevice == nullptr) {
346 return;
347 }
348
349 AudioDeviceDescriptor deviceDesc;
350 deviceDesc.deviceType_ = DEVICE_TYPE_SPEAKER;
351 deviceDesc.networkId_ = "testNetworkId";
352 DmDevice audioDmDevice;
353 audioConnectedDevice->dmDeviceMap_.insert(std::make_pair(deviceDesc.networkId_, audioDmDevice));
354 audioConnectedDevice->UpdateDeviceDesc4DmDevice(deviceDesc);
355 }
356
AudioConnectedDeviceGetDevicesInnerFuzzTest()357 void AudioConnectedDeviceGetDevicesInnerFuzzTest()
358 {
359 auto audioConnectedDevice = make_shared<AudioConnectedDevice>();
360 if (audioConnectedDevice == nullptr || DeviceFlagVec.size() == 0) {
361 return;
362 }
363
364 DeviceFlag deviceFlag = DeviceFlagVec[GetData<uint32_t>() % DeviceFlagVec.size()];
365 std::shared_ptr<AudioDeviceDescriptor> audioConnectedDeviceDesc = std::make_shared<AudioDeviceDescriptor>();
366 audioConnectedDevice->connectedDevices_.push_back(audioConnectedDeviceDesc);
367 audioConnectedDevice->GetDevicesInner(deviceFlag);
368 }
369
AudioConnectedDeviceFindConnectedHeadsetFuzzTest()370 void AudioConnectedDeviceFindConnectedHeadsetFuzzTest()
371 {
372 auto audioConnectedDevice = make_shared<AudioConnectedDevice>();
373 if (audioConnectedDevice == nullptr) {
374 return;
375 }
376
377 std::shared_ptr<AudioDeviceDescriptor> audioConnectedDeviceDesc = std::make_shared<AudioDeviceDescriptor>();
378 audioConnectedDevice->connectedDevices_.push_back(audioConnectedDeviceDesc);
379 audioConnectedDevice->FindConnectedHeadset();
380 }
381
AudioConnectedDeviceGetDevicesForGroupFuzzTest()382 void AudioConnectedDeviceGetDevicesForGroupFuzzTest()
383 {
384 static const vector<GroupType> testGroupType = {
385 VOLUME_TYPE,
386 INTERRUPT_TYPE,
387 };
388 auto audioConnectedDevice = make_shared<AudioConnectedDevice>();
389 if (audioConnectedDevice == nullptr || testGroupType.size() == 0) {
390 return;
391 }
392
393 int32_t groupId = GetData<int32_t>();
394 GroupType type = testGroupType[GetData<uint32_t>() % testGroupType.size()];
395 std::shared_ptr<AudioDeviceDescriptor> audioConnectedDeviceDesc = std::make_shared<AudioDeviceDescriptor>();
396 audioConnectedDevice->connectedDevices_.push_back(audioConnectedDeviceDesc);
397 audioConnectedDevice->GetDevicesForGroup(type, groupId);
398 }
399
AudioConnectedDeviceRegisterNameMonitorHelperFuzzTest()400 void AudioConnectedDeviceRegisterNameMonitorHelperFuzzTest()
401 {
402 auto audioConnectedDevice = make_shared<AudioConnectedDevice>();
403 if (audioConnectedDevice == nullptr) {
404 return;
405 }
406
407 audioConnectedDevice->RegisterNameMonitorHelper();
408 }
409
410 TestFuncs g_testFuncs[TESTSIZE] = {
411 IsConnectedOutputDeviceFuzzTest,
412 CheckExistOutputDeviceFuzzTest,
413 CheckExistInputDeviceFuzzTest,
414 GetConnectedDeviceByTypeFuzzTest,
415 UpdateConnectDeviceFuzzTest,
416 GetUsbDeviceDescriptorFuzzTest,
417 UpdateSpatializationSupportedFuzzTest,
418 CheckDeviceConnectedFuzzTest,
419 HasArmFuzzTest,
420 HasHifiFuzzTest,
421 IsArmDeviceFuzzTest,
422 AudioConnectedDeviceGetAllConnectedDeviceByTypeFuzzTest,
423 AudioConnectedDeviceDelConnectedDeviceFuzzTest,
424 AudioConnectedDeviceSetDisplayNameFuzzTest,
425 AudioConnectedDeviceUpdateDmDeviceMapFuzzTest,
426 AudioConnectedDeviceUpdateDeviceDesc4DmDeviceFuzzTest,
427 AudioConnectedDeviceGetDevicesInnerFuzzTest,
428 AudioConnectedDeviceFindConnectedHeadsetFuzzTest,
429 AudioConnectedDeviceGetDevicesForGroupFuzzTest,
430 AudioConnectedDeviceRegisterNameMonitorHelperFuzzTest,
431 };
432
FuzzTest(const uint8_t * rawData,size_t size)433 bool FuzzTest(const uint8_t* rawData, size_t size)
434 {
435 if (rawData == nullptr) {
436 return false;
437 }
438
439 // initialize data
440 RAW_DATA = rawData;
441 g_dataSize = size;
442 g_pos = 0;
443
444 uint32_t code = GetData<uint32_t>();
445 uint32_t len = GetArrLength(g_testFuncs);
446 if (len > 0) {
447 g_testFuncs[code % len]();
448 } else {
449 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
450 }
451
452 return true;
453 }
454 } // namespace AudioStandard
455 } // namesapce OHOS
456
457 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)458 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
459 {
460 if (size < OHOS::AudioStandard::THRESHOLD) {
461 return 0;
462 }
463
464 OHOS::AudioStandard::FuzzTest(data, size);
465 return 0;
466 }
467