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 <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 #include "audio_policy_utils.h"
33 #include "audio_stream_descriptor.h"
34 #include "i_hpae_manager.h"
35 #include "manager/hdi_adapter_manager.h"
36 #include "util/id_handler.h"
37
38 using namespace std;
39
40 namespace OHOS {
41 namespace AudioStandard {
42 const int32_t SYSTEM_ABILITY_ID = 3009;
43 const bool RUN_ON_CREATE = false;
44 bool g_hasServerInit = false;
45 static const uint8_t* RAW_DATA = nullptr;
46 static size_t g_dataSize = 0;
47 static size_t g_pos;
48 const size_t THRESHOLD = 10;
49 const int32_t DEVICE_COUNT = 4;
50 const int32_t COUNT = 8;
51 static int32_t NUM_2 = 2;
52 typedef void (*TestFuncs)();
53
54 class RemoteObjectFuzzTestStub : public IRemoteObject {
55 public:
RemoteObjectFuzzTestStub()56 RemoteObjectFuzzTestStub() : IRemoteObject(u"IRemoteObject") {}
GetObjectRefCount()57 int32_t GetObjectRefCount() { return 0; };
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)58 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
AddDeathRecipient(const sptr<DeathRecipient> & recipient)59 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)60 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
Dump(int fd,const std::vector<std::u16string> & args)61 int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
62
63 DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectFuzzTestStub");
64 };
65
66 class AudioClientTrackerFuzzTest : public AudioClientTracker {
67 public:
68 virtual ~AudioClientTrackerFuzzTest() = default;
MuteStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)69 virtual void MuteStreamImpl(const StreamSetStateEventInternal &streamSetStateEventInternal) {};
UnmuteStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)70 virtual void UnmuteStreamImpl(const StreamSetStateEventInternal &streamSetStateEventInternal) {};
PausedStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)71 virtual void PausedStreamImpl(const StreamSetStateEventInternal &streamSetStateEventInternal) {};
ResumeStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)72 virtual void ResumeStreamImpl(const StreamSetStateEventInternal &streamSetStateEventInternal) {};
SetLowPowerVolumeImpl(float volume)73 virtual void SetLowPowerVolumeImpl(float volume) {};
GetLowPowerVolumeImpl(float & volume)74 virtual void GetLowPowerVolumeImpl(float &volume) {};
GetSingleStreamVolumeImpl(float & volume)75 virtual void GetSingleStreamVolumeImpl(float &volume) {};
SetOffloadModeImpl(int32_t state,bool isAppBack)76 virtual void SetOffloadModeImpl(int32_t state, bool isAppBack) {};
UnsetOffloadModeImpl()77 virtual void UnsetOffloadModeImpl() {};
78 };
79
80 const vector<DeviceFlag> g_testDeviceFlags = {
81 NONE_DEVICES_FLAG,
82 OUTPUT_DEVICES_FLAG,
83 INPUT_DEVICES_FLAG,
84 ALL_DEVICES_FLAG,
85 DISTRIBUTED_OUTPUT_DEVICES_FLAG,
86 DISTRIBUTED_INPUT_DEVICES_FLAG,
87 ALL_DISTRIBUTED_DEVICES_FLAG,
88 ALL_L_D_DEVICES_FLAG,
89 DEVICE_FLAG_MAX
90 };
91
92 const vector<AudioStreamDeviceChangeReason> g_testReasons = {
93 AudioStreamDeviceChangeReason::UNKNOWN,
94 AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE,
95 AudioStreamDeviceChangeReason::OLD_DEVICE_UNAVALIABLE,
96 AudioStreamDeviceChangeReason::OVERRODE,
97 };
98
99 const vector<StreamSetState> g_testStreamSetStates = {
100 STREAM_PAUSE,
101 STREAM_RESUME,
102 STREAM_MUTE,
103 STREAM_UNMUTE,
104 };
105
106 vector<InterruptHint> g_testInterruptHints = {
107 INTERRUPT_HINT_NONE,
108 INTERRUPT_HINT_RESUME,
109 INTERRUPT_HINT_PAUSE,
110 INTERRUPT_HINT_STOP,
111 INTERRUPT_HINT_DUCK,
112 INTERRUPT_HINT_UNDUCK,
113 INTERRUPT_HINT_MUTE,
114 INTERRUPT_HINT_UNMUTE,
115 INTERRUPT_HINT_EXIT_STANDALONE
116 };
117
118 vector<AudioParamKey> g_testAudioParamKeys = {
119 NONE,
120 VOLUME,
121 INTERRUPT,
122 PARAM_KEY_STATE,
123 A2DP_SUSPEND_STATE,
124 BT_HEADSET_NREC,
125 BT_WBS,
126 A2DP_OFFLOAD_STATE,
127 GET_DP_DEVICE_INFO,
128 GET_PENCIL_INFO,
129 GET_UWB_INFO,
130 USB_DEVICE,
131 PERF_INFO,
132 MMI,
133 PARAM_KEY_LOWPOWER,
134 };
135
136 template<class T>
GetArrLength(T & arr)137 uint32_t GetArrLength(T& arr)
138 {
139 if (arr == nullptr) {
140 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
141 return 0;
142 }
143 return sizeof(arr) / sizeof(arr[0]);
144 }
145
146 template<class T>
GetData()147 T GetData()
148 {
149 T object {};
150 size_t objectSize = sizeof(object);
151 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
152 return object;
153 }
154 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
155 if (ret != EOK) {
156 return {};
157 }
158 g_pos += objectSize;
159 return object;
160 }
161
GetServerPtr()162 sptr<AudioPolicyServer> GetServerPtr()
163 {
164 static sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
165 if (!g_hasServerInit && server != nullptr) {
166 IdHandler::GetInstance();
167 HdiAdapterManager::GetInstance();
168 HPAE::IHpaeManager::GetHpaeManager().Init();
169 server->OnStart();
170 server->OnAddSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID, "");
171 #ifdef FEATURE_MULTIMODALINPUT_INPUT
172 server->OnAddSystemAbility(MULTIMODAL_INPUT_SERVICE_ID, "");
173 #endif
174 server->OnAddSystemAbility(BLUETOOTH_HOST_SYS_ABILITY_ID, "");
175 server->OnAddSystemAbility(POWER_MANAGER_SERVICE_ID, "");
176 server->OnAddSystemAbility(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, "");
177 server->audioPolicyService_.SetDefaultDeviceLoadFlag(true);
178 g_hasServerInit = true;
179 }
180 return server;
181 }
182
AudioPolicyServerRegisterDefaultVolumeTypeListenerFuzzTest()183 void AudioPolicyServerRegisterDefaultVolumeTypeListenerFuzzTest()
184 {
185 auto audioPolicyServer = GetServerPtr();
186 CHECK_AND_RETURN(audioPolicyServer != nullptr);
187 audioPolicyServer->RegisterDefaultVolumeTypeListener();
188 }
189
AudioPolicyServerOnAddSystemAbilityExtractFuzzTest()190 void AudioPolicyServerOnAddSystemAbilityExtractFuzzTest()
191 {
192 auto audioPolicyServer = GetServerPtr();
193 CHECK_AND_RETURN(audioPolicyServer != nullptr);
194 int32_t systemAbilityId = APP_MGR_SERVICE_ID;
195 std::string deviceId = "";
196 audioPolicyServer->OnAddSystemAbilityExtract(systemAbilityId, deviceId);
197 int32_t systemAbilityId1 = 0;
198 audioPolicyServer->OnAddSystemAbilityExtract(systemAbilityId1, deviceId);
199 }
200
AudioPolicyServerOnRemoveSystemAbilityFuzzTest()201 void AudioPolicyServerOnRemoveSystemAbilityFuzzTest()
202 {
203 auto audioPolicyServer = GetServerPtr();
204 CHECK_AND_RETURN(audioPolicyServer != nullptr);
205 int32_t systemAbilityId = APP_MGR_SERVICE_ID;
206 std::string deviceId = "";
207 audioPolicyServer->OnRemoveSystemAbility(systemAbilityId, deviceId);
208 }
209
AudioPolicyServerMaxOrMinVolumeOptionFuzzTest()210 void AudioPolicyServerMaxOrMinVolumeOptionFuzzTest()
211 {
212 auto audioPolicyServer = GetServerPtr();
213 CHECK_AND_RETURN(audioPolicyServer != nullptr);
214 int32_t volLevel = GetData<int32_t>();
215 int32_t keyType = GetData<int32_t>();
216 AudioStreamType streamInFocus = AudioStreamType::STREAM_ALL;
217 audioPolicyServer->MaxOrMinVolumeOption(volLevel, keyType, streamInFocus);
218 }
219
AudioPolicyServerChangeVolumeOnVoiceAssistantFuzzTest()220 void AudioPolicyServerChangeVolumeOnVoiceAssistantFuzzTest()
221 {
222 auto audioPolicyServer = GetServerPtr();
223 CHECK_AND_RETURN(audioPolicyServer != nullptr);
224 AudioStreamType streamInFocus = AudioStreamType::STREAM_VOICE_ASSISTANT;
225 audioPolicyServer->ChangeVolumeOnVoiceAssistant(streamInFocus);
226 }
227
AudioPolicyServerIsContinueAddVolFuzzTest()228 void AudioPolicyServerIsContinueAddVolFuzzTest()
229 {
230 auto audioPolicyServer = GetServerPtr();
231 CHECK_AND_RETURN(audioPolicyServer != nullptr);
232 audioPolicyServer->IsContinueAddVol();
233 }
234
AudioPolicyServerTriggerMuteCheckFuzzTest()235 void AudioPolicyServerTriggerMuteCheckFuzzTest()
236 {
237 auto audioPolicyServer = GetServerPtr();
238 CHECK_AND_RETURN(audioPolicyServer != nullptr);
239 audioPolicyServer->TriggerMuteCheck();
240 }
241
AudioPolicyServerProcessVolumeKeyEventsFuzzTest()242 void AudioPolicyServerProcessVolumeKeyEventsFuzzTest()
243 {
244 auto audioPolicyServer = GetServerPtr();
245 CHECK_AND_RETURN(audioPolicyServer != nullptr);
246 int32_t keyType = GetData<int32_t>();
247 audioPolicyServer->ProcessVolumeKeyEvents(keyType);
248 }
249
AudioPolicyServerSetVolumeInternalByKeyEventFuzzTest()250 void AudioPolicyServerSetVolumeInternalByKeyEventFuzzTest()
251 {
252 auto audioPolicyServer = GetServerPtr();
253 CHECK_AND_RETURN(audioPolicyServer != nullptr);
254 AudioStreamType streamInFocus = AudioStreamType::STREAM_ALL;
255 int32_t zoneId = GetData<int32_t>();
256 int32_t keyType = GetData<int32_t>();
257 audioPolicyServer->SetVolumeInternalByKeyEvent(streamInFocus, zoneId, keyType);
258 }
259
AudioPolicyServerSubscribeSafeVolumeEventFuzzTest()260 void AudioPolicyServerSubscribeSafeVolumeEventFuzzTest()
261 {
262 auto audioPolicyServer = GetServerPtr();
263 CHECK_AND_RETURN(audioPolicyServer != nullptr);
264 AudioStreamType streamInFocus = AudioStreamType::STREAM_ALL;
265 int32_t zoneId = GetData<int32_t>();
266 int32_t keyType = GetData<int32_t>();
267 audioPolicyServer->SubscribeSafeVolumeEvent();
268 }
269
AudioPolicyServerIsVolumeTypeValidFuzzTest()270 void AudioPolicyServerIsVolumeTypeValidFuzzTest()
271 {
272 auto audioPolicyServer = GetServerPtr();
273 CHECK_AND_RETURN(audioPolicyServer != nullptr);
274 AudioStreamType streamInFocus = AudioStreamType::STREAM_ALL;
275 audioPolicyServer->IsVolumeTypeValid(streamInFocus);
276 }
277
AudioPolicyServerIsVolumeLevelValidFuzzTest()278 void AudioPolicyServerIsVolumeLevelValidFuzzTest()
279 {
280 auto audioPolicyServer = GetServerPtr();
281 CHECK_AND_RETURN(audioPolicyServer != nullptr);
282 AudioStreamType streamInFocus = AudioStreamType::STREAM_ALL;
283 int32_t volumeLevel = GetData<int32_t>();
284 audioPolicyServer->IsVolumeLevelValid(streamInFocus, volumeLevel);
285 }
286
AudioPolicyServerIsRingerModeValidFuzzTest()287 void AudioPolicyServerIsRingerModeValidFuzzTest()
288 {
289 auto audioPolicyServer = GetServerPtr();
290 CHECK_AND_RETURN(audioPolicyServer != nullptr);
291 AudioRingerMode ringMode = AudioRingerMode::RINGER_MODE_SILENT;
292 audioPolicyServer->IsRingerModeValid(ringMode);
293 }
294
AudioPolicyServerSubscribeOsAccountChangeEventsFuzzTest()295 void AudioPolicyServerSubscribeOsAccountChangeEventsFuzzTest()
296 {
297 auto audioPolicyServer = GetServerPtr();
298 CHECK_AND_RETURN(audioPolicyServer != nullptr);
299 audioPolicyServer->SubscribeOsAccountChangeEvents();
300 }
301
AudioPolicyServerAddRemoteDevstatusCallbackFuzzTest()302 void AudioPolicyServerAddRemoteDevstatusCallbackFuzzTest()
303 {
304 auto audioPolicyServer = GetServerPtr();
305 CHECK_AND_RETURN(audioPolicyServer != nullptr);
306 audioPolicyServer->AddRemoteDevstatusCallback();
307 }
308
AudioPolicyServerOnReceiveEventFuzzTest()309 void AudioPolicyServerOnReceiveEventFuzzTest()
310 {
311 auto audioPolicyServer = GetServerPtr();
312 CHECK_AND_RETURN(audioPolicyServer != nullptr);
313 EventFwk::CommonEventData eventData;
314 audioPolicyServer->OnReceiveEvent(eventData);
315 }
316
AudioPolicyServerSubscribeBackgroundTaskFuzzTest()317 void AudioPolicyServerSubscribeBackgroundTaskFuzzTest()
318 {
319 auto audioPolicyServer = GetServerPtr();
320 CHECK_AND_RETURN(audioPolicyServer != nullptr);
321 audioPolicyServer->SubscribeBackgroundTask();
322 }
323
AudioPolicyServerSubscribeCommonEventExecuteFuzzTest()324 void AudioPolicyServerSubscribeCommonEventExecuteFuzzTest()
325 {
326 auto audioPolicyServer = GetServerPtr();
327 CHECK_AND_RETURN(audioPolicyServer != nullptr);
328 audioPolicyServer->SubscribeCommonEventExecute();
329 }
330
AudioPolicyServerCheckSubscribePowerStateChangeFuzzTest()331 void AudioPolicyServerCheckSubscribePowerStateChangeFuzzTest()
332 {
333 auto audioPolicyServer = GetServerPtr();
334 CHECK_AND_RETURN(audioPolicyServer != nullptr);
335 audioPolicyServer->CheckSubscribePowerStateChange();
336 }
337
AudioPolicyServerNotifySettingsDataReadyFuzzTest()338 void AudioPolicyServerNotifySettingsDataReadyFuzzTest()
339 {
340 auto audioPolicyServer = GetServerPtr();
341 CHECK_AND_RETURN(audioPolicyServer != nullptr);
342 audioPolicyServer->NotifySettingsDataReady();
343 }
344
AudioPolicyServerGetMaxVolumeLevelFuzzTest()345 void AudioPolicyServerGetMaxVolumeLevelFuzzTest()
346 {
347 auto audioPolicyServer = GetServerPtr();
348 CHECK_AND_RETURN(audioPolicyServer != nullptr);
349 int32_t volumeType = GetData<int32_t>();
350 int32_t deviceType = GetData<int32_t>();
351 int32_t volumeLevel = GetData<int32_t>();
352 audioPolicyServer->GetMaxVolumeLevel(volumeType, volumeLevel, deviceType);
353 }
354
AudioPolicyServerGetMinVolumeLevelFuzzTest()355 void AudioPolicyServerGetMinVolumeLevelFuzzTest()
356 {
357 auto audioPolicyServer = GetServerPtr();
358 CHECK_AND_RETURN(audioPolicyServer != nullptr);
359 int32_t volumeType = GetData<int32_t>();
360 int32_t deviceType = GetData<int32_t>();
361 int32_t volumeLevel = GetData<int32_t>();
362 audioPolicyServer->GetMinVolumeLevel(volumeType, volumeLevel, deviceType);
363 }
364
AudioPolicyServerSetSystemVolumeLevelLegacyFuzzTest()365 void AudioPolicyServerSetSystemVolumeLevelLegacyFuzzTest()
366 {
367 auto audioPolicyServer = GetServerPtr();
368 CHECK_AND_RETURN(audioPolicyServer != nullptr);
369 int32_t streamTypeIn = GetData<int32_t>();
370 int32_t volumeLevel = GetData<int32_t>();
371 audioPolicyServer->SetSystemVolumeLevelLegacy(streamTypeIn, volumeLevel);
372 }
373
AudioPolicyServerSetAdjustVolumeForZoneFuzzTest()374 void AudioPolicyServerSetAdjustVolumeForZoneFuzzTest()
375 {
376 auto audioPolicyServer = GetServerPtr();
377 CHECK_AND_RETURN(audioPolicyServer != nullptr);
378 int32_t zoneId = GetData<int32_t>();
379 audioPolicyServer->SetAdjustVolumeForZone(zoneId);
380 }
381
AudioPolicyServerGetSelfAppVolumeLevelFuzzTest()382 void AudioPolicyServerGetSelfAppVolumeLevelFuzzTest()
383 {
384 auto audioPolicyServer = GetServerPtr();
385 CHECK_AND_RETURN(audioPolicyServer != nullptr);
386 int32_t volumeLevel = GetData<int32_t>();
387 audioPolicyServer->GetSelfAppVolumeLevel(volumeLevel);
388 }
389
AudioPolicyServerGetSystemVolumeLevelFuzzTest()390 void AudioPolicyServerGetSystemVolumeLevelFuzzTest()
391 {
392 auto audioPolicyServer = GetServerPtr();
393 CHECK_AND_RETURN(audioPolicyServer != nullptr);
394 int32_t streamType = GetData<int32_t>();
395 int32_t uid = GetData<int32_t>();
396 int32_t volumeLevel = GetData<int32_t>();
397 audioPolicyServer->GetSystemVolumeLevel(streamType, uid, volumeLevel);
398 }
399
AudioPolicyServerGetSystemVolumeLevelNoMuteStateFuzzTest()400 void AudioPolicyServerGetSystemVolumeLevelNoMuteStateFuzzTest()
401 {
402 auto audioPolicyServer = GetServerPtr();
403 CHECK_AND_RETURN(audioPolicyServer != nullptr);
404 AudioStreamType streamInFocus = AudioStreamType::STREAM_ALL;
405 audioPolicyServer->GetSystemVolumeLevelNoMuteState(streamInFocus);
406 }
407
AudioPolicyServerGetSystemVolumeLevelInternalFuzzTest()408 void AudioPolicyServerGetSystemVolumeLevelInternalFuzzTest()
409 {
410 auto audioPolicyServer = GetServerPtr();
411 CHECK_AND_RETURN(audioPolicyServer != nullptr);
412 AudioStreamType streamInFocus = AudioStreamType::STREAM_ALL;
413 int32_t zoneId = GetData<int32_t>();
414 audioPolicyServer->GetSystemVolumeLevelInternal(streamInFocus, zoneId);
415 }
416
AudioPolicyServerGetAppVolumeLevelInternalFuzzTest()417 void AudioPolicyServerGetAppVolumeLevelInternalFuzzTest()
418 {
419 auto audioPolicyServer = GetServerPtr();
420 CHECK_AND_RETURN(audioPolicyServer != nullptr);
421 int32_t appUid = GetData<int32_t>();
422 int32_t volumeLevel = GetData<int32_t>();
423 audioPolicyServer->GetAppVolumeLevelInternal(appUid, volumeLevel);
424 }
425
AudioPolicyServerSetLowPowerVolumeFuzzTest()426 void AudioPolicyServerSetLowPowerVolumeFuzzTest()
427 {
428 auto audioPolicyServer = GetServerPtr();
429 CHECK_AND_RETURN(audioPolicyServer != nullptr);
430 int32_t streamId = GetData<int32_t>();
431 float volume = GetData<float>();
432 audioPolicyServer->SetLowPowerVolume(streamId, volume);
433 }
434
AudioPolicyServerGetFastStreamInfoFuzzTest()435 void AudioPolicyServerGetFastStreamInfoFuzzTest()
436 {
437 auto audioPolicyServer = GetServerPtr();
438 CHECK_AND_RETURN(audioPolicyServer != nullptr);
439 AudioStreamInfo streamInfo;
440 audioPolicyServer->GetFastStreamInfo(streamInfo);
441 }
442
AudioPolicyServerGetLowPowerVolumeFuzzTest()443 void AudioPolicyServerGetLowPowerVolumeFuzzTest()
444 {
445 auto audioPolicyServer = GetServerPtr();
446 CHECK_AND_RETURN(audioPolicyServer != nullptr);
447 int32_t streamId = GetData<int32_t>();
448 float outVolume;
449 audioPolicyServer->GetLowPowerVolume(streamId, outVolume);
450 }
451
AudioPolicyServerGetSingleStreamVolumeFuzzTest()452 void AudioPolicyServerGetSingleStreamVolumeFuzzTest()
453 {
454 auto audioPolicyServer = GetServerPtr();
455 CHECK_AND_RETURN(audioPolicyServer != nullptr);
456 int32_t streamId = GetData<int32_t>();
457 float outVolume;
458 audioPolicyServer->GetSingleStreamVolume(streamId, outVolume);
459 }
460
AudioPolicyServerIsVolumeUnadjustableFuzzTest()461 void AudioPolicyServerIsVolumeUnadjustableFuzzTest()
462 {
463 auto audioPolicyServer = GetServerPtr();
464 CHECK_AND_RETURN(audioPolicyServer != nullptr);
465 bool unadjustable;
466 audioPolicyServer->IsVolumeUnadjustable(unadjustable);
467 }
468
AudioPolicyServerCheckCanMuteVolumeTypeByStepFuzzTest()469 void AudioPolicyServerCheckCanMuteVolumeTypeByStepFuzzTest()
470 {
471 auto audioPolicyServer = GetServerPtr();
472 CHECK_AND_RETURN(audioPolicyServer != nullptr);
473 AudioVolumeType volumeType = AudioVolumeType::STREAM_VOICE_CALL;
474 int32_t volumeLevel = GetData<int32_t>();
475 audioPolicyServer->CheckCanMuteVolumeTypeByStep(volumeType, volumeLevel);
476 }
477
AudioPolicyServerGetSystemVolumeInDbFuzzTest()478 void AudioPolicyServerGetSystemVolumeInDbFuzzTest()
479 {
480 auto audioPolicyServer = GetServerPtr();
481 CHECK_AND_RETURN(audioPolicyServer != nullptr);
482 int32_t volumeTypeIn = GetData<int32_t>();
483 int32_t volumeLevel = GetData<int32_t>();
484 int32_t deviceTypeIn = GetData<int32_t>();
485 float volume;
486 audioPolicyServer->GetSystemVolumeInDb(volumeTypeIn, volumeLevel, deviceTypeIn, volume);
487 }
488
AudioPolicyServerSetStreamMuteLegacyFuzzTest()489 void AudioPolicyServerSetStreamMuteLegacyFuzzTest()
490 {
491 auto audioPolicyServer = GetServerPtr();
492 CHECK_AND_RETURN(audioPolicyServer != nullptr);
493 int32_t streamTypeIn = GetData<int32_t>();
494 int32_t deviceTypeIn = GetData<int32_t>();
495 bool mute = true;
496 audioPolicyServer->SetStreamMuteLegacy(streamTypeIn, mute, deviceTypeIn);
497 }
498
AudioPolicyServerSetStreamMuteInternalFuzzTest()499 void AudioPolicyServerSetStreamMuteInternalFuzzTest()
500 {
501 auto audioPolicyServer = GetServerPtr();
502 CHECK_AND_RETURN(audioPolicyServer != nullptr);
503 int32_t zoneId = GetData<int32_t>();
504 DeviceType deviceType = DEVICE_TYPE_NONE;
505 bool mute = true;
506 bool isUpdateUi = true;
507 AudioStreamType streamType = AudioStreamType::STREAM_ALL;
508 audioPolicyServer->SetStreamMuteInternal(streamType, mute, isUpdateUi, deviceType, zoneId);
509 }
510
AudioPolicyServerUpdateSystemMuteStateAccordingMusicStateFuzzTest()511 void AudioPolicyServerUpdateSystemMuteStateAccordingMusicStateFuzzTest()
512 {
513 auto audioPolicyServer = GetServerPtr();
514 CHECK_AND_RETURN(audioPolicyServer != nullptr);
515 bool mute = true;
516 bool isUpdateUi = true;
517 AudioStreamType streamType = AudioStreamType::STREAM_ALL;
518 audioPolicyServer->UpdateSystemMuteStateAccordingMusicState(streamType, mute, isUpdateUi);
519 }
520
AudioPolicyServerSendMuteKeyEventCbWithUpdateUiOrNotFuzzTest()521 void AudioPolicyServerSendMuteKeyEventCbWithUpdateUiOrNotFuzzTest()
522 {
523 auto audioPolicyServer = GetServerPtr();
524 CHECK_AND_RETURN(audioPolicyServer != nullptr);
525 int32_t zoneId = GetData<int32_t>();
526 bool isUpdateUi = true;
527 AudioStreamType streamType = AudioStreamType::STREAM_ALL;
528 audioPolicyServer->SendMuteKeyEventCbWithUpdateUiOrNot(streamType, isUpdateUi, zoneId);
529 }
530
AudioPolicyServerSetSingleStreamMuteFuzzTest()531 void AudioPolicyServerSetSingleStreamMuteFuzzTest()
532 {
533 auto audioPolicyServer = GetServerPtr();
534 CHECK_AND_RETURN(audioPolicyServer != nullptr);
535 int32_t zoneId = GetData<int32_t>();
536 bool isUpdateUi = true;
537 AudioStreamType streamType = AudioStreamType::STREAM_ALL;
538 DeviceType deviceType = DEVICE_TYPE_NONE;
539 bool mute = true;
540 audioPolicyServer->SetSingleStreamMute(streamType, mute, isUpdateUi, deviceType, zoneId);
541 }
542
AudioPolicyServerProcUpdateRingerModeForMuteFuzzTest()543 void AudioPolicyServerProcUpdateRingerModeForMuteFuzzTest()
544 {
545 auto audioPolicyServer = GetServerPtr();
546 CHECK_AND_RETURN(audioPolicyServer != nullptr);
547 bool updateRingerMode = true;
548 bool mute = true;
549 audioPolicyServer->ProcUpdateRingerModeForMute(updateRingerMode, mute);
550 }
551
AudioPolicyServerGetSystemVolumeDbFuzzTest()552 void AudioPolicyServerGetSystemVolumeDbFuzzTest()
553 {
554 auto audioPolicyServer = GetServerPtr();
555 CHECK_AND_RETURN(audioPolicyServer != nullptr);
556 AudioStreamType streamType = AudioStreamType::STREAM_ALL;
557 audioPolicyServer->GetSystemVolumeDb(streamType);
558 }
559
AudioPolicyServerSetSelfAppVolumeLevelFuzztest()560 void AudioPolicyServerSetSelfAppVolumeLevelFuzztest()
561 {
562 auto audioPolicyServer = GetServerPtr();
563 CHECK_AND_RETURN(audioPolicyServer != nullptr);
564 int32_t volumeLevel = GetData<int32_t>();
565 int32_t volumeFlag = GetData<int32_t>();
566 audioPolicyServer->SetSelfAppVolumeLevel(volumeLevel, volumeFlag);
567 }
568
AudioPolicyServerSetAppVolumeLevelInternalFuzztest()569 void AudioPolicyServerSetAppVolumeLevelInternalFuzztest()
570 {
571 auto audioPolicyServer = GetServerPtr();
572 CHECK_AND_RETURN(audioPolicyServer != nullptr);
573 bool isUpdateUi = GetData<bool>();
574 bool muted = GetData<bool>();
575 int32_t appUid = GetData<int32_t>();
576 audioPolicyServer->SetAppVolumeLevelInternal(appUid, muted, isUpdateUi);
577 }
578
AudioPolicyServerSetSystemVolumeLevelInternalFuzztest()579 void AudioPolicyServerSetSystemVolumeLevelInternalFuzztest()
580 {
581 auto audioPolicyServer = GetServerPtr();
582 CHECK_AND_RETURN(audioPolicyServer != nullptr);
583 AudioStreamType streamType = AudioStreamType::STREAM_VOICE_CALL_ASSISTANT;
584 bool isUpdateUi = GetData<bool>();
585 int32_t volumeLevel = 0;
586 int32_t zoneId = GetData<int32_t>();
587 audioPolicyServer->SetSystemVolumeLevelInternal(streamType, volumeLevel, isUpdateUi, zoneId);
588 }
589
AudioPolicyServerSetSystemVolumeLevelWithDeviceInternalFuzztest()590 void AudioPolicyServerSetSystemVolumeLevelWithDeviceInternalFuzztest()
591 {
592 auto audioPolicyServer = GetServerPtr();
593 CHECK_AND_RETURN(audioPolicyServer != nullptr);
594 AudioStreamType streamType = AudioStreamType::STREAM_VOICE_CALL_ASSISTANT;
595 bool isUpdateUi = GetData<bool>();
596 int32_t volumeLevel = 0;
597 DeviceType deviceType = DeviceType::DEVICE_TYPE_EARPIECE;
598 audioPolicyServer->SetSystemVolumeLevelWithDeviceInternal(streamType, volumeLevel, isUpdateUi, deviceType);
599 }
600
AudioPolicyServerSendVolumeKeyEventCbWithUpdateUiOrNotFuzztest()601 void AudioPolicyServerSendVolumeKeyEventCbWithUpdateUiOrNotFuzztest()
602 {
603 auto audioPolicyServer = GetServerPtr();
604 CHECK_AND_RETURN(audioPolicyServer != nullptr);
605 AudioStreamType streamType = AudioStreamType::STREAM_VOICE_CALL_ASSISTANT;
606 bool isUpdateUi = GetData<bool>();
607 int32_t zoneId = GetData<int32_t>();
608 audioPolicyServer->SendVolumeKeyEventCbWithUpdateUiOrNot(streamType, isUpdateUi, zoneId);
609 }
610
AudioPolicyServerUpdateMuteStateAccordingToVolLevelFuzztest()611 void AudioPolicyServerUpdateMuteStateAccordingToVolLevelFuzztest()
612 {
613 auto audioPolicyServer = GetServerPtr();
614 CHECK_AND_RETURN(audioPolicyServer != nullptr);
615 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
616 bool isUpdateUi = GetData<bool>();
617 int32_t zoneId = GetData<int32_t>();
618 int32_t volumeLevel = 0;
619 bool mute = false;
620 audioPolicyServer->UpdateMuteStateAccordingToVolLevel(streamType, volumeLevel, mute, isUpdateUi, zoneId);
621 volumeLevel = 1;
622 mute = true;
623 audioPolicyServer->UpdateMuteStateAccordingToVolLevel(streamType, volumeLevel, mute, isUpdateUi, zoneId);
624 }
625
AudioPolicyServerProcUpdateRingerModeFuzztest()626 void AudioPolicyServerProcUpdateRingerModeFuzztest()
627 {
628 auto audioPolicyServer = GetServerPtr();
629 CHECK_AND_RETURN(audioPolicyServer != nullptr);
630 audioPolicyServer->supportVibrator_ = true;
631 audioPolicyServer->ProcUpdateRingerMode();
632 audioPolicyServer->supportVibrator_ = false;
633 audioPolicyServer->ProcUpdateRingerMode();
634 }
635
AudioPolicyServerSetAppSingleStreamVolumeFuzztest()636 void AudioPolicyServerSetAppSingleStreamVolumeFuzztest()
637 {
638 auto audioPolicyServer = GetServerPtr();
639 CHECK_AND_RETURN(audioPolicyServer != nullptr);
640 int32_t volumeLevel = GetData<int32_t>();
641 bool isUpdateUi = GetData<bool>();
642 int32_t appUid = GetData<int32_t>();
643 audioPolicyServer->SetAppSingleStreamVolume(appUid, volumeLevel, isUpdateUi);
644 }
645
AudioPolicyServerSetSingleStreamVolumeFuzztest()646 void AudioPolicyServerSetSingleStreamVolumeFuzztest()
647 {
648 auto audioPolicyServer = GetServerPtr();
649 CHECK_AND_RETURN(audioPolicyServer != nullptr);
650 int32_t volumeLevel = GetData<int32_t>();
651 bool isUpdateUi = GetData<bool>();
652 bool mute = GetData<bool>();
653 int32_t zoneId = GetData<int32_t>();
654 audioPolicyServer->SetSingleStreamVolume(AudioStreamType::STREAM_RING, volumeLevel, isUpdateUi, mute, zoneId);
655 audioPolicyServer->SetSingleStreamVolume(AudioStreamType::STREAM_VOICE_ASSISTANT, volumeLevel,
656 isUpdateUi, mute, zoneId);
657 }
658
AudioPolicyServerSetSingleStreamVolumeWithDeviceFuzztest()659 void AudioPolicyServerSetSingleStreamVolumeWithDeviceFuzztest()
660 {
661 auto audioPolicyServer = GetServerPtr();
662 CHECK_AND_RETURN(audioPolicyServer != nullptr);
663 bool mute = GetData<bool>();
664 AudioStreamType streamType = STREAM_RING;
665 int32_t volumeLevel = GetData<int32_t>();
666 bool isUpdateUi = GetData<bool>();
667 DeviceType deviceType = GetData<DeviceType>();
668 audioPolicyServer->SetSingleStreamVolumeWithDevice(streamType, volumeLevel, isUpdateUi, deviceType);
669 }
670
AudioPolicyServerGetStreamMuteFuzztest()671 void AudioPolicyServerGetStreamMuteFuzztest()
672 {
673 auto audioPolicyServer = GetServerPtr();
674 CHECK_AND_RETURN(audioPolicyServer != nullptr);
675 bool mute = GetData<bool>();
676 AudioStreamType streamTypeIn = STREAM_RING;
677 audioPolicyServer->GetStreamMute(streamTypeIn, mute);
678 }
679
AudioPolicyServerMapExternalToInternalDeviceTypeFuzztest()680 void AudioPolicyServerMapExternalToInternalDeviceTypeFuzztest()
681 {
682 auto audioPolicyServer = GetServerPtr();
683 CHECK_AND_RETURN(audioPolicyServer != nullptr);
684 AudioDeviceDescriptor desc = std::make_shared<AudioDeviceDescriptor>();
685 desc.deviceType_ = DEVICE_TYPE_USB_HEADSET;
686 audioPolicyServer->MapExternalToInternalDeviceType(desc);
687 desc.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
688 desc.deviceRole_ = INPUT_DEVICE;
689 audioPolicyServer->MapExternalToInternalDeviceType(desc);
690 desc.deviceType_ = DEVICE_TYPE_NEARLINK;
691 desc.deviceRole_ = INPUT_DEVICE;
692 audioPolicyServer->MapExternalToInternalDeviceType(desc);
693 }
694
AudioPolicyServerGetPreferredOutputDeviceDescriptorsFuzztest()695 void AudioPolicyServerGetPreferredOutputDeviceDescriptorsFuzztest()
696 {
697 auto audioPolicyServer = GetServerPtr();
698 CHECK_AND_RETURN(audioPolicyServer != nullptr);
699 AudioRendererInfo rendererInfo;
700 std::vector<std::shared_ptr<AudioDeviceDescriptor>> deviceDescs;
701 auto deviceDesc = std::make_shared<AudioDeviceDescriptor>();
702 deviceDescs.push_back(deviceDesc);
703 bool forceNoBTPermission = false;
704 audioPolicyServer->GetPreferredOutputDeviceDescriptors(rendererInfo, forceNoBTPermission, deviceDescs);
705 }
706
AudioPolicyServerGetPreferredInputDeviceDescriptorsFuzztest()707 void AudioPolicyServerGetPreferredInputDeviceDescriptorsFuzztest()
708 {
709 auto audioPolicyServer = GetServerPtr();
710 CHECK_AND_RETURN(audioPolicyServer != nullptr);
711 AudioCapturerInfo capturerInfo;
712 std::vector<std::shared_ptr<AudioDeviceDescriptor>> deviceDescs;
713 auto deviceDesc = std::make_shared<AudioDeviceDescriptor>();
714 deviceDescs.push_back(deviceDesc);
715 audioPolicyServer->GetPreferredInputDeviceDescriptors(capturerInfo, deviceDescs);
716 }
717
AudioPolicyServerIsFastRecordingSupportedFuzztest()718 void AudioPolicyServerIsFastRecordingSupportedFuzztest()
719 {
720 auto audioPolicyServer = GetServerPtr();
721 CHECK_AND_RETURN(audioPolicyServer != nullptr);
722 AudioStreamInfo streamInfo = {};
723 int32_t source = GetData<uint16_t>();
724 bool support = GetData<bool>();
725 audioPolicyServer->IsFastRecordingSupported(streamInfo, source, support);
726 }
727
AudioPolicyServerSetRingerModeInternalFuzztest()728 void AudioPolicyServerSetRingerModeInternalFuzztest()
729 {
730 auto audioPolicyServer = GetServerPtr();
731 CHECK_AND_RETURN(audioPolicyServer != nullptr);
732 AudioRingerMode inputRingerMode = GetData<AudioRingerMode>();
733 bool hasUpdatedVolume = false;
734 audioPolicyServer->SetRingerModeInternal(inputRingerMode, hasUpdatedVolume);
735 }
736
AudioPolicyServerInitMicrophoneMuteFuzztest()737 void AudioPolicyServerInitMicrophoneMuteFuzztest()
738 {
739 auto audioPolicyServer = GetServerPtr();
740 CHECK_AND_RETURN(audioPolicyServer != nullptr);
741 audioPolicyServer->isInitMuteState_ = true;
742 audioPolicyServer->InitMicrophoneMute();
743 audioPolicyServer->isInitMuteState_ = false;
744 audioPolicyServer->InitMicrophoneMute();
745 }
746
AudioPolicyServerSetMicrophoneMuteAudioConfigFuzztest()747 void AudioPolicyServerSetMicrophoneMuteAudioConfigFuzztest()
748 {
749 auto audioPolicyServer = GetServerPtr();
750 CHECK_AND_RETURN(audioPolicyServer != nullptr);
751 bool isMute = GetData<bool>();
752 audioPolicyServer->SetMicrophoneMuteAudioConfig(isMute);
753 }
754
AudioPolicyServerSetMicrophoneMutePersistentFuzztest()755 void AudioPolicyServerSetMicrophoneMutePersistentFuzztest()
756 {
757 auto audioPolicyServer = GetServerPtr();
758 CHECK_AND_RETURN(audioPolicyServer != nullptr);
759 bool isMute = GetData<bool>();
760 PolicyType typeIn = GetData<PolicyType>();
761 audioPolicyServer->SetMicrophoneMutePersistent(isMute, typeIn);
762 }
763
AudioPolicyServerSetAudioSceneFuzztest()764 void AudioPolicyServerSetAudioSceneFuzztest()
765 {
766 auto audioPolicyServer = GetServerPtr();
767 CHECK_AND_RETURN(audioPolicyServer != nullptr);
768 AudioScene audioSceneIn = AUDIO_SCENE_DEFAULT;
769 audioPolicyServer->SetAudioScene(audioSceneIn);
770 audioSceneIn = AUDIO_SCENE_PHONE_CALL;
771 audioPolicyServer->SetAudioScene(audioSceneIn);
772 audioSceneIn = AUDIO_SCENE_PHONE_CHAT;
773 audioPolicyServer->SetAudioScene(audioSceneIn);
774 }
775
AudioPolicyServerSetAndUnsetAudioInterruptCallbackFuzztest()776 void AudioPolicyServerSetAndUnsetAudioInterruptCallbackFuzztest()
777 {
778 auto audioPolicyServer = GetServerPtr();
779 CHECK_AND_RETURN(audioPolicyServer != nullptr);
780 uint32_t sessionID = GetData<uint32_t>();
781 uint32_t zoneID = GetData<uint32_t>();
782 uint32_t clientUid = GetData<uint32_t>();
783 sptr<IRemoteObject> object = new RemoteObjectFuzzTestStub();
784 audioPolicyServer->SetAudioInterruptCallback(sessionID, object, clientUid, zoneID);
785 audioPolicyServer->UnsetAudioInterruptCallback(sessionID, zoneID);
786 }
787
AudioPolicyServerVerifySessionIdFuzztest()788 void AudioPolicyServerVerifySessionIdFuzztest()
789 {
790 auto audioPolicyServer = GetServerPtr();
791 CHECK_AND_RETURN(audioPolicyServer != nullptr);
792 uint32_t sessionId = GetData<uint32_t>();
793 uint32_t clientUid = GetData<uint32_t>();
794 audioPolicyServer->VerifySessionId(sessionId, clientUid);
795 }
796
AudioPolicyServerSetAndUnsetAudioRouteCallbackFuzztest()797 void AudioPolicyServerSetAndUnsetAudioRouteCallbackFuzztest()
798 {
799 auto audioPolicyServer = GetServerPtr();
800 CHECK_AND_RETURN(audioPolicyServer != nullptr);
801 uint32_t sessionId = GetData<uint32_t>();
802 sptr<IRemoteObject> object = new RemoteObjectFuzzTestStub();
803 uint32_t clientUid = GetData<uint32_t>();
804 audioPolicyServer->SetAudioRouteCallback(sessionId, object, clientUid);
805 audioPolicyServer->UnsetAudioRouteCallback(sessionId);
806 }
807
AudioPolicyServerSubscribeAccessibilityConfigObserverFuzzTest()808 void AudioPolicyServerSubscribeAccessibilityConfigObserverFuzzTest()
809 {
810 auto audioPolicyServer = GetServerPtr();
811 CHECK_AND_RETURN(audioPolicyServer != nullptr);
812 audioPolicyServer->SubscribeAccessibilityConfigObserver();
813 }
814
AudioPolicyServerGetMinStreamVolumeFuzzTest()815 void AudioPolicyServerGetMinStreamVolumeFuzzTest()
816 {
817 auto audioPolicyServer = GetServerPtr();
818 CHECK_AND_RETURN(audioPolicyServer != nullptr);
819
820 float volume = GetData<float>();
821 audioPolicyServer->GetMinStreamVolume(volume);
822 }
823
AudioPolicyServerGetMaxStreamVolumeFuzzTest()824 void AudioPolicyServerGetMaxStreamVolumeFuzzTest()
825 {
826 auto audioPolicyServer = GetServerPtr();
827 CHECK_AND_RETURN(audioPolicyServer != nullptr);
828
829 float volume = GetData<float>();
830 audioPolicyServer->GetMaxStreamVolume(volume);
831 }
832
AudioPolicyServerGetMaxRendererInstancesFuzzTest()833 void AudioPolicyServerGetMaxRendererInstancesFuzzTest()
834 {
835 auto audioPolicyServer = GetServerPtr();
836 CHECK_AND_RETURN(audioPolicyServer != nullptr);
837
838 int32_t ret = GetData<int32_t>();
839 audioPolicyServer->isFirstAudioServiceStart_ = GetData<bool>();
840 audioPolicyServer->GetMaxRendererInstances(ret);
841 }
842
AudioPolicyServerRegisterDataObserverFuzzTest()843 void AudioPolicyServerRegisterDataObserverFuzzTest()
844 {
845 auto audioPolicyServer = GetServerPtr();
846 CHECK_AND_RETURN(audioPolicyServer != nullptr);
847
848 audioPolicyServer->RegisterDataObserver();
849 }
850
AudioPolicyServerQueryEffectSceneModeFuzzTest()851 void AudioPolicyServerQueryEffectSceneModeFuzzTest()
852 {
853 auto audioPolicyServer = GetServerPtr();
854 CHECK_AND_RETURN(audioPolicyServer != nullptr);
855
856 SupportedEffectConfig supportedEffectConfig;
857 audioPolicyServer->QueryEffectSceneMode(supportedEffectConfig);
858 }
859
AudioPolicyServerGetHardwareOutputSamplingRateFuzzTest()860 void AudioPolicyServerGetHardwareOutputSamplingRateFuzzTest()
861 {
862 auto audioPolicyServer = GetServerPtr();
863 CHECK_AND_RETURN(audioPolicyServer != nullptr);
864
865 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
866 int32_t ret = GetData<int32_t>();
867 audioPolicyServer->GetHardwareOutputSamplingRate(desc, ret);
868 }
869
AudioPolicyServerGetAudioCapturerMicrophoneDescriptorsFuzzTest()870 void AudioPolicyServerGetAudioCapturerMicrophoneDescriptorsFuzzTest()
871 {
872 auto audioPolicyServer = GetServerPtr();
873 CHECK_AND_RETURN(audioPolicyServer != nullptr);
874
875 int32_t sessionId = GetData<int32_t>();
876 vector<sptr<MicrophoneDescriptor>> micDescs;
877 audioPolicyServer->GetAudioCapturerMicrophoneDescriptors(sessionId, micDescs);
878 }
879
AudioPolicyServerGetAvailableMicrophonesFuzzTest()880 void AudioPolicyServerGetAvailableMicrophonesFuzzTest()
881 {
882 auto audioPolicyServer = GetServerPtr();
883 CHECK_AND_RETURN(audioPolicyServer != nullptr);
884
885 vector<sptr<MicrophoneDescriptor>> retMicList;
886 audioPolicyServer->GetAvailableMicrophones(retMicList);
887 }
888
AudioPolicyServerSetDeviceAbsVolumeSupportedFuzzTest()889 void AudioPolicyServerSetDeviceAbsVolumeSupportedFuzzTest()
890 {
891 auto audioPolicyServer = GetServerPtr();
892 CHECK_AND_RETURN(audioPolicyServer != nullptr);
893
894 std::string macAddress = "test_mac";
895 bool support = GetData<bool>();
896 audioPolicyServer->SetDeviceAbsVolumeSupported(macAddress, support);
897 }
898
AudioPolicyServerIsAbsVolumeSceneFuzzTest()899 void AudioPolicyServerIsAbsVolumeSceneFuzzTest()
900 {
901 auto audioPolicyServer = GetServerPtr();
902 CHECK_AND_RETURN(audioPolicyServer != nullptr);
903
904 bool ret = GetData<bool>();
905 audioPolicyServer->IsAbsVolumeScene(ret);
906 }
907
AudioPolicyServerSetA2dpDeviceVolumeFuzzTest()908 void AudioPolicyServerSetA2dpDeviceVolumeFuzzTest()
909 {
910 auto audioPolicyServer = GetServerPtr();
911 CHECK_AND_RETURN(audioPolicyServer != nullptr);
912
913 std::string macAddress = "test_mac";
914 int32_t volume = GetData<int32_t>();
915 bool updateUi = GetData<bool>();
916 audioPolicyServer->SetA2dpDeviceVolume(macAddress, volume, updateUi);
917 }
918
AudioPolicyServerSetNearlinkDeviceVolumeFuzzTest()919 void AudioPolicyServerSetNearlinkDeviceVolumeFuzzTest()
920 {
921 auto audioPolicyServer = GetServerPtr();
922 CHECK_AND_RETURN(audioPolicyServer != nullptr);
923
924 std::string macAddress = "test_mac";
925 int32_t volume = GetData<int32_t>();
926 int32_t streamTypeIn = GetData<int32_t>();
927 bool updateUi = GetData<bool>();
928 audioPolicyServer->SetNearlinkDeviceVolume(macAddress, streamTypeIn, volume, updateUi);
929 }
930
AudioPolicyServerGetAvailableDevicesFuzzTest()931 void AudioPolicyServerGetAvailableDevicesFuzzTest()
932 {
933 auto audioPolicyServer = GetServerPtr();
934 CHECK_AND_RETURN(audioPolicyServer != nullptr);
935
936 int32_t usageIn = GetData<int32_t>();
937 std::vector<std::shared_ptr<AudioDeviceDescriptor>> descs;
938 audioPolicyServer->GetAvailableDevices(usageIn, descs);
939 }
940
AudioPolicyServerSetAvailableDeviceChangeCallbackFuzzTest()941 void AudioPolicyServerSetAvailableDeviceChangeCallbackFuzzTest()
942 {
943 auto audioPolicyServer = GetServerPtr();
944 CHECK_AND_RETURN(audioPolicyServer != nullptr);
945
946 int32_t clientId = GetData<int32_t>();
947 int32_t usageIn = GetData<int32_t>();
948 sptr<IRemoteObject> object = nullptr;
949
950 audioPolicyServer->SetAvailableDeviceChangeCallback(clientId, usageIn, object);
951 }
952
AudioPolicyServerUnsetAvailableDeviceChangeCallbackFuzzTest()953 void AudioPolicyServerUnsetAvailableDeviceChangeCallbackFuzzTest()
954 {
955 auto audioPolicyServer = GetServerPtr();
956 CHECK_AND_RETURN(audioPolicyServer != nullptr);
957
958 int32_t clientId = GetData<int32_t>();
959 int32_t usageIn = GetData<int32_t>();
960
961 audioPolicyServer->UnsetAvailableDeviceChangeCallback(clientId, usageIn);
962 }
963
AudioPolicyServerOffloadStopPlayingFuzzTest()964 void AudioPolicyServerOffloadStopPlayingFuzzTest()
965 {
966 auto audioPolicyServer = GetServerPtr();
967 CHECK_AND_RETURN(audioPolicyServer != nullptr);
968
969 StreamUsage streamUsage = GetData<StreamUsage>();
970 ContentType contentType = GetData<ContentType>();
971 AudioFocusType audioFocusType = GetData<AudioFocusType>();
972 uint32_t streamId = GetData<uint32_t>();
973 AudioInterrupt audioInterrupt(streamUsage, contentType, audioFocusType, streamId);
974
975 audioPolicyServer->OffloadStopPlaying(audioInterrupt);
976 }
977
AudioPolicyServerCheckAudioSessionStrategyFuzzTest()978 void AudioPolicyServerCheckAudioSessionStrategyFuzzTest()
979 {
980 auto audioPolicyServer = GetServerPtr();
981 CHECK_AND_RETURN(audioPolicyServer != nullptr);
982
983 AudioSessionStrategy sessionStrategy;
984 sessionStrategy.concurrencyMode = GetData<AudioConcurrencyMode>();
985
986 audioPolicyServer->CheckAudioSessionStrategy(sessionStrategy);
987 }
988
AudioPolicyServerSetAudioSessionSceneFuzzTest()989 void AudioPolicyServerSetAudioSessionSceneFuzzTest()
990 {
991 auto audioPolicyServer = GetServerPtr();
992 CHECK_AND_RETURN(audioPolicyServer != nullptr);
993
994 int32_t audioSessionScene = GetData<int32_t>();
995
996 audioPolicyServer->SetAudioSessionScene(audioSessionScene);
997 }
998
AudioPolicyServerGetDefaultOutputDeviceFuzzTest()999 void AudioPolicyServerGetDefaultOutputDeviceFuzzTest()
1000 {
1001 auto audioPolicyServer = GetServerPtr();
1002 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1003
1004 int32_t deviceType = GetData<int32_t>();
1005 std::shared_ptr<AudioCoreService> coreService = make_shared<AudioCoreService>();
1006
1007 audioPolicyServer->GetDefaultOutputDevice(deviceType);
1008 }
1009
AudioPolicyServerSetDefaultOutputDeviceFuzzTest()1010 void AudioPolicyServerSetDefaultOutputDeviceFuzzTest()
1011 {
1012 auto audioPolicyServer = GetServerPtr();
1013 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1014
1015 int32_t deviceType = GetData<int32_t>();
1016
1017 audioPolicyServer->SetDefaultOutputDevice(deviceType);
1018 }
1019
AudioPolicyServerLoadSplitModuleFuzzTest()1020 void AudioPolicyServerLoadSplitModuleFuzzTest()
1021 {
1022 auto audioPolicyServer = GetServerPtr();
1023 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1024
1025 std::string splitArgs = "test_split_args";
1026 std::string networkId = "test_network_id";
1027
1028 audioPolicyServer->LoadSplitModule(splitArgs, networkId);
1029 }
1030
AudioPolicyServerIsAllowedPlaybackFuzzTest()1031 void AudioPolicyServerIsAllowedPlaybackFuzzTest()
1032 {
1033 auto audioPolicyServer = GetServerPtr();
1034 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1035
1036 int32_t uid = GetData<int32_t>();
1037 int32_t pid = GetData<int32_t>();
1038 bool isAllowed = GetData<bool>();
1039
1040 audioPolicyServer->IsAllowedPlayback(uid, pid, isAllowed);
1041 }
1042
AudioPolicyServerSetVoiceRingtoneMuteFuzzTest()1043 void AudioPolicyServerSetVoiceRingtoneMuteFuzzTest()
1044 {
1045 auto audioPolicyServer = GetServerPtr();
1046 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1047
1048 bool isMute = GetData<bool>();
1049
1050 audioPolicyServer->SetVoiceRingtoneMute(isMute);
1051 }
1052
AudioPolicyServerNotifySessionStateChangeFuzzTest()1053 void AudioPolicyServerNotifySessionStateChangeFuzzTest()
1054 {
1055 auto audioPolicyServer = GetServerPtr();
1056 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1057
1058 bool hasSession = GetData<bool>();
1059 int32_t uid = GetData<int32_t>();
1060 int32_t pid = GetData<int32_t>();
1061
1062 audioPolicyServer->NotifySessionStateChange(uid, pid, hasSession);
1063 }
1064
AudioPolicyServerNotifyFreezeStateChangeFuzzTest()1065 void AudioPolicyServerNotifyFreezeStateChangeFuzzTest()
1066 {
1067 auto audioPolicyServer = GetServerPtr();
1068 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1069
1070 bool isFreeze = GetData<bool>();
1071 int32_t pid = GetData<int32_t>();
1072 std::set<int32_t> pidList;
1073 pidList.insert(pid);
1074 audioPolicyServer->NotifyFreezeStateChange(pidList, isFreeze);
1075 }
1076
AudioPolicyServerResetAllProxyFuzzTest()1077 void AudioPolicyServerResetAllProxyFuzzTest()
1078 {
1079 auto audioPolicyServer = GetServerPtr();
1080 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1081
1082 audioPolicyServer->ResetAllProxy();
1083 }
1084
AudioPolicyServerNotifyProcessBackgroundStateFuzzTest()1085 void AudioPolicyServerNotifyProcessBackgroundStateFuzzTest()
1086 {
1087 auto audioPolicyServer = GetServerPtr();
1088 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1089
1090 int32_t uid = GetData<int32_t>();
1091 int32_t pid = GetData<int32_t>();
1092
1093 audioPolicyServer->NotifyProcessBackgroundState(uid, pid);
1094 }
1095
AudioPolicyServerSetVirtualCallFuzzTest()1096 void AudioPolicyServerSetVirtualCallFuzzTest()
1097 {
1098 auto audioPolicyServer = GetServerPtr();
1099 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1100
1101 bool isVirtual = GetData<bool>();
1102
1103 audioPolicyServer->SetVirtualCall(isVirtual);
1104 }
1105
AudioPolicyServerSetDeviceConnectionStatusFuzzTest()1106 void AudioPolicyServerSetDeviceConnectionStatusFuzzTest()
1107 {
1108 auto audioPolicyServer = GetServerPtr();
1109 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1110
1111 bool isConnected = GetData<bool>();
1112 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1113
1114 audioPolicyServer->SetDeviceConnectionStatus(desc, isConnected);
1115 }
1116
AudioPolicyServerSetQueryAllowedPlaybackCallbackFuzzTest()1117 void AudioPolicyServerSetQueryAllowedPlaybackCallbackFuzzTest()
1118 {
1119 auto audioPolicyServer = GetServerPtr();
1120 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1121
1122 sptr<IRemoteObject> object = new RemoteObjectFuzzTestStub();
1123
1124 audioPolicyServer->SetQueryAllowedPlaybackCallback(object);
1125 }
1126
AudioPolicyServerSetBackgroundMuteCallbackFuzzTest()1127 void AudioPolicyServerSetBackgroundMuteCallbackFuzzTest()
1128 {
1129 auto audioPolicyServer = GetServerPtr();
1130 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1131
1132 sptr<IRemoteObject> object = new RemoteObjectFuzzTestStub();
1133
1134 audioPolicyServer->SetBackgroundMuteCallback(object);
1135 }
1136
AudioPolicyServerGetDirectPlaybackSupportFuzzTest()1137 void AudioPolicyServerGetDirectPlaybackSupportFuzzTest()
1138 {
1139 auto audioPolicyServer = GetServerPtr();
1140 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1141
1142 AudioStreamInfo streamInfo;
1143 int32_t streamUsage = GetData<int32_t>();
1144 int32_t retMod = GetData<int32_t>();
1145
1146 audioPolicyServer->GetDirectPlaybackSupport(streamInfo, streamUsage, retMod);
1147 }
1148
AudioPolicyServerGetMaxVolumeLevelByUsageFuzzTest()1149 void AudioPolicyServerGetMaxVolumeLevelByUsageFuzzTest()
1150 {
1151 auto audioPolicyServer = GetServerPtr();
1152 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1153
1154 int32_t streamUsage = GetData<int32_t>();
1155 int32_t retMaxVolumeLevel = GetData<int32_t>();
1156
1157 audioPolicyServer->GetMaxVolumeLevelByUsage(streamUsage, retMaxVolumeLevel);
1158 }
1159
AudioPolicyServerGetMinVolumeLevelByUsageFuzzTest()1160 void AudioPolicyServerGetMinVolumeLevelByUsageFuzzTest()
1161 {
1162 auto audioPolicyServer = GetServerPtr();
1163 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1164
1165 int32_t streamUsage = GetData<int32_t>();
1166 int32_t retMinVolumeLevel = GetData<int32_t>();
1167
1168 audioPolicyServer->GetMinVolumeLevelByUsage(streamUsage, retMinVolumeLevel);
1169 }
1170
AudioPolicyServerGetVolumeLevelByUsageFuzzTest()1171 void AudioPolicyServerGetVolumeLevelByUsageFuzzTest()
1172 {
1173 auto audioPolicyServer = GetServerPtr();
1174 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1175
1176 int32_t streamUsage = GetData<int32_t>();
1177 int32_t retVolumeLevel = GetData<int32_t>();
1178
1179 audioPolicyServer->GetVolumeLevelByUsage(streamUsage, retVolumeLevel);
1180 }
1181
AudioPolicyServerGetStreamMuteByUsageFuzzTest()1182 void AudioPolicyServerGetStreamMuteByUsageFuzzTest()
1183 {
1184 auto audioPolicyServer = GetServerPtr();
1185 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1186
1187 int32_t streamUsage = GetData<int32_t>();
1188 bool isMute = GetData<bool>();
1189
1190 audioPolicyServer->GetStreamMuteByUsage(streamUsage, isMute);
1191 }
1192
AudioPolicyServerGetVolumeInDbByStreamFuzzTest()1193 void AudioPolicyServerGetVolumeInDbByStreamFuzzTest()
1194 {
1195 auto audioPolicyServer = GetServerPtr();
1196 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1197
1198 int32_t streamUsageIn = GetData<int32_t>();
1199 int32_t volumeLevel = GetData<int32_t>();
1200 int32_t deviceType = GetData<int32_t>();
1201 float ret = GetData<float>();
1202
1203 audioPolicyServer->GetVolumeInDbByStream(streamUsageIn, volumeLevel, deviceType, ret);
1204 }
1205
AudioPolicyServerGetSupportedAudioVolumeTypesFuzzTest()1206 void AudioPolicyServerGetSupportedAudioVolumeTypesFuzzTest()
1207 {
1208 auto audioPolicyServer = GetServerPtr();
1209 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1210
1211 std::vector<int32_t> ret;
1212 ret.push_back(GetData<int32_t>());
1213 audioPolicyServer->GetSupportedAudioVolumeTypes(ret);
1214 }
1215
AudioPolicyServerGetAudioVolumeTypeByStreamUsageFuzzTest()1216 void AudioPolicyServerGetAudioVolumeTypeByStreamUsageFuzzTest()
1217 {
1218 auto audioPolicyServer = GetServerPtr();
1219 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1220
1221 int32_t streamUsageIn = GetData<int32_t>();
1222 int32_t ret = 0;
1223 audioPolicyServer->GetAudioVolumeTypeByStreamUsage(streamUsageIn, ret);
1224 }
1225
AudioPolicyServerGetStreamUsagesByVolumeTypeFuzzTest()1226 void AudioPolicyServerGetStreamUsagesByVolumeTypeFuzzTest()
1227 {
1228 auto audioPolicyServer = GetServerPtr();
1229 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1230
1231 int32_t audioVolumeTypeIn = GetData<int32_t>();
1232 std::vector<int32_t> ret;
1233 audioPolicyServer->GetStreamUsagesByVolumeType(audioVolumeTypeIn, ret);
1234 }
1235
AudioPolicyServerSetCallbackStreamUsageInfoFuzzTest()1236 void AudioPolicyServerSetCallbackStreamUsageInfoFuzzTest()
1237 {
1238 auto audioPolicyServer = GetServerPtr();
1239 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1240
1241 std::set<int32_t> streamUsages;
1242 streamUsages.insert(GetData<int32_t>());
1243 audioPolicyServer->SetCallbackStreamUsageInfo(streamUsages);
1244 }
1245
AudioPolicyServerForceStopAudioStreamFuzzTest()1246 void AudioPolicyServerForceStopAudioStreamFuzzTest()
1247 {
1248 auto audioPolicyServer = GetServerPtr();
1249 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1250
1251 int32_t audioTypeIn = GetData<int32_t>();
1252 audioPolicyServer->ForceStopAudioStream(audioTypeIn);
1253 }
1254
AudioPolicyServerIsCapturerFocusAvailableFuzzTest()1255 void AudioPolicyServerIsCapturerFocusAvailableFuzzTest()
1256 {
1257 auto audioPolicyServer = GetServerPtr();
1258 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1259
1260 SourceType sourceType = GetData<SourceType>();
1261 int32_t capturerFlags = GetData<int32_t>();
1262 AudioCapturerInfo capturerInfo(sourceType, capturerFlags);
1263 bool ret = GetData<bool>();
1264
1265 audioPolicyServer->IsCapturerFocusAvailable(capturerInfo, ret);
1266 }
1267
AudioPolicyServerUpdateDefaultOutputDeviceWhenStartingFuzzTest()1268 void AudioPolicyServerUpdateDefaultOutputDeviceWhenStartingFuzzTest()
1269 {
1270 auto audioPolicyServer = GetServerPtr();
1271 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1272
1273 uint32_t sessionID = GetData<uint32_t>();
1274
1275 audioPolicyServer->UpdateDefaultOutputDeviceWhenStarting(sessionID);
1276 }
1277
AudioPolicyServerUpdateDefaultOutputDeviceWhenStoppingFuzzTest()1278 void AudioPolicyServerUpdateDefaultOutputDeviceWhenStoppingFuzzTest()
1279 {
1280 auto audioPolicyServer = GetServerPtr();
1281 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1282
1283 uint32_t sessionID = GetData<uint32_t>();
1284
1285 audioPolicyServer->UpdateDefaultOutputDeviceWhenStopping(sessionID);
1286 }
1287
AudioPolicyServerIsAcousticEchoCancelerSupportedFuzzTest()1288 void AudioPolicyServerIsAcousticEchoCancelerSupportedFuzzTest()
1289 {
1290 auto audioPolicyServer = GetServerPtr();
1291 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1292
1293 int32_t sourceType = GetData<int32_t>();
1294 bool ret = GetData<bool>();
1295
1296 audioPolicyServer->IsAcousticEchoCancelerSupported(sourceType, ret);
1297 }
1298
AudioPolicyServerSetKaraokeParametersFuzzTest()1299 void AudioPolicyServerSetKaraokeParametersFuzzTest()
1300 {
1301 auto audioPolicyServer = GetServerPtr();
1302 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1303
1304 std::string parameters = "test_parameters";
1305 bool ret = GetData<bool>();
1306
1307 audioPolicyServer->SetKaraokeParameters(parameters, ret);
1308 }
1309
AudioPolicyServerUpdateDeviceInfoFuzzTest()1310 void AudioPolicyServerUpdateDeviceInfoFuzzTest()
1311 {
1312 auto audioPolicyServer = GetServerPtr();
1313 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1314
1315 int32_t command = GetData<int32_t>();
1316 std::shared_ptr<AudioDeviceDescriptor> deviceDesc = std::make_shared<AudioDeviceDescriptor>();
1317
1318 audioPolicyServer->UpdateDeviceInfo(deviceDesc, command);
1319 }
1320
AudioPolicyServerSetSleAudioOperationCallbackFuzzTest()1321 void AudioPolicyServerSetSleAudioOperationCallbackFuzzTest()
1322 {
1323 auto audioPolicyServer = GetServerPtr();
1324 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1325
1326 sptr<IRemoteObject> object = nullptr;
1327 audioPolicyServer->SetSleAudioOperationCallback(object);
1328 }
1329
AudioPolicyServerSetCollaborativePlaybackEnabledForDeviceFuzzTest()1330 void AudioPolicyServerSetCollaborativePlaybackEnabledForDeviceFuzzTest()
1331 {
1332 auto audioPolicyServer = GetServerPtr();
1333 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1334
1335 std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
1336 bool enabled = GetData<bool>();
1337
1338 audioPolicyServer->SetCollaborativePlaybackEnabledForDevice(selectedAudioDevice, enabled);
1339 }
1340
AudioPolicyServerIsCollaborativePlaybackSupportedFuzzTest()1341 void AudioPolicyServerIsCollaborativePlaybackSupportedFuzzTest()
1342 {
1343 auto audioPolicyServer = GetServerPtr();
1344 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1345
1346 bool ret = GetData<bool>();
1347
1348 audioPolicyServer->IsCollaborativePlaybackSupported(ret);
1349 }
1350
AudioPolicyServerIsCollaborativePlaybackEnabledForDeviceFuzzTest()1351 void AudioPolicyServerIsCollaborativePlaybackEnabledForDeviceFuzzTest()
1352 {
1353 auto audioPolicyServer = GetServerPtr();
1354 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1355
1356 std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice = std::make_shared<AudioDeviceDescriptor>();
1357 bool enabled = GetData<bool>();
1358
1359 audioPolicyServer->IsCollaborativePlaybackEnabledForDevice(selectedAudioDevice, enabled);
1360 }
1361
AudioPolicyServerCallRingtoneLibraryFuzzTest()1362 void AudioPolicyServerCallRingtoneLibraryFuzzTest()
1363 {
1364 auto audioPolicyServer = GetServerPtr();
1365 CHECK_AND_RETURN(audioPolicyServer != nullptr);
1366
1367 audioPolicyServer->CallRingtoneLibrary();
1368 }
1369
SetAndUnsetDistributedRoutingRoleCallbackFuzzTest()1370 void SetAndUnsetDistributedRoutingRoleCallbackFuzzTest()
1371 {
1372 sptr<RemoteObjectFuzzTestStub> remoteObjectStub = sptr<RemoteObjectFuzzTestStub>();
1373 CHECK_AND_RETURN(remoteObjectStub != nullptr);
1374 auto server = GetServerPtr();
1375 CHECK_AND_RETURN(server != nullptr);
1376 server->SetDistributedRoutingRoleCallback(remoteObjectStub);
1377 server->UnsetDistributedRoutingRoleCallback();
1378 }
1379
OnDistributedRoutingRoleChangeFuzzTest()1380 void OnDistributedRoutingRoleChangeFuzzTest()
1381 {
1382 shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
1383 CHECK_AND_RETURN(desc != nullptr);
1384 OHOS::AudioStandard::CastType castTypeValue = GetData<OHOS::AudioStandard::CastType>();
1385 auto server = GetServerPtr();
1386 CHECK_AND_RETURN(server != nullptr);
1387 server->OnDistributedRoutingRoleChange(desc, castTypeValue);
1388 }
1389
RegisterAndUnRegisterPowerStateListenerFuzzTest()1390 void RegisterAndUnRegisterPowerStateListenerFuzzTest()
1391 {
1392 sptr<AudioPolicyServer> server = GetServerPtr();
1393 CHECK_AND_RETURN(server != nullptr);
1394 server->RegisterPowerStateListener();
1395 server->UnRegisterPowerStateListener();
1396 }
1397
RegisterAppStateListenerFuzzTest()1398 void RegisterAppStateListenerFuzzTest()
1399 {
1400 sptr<AudioPolicyServer> server = GetServerPtr();
1401 CHECK_AND_RETURN(server != nullptr);
1402 server->RegisterAppStateListener();
1403 }
1404
RegisterAndUnRegisterSyncHibernateListenerFuzzTest()1405 void RegisterAndUnRegisterSyncHibernateListenerFuzzTest()
1406 {
1407 sptr<AudioPolicyServer> server = GetServerPtr();
1408 CHECK_AND_RETURN(server != nullptr);
1409 server->RegisterSyncHibernateListener();
1410 server->UnRegisterSyncHibernateListener();
1411 }
1412
AudioPolicyServerRegisterSpatializationStateEventListenerFuzzTest()1413 void AudioPolicyServerRegisterSpatializationStateEventListenerFuzzTest()
1414 {
1415 uint32_t sessionID = GetData<uint32_t>();
1416 int32_t streamUsageIn = GetData<int32_t>();
1417
1418 sptr<RemoteObjectFuzzTestStub> object = sptr<RemoteObjectFuzzTestStub>();
1419 CHECK_AND_RETURN(object != nullptr);
1420 auto server = GetServerPtr();
1421 CHECK_AND_RETURN(server != nullptr);
1422 server->RegisterSpatializationStateEventListener(sessionID, streamUsageIn, object);
1423 server->UnregisterSpatializationStateEventListener(sessionID);
1424 }
1425
AudioPolicyServerAudioInterruptZoneFuzzTest()1426 void AudioPolicyServerAudioInterruptZoneFuzzTest()
1427 {
1428 std::set<int32_t> pids;
1429 int32_t zoneID = GetData<int32_t>();
1430 int32_t count = DEVICE_COUNT;
1431 for (int32_t i = 0; i < count; ++i) {
1432 pids.insert(GetData<int32_t>());
1433 }
1434
1435 auto server = GetServerPtr();
1436 CHECK_AND_RETURN(server != nullptr);
1437 server->CreateAudioInterruptZone(pids, zoneID);
1438 server->AddAudioInterruptZonePids(pids, zoneID);
1439 server->RemoveAudioInterruptZonePids(pids, zoneID);
1440 server->ReleaseAudioInterruptZone(zoneID);
1441 }
1442
AudioPolicyServerRegisterAudioZoneClientFuzzTest()1443 void AudioPolicyServerRegisterAudioZoneClientFuzzTest()
1444 {
1445 auto server = GetServerPtr();
1446 CHECK_AND_RETURN(server != nullptr);
1447 sptr<RemoteObjectFuzzTestStub> object = sptr<RemoteObjectFuzzTestStub>();
1448 CHECK_AND_RETURN(object != nullptr);
1449 server->RegisterAudioZoneClient(object);
1450 }
1451
AudioPolicyServerAudioZoneQueryFuzzTest()1452 void AudioPolicyServerAudioZoneQueryFuzzTest()
1453 {
1454 auto server = GetServerPtr();
1455 CHECK_AND_RETURN(server != nullptr);
1456 std::string name = "zone";
1457 AudioZoneContext context;
1458 int32_t zoneId = 0;
1459 server->CreateAudioZone(name, context, zoneId, 0);
1460
1461 std::vector<std::shared_ptr<AudioZoneDescriptor>> descs;
1462 server->GetAllAudioZone(descs);
1463
1464 std::shared_ptr<AudioZoneDescriptor> desc;
1465 server->GetAudioZone(zoneId, desc);
1466
1467 int32_t queriedZoneId = 0;
1468 server->GetAudioZoneByName(name, queriedZoneId);
1469
1470 server->ReleaseAudioZone(zoneId);
1471 }
1472
AudioPolicyServerBindUnbindDeviceToAudioZoneFuzzTest()1473 void AudioPolicyServerBindUnbindDeviceToAudioZoneFuzzTest()
1474 {
1475 auto server = GetServerPtr();
1476 CHECK_AND_RETURN(server != nullptr);
1477 std::string name = "zone";
1478 AudioZoneContext context;
1479 int32_t zoneId = 0;
1480 server->CreateAudioZone(name, context, zoneId, 0);
1481
1482 std::vector<std::shared_ptr<AudioDeviceDescriptor>> devices;
1483 int32_t deviceCount = DEVICE_COUNT;
1484 for (int32_t i = 0; i < deviceCount; ++i) {
1485 auto device = std::make_shared<AudioDeviceDescriptor>();
1486 devices.push_back(device);
1487 }
1488
1489 server->BindDeviceToAudioZone(zoneId, devices);
1490
1491 server->UnBindDeviceToAudioZone(zoneId, devices);
1492
1493 server->ReleaseAudioZone(zoneId);
1494 }
1495
AudioPolicyServerEnableAudioZoneReportFuzzTest()1496 void AudioPolicyServerEnableAudioZoneReportFuzzTest()
1497 {
1498 auto server = GetServerPtr();
1499 CHECK_AND_RETURN(server != nullptr);
1500 bool enable = GetData<bool>();
1501 server->EnableAudioZoneReport(enable);
1502
1503 std::string name = "zone";
1504 AudioZoneContext context;
1505 int32_t zoneId = 0;
1506 server->CreateAudioZone(name, context, zoneId, 0);
1507
1508 bool changeEnable = GetData<bool>();
1509 server->EnableAudioZoneChangeReport(zoneId, changeEnable);
1510
1511 server->ReleaseAudioZone(zoneId);
1512 }
1513
AudioPolicyServerAddRemoveUidToAudioZoneFuzzTest()1514 void AudioPolicyServerAddRemoveUidToAudioZoneFuzzTest()
1515 {
1516 auto server = GetServerPtr();
1517 CHECK_AND_RETURN(server != nullptr);
1518 std::string name = "zone";
1519 AudioZoneContext context;
1520 int32_t zoneId = 0;
1521 server->CreateAudioZone(name, context, zoneId, 0);
1522
1523 int32_t uid = GetData<int32_t>();
1524 server->AddUidToAudioZone(zoneId, uid);
1525 server->RemoveUidFromAudioZone(zoneId, uid);
1526
1527 server->ReleaseAudioZone(zoneId);
1528 }
1529
AudioPolicyServerAddStreamToAudioZoneFuzzTest()1530 void AudioPolicyServerAddStreamToAudioZoneFuzzTest()
1531 {
1532 auto server = GetServerPtr();
1533 CHECK_AND_RETURN(server != nullptr);
1534 std::string zoneName = "zone";
1535 AudioZoneContext context;
1536 int32_t zoneId = 0;
1537 server->CreateAudioZone(zoneName, context, zoneId, 0);
1538
1539 AudioZoneStream stream;
1540 stream.streamUsage = GetData<StreamUsage>();
1541 stream.sourceType = GetData<SourceType>();
1542 stream.isPlay = GetData<bool>();
1543 server->AddStreamToAudioZone(zoneId, stream);
1544 server->RemoveStreamFromAudioZone(zoneId, stream);
1545 server->ReleaseAudioZone(zoneId);
1546 }
1547
AudioPolicyServerAddStreamsToAudioZoneFuzzTest()1548 void AudioPolicyServerAddStreamsToAudioZoneFuzzTest()
1549 {
1550 auto server = GetServerPtr();
1551 CHECK_AND_RETURN(server != nullptr);
1552 std::string zoneName = "zone";
1553 AudioZoneContext context;
1554 int32_t zoneId = 0;
1555 server->CreateAudioZone(zoneName, context, zoneId, 0);
1556
1557 std::vector<AudioZoneStream> streams;
1558 int32_t count = COUNT;
1559 for (int32_t i = 0; i < count; ++i) {
1560 AudioZoneStream stream;
1561 stream.streamUsage = GetData<StreamUsage>();
1562 stream.sourceType = GetData<SourceType>();
1563 stream.isPlay = GetData<bool>();
1564 streams.push_back(stream);
1565 }
1566 server->AddStreamsToAudioZone(zoneId, streams);
1567 server->RemoveStreamsFromAudioZone(zoneId, streams);
1568 server->ReleaseAudioZone(zoneId);
1569 }
1570
AudioPolicyServerSetZoneDeviceVisibleFuzzTest()1571 void AudioPolicyServerSetZoneDeviceVisibleFuzzTest()
1572 {
1573 auto server = GetServerPtr();
1574 CHECK_AND_RETURN(server != nullptr);
1575 bool visible = GetData<bool>();
1576 server->SetZoneDeviceVisible(visible);
1577 }
1578
AudioPolicyServerEnableSystemVolumeProxyFuzzTest()1579 void AudioPolicyServerEnableSystemVolumeProxyFuzzTest()
1580 {
1581 auto server = GetServerPtr();
1582 CHECK_AND_RETURN(server != nullptr);
1583 std::string zoneName = "zone";
1584 AudioZoneContext context;
1585 int32_t zoneId = 0;
1586 server->CreateAudioZone(zoneName, context, zoneId, 0);
1587 bool enable = GetData<bool>();
1588 server->EnableSystemVolumeProxy(zoneId, enable);
1589 server->ReleaseAudioZone(zoneId);
1590 }
1591
AudioPolicyServerGetAudioInterruptForZoneFuzzTest()1592 void AudioPolicyServerGetAudioInterruptForZoneFuzzTest()
1593 {
1594 auto server = GetServerPtr();
1595 CHECK_AND_RETURN(server != nullptr);
1596 std::string zoneName = "zone";
1597 AudioZoneContext context;
1598 int32_t zoneId = 0;
1599 server->CreateAudioZone(zoneName, context, zoneId, 0);
1600 std::vector<std::map<AudioInterrupt, int32_t>> retList;
1601 server->GetAudioInterruptForZone(zoneId, retList);
1602 std::string deviceTag = "dev";
1603 server->GetAudioInterruptForZone(zoneId, deviceTag, retList);
1604 server->ReleaseAudioZone(zoneId);
1605 }
1606
AudioPolicyServerGetMaxAmplitudeFuzzTest()1607 void AudioPolicyServerGetMaxAmplitudeFuzzTest()
1608 {
1609 int32_t deviceId = GetData<int32_t>();
1610 float ret = GetData<float>();
1611 auto server = GetServerPtr();
1612 CHECK_AND_RETURN(server != nullptr);
1613 server->GetMaxAmplitude(deviceId, ret);
1614 }
1615
AudioPolicyServerIsHeadTrackingDataRequestedFuzzTest()1616 void AudioPolicyServerIsHeadTrackingDataRequestedFuzzTest()
1617 {
1618 std::string macAddress = "test";
1619 bool ret = GetData<bool>();
1620 auto server = GetServerPtr();
1621 CHECK_AND_RETURN(server != nullptr);
1622 server->IsHeadTrackingDataRequested(macAddress, ret);
1623 }
1624
AudioPolicyServerUnsetAudioDeviceRefinerCallbackFuzzTest()1625 void AudioPolicyServerUnsetAudioDeviceRefinerCallbackFuzzTest()
1626 {
1627 auto server = GetServerPtr();
1628 CHECK_AND_RETURN(server != nullptr);
1629 server->UnsetAudioDeviceRefinerCallback();
1630 }
1631
AudioPolicyServerTriggerFetchDeviceFuzzTest()1632 void AudioPolicyServerTriggerFetchDeviceFuzzTest()
1633 {
1634 AudioStreamDeviceChangeReasonExt reason = GetData<AudioStreamDeviceChangeReason>();
1635 auto server = GetServerPtr();
1636 CHECK_AND_RETURN(server != nullptr);
1637 server->TriggerFetchDevice(reason);
1638 }
1639
AudioPolicyServerSetPreferredDeviceFuzzTest()1640 void AudioPolicyServerSetPreferredDeviceFuzzTest()
1641 {
1642 auto server = GetServerPtr();
1643 CHECK_AND_RETURN(server != nullptr);
1644 int32_t preferredTypeIn = GetData<int32_t>();
1645 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
1646 CHECK_AND_RETURN(audioDeviceDescriptor != nullptr);
1647 int32_t uid = GetData<int32_t>();
1648 server->SetPreferredDevice(preferredTypeIn, audioDeviceDescriptor, uid);
1649 }
1650
AudioPolicyServerSetDeviceVolumeBehaviorFuzzTest()1651 void AudioPolicyServerSetDeviceVolumeBehaviorFuzzTest()
1652 {
1653 auto server = GetServerPtr();
1654 CHECK_AND_RETURN(server != nullptr);
1655 int32_t deviceType = GetData<int32_t>();
1656 VolumeBehavior volumeBehavior;
1657 std::string networkId = "test";
1658 server->SetDeviceVolumeBehavior(networkId, deviceType, volumeBehavior);
1659 }
1660
AudioPolicyServerUnsetAudioDeviceAnahsCallbackFuzzTest()1661 void AudioPolicyServerUnsetAudioDeviceAnahsCallbackFuzzTest()
1662 {
1663 auto server = GetServerPtr();
1664 CHECK_AND_RETURN(server != nullptr);
1665 server->UnsetAudioDeviceAnahsCallback();
1666 }
1667
AudioPolicyServerSendVolumeKeyEventToRssWhenAccountsChangedFuzzTest()1668 void AudioPolicyServerSendVolumeKeyEventToRssWhenAccountsChangedFuzzTest()
1669 {
1670 auto server = GetServerPtr();
1671 CHECK_AND_RETURN(server != nullptr);
1672 server->SendVolumeKeyEventToRssWhenAccountsChanged();
1673 }
1674
AudioPolicyServerNotifyAccountsChangedFuzzTest()1675 void AudioPolicyServerNotifyAccountsChangedFuzzTest()
1676 {
1677 const int32_t id = GetData<int32_t>();
1678 auto server = GetServerPtr();
1679 CHECK_AND_RETURN(server != nullptr);
1680 server->NotifyAccountsChanged(id);
1681 }
1682
AudioPolicyServerMoveToNewPipeFuzzTest()1683 void AudioPolicyServerMoveToNewPipeFuzzTest()
1684 {
1685 uint32_t sessionId = GetData<uint32_t>();
1686 int32_t pipeType = GetData<int32_t>();
1687 auto server = GetServerPtr();
1688 CHECK_AND_RETURN(server != nullptr);
1689 server->MoveToNewPipe(sessionId, pipeType);
1690 }
1691
AudioPolicyServerCheckHibernateStateFuzzTest()1692 void AudioPolicyServerCheckHibernateStateFuzzTest()
1693 {
1694 auto server = GetServerPtr();
1695 CHECK_AND_RETURN(server != nullptr);
1696 server->CheckHibernateState(GetData<bool>());
1697 }
1698
AudioPolicyServerUpdateSafeVolumeByS4FuzzTest()1699 void AudioPolicyServerUpdateSafeVolumeByS4FuzzTest()
1700 {
1701 auto server = GetServerPtr();
1702 CHECK_AND_RETURN(server != nullptr);
1703 server->UpdateSafeVolumeByS4();
1704 }
1705
AudioPolicyServerCheckConnectedDeviceFuzzTest()1706 void AudioPolicyServerCheckConnectedDeviceFuzzTest()
1707 {
1708 auto server = GetServerPtr();
1709 CHECK_AND_RETURN(server != nullptr);
1710 server->CheckConnectedDevice();
1711 }
1712
AudioPolicyServerSetDeviceConnectedFlagFalseAfterDurationFuzzTest()1713 void AudioPolicyServerSetDeviceConnectedFlagFalseAfterDurationFuzzTest()
1714 {
1715 auto server = GetServerPtr();
1716 CHECK_AND_RETURN(server != nullptr);
1717 server->SetDeviceConnectedFlagFalseAfterDuration();
1718 }
1719
AudioPolicyServerInjectInterruptionFuzzTest()1720 void AudioPolicyServerInjectInterruptionFuzzTest()
1721 {
1722 InterruptEvent event;
1723 event.eventType = GetData<InterruptType>();
1724 event.forceType = GetData<InterruptForceType>();
1725 event.hintType = GetData<InterruptHint>();
1726 event.callbackToApp = GetData<bool>();
1727 std::string a = "test";
1728 auto server = GetServerPtr();
1729 CHECK_AND_RETURN(server != nullptr);
1730 server->InjectInterruption(a, event);
1731 }
1732
AudioPolicyServerProcessRemoteInterruptFuzzTest()1733 void AudioPolicyServerProcessRemoteInterruptFuzzTest()
1734 {
1735 auto server = GetServerPtr();
1736 CHECK_AND_RETURN(server != nullptr);
1737 std::set<int32_t> sessionIds;
1738 sessionIds.insert(GetData<int32_t>());
1739 InterruptEventInternal interruptEvent;
1740 uint32_t index = GetData<uint32_t>() % g_testInterruptHints.size();
1741 interruptEvent.hintType = g_testInterruptHints[index];
1742 server->ProcessRemoteInterrupt(sessionIds, interruptEvent);
1743 }
1744
AudioPolicyServerGetStreamIdsForAudioSessionByStreamUsageFuzzTest()1745 void AudioPolicyServerGetStreamIdsForAudioSessionByStreamUsageFuzzTest()
1746 {
1747 auto server = GetServerPtr();
1748 CHECK_AND_RETURN(server != nullptr);
1749 int32_t zoneId = GetData<int32_t>();
1750 std::set<StreamUsage> streamUsageSet = {STREAM_USAGE_MEDIA, STREAM_USAGE_MUSIC, STREAM_USAGE_AUDIOBOOK};
1751 server->GetStreamIdsForAudioSessionByStreamUsage(zoneId, streamUsageSet);
1752 }
1753
AudioPolicyServerActivateAudioInterruptFuzzTest()1754 void AudioPolicyServerActivateAudioInterruptFuzzTest()
1755 {
1756 auto server = GetServerPtr();
1757 CHECK_AND_RETURN(server != nullptr);
1758 AudioInterrupt audioInterruptIn;
1759 int32_t zoneID = GetData<int32_t>();
1760 bool isUpdatedAudioStrategy = GetData<bool>();
1761 server->ActivateAudioInterrupt(audioInterruptIn, zoneID, isUpdatedAudioStrategy);
1762 }
1763
AudioPolicyServerDeactivateAudioInterruptFuzzTest()1764 void AudioPolicyServerDeactivateAudioInterruptFuzzTest()
1765 {
1766 auto server = GetServerPtr();
1767 CHECK_AND_RETURN(server != nullptr);
1768 AudioInterrupt audioInterruptIn;
1769 int32_t zoneID = GetData<int32_t>();
1770 server->DeactivateAudioInterrupt(audioInterruptIn, zoneID);
1771 }
1772
AudioPolicyServerActivatePreemptModeFuzzTest()1773 void AudioPolicyServerActivatePreemptModeFuzzTest()
1774 {
1775 auto server = GetServerPtr();
1776 CHECK_AND_RETURN(server != nullptr);
1777 server->ActivatePreemptMode();
1778 }
1779
AudioPolicyServerDeactivatePreemptModeFuzzTest()1780 void AudioPolicyServerDeactivatePreemptModeFuzzTest()
1781 {
1782 auto server = GetServerPtr();
1783 CHECK_AND_RETURN(server != nullptr);
1784 server->DeactivatePreemptMode();
1785 }
1786
AudioPolicyServerGetStreamInFocusFuzzTest()1787 void AudioPolicyServerGetStreamInFocusFuzzTest()
1788 {
1789 auto server = GetServerPtr();
1790 CHECK_AND_RETURN(server != nullptr);
1791 int32_t zoneID = GetData<int32_t>();
1792 int32_t streamType = GetData<int32_t>();
1793 server->GetStreamInFocus(zoneID, streamType);
1794 }
1795
AudioPolicyServerGetSessionInfoInFocusFuzzTest()1796 void AudioPolicyServerGetSessionInfoInFocusFuzzTest()
1797 {
1798 auto server = GetServerPtr();
1799 CHECK_AND_RETURN(server != nullptr);
1800 AudioInterrupt audioInterrupt;
1801 int32_t zoneID = GetData<int32_t>();
1802 server->GetSessionInfoInFocus(audioInterrupt, zoneID);
1803 }
1804
AudioPolicyServerGetAudioFocusInfoListFuzzTest()1805 void AudioPolicyServerGetAudioFocusInfoListFuzzTest()
1806 {
1807 auto server = GetServerPtr();
1808 CHECK_AND_RETURN(server != nullptr);
1809 AudioInterrupt audioInterrupt;
1810 int32_t audioFocuState = GetData<int32_t>();
1811 std::vector<std::map<AudioInterrupt, int32_t>> focusInfoList;
1812 std::map<AudioInterrupt, int32_t> interruptMap;
1813 interruptMap[audioInterrupt] = audioFocuState;
1814 focusInfoList.emplace_back(interruptMap);
1815 int32_t zoneID = GetData<int32_t>();
1816 server->GetAudioFocusInfoList(focusInfoList, zoneID);
1817 }
1818
AudioPolicyServerVerifyPermissionFuzzTest()1819 void AudioPolicyServerVerifyPermissionFuzzTest()
1820 {
1821 auto server = GetServerPtr();
1822 CHECK_AND_RETURN(server != nullptr);
1823 std::string permissionName = "ohos.permission.MANAGE_AUDIO_POLICY";
1824 uint32_t tokenId = GetData<uint32_t>();
1825 bool isRecording = GetData<bool>();
1826 server->VerifyPermission(permissionName, tokenId, isRecording);
1827 }
1828
AudioPolicyServerGetStreamVolumeInfoMapFuzzTest()1829 void AudioPolicyServerGetStreamVolumeInfoMapFuzzTest()
1830 {
1831 auto server = GetServerPtr();
1832 CHECK_AND_RETURN(server != nullptr);
1833 StreamVolumeInfoMap streamVolumeInfos;
1834 server->GetStreamVolumeInfoMap(streamVolumeInfos);
1835 }
1836
AudioPolicyServerDumpFuzzTest()1837 void AudioPolicyServerDumpFuzzTest()
1838 {
1839 auto server = GetServerPtr();
1840 CHECK_AND_RETURN(server != nullptr);
1841 int32_t fd = GetData<int32_t>();
1842 vector<std::u16string> testDumpArges = {
1843 u"-fb",
1844 u"test",
1845 u"test2",
1846 u"test3",
1847 };
1848 std::vector<std::u16string> args(testDumpArges.begin(), testDumpArges.begin() +
1849 (GetData<uint32_t>() % testDumpArges.size()));
1850 server->Dump(fd, args);
1851 }
1852
AudioPolicyServerInitPolicyDumpMapFuzzTest()1853 void AudioPolicyServerInitPolicyDumpMapFuzzTest()
1854 {
1855 auto server = GetServerPtr();
1856 CHECK_AND_RETURN(server != nullptr);
1857 server->InitPolicyDumpMap();
1858 }
1859
AudioPolicyServerPolicyDataDumpFuzzTest()1860 void AudioPolicyServerPolicyDataDumpFuzzTest()
1861 {
1862 auto server = GetServerPtr();
1863 CHECK_AND_RETURN(server != nullptr);
1864 std::string dumpString = "dump_string";
1865 server->PolicyDataDump(dumpString);
1866 }
1867
AudioPolicyServerArgInfoDumpFuzzTest()1868 void AudioPolicyServerArgInfoDumpFuzzTest()
1869 {
1870 auto server = GetServerPtr();
1871 CHECK_AND_RETURN(server != nullptr);
1872 std::string dumpString = "dump_string";
1873 std::queue<std::u16string> argQue;
1874 server->ArgInfoDump(dumpString, argQue);
1875 }
1876
AudioPolicyServerInfoDumpHelpFuzzTest()1877 void AudioPolicyServerInfoDumpHelpFuzzTest()
1878 {
1879 auto server = GetServerPtr();
1880 CHECK_AND_RETURN(server != nullptr);
1881 std::string dumpString = "dump_string";
1882 server->InfoDumpHelp(dumpString);
1883 }
1884
AudioPolicyServerGetPreferredOutputStreamTypeFuzzTest()1885 void AudioPolicyServerGetPreferredOutputStreamTypeFuzzTest()
1886 {
1887 auto server = GetServerPtr();
1888 CHECK_AND_RETURN(server != nullptr);
1889 AudioRendererInfo rendererInfo;
1890 int32_t streamType = GetData<int32_t>();
1891 server->GetPreferredOutputStreamType(rendererInfo, streamType);
1892 }
1893
AudioPolicyServerGetPreferredInputStreamTypeFuzzTest()1894 void AudioPolicyServerGetPreferredInputStreamTypeFuzzTest()
1895 {
1896 auto server = GetServerPtr();
1897 CHECK_AND_RETURN(server != nullptr);
1898 AudioCapturerInfo capturerInfo;
1899 int32_t streamType = GetData<int32_t>();
1900 server->GetPreferredInputStreamType(capturerInfo, streamType);
1901 }
1902
AudioPolicyServerCreateRendererClientFuzzTest()1903 void AudioPolicyServerCreateRendererClientFuzzTest()
1904 {
1905 auto server = GetServerPtr();
1906 CHECK_AND_RETURN(server != nullptr);
1907 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
1908 if (streamDesc == nullptr) {
1909 return;
1910 }
1911 uint32_t flag = GetData<uint32_t>();
1912 uint32_t sessionId = GetData<uint32_t>();
1913 std::string networkId = "abc";
1914 server->CreateRendererClient(streamDesc, flag, sessionId, networkId);
1915 }
1916
AudioPolicyServerCreateCapturerClientFuzzTest()1917 void AudioPolicyServerCreateCapturerClientFuzzTest()
1918 {
1919 auto server = GetServerPtr();
1920 CHECK_AND_RETURN(server != nullptr);
1921 std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
1922 if (streamDesc == nullptr) {
1923 return;
1924 }
1925 uint32_t flag = GetData<uint32_t>();
1926 uint32_t sessionId = GetData<uint32_t>();
1927 server->CreateCapturerClient(streamDesc, flag, sessionId);
1928 }
1929
AudioPolicyServerRegisterTrackerFuzzTest()1930 void AudioPolicyServerRegisterTrackerFuzzTest()
1931 {
1932 auto server = GetServerPtr();
1933 CHECK_AND_RETURN(server != nullptr);
1934 int32_t modeIn = GetData<int32_t>();
1935 AudioStreamChangeInfo streamChangeInfoIn;
1936 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1937 CHECK_AND_RETURN(samgr != nullptr);
1938 sptr<IRemoteObject> object = samgr->GetSystemAbility(SYSTEM_ABILITY_ID);
1939 server->RegisterTracker(modeIn, streamChangeInfoIn, object);
1940 }
1941
AudioPolicyServerUpdateTrackerFuzzTest()1942 void AudioPolicyServerUpdateTrackerFuzzTest()
1943 {
1944 auto server = GetServerPtr();
1945 CHECK_AND_RETURN(server != nullptr);
1946 int32_t modeIn = GetData<int32_t>();
1947 AudioStreamChangeInfo streamChangeInfoIn;
1948 server->UpdateTracker(modeIn, streamChangeInfoIn);
1949 }
1950
AudioPolicyServerFetchInputDeviceForTrackFuzzTest()1951 void AudioPolicyServerFetchInputDeviceForTrackFuzzTest()
1952 {
1953 auto server = GetServerPtr();
1954 CHECK_AND_RETURN(server != nullptr);
1955 AudioStreamChangeInfo streamChangeInfoIn;
1956 server->FetchInputDeviceForTrack(streamChangeInfoIn);
1957 }
1958
AudioPolicyServerGetCurrentRendererChangeInfosFuzzTest()1959 void AudioPolicyServerGetCurrentRendererChangeInfosFuzzTest()
1960 {
1961 auto server = GetServerPtr();
1962 CHECK_AND_RETURN(server != nullptr);
1963 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = std::make_shared<AudioRendererChangeInfo>();
1964 if (rendererChangeInfo == nullptr) {
1965 return;
1966 }
1967 std::vector<shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
1968 audioRendererChangeInfos.push_back(rendererChangeInfo);
1969 server->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
1970 }
1971
AudioPolicyServerGetCurrentCapturerChangeInfosFuzzTest()1972 void AudioPolicyServerGetCurrentCapturerChangeInfosFuzzTest()
1973 {
1974 auto server = GetServerPtr();
1975 CHECK_AND_RETURN(server != nullptr);
1976 shared_ptr<AudioCapturerChangeInfo> captureChangeInfo = make_shared<AudioCapturerChangeInfo>();
1977 if (captureChangeInfo == nullptr) {
1978 return;
1979 }
1980 std::vector<shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1981 audioCapturerChangeInfos.push_back(captureChangeInfo);
1982 server->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1983 }
1984
AudioPolicyServerRegisteredTrackerClientDiedFuzzTest()1985 void AudioPolicyServerRegisteredTrackerClientDiedFuzzTest()
1986 {
1987 auto server = GetServerPtr();
1988 CHECK_AND_RETURN(server != nullptr);
1989 pid_t pid = GetData<pid_t>();
1990 pid_t uid = GetData<pid_t>();
1991 server->RegisteredTrackerClientDied(pid, uid);
1992 }
1993
AudioPolicyServerRegisteredStreamListenerClientDiedFuzzTest()1994 void AudioPolicyServerRegisteredStreamListenerClientDiedFuzzTest()
1995 {
1996 auto server = GetServerPtr();
1997 CHECK_AND_RETURN(server != nullptr);
1998 pid_t pid = GetData<pid_t>();
1999 pid_t uid = GetData<pid_t>();
2000 server->RegisteredStreamListenerClientDied(pid, uid);
2001 }
2002
AudioPolicyServerResumeStreamStateFuzzTest()2003 void AudioPolicyServerResumeStreamStateFuzzTest()
2004 {
2005 auto server = GetServerPtr();
2006 CHECK_AND_RETURN(server != nullptr);
2007 server->ResumeStreamState();
2008 }
2009
AudioPolicyServerGetNetworkIdByGroupIdFuzzTest()2010 void AudioPolicyServerGetNetworkIdByGroupIdFuzzTest()
2011 {
2012 auto server = GetServerPtr();
2013 CHECK_AND_RETURN(server != nullptr);
2014 int32_t groupId = GetData<int32_t>();
2015 std::string networkId = "network_id";
2016 server->GetNetworkIdByGroupId(groupId, networkId);
2017 }
2018
AudioPolicyServerOnAudioParameterChangeFuzzTest()2019 void AudioPolicyServerOnAudioParameterChangeFuzzTest()
2020 {
2021 std::string networkId = "network_id";
2022 uint32_t index = GetData<uint32_t>() % g_testAudioParamKeys.size();
2023 AudioParamKey key = g_testAudioParamKeys[index];
2024 std::string condition = "condition";
2025 std::string value = "value";
2026 sptr<AudioPolicyServer> server = GetServerPtr();
2027 if (server == nullptr) {
2028 return;
2029 }
2030 auto callback = std::make_shared<AudioPolicyServer::RemoteParameterCallback>(server);
2031 CHECK_AND_RETURN(callback != nullptr);
2032 callback->OnAudioParameterChange(networkId, key, condition, value);
2033 }
2034
AudioPolicyServerVolumeOnChangeFuzzTest()2035 void AudioPolicyServerVolumeOnChangeFuzzTest()
2036 {
2037 std::string networkId = "network_id";
2038 std::string condition = "condition";
2039 sptr<AudioPolicyServer> server = GetServerPtr();
2040 if (server == nullptr) {
2041 return;
2042 }
2043 auto callback = std::make_shared<AudioPolicyServer::RemoteParameterCallback>(server);
2044 CHECK_AND_RETURN(callback != nullptr);
2045 callback->VolumeOnChange(networkId, condition);
2046 }
2047
AudioPolicyServerInterruptOnChangeFuzzTest()2048 void AudioPolicyServerInterruptOnChangeFuzzTest()
2049 {
2050 std::string networkId = "network_id";
2051 std::string condition = "condition";
2052 sptr<AudioPolicyServer> server = GetServerPtr();
2053 if (server == nullptr) {
2054 return;
2055 }
2056 auto callback = std::make_shared<AudioPolicyServer::RemoteParameterCallback>(server);
2057 CHECK_AND_RETURN(callback != nullptr);
2058 callback->InterruptOnChange(networkId, condition);
2059 }
2060
AudioPolicyServerStateOnChangeFuzzTest()2061 void AudioPolicyServerStateOnChangeFuzzTest()
2062 {
2063 std::string networkId = "network_id";
2064 std::string condition = "condition";
2065 std::string value = "value";
2066 sptr<AudioPolicyServer> server = GetServerPtr();
2067 if (server == nullptr) {
2068 return;
2069 }
2070 auto callback = std::make_shared<AudioPolicyServer::RemoteParameterCallback>(server);
2071 CHECK_AND_RETURN(callback != nullptr);
2072 callback->StateOnChange(networkId, condition, value);
2073 }
2074
AudioPolicyServerPermStateChangeCallbackFuzzTest()2075 void AudioPolicyServerPermStateChangeCallbackFuzzTest()
2076 {
2077 Security::AccessToken::PermStateChangeScope scopeInfo;
2078 sptr<AudioPolicyServer> server = GetServerPtr();
2079 if (server == nullptr) {
2080 return;
2081 }
2082 auto callback = std::make_shared<AudioPolicyServer::PerStateChangeCbCustomizeCallback>(scopeInfo, server);
2083 Security::AccessToken::PermStateChangeInfo result;
2084 CHECK_AND_RETURN(callback != nullptr);
2085 callback->PermStateChangeCallback(result);
2086 }
2087
AudioPolicyServerUpdateMicPrivacyByCapturerStateFuzzTest()2088 void AudioPolicyServerUpdateMicPrivacyByCapturerStateFuzzTest()
2089 {
2090 Security::AccessToken::PermStateChangeScope scopeInfo;
2091 sptr<AudioPolicyServer> server = GetServerPtr();
2092 if (server == nullptr) {
2093 return;
2094 }
2095 auto callback = std::make_shared<AudioPolicyServer::PerStateChangeCbCustomizeCallback>(scopeInfo, server);
2096 bool targetMuteState = GetData<bool>();
2097 uint32_t targetTokenId = GetData<uint32_t>();
2098 int32_t appUid = GetData<int32_t>();
2099 CHECK_AND_RETURN(callback != nullptr);
2100 callback->UpdateMicPrivacyByCapturerState(targetMuteState, targetTokenId, appUid);
2101 }
2102
2103 TestFuncs g_testFuncs[] = {
2104 AudioPolicyServerRegisterDefaultVolumeTypeListenerFuzzTest,
2105 AudioPolicyServerOnAddSystemAbilityExtractFuzzTest,
2106 AudioPolicyServerOnRemoveSystemAbilityFuzzTest,
2107 AudioPolicyServerMaxOrMinVolumeOptionFuzzTest,
2108 AudioPolicyServerChangeVolumeOnVoiceAssistantFuzzTest,
2109 AudioPolicyServerIsContinueAddVolFuzzTest,
2110 AudioPolicyServerTriggerMuteCheckFuzzTest,
2111 AudioPolicyServerProcessVolumeKeyEventsFuzzTest,
2112 AudioPolicyServerSetVolumeInternalByKeyEventFuzzTest,
2113 AudioPolicyServerSubscribeSafeVolumeEventFuzzTest,
2114 AudioPolicyServerIsVolumeTypeValidFuzzTest,
2115 AudioPolicyServerIsVolumeLevelValidFuzzTest,
2116 AudioPolicyServerIsRingerModeValidFuzzTest,
2117 AudioPolicyServerSubscribeOsAccountChangeEventsFuzzTest,
2118 AudioPolicyServerAddRemoteDevstatusCallbackFuzzTest,
2119 AudioPolicyServerOnReceiveEventFuzzTest,
2120 AudioPolicyServerSubscribeBackgroundTaskFuzzTest,
2121 AudioPolicyServerSubscribeCommonEventExecuteFuzzTest,
2122 AudioPolicyServerCheckSubscribePowerStateChangeFuzzTest,
2123 AudioPolicyServerNotifySettingsDataReadyFuzzTest,
2124 AudioPolicyServerGetMaxVolumeLevelFuzzTest,
2125 AudioPolicyServerGetMinVolumeLevelFuzzTest,
2126 AudioPolicyServerSetSystemVolumeLevelLegacyFuzzTest,
2127 AudioPolicyServerSetAdjustVolumeForZoneFuzzTest,
2128 AudioPolicyServerGetSelfAppVolumeLevelFuzzTest,
2129 AudioPolicyServerGetSystemVolumeLevelFuzzTest,
2130 AudioPolicyServerGetSystemVolumeLevelNoMuteStateFuzzTest,
2131 AudioPolicyServerGetSystemVolumeLevelInternalFuzzTest,
2132 AudioPolicyServerGetAppVolumeLevelInternalFuzzTest,
2133 AudioPolicyServerSetLowPowerVolumeFuzzTest,
2134 AudioPolicyServerGetFastStreamInfoFuzzTest,
2135 AudioPolicyServerGetLowPowerVolumeFuzzTest,
2136 AudioPolicyServerGetSingleStreamVolumeFuzzTest,
2137 AudioPolicyServerIsVolumeUnadjustableFuzzTest,
2138 AudioPolicyServerCheckCanMuteVolumeTypeByStepFuzzTest,
2139 AudioPolicyServerGetSystemVolumeInDbFuzzTest,
2140 AudioPolicyServerSetStreamMuteLegacyFuzzTest,
2141 AudioPolicyServerSetStreamMuteInternalFuzzTest,
2142 AudioPolicyServerUpdateSystemMuteStateAccordingMusicStateFuzzTest,
2143 AudioPolicyServerSendMuteKeyEventCbWithUpdateUiOrNotFuzzTest,
2144 AudioPolicyServerSetSingleStreamMuteFuzzTest,
2145 AudioPolicyServerProcUpdateRingerModeForMuteFuzzTest,
2146 AudioPolicyServerGetSystemVolumeDbFuzzTest,
2147 AudioPolicyServerSetSelfAppVolumeLevelFuzztest,
2148 AudioPolicyServerSetAppVolumeLevelInternalFuzztest,
2149 AudioPolicyServerSetSystemVolumeLevelInternalFuzztest,
2150 AudioPolicyServerSetSystemVolumeLevelWithDeviceInternalFuzztest,
2151 AudioPolicyServerSendVolumeKeyEventCbWithUpdateUiOrNotFuzztest,
2152 AudioPolicyServerUpdateMuteStateAccordingToVolLevelFuzztest,
2153 AudioPolicyServerProcUpdateRingerModeFuzztest,
2154 AudioPolicyServerSetAppSingleStreamVolumeFuzztest,
2155 AudioPolicyServerSetSingleStreamVolumeFuzztest,
2156 AudioPolicyServerSetSingleStreamVolumeWithDeviceFuzztest,
2157 AudioPolicyServerGetStreamMuteFuzztest,
2158 AudioPolicyServerMapExternalToInternalDeviceTypeFuzztest,
2159 AudioPolicyServerGetPreferredInputDeviceDescriptorsFuzztest,
2160 AudioPolicyServerIsFastRecordingSupportedFuzztest,
2161 AudioPolicyServerSetRingerModeInternalFuzztest,
2162 AudioPolicyServerInitMicrophoneMuteFuzztest,
2163 AudioPolicyServerSetMicrophoneMuteAudioConfigFuzztest,
2164 AudioPolicyServerSetMicrophoneMutePersistentFuzztest,
2165 AudioPolicyServerSetAudioSceneFuzztest,
2166 AudioPolicyServerSetAndUnsetAudioInterruptCallbackFuzztest,
2167 AudioPolicyServerVerifySessionIdFuzztest,
2168 AudioPolicyServerSetAndUnsetAudioRouteCallbackFuzztest,
2169 AudioPolicyServerSubscribeAccessibilityConfigObserverFuzzTest,
2170 AudioPolicyServerGetMinStreamVolumeFuzzTest,
2171 AudioPolicyServerGetMaxStreamVolumeFuzzTest,
2172 AudioPolicyServerGetMaxRendererInstancesFuzzTest,
2173 AudioPolicyServerRegisterDataObserverFuzzTest,
2174 AudioPolicyServerQueryEffectSceneModeFuzzTest,
2175 AudioPolicyServerGetHardwareOutputSamplingRateFuzzTest,
2176 AudioPolicyServerGetAudioCapturerMicrophoneDescriptorsFuzzTest,
2177 AudioPolicyServerGetAvailableMicrophonesFuzzTest,
2178 AudioPolicyServerSetDeviceAbsVolumeSupportedFuzzTest,
2179 AudioPolicyServerIsAbsVolumeSceneFuzzTest,
2180 AudioPolicyServerSetA2dpDeviceVolumeFuzzTest,
2181 AudioPolicyServerSetNearlinkDeviceVolumeFuzzTest,
2182 AudioPolicyServerGetAvailableDevicesFuzzTest,
2183 AudioPolicyServerSetAvailableDeviceChangeCallbackFuzzTest,
2184 AudioPolicyServerUnsetAvailableDeviceChangeCallbackFuzzTest,
2185 AudioPolicyServerOffloadStopPlayingFuzzTest,
2186 AudioPolicyServerCheckAudioSessionStrategyFuzzTest,
2187 AudioPolicyServerSetAudioSessionSceneFuzzTest,
2188 AudioPolicyServerGetDefaultOutputDeviceFuzzTest,
2189 AudioPolicyServerSetDefaultOutputDeviceFuzzTest,
2190 AudioPolicyServerLoadSplitModuleFuzzTest,
2191 AudioPolicyServerIsAllowedPlaybackFuzzTest,
2192 AudioPolicyServerSetVoiceRingtoneMuteFuzzTest,
2193 AudioPolicyServerNotifySessionStateChangeFuzzTest,
2194 AudioPolicyServerNotifyFreezeStateChangeFuzzTest,
2195 AudioPolicyServerResetAllProxyFuzzTest,
2196 AudioPolicyServerNotifyProcessBackgroundStateFuzzTest,
2197 AudioPolicyServerSetVirtualCallFuzzTest,
2198 AudioPolicyServerSetDeviceConnectionStatusFuzzTest,
2199 AudioPolicyServerSetQueryAllowedPlaybackCallbackFuzzTest,
2200 AudioPolicyServerSetBackgroundMuteCallbackFuzzTest,
2201 AudioPolicyServerGetDirectPlaybackSupportFuzzTest,
2202 AudioPolicyServerGetMaxVolumeLevelByUsageFuzzTest,
2203 AudioPolicyServerGetMinVolumeLevelByUsageFuzzTest,
2204 AudioPolicyServerGetVolumeLevelByUsageFuzzTest,
2205 AudioPolicyServerGetStreamMuteByUsageFuzzTest,
2206 AudioPolicyServerGetVolumeInDbByStreamFuzzTest,
2207 AudioPolicyServerGetSupportedAudioVolumeTypesFuzzTest,
2208 AudioPolicyServerGetAudioVolumeTypeByStreamUsageFuzzTest,
2209 AudioPolicyServerGetStreamUsagesByVolumeTypeFuzzTest,
2210 AudioPolicyServerSetCallbackStreamUsageInfoFuzzTest,
2211 AudioPolicyServerForceStopAudioStreamFuzzTest,
2212 AudioPolicyServerIsCapturerFocusAvailableFuzzTest,
2213 AudioPolicyServerUpdateDefaultOutputDeviceWhenStartingFuzzTest,
2214 AudioPolicyServerUpdateDefaultOutputDeviceWhenStoppingFuzzTest,
2215 AudioPolicyServerIsAcousticEchoCancelerSupportedFuzzTest,
2216 AudioPolicyServerSetKaraokeParametersFuzzTest,
2217 AudioPolicyServerUpdateDeviceInfoFuzzTest,
2218 AudioPolicyServerSetSleAudioOperationCallbackFuzzTest,
2219 AudioPolicyServerSetCollaborativePlaybackEnabledForDeviceFuzzTest,
2220 AudioPolicyServerIsCollaborativePlaybackSupportedFuzzTest,
2221 AudioPolicyServerIsCollaborativePlaybackEnabledForDeviceFuzzTest,
2222 AudioPolicyServerCallRingtoneLibraryFuzzTest,
2223 SetAndUnsetDistributedRoutingRoleCallbackFuzzTest,
2224 OnDistributedRoutingRoleChangeFuzzTest,
2225 RegisterAndUnRegisterPowerStateListenerFuzzTest,
2226 RegisterAppStateListenerFuzzTest,
2227 RegisterAndUnRegisterSyncHibernateListenerFuzzTest,
2228 AudioPolicyServerRegisterSpatializationStateEventListenerFuzzTest,
2229 AudioPolicyServerAudioInterruptZoneFuzzTest,
2230 AudioPolicyServerRegisterAudioZoneClientFuzzTest,
2231 AudioPolicyServerAudioZoneQueryFuzzTest,
2232 AudioPolicyServerBindUnbindDeviceToAudioZoneFuzzTest,
2233 AudioPolicyServerEnableAudioZoneReportFuzzTest,
2234 AudioPolicyServerAddRemoveUidToAudioZoneFuzzTest,
2235 AudioPolicyServerAddStreamToAudioZoneFuzzTest,
2236 AudioPolicyServerAddStreamsToAudioZoneFuzzTest,
2237 AudioPolicyServerSetZoneDeviceVisibleFuzzTest,
2238 AudioPolicyServerEnableSystemVolumeProxyFuzzTest,
2239 AudioPolicyServerGetAudioInterruptForZoneFuzzTest,
2240 AudioPolicyServerTriggerFetchDeviceFuzzTest,
2241 AudioPolicyServerUnsetAudioDeviceRefinerCallbackFuzzTest,
2242 AudioPolicyServerIsHeadTrackingDataRequestedFuzzTest,
2243 AudioPolicyServerGetMaxAmplitudeFuzzTest,
2244 AudioPolicyServerSetPreferredDeviceFuzzTest,
2245 AudioPolicyServerSetDeviceVolumeBehaviorFuzzTest,
2246 AudioPolicyServerUnsetAudioDeviceAnahsCallbackFuzzTest,
2247 AudioPolicyServerSendVolumeKeyEventToRssWhenAccountsChangedFuzzTest,
2248 AudioPolicyServerNotifyAccountsChangedFuzzTest,
2249 AudioPolicyServerMoveToNewPipeFuzzTest,
2250 AudioPolicyServerCheckHibernateStateFuzzTest,
2251 AudioPolicyServerUpdateSafeVolumeByS4FuzzTest,
2252 AudioPolicyServerCheckConnectedDeviceFuzzTest,
2253 AudioPolicyServerSetDeviceConnectedFlagFalseAfterDurationFuzzTest,
2254 AudioPolicyServerInjectInterruptionFuzzTest,
2255 AudioPolicyServerProcessRemoteInterruptFuzzTest,
2256 AudioPolicyServerGetStreamIdsForAudioSessionByStreamUsageFuzzTest,
2257 AudioPolicyServerActivateAudioInterruptFuzzTest,
2258 AudioPolicyServerDeactivateAudioInterruptFuzzTest,
2259 AudioPolicyServerActivatePreemptModeFuzzTest,
2260 AudioPolicyServerDeactivatePreemptModeFuzzTest,
2261 AudioPolicyServerGetStreamInFocusFuzzTest,
2262 AudioPolicyServerGetSessionInfoInFocusFuzzTest,
2263 AudioPolicyServerGetAudioFocusInfoListFuzzTest,
2264 AudioPolicyServerVerifyPermissionFuzzTest,
2265 AudioPolicyServerGetStreamVolumeInfoMapFuzzTest,
2266 AudioPolicyServerDumpFuzzTest,
2267 AudioPolicyServerInitPolicyDumpMapFuzzTest,
2268 AudioPolicyServerPolicyDataDumpFuzzTest,
2269 AudioPolicyServerArgInfoDumpFuzzTest,
2270 AudioPolicyServerInfoDumpHelpFuzzTest,
2271 AudioPolicyServerGetPreferredOutputStreamTypeFuzzTest,
2272 AudioPolicyServerGetPreferredInputStreamTypeFuzzTest,
2273 AudioPolicyServerCreateRendererClientFuzzTest,
2274 AudioPolicyServerCreateCapturerClientFuzzTest,
2275 AudioPolicyServerRegisterTrackerFuzzTest,
2276 AudioPolicyServerUpdateTrackerFuzzTest,
2277 AudioPolicyServerFetchInputDeviceForTrackFuzzTest,
2278 AudioPolicyServerGetCurrentRendererChangeInfosFuzzTest,
2279 AudioPolicyServerGetCurrentCapturerChangeInfosFuzzTest,
2280 AudioPolicyServerRegisteredTrackerClientDiedFuzzTest,
2281 AudioPolicyServerRegisteredStreamListenerClientDiedFuzzTest,
2282 AudioPolicyServerResumeStreamStateFuzzTest,
2283 AudioPolicyServerGetNetworkIdByGroupIdFuzzTest,
2284 AudioPolicyServerOnAudioParameterChangeFuzzTest,
2285 AudioPolicyServerVolumeOnChangeFuzzTest,
2286 AudioPolicyServerInterruptOnChangeFuzzTest,
2287 AudioPolicyServerStateOnChangeFuzzTest,
2288 AudioPolicyServerUpdateMicPrivacyByCapturerStateFuzzTest,
2289 };
2290
FuzzTest(const uint8_t * rawData,size_t size)2291 bool FuzzTest(const uint8_t* rawData, size_t size)
2292 {
2293 if (rawData == nullptr) {
2294 return false;
2295 }
2296
2297 // initialize data
2298 RAW_DATA = rawData;
2299 g_dataSize = size;
2300 g_pos = 0;
2301
2302 uint32_t code = GetData<uint32_t>();
2303 uint32_t len = GetArrLength(g_testFuncs);
2304 if (len > 0) {
2305 g_testFuncs[code % len]();
2306 } else {
2307 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
2308 }
2309
2310 return true;
2311 }
2312 } // namespace AudioStandard
2313 } // namesapce OHOS
2314
2315 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)2316 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
2317 {
2318 if (size < OHOS::AudioStandard::THRESHOLD) {
2319 return 0;
2320 }
2321
2322 OHOS::AudioStandard::FuzzTest(data, size);
2323 return 0;
2324 }
2325