1 /*
2 * Copyright (c) 2024-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 "volume_data_maintainer.h"
17 using namespace std;
18
19 namespace OHOS {
20 namespace AudioStandard {
21
22 const int32_t NUM_2 = 2;
23 const int32_t NUM_3 = 3;
24 typedef void (*TestPtr)(const uint8_t *, size_t);
25
26 const vector<DeviceType> g_testDeviceTypes = {
27 DEVICE_TYPE_NONE,
28 DEVICE_TYPE_INVALID,
29 DEVICE_TYPE_EARPIECE,
30 DEVICE_TYPE_SPEAKER,
31 DEVICE_TYPE_WIRED_HEADSET,
32 DEVICE_TYPE_WIRED_HEADPHONES,
33 DEVICE_TYPE_BLUETOOTH_SCO,
34 DEVICE_TYPE_BLUETOOTH_A2DP,
35 DEVICE_TYPE_BLUETOOTH_A2DP_IN,
36 DEVICE_TYPE_HEARING_AID,
37 DEVICE_TYPE_MIC,
38 DEVICE_TYPE_WAKEUP,
39 DEVICE_TYPE_USB_HEADSET,
40 DEVICE_TYPE_DP,
41 DEVICE_TYPE_REMOTE_CAST,
42 DEVICE_TYPE_USB_DEVICE,
43 DEVICE_TYPE_ACCESSORY,
44 DEVICE_TYPE_REMOTE_DAUDIO,
45 DEVICE_TYPE_HDMI,
46 DEVICE_TYPE_LINE_DIGITAL,
47 DEVICE_TYPE_NEARLINK,
48 DEVICE_TYPE_NEARLINK_IN,
49 DEVICE_TYPE_FILE_SINK,
50 DEVICE_TYPE_FILE_SOURCE,
51 DEVICE_TYPE_EXTERN_CABLE,
52 DEVICE_TYPE_DEFAULT,
53 DEVICE_TYPE_USB_ARM_HEADSET,
54 DEVICE_TYPE_MAX
55 };
56
57 const vector<AudioStreamType> g_testStreamTypes = {
58 STREAM_DEFAULT,
59 STREAM_VOICE_CALL,
60 STREAM_MUSIC,
61 STREAM_RING,
62 STREAM_MEDIA,
63 STREAM_VOICE_ASSISTANT,
64 STREAM_SYSTEM,
65 STREAM_ALARM,
66 STREAM_NOTIFICATION,
67 STREAM_BLUETOOTH_SCO,
68 STREAM_ENFORCED_AUDIBLE,
69 STREAM_DTMF,
70 STREAM_TTS,
71 STREAM_ACCESSIBILITY,
72 STREAM_RECORDING,
73 STREAM_MOVIE,
74 STREAM_GAME,
75 STREAM_SPEECH,
76 STREAM_SYSTEM_ENFORCED,
77 STREAM_ULTRASONIC,
78 STREAM_WAKEUP,
79 STREAM_VOICE_MESSAGE,
80 STREAM_NAVIGATION,
81 STREAM_INTERNAL_FORCE_STOP,
82 STREAM_SOURCE_VOICE_CALL,
83 STREAM_VOICE_COMMUNICATION,
84 STREAM_VOICE_RING,
85 STREAM_VOICE_CALL_ASSISTANT,
86 STREAM_CAMCORDER,
87 STREAM_APP,
88 STREAM_TYPE_MAX,
89 STREAM_ALL,
90 };
91
92 template<class T>
GetArrLength(T & arr)93 uint32_t GetArrLength(T& arr)
94 {
95 if (arr == nullptr) {
96 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
97 return 0;
98 }
99 return sizeof(arr) / sizeof(arr[0]);
100 }
101
VolumeDataMaintainerSaveVolumeFuzzTest(const uint8_t * rawData,size_t size)102 void VolumeDataMaintainerSaveVolumeFuzzTest(const uint8_t *rawData, size_t size)
103 {
104 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
105 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
106 DeviceType typeRet = g_testDeviceTypes[index];
107 index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
108 AudioStreamType streamTypeRet = g_testStreamTypes[index];
109 int32_t volumeLevelRet = static_cast<int32_t>(size);
110 volumeDataMaintainerRet->SaveVolume(typeRet, streamTypeRet, volumeLevelRet);
111 }
112
VolumeDataMaintainerGetVolumeFuzzTest(const uint8_t * rawData,size_t size)113 void VolumeDataMaintainerGetVolumeFuzzTest(const uint8_t *rawData, size_t size)
114 {
115 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
116 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
117 DeviceType deviceTypeRet = g_testDeviceTypes[index];
118 index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
119 AudioStreamType streamTypeRet = g_testStreamTypes[index];
120 volumeDataMaintainerRet->GetVolume(deviceTypeRet, streamTypeRet);
121 }
122
VolumeDataMaintainerSaveMuteStatusFuzzTest(const uint8_t * rawData,size_t size)123 void VolumeDataMaintainerSaveMuteStatusFuzzTest(const uint8_t *rawData, size_t size)
124 {
125 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
126 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
127 DeviceType deviceTypeRet = g_testDeviceTypes[index];
128 index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
129 AudioStreamType streamTypeRet = g_testStreamTypes[index];
130 bool muteStatusRet = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
131 volumeDataMaintainerRet->SaveMuteStatus(deviceTypeRet, streamTypeRet, muteStatusRet);
132 }
133
VolumeDataMaintainerGetMuteStatusInternalFuzzTest(const uint8_t * rawData,size_t size)134 void VolumeDataMaintainerGetMuteStatusInternalFuzzTest(const uint8_t *rawData, size_t size)
135 {
136 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
137 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
138 DeviceType deviceTypeRet = g_testDeviceTypes[index];
139 index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
140 AudioStreamType streamTypeRet = g_testStreamTypes[index];
141 volumeDataMaintainerRet->GetMuteStatusInternal(deviceTypeRet, streamTypeRet);
142 }
143
VolumeDataMaintainerGetMuteTransferStatusFuzzTest(const uint8_t * rawData,size_t size)144 void VolumeDataMaintainerGetMuteTransferStatusFuzzTest(const uint8_t *rawData, size_t size)
145 {
146 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
147 int32_t affectedRet;
148 bool statusRet;
149 volumeDataMaintainerRet->GetMuteAffected(affectedRet);
150 volumeDataMaintainerRet->GetMuteTransferStatus(statusRet);
151 }
152
VolumeDataMaintainerGetSafeStatusFuzzTest(const uint8_t * rawData,size_t size)153 void VolumeDataMaintainerGetSafeStatusFuzzTest(const uint8_t *rawData, size_t size)
154 {
155 vector<SafeStatus> testSafeStatus = {
156 SAFE_UNKNOWN,
157 SAFE_INACTIVE,
158 SAFE_ACTIVE,
159 };
160 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
161 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
162 DeviceType deviceTypeRet = g_testDeviceTypes[index];
163 index = static_cast<uint32_t>(size) % testSafeStatus.size();
164 SafeStatus safeStatusRet = testSafeStatus[index];
165 volumeDataMaintainerRet->SaveSafeStatus(deviceTypeRet, safeStatusRet);
166 volumeDataMaintainerRet->GetSafeStatus(deviceTypeRet, safeStatusRet);
167 }
168
VolumeDataMaintainerGetSafeVolumeTimeFuzzTest(const uint8_t * rawData,size_t size)169 void VolumeDataMaintainerGetSafeVolumeTimeFuzzTest(const uint8_t *rawData, size_t size)
170 {
171 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
172 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
173 DeviceType deviceTypeRet = g_testDeviceTypes[index];
174 int64_t timeRet = static_cast<int64_t>(size);
175 volumeDataMaintainerRet->SaveSafeVolumeTime(deviceTypeRet, timeRet);
176 volumeDataMaintainerRet->GetSafeVolumeTime(deviceTypeRet, timeRet);
177 }
178
VolumeDataMaintainerRegisterClonedFuzzTest(const uint8_t * rawData,size_t size)179 void VolumeDataMaintainerRegisterClonedFuzzTest(const uint8_t *rawData, size_t size)
180 {
181 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
182 std::string keyRet;
183 std::string valueRet;
184 volumeDataMaintainerRet->SaveSystemSoundUrl(keyRet, valueRet);
185 volumeDataMaintainerRet->GetSystemSoundUrl(keyRet, valueRet);
186 volumeDataMaintainerRet->RegisterCloned();
187 }
188
VolumeDataMaintainerGetMicMuteStateFuzzTest(const uint8_t * rawData,size_t size)189 void VolumeDataMaintainerGetMicMuteStateFuzzTest(const uint8_t *rawData, size_t size)
190 {
191 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
192 bool isMuteRet = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
193 volumeDataMaintainerRet->SaveMicMuteState(isMuteRet);
194 volumeDataMaintainerRet->GetMicMuteState(isMuteRet);
195 }
196
VolumeDataMaintainerGetDeviceTypeNameFuzzTest(const uint8_t * rawData,size_t size)197 void VolumeDataMaintainerGetDeviceTypeNameFuzzTest(const uint8_t *rawData, size_t size)
198 {
199 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
200 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
201 DeviceType deviceTypeRet = g_testDeviceTypes[index];
202 volumeDataMaintainerRet->GetDeviceTypeName(deviceTypeRet);
203 }
204
VolumeDataMaintainerGetVolumeKeyForDataShareFuzzTest(const uint8_t * rawData,size_t size)205 void VolumeDataMaintainerGetVolumeKeyForDataShareFuzzTest(const uint8_t *rawData, size_t size)
206 {
207 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
208 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
209 DeviceType deviceTypeRet = g_testDeviceTypes[index];
210 index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
211 AudioStreamType streamTypeRet = g_testStreamTypes[index];
212 volumeDataMaintainerRet->GetVolumeKeyForDataShare(deviceTypeRet, streamTypeRet);
213 }
214
VolumeDataMaintainerSaveMuteStatusInternalFuzzTest(const uint8_t * rawData,size_t size)215 void VolumeDataMaintainerSaveMuteStatusInternalFuzzTest(const uint8_t *rawData, size_t size)
216 {
217 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
218 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
219 DeviceType deviceType = g_testDeviceTypes[index];
220 index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
221 AudioStreamType streamType = g_testStreamTypes[index];
222 bool muteStatus = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
223 bool result = volumeDataMaintainer->SaveMuteStatusInternal(deviceType, streamType, muteStatus);
224 }
225
VolumeDataMaintainerGetAppMuteFuzzTest(const uint8_t * rawData,size_t size)226 void VolumeDataMaintainerGetAppMuteFuzzTest(const uint8_t *rawData, size_t size)
227 {
228 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
229 int32_t appUid = static_cast<int32_t>(size);
230 bool isMute = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
231 volumeDataMaintainer->appMuteStatusMap_.erase(appUid);
232
233 volumeDataMaintainer->GetAppMute(appUid, isMute);
234 }
235
VolumeDataMaintainerGetAppMuteOwnedFuzzTest(const uint8_t * rawData,size_t size)236 void VolumeDataMaintainerGetAppMuteOwnedFuzzTest(const uint8_t *rawData, size_t size)
237 {
238 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
239 int32_t appUid = static_cast<int32_t>(size);
240 bool isMute = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
241 int32_t callingUid = IPCSkeleton::GetCallingUid();
242 volumeDataMaintainer->appMuteStatusMap_[appUid][callingUid] = !isMute;
243
244 volumeDataMaintainer->GetAppMuteOwned(appUid, isMute);
245 }
246
VolumeDataMaintainerGetDeviceVolumeInternalFuzzTest(const uint8_t * rawData,size_t size)247 void VolumeDataMaintainerGetDeviceVolumeInternalFuzzTest(const uint8_t *rawData, size_t size)
248 {
249 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
250 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
251 DeviceType deviceType = g_testDeviceTypes[index];
252 index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
253 AudioStreamType streamType = g_testStreamTypes[index];
254 volumeDataMaintainer->GetDeviceVolumeInternal(deviceType, streamType);
255 }
256
VolumeDataMaintainerSetMuteAffectedToMuteStatusDataBaseFuzzTest(const uint8_t * rawData,size_t size)257 void VolumeDataMaintainerSetMuteAffectedToMuteStatusDataBaseFuzzTest(const uint8_t *rawData, size_t size)
258 {
259 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
260 std::lock_guard<ffrt::mutex> lock(volumeDataMaintainer->volumeMutex_);
261 volumeDataMaintainer->volumeLevelMap_.clear();
262 volumeDataMaintainer->appVolumeLevelMap_.clear();
263 volumeDataMaintainer->appMuteStatusMap_.clear();
264
265 int32_t affected = static_cast<int32_t>(size);
266 volumeDataMaintainer->SetMuteAffectedToMuteStatusDataBase(affected);
267 }
268
VolumeDataMaintainerSetRestoreVolumeLevelFuzzTest(const uint8_t * rawData,size_t size)269 void VolumeDataMaintainerSetRestoreVolumeLevelFuzzTest(const uint8_t *rawData, size_t size)
270 {
271 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
272 std::lock_guard<ffrt::mutex> lock(volumeDataMaintainer->volumeMutex_);
273 volumeDataMaintainer->volumeLevelMap_.clear();
274 volumeDataMaintainer->appVolumeLevelMap_.clear();
275 volumeDataMaintainer->appMuteStatusMap_.clear();
276
277 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
278 DeviceType deviceType = g_testDeviceTypes[index];
279 int32_t volume = static_cast<int32_t>(size);
280 volumeDataMaintainer->SetRestoreVolumeLevel(deviceType, volume);
281 }
282
VolumeDataMaintainerGetRestoreVolumeLevelFuzzTest(const uint8_t * rawData,size_t size)283 void VolumeDataMaintainerGetRestoreVolumeLevelFuzzTest(const uint8_t *rawData, size_t size)
284 {
285 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainer = std::make_shared<VolumeDataMaintainer>();
286 std::lock_guard<ffrt::mutex> lock(volumeDataMaintainer->volumeMutex_);
287 volumeDataMaintainer->volumeLevelMap_.clear();
288 volumeDataMaintainer->appVolumeLevelMap_.clear();
289 volumeDataMaintainer->appMuteStatusMap_.clear();
290
291 uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
292 DeviceType deviceType = g_testDeviceTypes[index];
293 int32_t volume = static_cast<int32_t>(size);
294 volumeDataMaintainer->GetRestoreVolumeLevel(deviceType, volume);
295 }
296
VolumeDataMaintainerGetRingerModeFuzzTest(const uint8_t * rawData,size_t size)297 void VolumeDataMaintainerGetRingerModeFuzzTest(const uint8_t *rawData, size_t size)
298 {
299 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
300 int32_t affectedRet = static_cast<int32_t>(size);
301 bool statusRet = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
302 uint32_t index = static_cast<uint32_t>(size) % NUM_3;
303 AudioRingerMode ringerModeRet = static_cast<AudioRingerMode>(index);
304 volumeDataMaintainerRet->SetMuteAffectedToMuteStatusDataBase(affectedRet);
305 volumeDataMaintainerRet->SaveMuteTransferStatus(statusRet);
306 volumeDataMaintainerRet->SaveRingerMode(ringerModeRet);
307 volumeDataMaintainerRet->GetRingerMode(ringerModeRet);
308 }
309
VolumeDataMaintainerGetDeviceVolumeFuzzTest(const uint8_t * rawData,size_t size)310 void VolumeDataMaintainerGetDeviceVolumeFuzzTest(const uint8_t *rawData, size_t size)
311 {
312 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
313 uint32_t index = static_cast<uint32_t>(size);
314 DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()];
315 AudioStreamType streamType = g_testStreamTypes[index % g_testStreamTypes.size()];
316 volumeDataMaintainerRet->GetDeviceVolume(deviceType, streamType);
317 }
318
VolumeDataMaintainerSetStreamMuteStatusFuzzTest(const uint8_t * rawData,size_t size)319 void VolumeDataMaintainerSetStreamMuteStatusFuzzTest(const uint8_t *rawData, size_t size)
320 {
321 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
322 uint32_t index = static_cast<uint32_t>(size);
323 AudioStreamType streamType = g_testStreamTypes[index % g_testStreamTypes.size()];
324 bool muteStatus = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
325 volumeDataMaintainerRet->SetStreamMuteStatus(streamType, muteStatus);
326 }
327
VolumeDataMaintainerGetMuteStatusFuzzTest(const uint8_t * rawData,size_t size)328 void VolumeDataMaintainerGetMuteStatusFuzzTest(const uint8_t *rawData, size_t size)
329 {
330 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
331 uint32_t index = static_cast<uint32_t>(size);
332 DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()];
333 AudioStreamType streamType = g_testStreamTypes[index % g_testStreamTypes.size()];
334 volumeDataMaintainerRet->GetMuteStatus(deviceType, streamType);
335 }
336
VolumeDataMaintainerGetStreamMuteFuzzTest(const uint8_t * rawData,size_t size)337 void VolumeDataMaintainerGetStreamMuteFuzzTest(const uint8_t *rawData, size_t size)
338 {
339 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
340 uint32_t index = static_cast<uint32_t>(size);
341 AudioStreamType streamType = g_testStreamTypes[index % g_testStreamTypes.size()];
342 volumeDataMaintainerRet->GetStreamMute(streamType);
343 }
344
VolumeDataMaintainerSetAppVolumeFuzzTest(const uint8_t * rawData,size_t size)345 void VolumeDataMaintainerSetAppVolumeFuzzTest(const uint8_t *rawData, size_t size)
346 {
347 std::shared_ptr<VolumeDataMaintainer> volumeDataMaintainerRet = std::make_shared<VolumeDataMaintainer>();
348 int32_t appUid = static_cast<int32_t>(size);
349 int32_t volumeLevel = static_cast<int32_t>(size / NUM_2);
350 volumeDataMaintainerRet->SetAppVolume(appUid, volumeLevel);
351 }
352
353 } // namespace AudioStandard
354 } // namesapce OHOS
355
356 OHOS::AudioStandard::TestPtr g_testPtrs[] = {
357 OHOS::AudioStandard::VolumeDataMaintainerSaveVolumeFuzzTest,
358 OHOS::AudioStandard::VolumeDataMaintainerGetVolumeFuzzTest,
359 OHOS::AudioStandard::VolumeDataMaintainerSaveMuteStatusFuzzTest,
360 OHOS::AudioStandard::VolumeDataMaintainerGetMuteStatusInternalFuzzTest,
361 OHOS::AudioStandard::VolumeDataMaintainerGetMuteTransferStatusFuzzTest,
362 OHOS::AudioStandard::VolumeDataMaintainerGetSafeStatusFuzzTest,
363 OHOS::AudioStandard::VolumeDataMaintainerGetSafeVolumeTimeFuzzTest,
364 OHOS::AudioStandard::VolumeDataMaintainerRegisterClonedFuzzTest,
365 OHOS::AudioStandard::VolumeDataMaintainerGetMicMuteStateFuzzTest,
366 OHOS::AudioStandard::VolumeDataMaintainerGetDeviceTypeNameFuzzTest,
367 OHOS::AudioStandard::VolumeDataMaintainerGetVolumeKeyForDataShareFuzzTest,
368 OHOS::AudioStandard::VolumeDataMaintainerSaveMuteStatusInternalFuzzTest,
369 OHOS::AudioStandard::VolumeDataMaintainerGetAppMuteFuzzTest,
370 OHOS::AudioStandard::VolumeDataMaintainerGetAppMuteOwnedFuzzTest,
371 OHOS::AudioStandard::VolumeDataMaintainerGetDeviceVolumeInternalFuzzTest,
372 OHOS::AudioStandard::VolumeDataMaintainerSetMuteAffectedToMuteStatusDataBaseFuzzTest,
373 OHOS::AudioStandard::VolumeDataMaintainerSetRestoreVolumeLevelFuzzTest,
374 OHOS::AudioStandard::VolumeDataMaintainerGetRestoreVolumeLevelFuzzTest,
375 OHOS::AudioStandard::VolumeDataMaintainerGetRingerModeFuzzTest,
376 OHOS::AudioStandard::VolumeDataMaintainerGetDeviceVolumeFuzzTest,
377 OHOS::AudioStandard::VolumeDataMaintainerSetStreamMuteStatusFuzzTest,
378 OHOS::AudioStandard::VolumeDataMaintainerGetMuteStatusFuzzTest,
379 OHOS::AudioStandard::VolumeDataMaintainerGetStreamMuteFuzzTest,
380 OHOS::AudioStandard::VolumeDataMaintainerSetAppVolumeFuzzTest,
381 };
382
383 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)384 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
385 {
386 /* Run your code on data */
387 if (data == nullptr || size <= 1) {
388 return 0;
389 }
390 uint32_t len = OHOS::AudioStandard::GetArrLength(g_testPtrs);
391 if (len > 0) {
392 uint8_t firstByte = *data % len;
393 if (firstByte >= len) {
394 return 0;
395 }
396 data = data + 1;
397 size = size - 1;
398 g_testPtrs[firstByte](data, size);
399 }
400 return 0;
401 }