1 /*
2  * Copyright (c) 2022 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 
20 #include "i_audio_renderer_sink.h"
21 #include "audio_manager_base.h"
22 #include "audio_policy_manager_listener_stub.h"
23 #include "audio_server.h"
24 #include "message_parcel.h"
25 using namespace std;
26 
27 namespace OHOS {
28 namespace AudioStandard {
29 constexpr int32_t OFFSET = 4;
30 const std::u16string FORMMGR_INTERFACE_TOKEN = u"IStandardAudioService";
31 const int32_t SYSTEM_ABILITY_ID = 3001;
32 const bool RUN_ON_CREATE = false;
33 const int32_t LIMITSIZE = 4;
34 const int32_t SHIFT_LEFT_8 = 8;
35 const int32_t SHIFT_LEFT_16 = 16;
36 const int32_t SHIFT_LEFT_24 = 24;
37 const uint32_t LIMIT_MIN = 0;
38 const uint32_t LIMIT_MAX = static_cast<uint32_t>(AudioServerInterfaceCode::AUDIO_SERVER_CODE_MAX);
39 
Convert2Uint32(const uint8_t * ptr)40 uint32_t Convert2Uint32(const uint8_t *ptr)
41 {
42     if (ptr == nullptr) {
43         return 0;
44     }
45     /* Move the 0th digit to the left by 24 bits, the 1st digit to the left by 16 bits,
46        the 2nd digit to the left by 8 bits, and the 3rd digit not to the left */
47     return (ptr[0] << SHIFT_LEFT_24) | (ptr[1] << SHIFT_LEFT_16) | (ptr[2] << SHIFT_LEFT_8) | (ptr[3]);
48 }
49 
AudioServerFuzzTest(const uint8_t * rawData,size_t size)50 void AudioServerFuzzTest(const uint8_t *rawData, size_t size)
51 {
52     if (rawData == nullptr || size < LIMITSIZE) {
53         return;
54     }
55     uint32_t code =  Convert2Uint32(rawData) % (LIMIT_MAX - LIMIT_MIN + 1) + LIMIT_MIN;
56     rawData = rawData + OFFSET;
57     size = size - OFFSET;
58 
59     MessageParcel data;
60     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
61     data.WriteBuffer(rawData, size);
62     data.RewindRead(0);
63     MessageParcel reply;
64     MessageOption option;
65 
66     std::shared_ptr<AudioServer> AudioServerPtr =
67         std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
68 
69     if (code == static_cast<uint32_t>(AudioServerInterfaceCode::SET_PARAMETER_CALLBACK)) {
70         sptr<AudioPolicyManagerListenerStub> focusListenerStub = new(std::nothrow) AudioPolicyManagerListenerStub();
71         sptr<IRemoteObject> object = focusListenerStub->AsObject();
72         AudioServerPtr->SetParameterCallback(object);
73         return;
74     }
75     AudioServerPtr->OnRemoteRequest(code, data, reply, option);
76 
77     if (size < LIMITSIZE) {
78         return;
79     }
80     std::string netWorkId(reinterpret_cast<const char*>(rawData), size - 1);
81     AudioParamKey key = *reinterpret_cast<const AudioParamKey *>(rawData);
82     std::string condition(reinterpret_cast<const char*>(rawData), size - 1);
83     std::string value(reinterpret_cast<const char*>(rawData), size - 1);
84     AudioServerPtr->OnAudioSinkParamChange(netWorkId, key, condition, value);
85 }
86 
AudioServerCaptureSilentlyFuzzTest(const uint8_t * rawData,size_t size)87 void AudioServerCaptureSilentlyFuzzTest(const uint8_t *rawData, size_t size)
88 {
89     if (rawData == nullptr || size < LIMITSIZE) {
90         return;
91     }
92 
93     MessageParcel data;
94     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
95     data.WriteBuffer(rawData, size);
96     data.RewindRead(0);
97     MessageParcel reply;
98     MessageOption option;
99 
100     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
101     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_CAPTURE_SILENT_STATE),
102         data, reply, option);
103 }
104 
Convert2Float(const uint8_t * ptr)105 float Convert2Float(const uint8_t *ptr)
106 {
107     float floatValue = static_cast<float>(*ptr);
108     return floatValue / 128.0f - 1.0f;
109 }
110 
AudioServerOffloadSetVolumeFuzzTest(const uint8_t * rawData,size_t size)111 void AudioServerOffloadSetVolumeFuzzTest(const uint8_t *rawData, size_t size)
112 {
113     if (rawData == nullptr || size < LIMITSIZE) {
114         return;
115     }
116 
117     MessageParcel data;
118     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
119     float volume = Convert2Float(rawData);
120     data.WriteFloat(volume);
121     MessageParcel reply;
122     MessageOption option;
123 
124     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
125     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::OFFLOAD_SET_VOLUME),
126         data, reply, option);
127 }
128 
AudioServerNotifyStreamVolumeChangedFuzzTest(const uint8_t * rawData,size_t size)129 void AudioServerNotifyStreamVolumeChangedFuzzTest(const uint8_t *rawData, size_t size)
130 {
131     if (rawData == nullptr || size < LIMITSIZE) {
132         return;
133     }
134 
135     MessageParcel data;
136     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
137     uint32_t sizeMs = *reinterpret_cast<const uint32_t*>(rawData);
138     data.WriteUint32(sizeMs);
139     MessageParcel reply;
140     MessageOption option;
141 
142     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
143     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::NOTIFY_STREAM_VOLUME_CHANGED),
144         data, reply, option);
145 }
146 
AudioServerResetRouteForDisconnectFuzzTest(const uint8_t * rawData,size_t size)147 void AudioServerResetRouteForDisconnectFuzzTest(const uint8_t *rawData, size_t size)
148 {
149     if (rawData == nullptr || size < LIMITSIZE) {
150         return;
151     }
152 
153     MessageParcel data;
154     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
155     int32_t deviceType = *reinterpret_cast<const int32_t*>(rawData);
156     data.WriteInt32(deviceType);
157     MessageParcel reply;
158     MessageOption option;
159 
160     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
161     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::RESET_ROUTE_FOR_DISCONNECT),
162         data, reply, option);
163 }
164 
AudioServerGetEffectLatencyTest(const uint8_t * rawData,size_t size)165 void AudioServerGetEffectLatencyTest(const uint8_t *rawData, size_t size)
166 {
167     if (rawData == nullptr || size < LIMITSIZE) {
168         return;
169     }
170 
171     MessageParcel data;
172     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
173     std::string sessionId(reinterpret_cast<const char*>(rawData), size);
174     data.WriteString(sessionId);
175 
176     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
177     MessageParcel reply;
178     MessageOption option;
179     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_EFFECT_LATENCY),
180         data, reply, option);
181 }
182 
AudioServerUpdateLatencyTimestampTest(const uint8_t * rawData,size_t size)183 void AudioServerUpdateLatencyTimestampTest(const uint8_t *rawData, size_t size)
184 {
185     if (rawData == nullptr || size < LIMITSIZE) {
186         return;
187     }
188 
189     MessageParcel data;
190     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
191     std::string timestamp(reinterpret_cast<const char*>(rawData), size - 1);
192     bool isRenderer = *reinterpret_cast<const bool*>(rawData);
193     data.WriteString(timestamp);
194     data.WriteBool(isRenderer);
195 
196     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
197     MessageParcel reply;
198     MessageOption option;
199     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_LATENCY_TIMESTAMP),
200         data, reply, option);
201 }
202 
AudioServerGetMaxAmplitudeTest(const uint8_t * rawData,size_t size)203 void AudioServerGetMaxAmplitudeTest(const uint8_t *rawData, size_t size)
204 {
205     if (rawData == nullptr || size < LIMITSIZE) {
206         return;
207     }
208 
209     MessageParcel data;
210     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
211     bool isOutputDevice = *reinterpret_cast<const bool*>(rawData);
212     int32_t deviceType = *reinterpret_cast<const int32_t*>(rawData);
213     data.WriteBool(isOutputDevice);
214     data.WriteInt32(deviceType);
215 
216     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
217     MessageParcel reply;
218     MessageOption option;
219     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_MAX_AMPLITUDE),
220         data, reply, option);
221 }
222 
AudioServerResetAudioEndpointTest(const uint8_t * rawData,size_t size)223 void AudioServerResetAudioEndpointTest(const uint8_t *rawData, size_t size)
224 {
225     if (rawData == nullptr || size < LIMITSIZE) {
226         return;
227     }
228 
229     MessageParcel data;
230     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
231 
232     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
233     MessageParcel reply;
234     MessageOption option;
235     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::RESET_AUDIO_ENDPOINT),
236         data, reply, option);
237 }
238 
AudioServerCreatePlaybackCapturerManagerTest(const uint8_t * rawData,size_t size)239 void AudioServerCreatePlaybackCapturerManagerTest(const uint8_t *rawData, size_t size)
240 {
241     if (rawData == nullptr || size < LIMITSIZE) {
242         return;
243     }
244 
245     MessageParcel data;
246     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
247 
248     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
249     MessageParcel reply;
250     MessageOption option;
251     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::CREATE_PLAYBACK_CAPTURER_MANAGER),
252         data, reply, option);
253 }
254 
AudioServerSetOutputDeviceSinkTest(const uint8_t * rawData,size_t size)255 void AudioServerSetOutputDeviceSinkTest(const uint8_t *rawData, size_t size)
256 {
257     if (rawData == nullptr || size < LIMITSIZE) {
258         return;
259     }
260 
261     MessageParcel data;
262     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
263     int32_t deviceType = *reinterpret_cast<const int32_t*>(rawData);
264     std::string sinkName(reinterpret_cast<const char*>(rawData), size - 1);
265     data.WriteInt32(deviceType);
266     data.WriteString(sinkName);
267 
268     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
269     MessageParcel reply;
270     MessageOption option;
271     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_OUTPUT_DEVICE_SINK),
272         data, reply, option);
273 }
274 
AudioServerRequestThreadPriorityTest(const uint8_t * rawData,size_t size)275 void AudioServerRequestThreadPriorityTest(const uint8_t *rawData, size_t size)
276 {
277     if (rawData == nullptr || size < LIMITSIZE) {
278         return;
279     }
280 
281     MessageParcel data;
282     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
283     uint32_t tid = *reinterpret_cast<const uint32_t*>(rawData);
284     std::string bundleName(reinterpret_cast<const char*>(rawData), size - 1);
285     data.WriteUint32(tid);
286     data.WriteString(bundleName);
287 
288     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
289     MessageParcel reply;
290     MessageOption option;
291     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::REQUEST_THREAD_PRIORITY),
292         data, reply, option);
293 }
294 
AudioServerSetAudioMonoStateTest(const uint8_t * rawData,size_t size)295 void AudioServerSetAudioMonoStateTest(const uint8_t *rawData, size_t size)
296 {
297     if (rawData == nullptr || size < LIMITSIZE) {
298         return;
299     }
300 
301     MessageParcel data;
302     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
303     bool audioMono = *reinterpret_cast<const bool*>(rawData);
304     data.WriteBool(audioMono);
305 
306     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
307     MessageParcel reply;
308     MessageOption option;
309     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_MONO_STATE),
310         data, reply, option);
311 }
312 
AudioServerSetVoiceVolumeTest(const uint8_t * rawData,size_t size)313 void AudioServerSetVoiceVolumeTest(const uint8_t *rawData, size_t size)
314 {
315     if (rawData == nullptr || size < LIMITSIZE) {
316         return;
317     }
318 
319     MessageParcel data;
320     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
321     float volume = *reinterpret_cast<const float*>(rawData);
322     data.WriteFloat(volume);
323 
324     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
325     MessageParcel reply;
326     MessageOption option;
327     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_VOICE_VOLUME),
328         data, reply, option);
329 }
330 
AudioServerCheckRemoteDeviceStateTest(const uint8_t * rawData,size_t size)331 void AudioServerCheckRemoteDeviceStateTest(const uint8_t *rawData, size_t size)
332 {
333     if (rawData == nullptr || size < LIMITSIZE) {
334         return;
335     }
336 
337     MessageParcel data;
338     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
339     std::string networkId(reinterpret_cast<const char*>(rawData), size - 1);
340     DeviceRole deviceRole = *reinterpret_cast<const DeviceRole*>(rawData);
341     bool isStartDevice = *reinterpret_cast<const bool*>(rawData);
342     data.WriteString(networkId);
343     data.WriteInt32(static_cast<int32_t>(deviceRole));
344     data.WriteBool(isStartDevice);
345 
346     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
347     MessageParcel reply;
348     MessageOption option;
349     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::CHECK_REMOTE_DEVICE_STATE),
350         data, reply, option);
351 }
352 
AudioServerNotifyDeviceInfoTest(const uint8_t * rawData,size_t size)353 void AudioServerNotifyDeviceInfoTest(const uint8_t *rawData, size_t size)
354 {
355     if (rawData == nullptr || size < LIMITSIZE) {
356         return;
357     }
358 
359     MessageParcel data;
360     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
361     std::string networkId(reinterpret_cast<const char*>(rawData), size - 1);
362     bool connected = *reinterpret_cast<const bool*>(rawData);
363     data.WriteString(networkId);
364     data.WriteBool(connected);
365 
366     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
367     MessageParcel reply;
368     MessageOption option;
369     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::NOTIFY_DEVICE_INFO),
370         data, reply, option);
371 }
372 
AudioServerGetAudioParameterTest(const uint8_t * rawData,size_t size)373 void AudioServerGetAudioParameterTest(const uint8_t *rawData, size_t size)
374 {
375     if (rawData == nullptr || size < LIMITSIZE) {
376         return;
377     }
378 
379     MessageParcel data;
380     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
381     std::string key(reinterpret_cast<const char*>(rawData), size - 1);
382     data.WriteString(key);
383 
384     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
385     MessageParcel reply;
386     MessageOption option;
387     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_AUDIO_PARAMETER),
388         data, reply, option);
389 }
390 
AudioServerSetAudioParameterTest(const uint8_t * rawData,size_t size)391 void AudioServerSetAudioParameterTest(const uint8_t *rawData, size_t size)
392 {
393     if (rawData == nullptr || size < LIMITSIZE) {
394         return;
395     }
396 
397     MessageParcel data;
398     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
399     std::string key(reinterpret_cast<const char*>(rawData), size - 1);
400     std::string value(reinterpret_cast<const char*>(rawData), size - 1);
401     data.WriteString(key);
402     data.WriteString(value);
403 
404     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
405     MessageParcel reply;
406     MessageOption option;
407     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_PARAMETER),
408         data, reply, option);
409 }
410 
AudioServerSetMicrophoneMuteTest(const uint8_t * rawData,size_t size)411 void AudioServerSetMicrophoneMuteTest(const uint8_t *rawData, size_t size)
412 {
413     if (rawData == nullptr || size < LIMITSIZE) {
414         return;
415     }
416 
417     MessageParcel data;
418     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
419     bool isMute = *reinterpret_cast<const bool*>(rawData);
420     data.WriteBool(isMute);
421 
422     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
423     MessageParcel reply;
424     MessageOption option;
425     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_MICROPHONE_MUTE),
426         data, reply, option);
427 }
428 
AudioServerSetAudioBalanceValueTest(const uint8_t * rawData,size_t size)429 void AudioServerSetAudioBalanceValueTest(const uint8_t *rawData, size_t size)
430 {
431     if (rawData == nullptr || size < LIMITSIZE) {
432         return;
433     }
434 
435     MessageParcel data;
436     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
437     float audioBalance = *reinterpret_cast<const float*>(rawData);
438     data.WriteFloat(audioBalance);
439 
440     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
441     MessageParcel reply;
442     MessageOption option;
443     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_BALANCE_VALUE),
444         data, reply, option);
445 }
446 
AudioServerSetAudioSceneTest(const uint8_t * rawData,size_t size)447 void AudioServerSetAudioSceneTest(const uint8_t *rawData, size_t size)
448 {
449     if (rawData == nullptr || size < LIMITSIZE) {
450         return;
451     }
452 
453     MessageParcel data;
454     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
455     AudioScene audioScene = *reinterpret_cast<const AudioScene*>(rawData);
456     DeviceType outputDevice = *reinterpret_cast<const DeviceType*>(rawData);
457     DeviceType inputDevice = *reinterpret_cast<const DeviceType*>(rawData);
458     data.WriteInt32(static_cast<int32_t>(audioScene));
459     data.WriteInt32(static_cast<int32_t>(outputDevice));
460     data.WriteInt32(static_cast<int32_t>(inputDevice));
461 
462     std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
463     MessageParcel reply;
464     MessageOption option;
465     AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_SCENE),
466         data, reply, option);
467 }
468 } // namespace AudioStandard
469 } // namesapce OHOS
470 
471 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)472 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
473 {
474     /* Run your code on data */
475     OHOS::AudioStandard::AudioServerFuzzTest(data, size);
476     OHOS::AudioStandard::AudioServerCaptureSilentlyFuzzTest(data, size);
477     OHOS::AudioStandard::AudioServerOffloadSetVolumeFuzzTest(data, size);
478     OHOS::AudioStandard::AudioServerNotifyStreamVolumeChangedFuzzTest(data, size);
479     OHOS::AudioStandard::AudioServerResetRouteForDisconnectFuzzTest(data, size);
480     OHOS::AudioStandard::AudioServerGetEffectLatencyTest(data, size);
481     OHOS::AudioStandard::AudioServerGetMaxAmplitudeTest(data, size);
482     OHOS::AudioStandard::AudioServerResetAudioEndpointTest(data, size);
483     OHOS::AudioStandard::AudioServerCreatePlaybackCapturerManagerTest(data, size);
484     OHOS::AudioStandard::AudioServerSetOutputDeviceSinkTest(data, size);
485     OHOS::AudioStandard::AudioServerRequestThreadPriorityTest(data, size);
486     OHOS::AudioStandard::AudioServerSetAudioMonoStateTest(data, size);
487     OHOS::AudioStandard::AudioServerSetVoiceVolumeTest(data, size);
488     OHOS::AudioStandard::AudioServerCheckRemoteDeviceStateTest(data, size);
489     OHOS::AudioStandard::AudioServerNotifyDeviceInfoTest(data, size);
490     OHOS::AudioStandard::AudioServerGetAudioParameterTest(data, size);
491     OHOS::AudioStandard::AudioServerSetAudioParameterTest(data, size);
492     OHOS::AudioStandard::AudioServerSetMicrophoneMuteTest(data, size);
493     OHOS::AudioStandard::AudioServerSetAudioBalanceValueTest(data, size);
494     OHOS::AudioStandard::AudioServerSetAudioSceneTest(data, size);
495     return 0;
496 }
497