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_spatialization_service.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 = 24;
54 static int32_t NUM_2 = 2;
55
56 typedef void (*TestFuncs)();
57
58 vector<AudioSpatializationSceneType> AudioSpatializationSceneTypeVec = {
59 SPATIALIZATION_SCENE_TYPE_DEFAULT,
60 SPATIALIZATION_SCENE_TYPE_MUSIC,
61 SPATIALIZATION_SCENE_TYPE_MOVIE,
62 SPATIALIZATION_SCENE_TYPE_AUDIOBOOK,
63 SPATIALIZATION_SCENE_TYPE_MAX,
64 };
65
66 vector<StreamUsage> StreamUsageVec = {
67 STREAM_USAGE_INVALID,
68 STREAM_USAGE_UNKNOWN,
69 STREAM_USAGE_MEDIA,
70 STREAM_USAGE_MUSIC,
71 STREAM_USAGE_VOICE_COMMUNICATION,
72 STREAM_USAGE_VOICE_ASSISTANT,
73 STREAM_USAGE_ALARM,
74 STREAM_USAGE_VOICE_MESSAGE,
75 STREAM_USAGE_NOTIFICATION_RINGTONE,
76 STREAM_USAGE_RINGTONE,
77 STREAM_USAGE_NOTIFICATION,
78 STREAM_USAGE_ACCESSIBILITY,
79 STREAM_USAGE_SYSTEM,
80 STREAM_USAGE_MOVIE,
81 STREAM_USAGE_GAME,
82 STREAM_USAGE_AUDIOBOOK,
83 STREAM_USAGE_NAVIGATION,
84 STREAM_USAGE_DTMF,
85 STREAM_USAGE_ENFORCED_TONE,
86 STREAM_USAGE_ULTRASONIC,
87 STREAM_USAGE_VIDEO_COMMUNICATION,
88 STREAM_USAGE_RANGING,
89 STREAM_USAGE_VOICE_MODEM_COMMUNICATION,
90 STREAM_USAGE_VOICE_RINGTONE,
91 STREAM_USAGE_VOICE_CALL_ASSISTANT,
92 STREAM_USAGE_MAX,
93 };
94
95 template<class T>
GetData()96 T GetData()
97 {
98 T object {};
99 size_t objectSize = sizeof(object);
100 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
101 return object;
102 }
103 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
104 if (ret != EOK) {
105 return {};
106 }
107 g_pos += objectSize;
108 return object;
109 }
110
111 template<class T>
GetArrLength(T & arr)112 uint32_t GetArrLength(T& arr)
113 {
114 if (arr == nullptr) {
115 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
116 return 0;
117 }
118 return sizeof(arr) / sizeof(arr[0]);
119 }
120
UpdateCurrentDeviceFuzzTest()121 void UpdateCurrentDeviceFuzzTest()
122 {
123 AudioSpatializationService service;
124 // Update with a new device
125 std::string newMacAddress = "00:11:22:33:44:55";
126 service.UpdateCurrentDevice(newMacAddress);
127 // Update with the same device (no change expected)
128 service.UpdateCurrentDevice(newMacAddress);
129 // Update with an empty address (should not change the current device)
130 std::string originalAddress = service.GetCurrentDeviceAddress();
131 service.UpdateCurrentDevice("");
132 // Update with a new device that has spatial capabilities
133 std::string spatialDeviceAddress = "AA:BB:CC:DD:EE:FF";
134 int32_t audioSpatialDeviceTypeCount = static_cast<int32_t>(AudioSpatialDeviceType::EARPHONE_TYPE_OTHERS) + 1;
135 AudioSpatialDeviceType audioSpatialDeviceType =
136 static_cast<AudioSpatialDeviceType>(GetData<int32_t>() % audioSpatialDeviceTypeCount);
137 service.addressToSpatialDeviceStateMap_[service.GetSha256EncryptAddress(spatialDeviceAddress)] = {
138 spatialDeviceAddress, // address
139 GetData<uint32_t>() % NUM_2, // isSpatializationSupported
140 GetData<uint32_t>() % NUM_2, // isHeadTrackingSupported
141 audioSpatialDeviceType // spatialDeviceType
142 };
143 service.UpdateCurrentDevice(spatialDeviceAddress);
144 // Update with a device that doesn't have spatial capabilities
145 std::string nonSpatialDeviceAddress = "11:22:33:44:55:66";
146 service.UpdateCurrentDevice(nonSpatialDeviceAddress);
147 }
148
RemoveOldestDeviceFuzzTest()149 void RemoveOldestDeviceFuzzTest()
150 {
151 AudioSpatializationService service;
152 service.addressToDeviceSpatialInfoMap_ = {
153 {"device1", "info1|1000"},
154 {"device2", "info2|2000"},
155 {"device3", "info3|1500"}
156 };
157 service.addressToSpatialEnabledMap_ = {
158 {"device1", AudioSpatializationState{GetData<uint32_t>() % NUM_2, GetData<uint32_t>() % NUM_2}},
159 {"device2", AudioSpatializationState{GetData<uint32_t>() % NUM_2, GetData<uint32_t>() % NUM_2}},
160 {"device3", AudioSpatializationState{GetData<uint32_t>() % NUM_2, GetData<uint32_t>() % NUM_2}}
161 };
162 int32_t audioSpatialDeviceTypeCount = static_cast<int32_t>(AudioSpatialDeviceType::EARPHONE_TYPE_OTHERS) + 1;
163 int32_t audioSpatialDeviceTypeCount1 = static_cast<int32_t>(AudioSpatialDeviceType::EARPHONE_TYPE_OTHERS) + 1;
164 AudioSpatialDeviceType audioSpatialDeviceType =
165 static_cast<AudioSpatialDeviceType>(GetData<int32_t>() % audioSpatialDeviceTypeCount);
166 AudioSpatialDeviceType audioSpatialDeviceType1 =
167 static_cast<AudioSpatialDeviceType>(GetData<int32_t>() % audioSpatialDeviceTypeCount1);
168 service.addressToSpatialDeviceStateMap_ = {
169 {"device1", AudioSpatialDeviceState{"device1", GetData<uint32_t>() % NUM_2,
170 GetData<uint32_t>() % NUM_2, audioSpatialDeviceType}},
171 {"device2", AudioSpatialDeviceState{"device2", GetData<uint32_t>() % NUM_2,
172 GetData<uint32_t>() % NUM_2, audioSpatialDeviceType1}},
173 {"device3", AudioSpatialDeviceState{"device3", GetData<uint32_t>() % NUM_2,
174 GetData<uint32_t>() % NUM_2, audioSpatialDeviceType}}
175 };
176 service.RemoveOldestDevice();
177 }
178
UpdateDeviceSpatialMapInfoFuzzTest()179 void UpdateDeviceSpatialMapInfoFuzzTest()
180 {
181 AudioSpatializationService service;
182 for (uint32_t i = 1; i <= AudioSpatializationService::MAX_DEVICE_NUM; ++i) {
183 std::string device = "device" + std::to_string(i);
184 std::string info = "info" + std::to_string(i);
185 service.UpdateDeviceSpatialMapInfo(device, info);
186 service.GetSha256EncryptAddress(device);
187 }
188 // Test updating existing devices
189 auto exitNum = GetData<uint32_t>() % AudioSpatializationService::MAX_DEVICE_NUM;
190 service.UpdateDeviceSpatialMapInfo("device" + to_string(exitNum), "info" + to_string(exitNum));
191 // Test adding more than the maximum number of devices
192 service.UpdateDeviceSpatialMapInfo("device" + to_string(exitNum + AudioSpatializationService::MAX_DEVICE_NUM),
193 "info" + to_string(exitNum + AudioSpatializationService::MAX_DEVICE_NUM));
194 }
195
WriteSpatializationStateToDbFuzzTest()196 void WriteSpatializationStateToDbFuzzTest()
197 {
198 AudioSpatializationService service;
199 uint32_t testSceneCount = GetData<uint32_t>() % AudioSpatializationSceneTypeVec.size();
200 AudioSpatializationSceneType testScene = AudioSpatializationSceneTypeVec[testSceneCount];
201 service.spatializationSceneType_ = testScene;
202 int32_t operationCount =
203 static_cast<int32_t>(AudioSpatializationService::WriteToDbOperation::WRITE_DEVICESPATIAL_INFO) + 1;
204 AudioSpatializationService::WriteToDbOperation operation =
205 static_cast<AudioSpatializationService::WriteToDbOperation>(GetData<uint8_t>() % operationCount);
206 service.WriteSpatializationStateToDb(operation, "");
207 }
208
GetSpatializationStateFuzzTest()209 void GetSpatializationStateFuzzTest()
210 {
211 AudioSpatializationService service;
212 service.spatializationEnabledReal_ = GetData<uint32_t>() % NUM_2;
213 service.headTrackingEnabledReal_ = GetData<uint32_t>() % NUM_2;
214 uint32_t streamUsageCount = GetData<uint32_t>() % StreamUsageVec.size();
215 StreamUsage supportedUsage = StreamUsageVec[streamUsageCount];
216 service.GetSpatializationState(supportedUsage);
217 }
218
SetHeadTrackingEnabledFuzzTest()219 void SetHeadTrackingEnabledFuzzTest()
220 {
221 AudioSpatializationService service;
222 bool enable = GetData<uint32_t>() % NUM_2;
223 service.SetHeadTrackingEnabled(enable);
224 }
225
AudioSpatializationServiceInitFuzzTest()226 void AudioSpatializationServiceInitFuzzTest()
227 {
228 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
229 vector<EffectChain> effectChains = {
230 {"EFFECTCHAIN_BT_MUSIC", {"apply1_1", "apply1_2"}, "SPATIALIZATION_AND_HEADTRACKING"},
231 {"Effect1", {"apply1_1", "apply1_2"}, "SPATIALIZATION_AND_HEADTRACKING"},
232 {"Effect2", {"apply2_1"}, "SPATIALIZATION"},
233 {"Effect3", {}, "HEADTRACKING"}
234 };
235 ptrAudioSpatializationService->Init(effectChains);
236 }
237
IsSpatializationEnabledFuzzTest()238 void IsSpatializationEnabledFuzzTest()
239 {
240 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
241 vector<string> preSettingSpatialAddressList = { "NO_PREVIOUS_SET_DEVICE", "1234", "test_address"};
242 uint32_t preSettingSpatialAddressCount = GetData<uint32_t>() % preSettingSpatialAddressList.size();
243 ptrAudioSpatializationService->preSettingSpatialAddress_ =
244 preSettingSpatialAddressList[preSettingSpatialAddressCount];
245 ptrAudioSpatializationService->IsSpatializationEnabled();
246 }
247
SetSpatializationEnabledFuzzTest()248 void SetSpatializationEnabledFuzzTest()
249 {
250 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
251 const bool enable = GetData<uint32_t>() % NUM_2;
252 ptrAudioSpatializationService->preSettingSpatialAddress_ = "NO_PREVIOUS_SET_DEVICE";
253 ptrAudioSpatializationService->spatializationStateFlag_.spatializationEnabled = GetData<uint32_t>() % NUM_2;
254 ptrAudioSpatializationService->SetSpatializationEnabled(enable);
255 }
256
IsHeadTrackingEnabledFuzzTest()257 void IsHeadTrackingEnabledFuzzTest()
258 {
259 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
260 vector<string> preSettingSpatialAddressList = { "NO_PREVIOUS_SET_DEVICE", "1234"};
261 uint32_t preSettingSpatialAddressCount = GetData<uint32_t>() % preSettingSpatialAddressList.size();
262 ptrAudioSpatializationService->preSettingSpatialAddress_ =
263 preSettingSpatialAddressList[preSettingSpatialAddressCount];
264 ptrAudioSpatializationService->IsHeadTrackingEnabled();
265 }
266
HandleHeadTrackingDeviceChangeFuzzTest()267 void HandleHeadTrackingDeviceChangeFuzzTest()
268 {
269 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
270 std::unordered_map<std::string, bool> changeInfo;
271 changeInfo.insert({"abc", GetData<uint32_t>() % NUM_2});
272 ptrAudioSpatializationService->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
273 ptrAudioSpatializationService->HandleHeadTrackingDeviceChange(changeInfo);
274 }
275
AudioSpatializationServiceIsSpatializationEnabledFuzzTest()276 void AudioSpatializationServiceIsSpatializationEnabledFuzzTest()
277 {
278 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
279 if (ptrAudioSpatializationService == nullptr) {
280 return;
281 }
282
283 std::string address = "test_address";
284 ptrAudioSpatializationService->IsSpatializationEnabled(address);
285 }
286
AudioSpatializationServiceIsSpatializationEnabledForCurrentDeviceFuzzTest()287 void AudioSpatializationServiceIsSpatializationEnabledForCurrentDeviceFuzzTest()
288 {
289 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
290 if (ptrAudioSpatializationService == nullptr) {
291 return;
292 }
293
294 ptrAudioSpatializationService->currentDeviceAddress_ = "test_address";
295 ptrAudioSpatializationService->IsSpatializationEnabledForCurrentDevice();
296 }
297
AudioSpatializationServiceSetSpatializationEnabledFuzzTest()298 void AudioSpatializationServiceSetSpatializationEnabledFuzzTest()
299 {
300 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
301 if (ptrAudioSpatializationService == nullptr) {
302 return;
303 }
304
305 const std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
306 const bool enable = GetData<bool>();
307
308 ptrAudioSpatializationService->SetSpatializationEnabled(selectedAudioDevice, enable);
309 }
310
AudioSpatializationServiceIsHeadTrackingEnabledFuzzTest()311 void AudioSpatializationServiceIsHeadTrackingEnabledFuzzTest()
312 {
313 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
314 if (ptrAudioSpatializationService == nullptr) {
315 return;
316 }
317
318 AudioSpatializationState spatializationState;
319 std::string address = "test_address";
320 ptrAudioSpatializationService->addressToSpatialEnabledMap_.insert({address, spatializationState});
321 ptrAudioSpatializationService->IsHeadTrackingEnabled(address);
322 }
323
AudioSpatializationServiceSetHeadTrackingEnabledFuzzTest()324 void AudioSpatializationServiceSetHeadTrackingEnabledFuzzTest()
325 {
326 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
327 if (ptrAudioSpatializationService == nullptr) {
328 return;
329 }
330
331 const std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
332 const bool enable = GetData<bool>();
333 ptrAudioSpatializationService->SetHeadTrackingEnabled(selectedAudioDevice, enable);
334 }
335
AudioSpatializationServiceHandleSpatializationEnabledChangeFuzzTest()336 void AudioSpatializationServiceHandleSpatializationEnabledChangeFuzzTest()
337 {
338 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
339 if (ptrAudioSpatializationService == nullptr) {
340 return;
341 }
342
343 const bool enable = GetData<bool>();
344 const std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
345 ptrAudioSpatializationService->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
346 ptrAudioSpatializationService->HandleSpatializationEnabledChange(selectedAudioDevice, enable);
347 }
348
AudioSpatializationServiceHandleSpatializationEnabledChangeForCurrentDeviceFuzzTest()349 void AudioSpatializationServiceHandleSpatializationEnabledChangeForCurrentDeviceFuzzTest()
350 {
351 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
352 if (ptrAudioSpatializationService == nullptr) {
353 return;
354 }
355
356 const bool enable = GetData<bool>();
357 ptrAudioSpatializationService->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
358 ptrAudioSpatializationService->HandleSpatializationEnabledChangeForCurrentDevice(enable);
359 }
360
AudioSpatializationServiceHandleHeadTrackingEnabledChangeFuzzTest()361 void AudioSpatializationServiceHandleHeadTrackingEnabledChangeFuzzTest()
362 {
363 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
364 if (ptrAudioSpatializationService == nullptr) {
365 return;
366 }
367
368 const bool enable = GetData<bool>();
369 const std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
370 ptrAudioSpatializationService->audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
371 ptrAudioSpatializationService->HandleHeadTrackingEnabledChange(selectedAudioDevice, enable);
372 }
373
AudioSpatializationServiceIsHeadTrackingSupportedForDeviceFuzzTest()374 void AudioSpatializationServiceIsHeadTrackingSupportedForDeviceFuzzTest()
375 {
376 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
377 if (ptrAudioSpatializationService == nullptr) {
378 return;
379 }
380
381 const std::string address = "1234";
382 ptrAudioSpatializationService->IsHeadTrackingSupportedForDevice(address);
383 }
384
AudioSpatializationServiceUpdateSpatialDeviceStateFuzzTest()385 void AudioSpatializationServiceUpdateSpatialDeviceStateFuzzTest()
386 {
387 static const vector<AudioSpatialDeviceType> audioSpatialDeviceTypeVec = {
388 EARPHONE_TYPE_NONE,
389 EARPHONE_TYPE_INEAR,
390 EARPHONE_TYPE_HALF_INEAR,
391 EARPHONE_TYPE_HEADPHONE,
392 EARPHONE_TYPE_GLASSES,
393 EARPHONE_TYPE_OTHERS,
394 };
395 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
396 if (ptrAudioSpatializationService == nullptr || audioSpatialDeviceTypeVec.empty()) {
397 return;
398 }
399
400 const AudioSpatialDeviceState audioSpatialDeviceState = {
401 "1234",
402 GetData<bool>(),
403 GetData<bool>(),
404 audioSpatialDeviceTypeVec[GetData<uint32_t>() % audioSpatialDeviceTypeVec.size()],
405 };
406 ptrAudioSpatializationService->UpdateSpatialDeviceState(audioSpatialDeviceState);
407 }
408
AudioSpatializationServiceGetSpatializationSceneTypeFuzzTest()409 void AudioSpatializationServiceGetSpatializationSceneTypeFuzzTest()
410 {
411 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
412 if (ptrAudioSpatializationService == nullptr) {
413 return;
414 }
415
416 ptrAudioSpatializationService->GetSpatializationSceneType();
417 }
418
AudioSpatializationServiceUnregisterSpatializationStateEventListenerFuzzTest()419 void AudioSpatializationServiceUnregisterSpatializationStateEventListenerFuzzTest()
420 {
421 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
422 if (ptrAudioSpatializationService == nullptr) {
423 return;
424 }
425
426 uint32_t sessionID = GetData<uint32_t>();
427 ptrAudioSpatializationService->UnregisterSpatializationStateEventListener(sessionID);
428 }
429
AudioSpatializationServiceSetSpatializationSceneTypeFuzzTest()430 void AudioSpatializationServiceSetSpatializationSceneTypeFuzzTest()
431 {
432 static const vector<AudioSpatializationSceneType> testAudioSpatializationSceneType = {
433 SPATIALIZATION_SCENE_TYPE_DEFAULT,
434 SPATIALIZATION_SCENE_TYPE_MUSIC,
435 SPATIALIZATION_SCENE_TYPE_MOVIE,
436 SPATIALIZATION_SCENE_TYPE_AUDIOBOOK,
437 SPATIALIZATION_SCENE_TYPE_MAX,
438 };
439 auto ptrAudioSpatializationService = std::make_shared<AudioSpatializationService>();
440 if (ptrAudioSpatializationService == nullptr || testAudioSpatializationSceneType.empty()) {
441 return;
442 }
443
444 AudioSpatializationSceneType spatializationSceneType =
445 testAudioSpatializationSceneType[GetData<uint32_t>() % testAudioSpatializationSceneType.size()];
446 ptrAudioSpatializationService->SetSpatializationSceneType(spatializationSceneType);
447 }
448
449 TestFuncs g_testFuncs[TESTSIZE] = {
450 UpdateCurrentDeviceFuzzTest,
451 RemoveOldestDeviceFuzzTest,
452 UpdateDeviceSpatialMapInfoFuzzTest,
453 WriteSpatializationStateToDbFuzzTest,
454 GetSpatializationStateFuzzTest,
455 SetHeadTrackingEnabledFuzzTest,
456 AudioSpatializationServiceInitFuzzTest,
457 IsSpatializationEnabledFuzzTest,
458 SetSpatializationEnabledFuzzTest,
459 IsHeadTrackingEnabledFuzzTest,
460 HandleHeadTrackingDeviceChangeFuzzTest,
461 AudioSpatializationServiceIsSpatializationEnabledFuzzTest,
462 AudioSpatializationServiceIsSpatializationEnabledForCurrentDeviceFuzzTest,
463 AudioSpatializationServiceSetSpatializationEnabledFuzzTest,
464 AudioSpatializationServiceIsHeadTrackingEnabledFuzzTest,
465 AudioSpatializationServiceSetHeadTrackingEnabledFuzzTest,
466 AudioSpatializationServiceHandleSpatializationEnabledChangeFuzzTest,
467 AudioSpatializationServiceHandleSpatializationEnabledChangeForCurrentDeviceFuzzTest,
468 AudioSpatializationServiceHandleHeadTrackingEnabledChangeFuzzTest,
469 AudioSpatializationServiceIsHeadTrackingSupportedForDeviceFuzzTest,
470 AudioSpatializationServiceUpdateSpatialDeviceStateFuzzTest,
471 AudioSpatializationServiceGetSpatializationSceneTypeFuzzTest,
472 AudioSpatializationServiceUnregisterSpatializationStateEventListenerFuzzTest,
473 AudioSpatializationServiceSetSpatializationSceneTypeFuzzTest,
474 };
475
FuzzTest(const uint8_t * rawData,size_t size)476 bool FuzzTest(const uint8_t* rawData, size_t size)
477 {
478 if (rawData == nullptr) {
479 return false;
480 }
481
482 // initialize data
483 RAW_DATA = rawData;
484 g_dataSize = size;
485 g_pos = 0;
486
487 uint32_t code = GetData<uint32_t>();
488 uint32_t len = GetArrLength(g_testFuncs);
489 if (len > 0) {
490 g_testFuncs[code % len]();
491 } else {
492 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
493 }
494
495 return true;
496 }
497 } // namespace AudioStandard
498 } // namesapce OHOS
499
500 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)501 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
502 {
503 if (size < OHOS::AudioStandard::THRESHOLD) {
504 return 0;
505 }
506
507 OHOS::AudioStandard::FuzzTest(data, size);
508 return 0;
509 }
510