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 = 16;
49 static int32_t NUM_2 = 2;
50 static int32_t NUM_3 = 3;
51 constexpr int32_t K_HUNDRED = 100;
52 constexpr int32_t K_TIME_SPAN_IN_MILLISECONDS_FOR_SELECTION = 200;
53 const bool FALSE_FLAG = false;
54 const bool NOT_SUPPORTED = false;
55 const int32_t DEVICE_INFO_INDEX_1 = 1;
56 const int32_t DEVICE_INFO_INDEX_2 = 2;
57
58 typedef void (*TestFuncs)();
59
60 template<class T>
GetData()61 T GetData()
62 {
63 T object {};
64 size_t objectSize = sizeof(object);
65 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
66 return object;
67 }
68 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
69 if (ret != EOK) {
70 return {};
71 }
72 g_pos += objectSize;
73 return object;
74 }
75
76 template<class T>
GetArrLength(T & arr)77 uint32_t GetArrLength(T& arr)
78 {
79 if (arr == nullptr) {
80 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
81 return 0;
82 }
83 return sizeof(arr) / sizeof(arr[0]);
84 }
85
86 vector<DeviceType> DeviceTypeVec = {
87 DEVICE_TYPE_NONE,
88 DEVICE_TYPE_INVALID,
89 DEVICE_TYPE_EARPIECE,
90 DEVICE_TYPE_SPEAKER,
91 DEVICE_TYPE_WIRED_HEADSET,
92 DEVICE_TYPE_WIRED_HEADPHONES,
93 DEVICE_TYPE_BLUETOOTH_SCO,
94 DEVICE_TYPE_BLUETOOTH_A2DP,
95 DEVICE_TYPE_BLUETOOTH_A2DP_IN,
96 DEVICE_TYPE_MIC,
97 DEVICE_TYPE_WAKEUP,
98 DEVICE_TYPE_USB_HEADSET,
99 DEVICE_TYPE_DP,
100 DEVICE_TYPE_REMOTE_CAST,
101 DEVICE_TYPE_USB_DEVICE,
102 DEVICE_TYPE_ACCESSORY,
103 DEVICE_TYPE_REMOTE_DAUDIO,
104 DEVICE_TYPE_HDMI,
105 DEVICE_TYPE_LINE_DIGITAL,
106 DEVICE_TYPE_NEARLINK,
107 DEVICE_TYPE_NEARLINK_IN,
108 DEVICE_TYPE_FILE_SINK,
109 DEVICE_TYPE_FILE_SOURCE,
110 DEVICE_TYPE_EXTERN_CABLE,
111 DEVICE_TYPE_DEFAULT,
112 DEVICE_TYPE_USB_ARM_HEADSET,
113 DEVICE_TYPE_MAX,
114 };
115
116 vector<DeviceFlag> DeviceFlagVec = {
117 NONE_DEVICES_FLAG,
118 OUTPUT_DEVICES_FLAG,
119 ALL_DEVICES_FLAG,
120 DISTRIBUTED_OUTPUT_DEVICES_FLAG,
121 DISTRIBUTED_INPUT_DEVICES_FLAG,
122 ALL_DISTRIBUTED_DEVICES_FLAG,
123 ALL_L_D_DEVICES_FLAG,
124 DEVICE_FLAG_MAX,
125 };
126
127 vector<DeviceRole> DeviceRoleVec = {
128 DEVICE_ROLE_NONE,
129 INPUT_DEVICE,
130 OUTPUT_DEVICE,
131 DEVICE_ROLE_MAX,
132 };
133
PrepareTestData(AffinityDeviceInfo & deviceInfo1,AffinityDeviceInfo & deviceInfo2,std::unordered_map<int32_t,AffinityDeviceInfo> & testDeviceInfoMap)134 void PrepareTestData(AffinityDeviceInfo& deviceInfo1, AffinityDeviceInfo& deviceInfo2,
135 std::unordered_map<int32_t, AffinityDeviceInfo>& testDeviceInfoMap)
136 {
137 deviceInfo1.groupName = "group1";
138 deviceInfo1.deviceType = DeviceType::DEVICE_TYPE_SPEAKER;
139 deviceInfo1.networkID = "network1";
140 deviceInfo1.chooseTimeStamp = K_HUNDRED;
141 deviceInfo1.isPrimary = true;
142 deviceInfo1.SupportedConcurrency = true;
143
144 deviceInfo2.groupName = "group1";
145 deviceInfo2.deviceType = DeviceType::DEVICE_TYPE_EARPIECE;
146 deviceInfo2.networkID = "network2";
147 deviceInfo2.chooseTimeStamp = K_TIME_SPAN_IN_MILLISECONDS_FOR_SELECTION;
148 deviceInfo2.isPrimary = FALSE_FLAG;
149 deviceInfo2.SupportedConcurrency = NOT_SUPPORTED;
150
151 testDeviceInfoMap[DEVICE_INFO_INDEX_1] = deviceInfo1;
152 testDeviceInfoMap[DEVICE_INFO_INDEX_2] = deviceInfo2;
153 }
154
ParseAffinityXmlFuzzTest()155 void ParseAffinityXmlFuzzTest()
156 {
157 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
158 audioAffinityManager->ParseAffinityXml();
159 if (!audioAffinityManager->rendererAffinityDeviceArray_.empty()) {
160 audioAffinityManager->rendererAffinityDeviceArray_[0];
161 }
162 if (!audioAffinityManager->capturerAffinityDeviceArray_.empty()) {
163 audioAffinityManager->capturerAffinityDeviceArray_[0];
164 }
165 }
166
OnXmlParsingCompletedFuzzTest()167 void OnXmlParsingCompletedFuzzTest()
168 {
169 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
170 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
171 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
172 uint32_t deviceFlagCount = GetData<uint32_t>() % DeviceFlagVec.size();
173 DeviceFlag deviceFlag = DeviceFlagVec[deviceFlagCount];
174 std::vector<AffinityDeviceInfo> xmlData = {
175 {"group", deviceType, deviceFlag, "network", 0, GetData<uint8_t>() % NUM_2, GetData<uint8_t>() % NUM_2}
176 };
177 audioAffinityManager->OnXmlParsingCompleted(xmlData);
178 }
179
GetRendererDeviceFuzzTest()180 void GetRendererDeviceFuzzTest()
181 {
182 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
183 int32_t testClientUID = GetData<int32_t>();
184 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
185 DeviceType testDeviceType = DeviceTypeVec[deviceTypeCount];
186 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
187 DeviceRole testDeviceRole = DeviceRoleVec[deviceRoleCount];
188 int32_t testInterruptGroupId = 1;
189 int32_t testVolumeGroupId = 1;
190 std::string testNetworkId = "test_network";
191 std::shared_ptr<AudioDeviceDescriptor> testDescriptor = std::make_shared<AudioDeviceDescriptor>(
192 testDeviceType, testDeviceRole, testInterruptGroupId, testVolumeGroupId, testNetworkId);
193 audioAffinityManager->activeRendererDeviceMap_[testClientUID] = testDescriptor;
194 std::shared_ptr<AudioDeviceDescriptor> result = audioAffinityManager->GetRendererDevice(testClientUID);
195 }
196
GetCapturerDeviceFuzzTest()197 void GetCapturerDeviceFuzzTest()
198 {
199 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
200 int32_t clientUID = GetData<int32_t>();
201 std::shared_ptr<AudioDeviceDescriptor> descriptor = std::make_shared<AudioDeviceDescriptor>();
202 descriptor->networkId_ = "test_network";
203 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
204 descriptor->deviceRole_ = DeviceRoleVec[deviceRoleCount];
205 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
206 descriptor->deviceType_ = DeviceTypeVec[deviceTypeCount];
207 audioAffinityManager->activeCapturerDeviceMap_[clientUID] = descriptor;
208 std::shared_ptr<AudioDeviceDescriptor> result = audioAffinityManager->GetCapturerDevice(clientUID);
209 }
210
DelSelectRendererDeviceFuzzTest()211 void DelSelectRendererDeviceFuzzTest()
212 {
213 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
214 int32_t clientUID1 = GetData<int32_t>();
215 int32_t clientUID2 = GetData<int32_t>();
216 std::shared_ptr<AudioDeviceDescriptor> descriptor = std::make_shared<AudioDeviceDescriptor>();
217 std::string networkId = "test_network";
218 std::string groupName = "test_group";
219 audioAffinityManager->DelSelectRendererDevice(clientUID1);
220 }
221
DelSelectCapturerDeviceFuzzTest()222 void DelSelectCapturerDeviceFuzzTest()
223 {
224 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
225 int32_t clientUID1 = GetData<int32_t>();
226 int32_t clientUID2 = GetData<int32_t>();
227 std::string networkId = "test_network";
228 std::string groupName = "test_group";
229 audioAffinityManager->activeCapturerDeviceMap_.count(clientUID1);
230 audioAffinityManager->activeCapturerDeviceMap_.count(clientUID2);
231 audioAffinityManager->DelSelectCapturerDevice(clientUID1);
232 }
233
RemoveOfflineRendererDeviceFuzzTest()234 void RemoveOfflineRendererDeviceFuzzTest()
235 {
236 AudioAffinityManager affinityManager;
237 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
238 DeviceType testDeviceType = DeviceTypeVec[deviceTypeCount];
239 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
240 DeviceRole testDeviceRole = DeviceRoleVec[deviceRoleCount];
241 int32_t testInterruptGroupId = 1;
242 int32_t testVolumeGroupId = 1;
243 std::string testNetworkID = "test_network_id";
244 AudioDeviceDescriptor updateDesc(
245 testDeviceType,
246 testDeviceRole,
247 testInterruptGroupId,
248 testVolumeGroupId,
249 testNetworkID
250 );
251 std::shared_ptr<AudioDeviceDescriptor> deviceDesc = std::make_shared<AudioDeviceDescriptor>(updateDesc);
252 int32_t testClientUID = GetData<int32_t>();
253 affinityManager.activeRendererDeviceMap_[testClientUID] = deviceDesc;
254 AffinityDeviceInfo affinityInfo;
255 affinityInfo.deviceType = testDeviceType;
256 affinityInfo.networkID = testNetworkID;
257 affinityInfo.groupName = "test_group";
258 affinityManager.rendererAffinityDeviceArray_.push_back(affinityInfo);
259 affinityManager.RemoveOfflineRendererDevice(updateDesc);
260 }
261
RemoveOfflineCapturerDeviceFuzzTest()262 void RemoveOfflineCapturerDeviceFuzzTest()
263 {
264 AudioAffinityManager affinityManager;
265 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
266 DeviceType testDeviceType = DeviceTypeVec[deviceTypeCount];
267 uint32_t deviceRoleCount = GetData<uint32_t>() % DeviceRoleVec.size();
268 DeviceRole testDeviceRole = DeviceRoleVec[deviceRoleCount];
269 int32_t testInterruptGroupId = 1;
270 int32_t testVolumeGroupId = 1;
271 std::string testNetworkID = "test_capturer_network_id";
272 AudioDeviceDescriptor updateDesc(
273 testDeviceType,
274 testDeviceRole,
275 testInterruptGroupId,
276 testVolumeGroupId,
277 testNetworkID
278 );
279 std::shared_ptr<AudioDeviceDescriptor> deviceDesc = std::make_shared<AudioDeviceDescriptor>(updateDesc);
280 int32_t testClientUID = GetData<int32_t>();
281 affinityManager.activeCapturerDeviceMap_[testClientUID] = deviceDesc;
282 AffinityDeviceInfo affinityInfo;
283 affinityInfo.deviceType = testDeviceType;
284 affinityInfo.networkID = testNetworkID;
285 affinityInfo.groupName = "test_capturer_group";
286 affinityManager.capturerAffinityDeviceArray_.push_back(affinityInfo);
287 affinityManager.RemoveOfflineCapturerDevice(updateDesc);
288 }
289
GetAffinityDeviceInfoByDeviceTypeFuzzTest()290 void GetAffinityDeviceInfoByDeviceTypeFuzzTest()
291 {
292 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
293 DeviceType targetType = DEVICE_TYPE_SPEAKER;
294 std::string targetNetwork = "network1";
295 uint32_t deviceFlagCount = GetData<uint32_t>() % DeviceFlagVec.size();
296 DeviceFlag deviceFlag = DeviceFlagVec[deviceFlagCount];
297 AffinityDeviceInfo device1 = {
298 .groupName = "group1",
299 .deviceType = DEVICE_TYPE_SPEAKER,
300 .deviceFlag = deviceFlag,
301 .networkID = "network1",
302 .chooseTimeStamp = GetData<int32_t>(),
303 .isPrimary = GetData<uint8_t>() % NUM_2,
304 .SupportedConcurrency = GetData<uint8_t>() % NUM_2
305 };
306 deviceFlagCount = GetData<uint32_t>() % DeviceFlagVec.size();
307 deviceFlag = DeviceFlagVec[deviceFlagCount];
308 AffinityDeviceInfo device2 = {
309 .groupName = "group2",
310 .deviceType = DEVICE_TYPE_BLUETOOTH_A2DP,
311 .deviceFlag = deviceFlag,
312 .networkID = "network2",
313 .chooseTimeStamp = GetData<int32_t>(),
314 .isPrimary = GetData<uint8_t>() % NUM_2,
315 .SupportedConcurrency = GetData<uint8_t>() % NUM_2
316 };
317 std::vector<AffinityDeviceInfo> testDevices_ = {device1, device2};
318 AffinityDeviceInfo result = audioAffinityManager->GetAffinityDeviceInfoByDeviceType(
319 testDevices_, targetType, targetNetwork);
320 }
321
GetActiveAffinityDeviceMapByGroupNameFuzzTest()322 void GetActiveAffinityDeviceMapByGroupNameFuzzTest()
323 {
324 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
325 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
326 uint32_t deviceFlagCount = GetData<uint32_t>() % DeviceFlagVec.size();
327 std::string targetGroup = "group1";
328 AffinityDeviceInfo device1 = {
329 .groupName = "group1",
330 .deviceType = DeviceTypeVec[deviceTypeCount],
331 .deviceFlag = DeviceFlagVec[deviceFlagCount],
332 .networkID = "network1",
333 .chooseTimeStamp = GetData<uint64_t>(),
334 .isPrimary = GetData<uint8_t>() % NUM_2,
335 .SupportedConcurrency = GetData<uint8_t>() % NUM_2
336 };
337 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
338 deviceFlagCount = GetData<uint32_t>() % DeviceFlagVec.size();
339 AffinityDeviceInfo device2 = {
340 .groupName = "group2",
341 .deviceType = DeviceTypeVec[deviceTypeCount],
342 .deviceFlag = DeviceFlagVec[deviceFlagCount],
343 .networkID = "network2",
344 .chooseTimeStamp = GetData<uint64_t>(),
345 .isPrimary = GetData<uint8_t>() % NUM_2,
346 .SupportedConcurrency = GetData<uint8_t>() % NUM_2
347 };
348 std::unordered_map<int32_t, AffinityDeviceInfo> group1Devices = {
349 {1, device1},
350 {NUM_2, device2}
351 };
352 deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
353 deviceFlagCount = GetData<uint32_t>() % DeviceFlagVec.size();
354 AffinityDeviceInfo device3 = {
355 .groupName = "group2",
356 .deviceType = DeviceTypeVec[deviceTypeCount],
357 .deviceFlag = DeviceFlagVec[deviceFlagCount],
358 .networkID = "network3",
359 .chooseTimeStamp = GetData<uint64_t>(),
360 .isPrimary = GetData<uint8_t>() % NUM_2,
361 .SupportedConcurrency = GetData<uint8_t>() % NUM_2
362 };
363 std::unordered_map<int32_t, AffinityDeviceInfo> group2Devices = {
364 {NUM_3, device3}
365 };
366 AFFINITYDEVINFOMAP testActiveGroupMap_ = {
367 {"group1", group1Devices},
368 {"group2", group2Devices}
369 };
370 audioAffinityManager->GetActiveAffinityDeviceMapByGroupName(testActiveGroupMap_, targetGroup);
371 }
372
GetAffinityClientUIDFuzzTest()373 void GetAffinityClientUIDFuzzTest()
374 {
375 AudioAffinityManager affinityManager;
376 std::unordered_map<int32_t, AffinityDeviceInfo> affinityDeviceInfoMap;
377 AffinityDeviceInfo deviceInfo1;
378 deviceInfo1.SupportedConcurrency = GetData<uint8_t>() % NUM_2;
379 deviceInfo1.chooseTimeStamp = GetData<uint64_t>();
380 AffinityDeviceInfo deviceInfo2;
381 deviceInfo2.SupportedConcurrency = GetData<uint8_t>() % NUM_2;
382 deviceInfo2.chooseTimeStamp = GetData<uint64_t>();
383 int32_t clientUID = GetData<int32_t>();
384 affinityDeviceInfoMap[clientUID] = deviceInfo1;
385 affinityDeviceInfoMap[clientUID + 1] = deviceInfo2;
386 int32_t result = affinityManager.GetAffinityClientUID(clientUID, affinityDeviceInfoMap);
387 }
388
DelActiveGroupAffinityMapFuzzTest()389 void DelActiveGroupAffinityMapFuzzTest()
390 {
391 AudioAffinityManager affinityManager;
392 AffinityDeviceInfo deviceInfo1;
393 AffinityDeviceInfo deviceInfo2;
394 std::unordered_map<int32_t, AffinityDeviceInfo> testDeviceInfoMap;
395 PrepareTestData(deviceInfo1, deviceInfo2, testDeviceInfoMap);
396 int32_t clientUID = GetData<int32_t>();
397 affinityManager.DelActiveGroupAffinityMap(clientUID, testDeviceInfoMap);
398 }
399
AudioAffinityManagerAddSelectRendererDeviceFuzzTest()400 void AudioAffinityManagerAddSelectRendererDeviceFuzzTest()
401 {
402 AudioAffinityManager affinityManager;
403 int32_t clientUID = GetData<int32_t>();
404 shared_ptr<AudioDeviceDescriptor> desc = make_shared<AudioDeviceDescriptor>();
405 affinityManager.AddSelectRendererDevice(clientUID, desc);
406 }
407
AudioAffinityManagerAddSelectCapturerDeviceFuzzTest()408 void AudioAffinityManagerAddSelectCapturerDeviceFuzzTest()
409 {
410 AudioAffinityManager affinityManager;
411 int32_t clientUID = GetData<int32_t>();
412 shared_ptr<AudioDeviceDescriptor> desc = make_shared<AudioDeviceDescriptor>();
413 affinityManager.AddSelectCapturerDevice(clientUID, desc);
414 }
415
AudioAffinityManagerDelSelectRendererDeviceFuzzTest()416 void AudioAffinityManagerDelSelectRendererDeviceFuzzTest()
417 {
418 AudioAffinityManager affinityManager;
419 int32_t clientUID = GetData<int32_t>();
420 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
421 affinityManager.activeRendererDeviceMap_.insert({clientUID, desc});
422 affinityManager.DelSelectRendererDevice(clientUID);
423 }
424
AudioAffinityManagerDelSelectCapturerDeviceFuzzTest()425 void AudioAffinityManagerDelSelectCapturerDeviceFuzzTest()
426 {
427 AudioAffinityManager affinityManager;
428 int32_t clientUID = GetData<int32_t>();
429 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
430 affinityManager.activeRendererDeviceMap_.insert({clientUID, desc});
431 affinityManager.DelSelectCapturerDevice(clientUID);
432 }
433
434 TestFuncs g_testFuncs[TESTSIZE] = {
435 ParseAffinityXmlFuzzTest,
436 OnXmlParsingCompletedFuzzTest,
437 GetRendererDeviceFuzzTest,
438 GetCapturerDeviceFuzzTest,
439 DelSelectRendererDeviceFuzzTest,
440 DelSelectCapturerDeviceFuzzTest,
441 RemoveOfflineRendererDeviceFuzzTest,
442 RemoveOfflineCapturerDeviceFuzzTest,
443 GetAffinityDeviceInfoByDeviceTypeFuzzTest,
444 GetActiveAffinityDeviceMapByGroupNameFuzzTest,
445 GetAffinityClientUIDFuzzTest,
446 DelActiveGroupAffinityMapFuzzTest,
447 AudioAffinityManagerAddSelectRendererDeviceFuzzTest,
448 AudioAffinityManagerAddSelectCapturerDeviceFuzzTest,
449 AudioAffinityManagerDelSelectRendererDeviceFuzzTest,
450 AudioAffinityManagerDelSelectCapturerDeviceFuzzTest,
451 };
452
FuzzTest(const uint8_t * rawData,size_t size)453 bool FuzzTest(const uint8_t* rawData, size_t size)
454 {
455 if (rawData == nullptr) {
456 return false;
457 }
458
459 // initialize data
460 RAW_DATA = rawData;
461 g_dataSize = size;
462 g_pos = 0;
463
464 uint32_t code = GetData<uint32_t>();
465 uint32_t len = GetArrLength(g_testFuncs);
466 if (len > 0) {
467 g_testFuncs[code % len]();
468 } else {
469 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
470 }
471
472 return true;
473 }
474 } // namespace AudioStandard
475 } // namesapce OHOS
476
477 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)478 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
479 {
480 if (size < OHOS::AudioStandard::THRESHOLD) {
481 return 0;
482 }
483
484 OHOS::AudioStandard::FuzzTest(data, size);
485 return 0;
486 }
487