From 4571aba2f66eb44f99a93e42aed5d0dae61e34ae Mon Sep 17 00:00:00 2001 From: zhangwenting Date: Fri, 29 Aug 2025 18:10:04 +0800 Subject: [PATCH] optimize audio framework fuzz case Signed-off-by: zhangwenting --- test/BUILD.gn | 2 + .../audio_adapter_manager_fuzzer.cpp | 1033 ++++++++--------- .../audio_adaptor_bluetooth_fuzzer.cpp | 52 +- .../audio_capturer_session_fuzzer.cpp | 67 +- .../audio_resource_service_fuzzer.cpp | 145 +++ test/fuzztest/audioserversup_fuzzer/BUILD.gn | 66 ++ .../audio_server_sup_fuzzer.cpp | 518 +++++++++ .../audioserversup_fuzzer/project.xml | 25 + test/fuzztest/audioservicesup_fuzzer/BUILD.gn | 59 + .../audio_service_sup_fuzzer.cpp | 143 +++ .../audioservicesup_fuzzer/project.xml | 25 + 11 files changed, 1468 insertions(+), 667 deletions(-) create mode 100644 test/fuzztest/audioserversup_fuzzer/BUILD.gn create mode 100644 test/fuzztest/audioserversup_fuzzer/audio_server_sup_fuzzer.cpp create mode 100644 test/fuzztest/audioserversup_fuzzer/project.xml create mode 100644 test/fuzztest/audioservicesup_fuzzer/BUILD.gn create mode 100644 test/fuzztest/audioservicesup_fuzzer/audio_service_sup_fuzzer.cpp create mode 100644 test/fuzztest/audioservicesup_fuzzer/project.xml diff --git a/test/BUILD.gn b/test/BUILD.gn index a6b312fe5f..76bf7ac59b 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -266,6 +266,7 @@ group("audio_fuzz_test") { "fuzztest/audioserverbalance_fuzzer:fuzztest", "fuzztest/audioservermore_fuzzer:fuzztest", "fuzztest/audioserverproxy_fuzzer:fuzztest", + "fuzztest/audioserversup_fuzzer:fuzztest", "fuzztest/audioservice_fuzzer:fuzztest", # "fuzztest/audioserviceclient_fuzzer:fuzztest", "fuzztest/audioservicecommon_fuzzer:fuzztest", @@ -273,6 +274,7 @@ group("audio_fuzz_test") { "fuzztest/audioserviceserversrc_fuzzer:fuzztest", "fuzztest/audioserviceserversrcenhance_fuzzer:fuzztest", "fuzztest/audioservicestub_fuzzer:fuzztest", + "fuzztest/audioservicesup_fuzzer:fuzztest", "fuzztest/audiosession_fuzzer:fuzztest", "fuzztest/audiosessionservice_fuzzer:fuzztest", "fuzztest/audiosocketthread_fuzzer:fuzztest", diff --git a/test/fuzztest/audioadaptermanager_fuzzer/audio_adapter_manager_fuzzer.cpp b/test/fuzztest/audioadaptermanager_fuzzer/audio_adapter_manager_fuzzer.cpp index 488f2e5d38..8869649c93 100644 --- a/test/fuzztest/audioadaptermanager_fuzzer/audio_adapter_manager_fuzzer.cpp +++ b/test/fuzztest/audioadaptermanager_fuzzer/audio_adapter_manager_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024-2025 Huawei Device Co., Ltd. + * Copyright (c) 2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -13,283 +13,184 @@ * limitations under the License. */ +#include "../fuzz_utils.h" + #include "audio_adapter_manager.h" #include "audio_server_proxy.h" + using namespace std; namespace OHOS { namespace AudioStandard { -static AudioAdapterManager *audioAdapterManager_; - -const int32_t NUM_2 = 2; -typedef void (*TestPtr)(const uint8_t *, size_t); - -const vector g_testAudioStreamTypes = { - STREAM_DEFAULT, - STREAM_VOICE_CALL, - STREAM_MUSIC, - STREAM_RING, - STREAM_MEDIA, - STREAM_VOICE_ASSISTANT, - STREAM_SYSTEM, - STREAM_ALARM, - STREAM_NOTIFICATION, - STREAM_BLUETOOTH_SCO, - STREAM_ENFORCED_AUDIBLE, - STREAM_DTMF, - STREAM_TTS, - STREAM_ACCESSIBILITY, - STREAM_RECORDING, - STREAM_MOVIE, - STREAM_GAME, - STREAM_SPEECH, - STREAM_SYSTEM_ENFORCED, - STREAM_ULTRASONIC, - STREAM_WAKEUP, - STREAM_VOICE_MESSAGE, - STREAM_NAVIGATION, - STREAM_INTERNAL_FORCE_STOP, - STREAM_SOURCE_VOICE_CALL, - STREAM_VOICE_COMMUNICATION, - STREAM_VOICE_RING, - STREAM_VOICE_CALL_ASSISTANT, - STREAM_CAMCORDER, - STREAM_APP, - STREAM_TYPE_MAX, - STREAM_ALL, -}; +typedef void (*TestPtr)(); -const vector g_testDeviceTypes = { - DEVICE_TYPE_NONE, - DEVICE_TYPE_INVALID, - DEVICE_TYPE_EARPIECE, - DEVICE_TYPE_SPEAKER, - DEVICE_TYPE_WIRED_HEADSET, - DEVICE_TYPE_WIRED_HEADPHONES, - DEVICE_TYPE_BLUETOOTH_SCO, - DEVICE_TYPE_BLUETOOTH_A2DP, - DEVICE_TYPE_BLUETOOTH_A2DP_IN, - DEVICE_TYPE_MIC, - DEVICE_TYPE_WAKEUP, - DEVICE_TYPE_USB_HEADSET, - DEVICE_TYPE_DP, - DEVICE_TYPE_REMOTE_CAST, - DEVICE_TYPE_USB_DEVICE, - DEVICE_TYPE_ACCESSORY, - DEVICE_TYPE_REMOTE_DAUDIO, - DEVICE_TYPE_HDMI, - DEVICE_TYPE_LINE_DIGITAL, - DEVICE_TYPE_NEARLINK, - DEVICE_TYPE_NEARLINK_IN, - DEVICE_TYPE_FILE_SINK, - DEVICE_TYPE_FILE_SOURCE, - DEVICE_TYPE_EXTERN_CABLE, - DEVICE_TYPE_DEFAULT, - DEVICE_TYPE_USB_ARM_HEADSET, - DEVICE_TYPE_MAX, -}; +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +static const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10; -const vector g_testStreamUsages = { - STREAM_USAGE_INVALID, - STREAM_USAGE_UNKNOWN, - STREAM_USAGE_MEDIA, - STREAM_USAGE_MUSIC, - STREAM_USAGE_VOICE_COMMUNICATION, - STREAM_USAGE_VOICE_ASSISTANT, - STREAM_USAGE_ALARM, - STREAM_USAGE_VOICE_MESSAGE, - STREAM_USAGE_NOTIFICATION_RINGTONE, - STREAM_USAGE_RINGTONE, - STREAM_USAGE_NOTIFICATION, - STREAM_USAGE_ACCESSIBILITY, - STREAM_USAGE_SYSTEM, - STREAM_USAGE_MOVIE, - STREAM_USAGE_GAME, - STREAM_USAGE_AUDIOBOOK, - STREAM_USAGE_NAVIGATION, - STREAM_USAGE_DTMF, - STREAM_USAGE_ENFORCED_TONE, - STREAM_USAGE_ULTRASONIC, - STREAM_USAGE_VIDEO_COMMUNICATION, - STREAM_USAGE_RANGING, - STREAM_USAGE_VOICE_MODEM_COMMUNICATION, - STREAM_USAGE_VOICE_RINGTONE, - STREAM_USAGE_VOICE_CALL_ASSISTANT, - STREAM_USAGE_MAX, -}; +static AudioAdapterManager *audioAdapterManager_; -template -uint32_t GetArrLength(T& arr) +void AudioVolumeManagerIsAppVolumeMuteFuzzTest() { - if (arr == nullptr) { - AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__); - return 0; - } - return sizeof(arr) / sizeof(arr[0]); + int32_t appUid = g_fuzzUtils.GetData(); + bool owned = g_fuzzUtils.GetData(); + bool isMute = g_fuzzUtils.GetData(); + AudioAdapterManager::GetInstance().IsAppVolumeMute(appUid, owned, isMute); } -void AudioVolumeManagerIsAppVolumeMuteFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSaveSpecifiedDeviceVolumeFuzzTest() { - static uint32_t randomStep = 0; - int32_t randIntValue = static_cast(size); - randomStep += randIntValue; - int32_t appUid = randIntValue; - bool owned = static_cast(static_cast(size) % NUM_2); - bool isMute = static_cast(static_cast(size + randomStep) % NUM_2); - AudioAdapterManager::GetInstance().IsAppVolumeMute(appUid, owned, isMute); + AudioAdapterManager::GetInstance().Init(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + int32_t volumeLevel = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); + AudioAdapterManager::GetInstance().GetMinVolumeLevel(streamType); + AudioAdapterManager::GetInstance().GetMaxVolumeLevel(streamType); + AudioAdapterManager::GetInstance().SaveSpecifiedDeviceVolume(streamType, volumeLevel, deviceType); } -void AudioVolumeManagerSaveSpecifiedDeviceVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerHandleStreamMuteStatusFuzzTest() { - uint32_t index = static_cast(size); - int32_t randIntValue = static_cast(size); - static uint32_t randomStep = 0; - randomStep += randIntValue; - audioAdapterManager_->Init(); - audioAdapterManager_->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - int32_t volumeLevel = randIntValue; - DeviceType deviceType = g_testDeviceTypes[(index + randomStep) % g_testDeviceTypes.size()]; - audioAdapterManager_->GetMinVolumeLevel(streamType); - audioAdapterManager_->GetMaxVolumeLevel(streamType); - audioAdapterManager_->SaveSpecifiedDeviceVolume(streamType, volumeLevel, deviceType); -} - -void AudioVolumeManagerHandleStreamMuteStatusFuzzTest(const uint8_t *rawData, size_t size) -{ - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - bool mute = static_cast(static_cast(size) % NUM_2); - StreamUsage streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()]; - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + bool mute = g_fuzzUtils.GetData(); + StreamUsage streamUsage = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); AudioAdapterManager::GetInstance().HandleStreamMuteStatus(streamType, mute, streamUsage, deviceType); } -void AudioVolumeManagerSetOffloadVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetOffloadVolumeFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - float volumeDb = static_cast(size); - audioAdapterManager_->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + float volumeDb = g_fuzzUtils.GetData(); + audioAdapterManager_->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); audioAdapterManager_->SetOffloadVolume(streamType, volumeDb, "offload"); } -void AudioVolumeManagerSetOffloadSessionIdFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetOffloadSessionIdFuzzTest() { - uint32_t sessionId = static_cast(size); + uint32_t sessionId = g_fuzzUtils.GetData(); AudioAdapterManager::GetInstance().SetOffloadSessionId(sessionId); } -void AudioVolumeManagerConnectServiceAdapterFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerConnectServiceAdapterFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); audioAdapterManager_->ConnectServiceAdapter(); audioAdapterManager_->InitKVStore(); } -void AudioVolumeManagerHandleKvDataFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerHandleKvDataFuzzTest() { - static uint32_t step = 0; + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - step += static_cast(size); - audioAdapterManager_->isNeedCopySystemUrlData_ = static_cast(step % NUM_2); - audioAdapterManager_->isNeedCopyVolumeData_ = static_cast(step % NUM_2); - audioAdapterManager_->isNeedCopyMuteData_ = static_cast(step % NUM_2); - audioAdapterManager_->isNeedCopyRingerModeData_ = static_cast(step % NUM_2); - audioAdapterManager_->isNeedCopySystemUrlData_ = static_cast(step % NUM_2); - bool isFirstBoot = static_cast(static_cast(size) % NUM_2); + audioAdapterManager_->isNeedCopySystemUrlData_ = g_fuzzUtils.GetData(); + audioAdapterManager_->isNeedCopyVolumeData_ = g_fuzzUtils.GetData(); + audioAdapterManager_->isNeedCopyMuteData_ = g_fuzzUtils.GetData(); + audioAdapterManager_->isNeedCopyRingerModeData_ = g_fuzzUtils.GetData(); + audioAdapterManager_->isNeedCopySystemUrlData_ = g_fuzzUtils.GetData(); + bool isFirstBoot = g_fuzzUtils.GetData(); audioAdapterManager_->HandleKvData(isFirstBoot); } -void AudioVolumeManagerReInitKVStoreFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerReInitKVStoreFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); audioAdapterManager_->ReInitKVStore(); } -void AudioVolumeManagerSaveRingtoneVolumeToLocalFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSaveRingtoneVolumeToLocalFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - int32_t volumeLevel = static_cast(size); - uint32_t index = static_cast(size); - AudioVolumeType volumeType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - audioAdapterManager_->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + int32_t volumeLevel = g_fuzzUtils.GetData(); + uint32_t index = g_fuzzUtils.GetData(); + AudioVolumeType volumeType = g_fuzzUtils.GetData(); + audioAdapterManager_->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); audioAdapterManager_->SaveRingtoneVolumeToLocal(volumeType, volumeLevel); } -void AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - audioAdapterManager_->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + audioAdapterManager_->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); audioAdapterManager_->UpdateSafeVolumeByS4(); } -void AudioVolumeManagerSetAppVolumeMutedFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetAppVolumeMutedFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - int32_t randIntValue = static_cast(size); - bool muted = static_cast(static_cast(size) % NUM_2); - audioAdapterManager_->SetAppVolumeLevel(randIntValue, randIntValue / NUM_2); + int32_t randIntValue = g_fuzzUtils.GetData(); + bool muted = g_fuzzUtils.GetData(); + audioAdapterManager_->SetAppVolumeLevel(randIntValue, g_fuzzUtils.GetData()); audioAdapterManager_->SetAppVolumeMuted(randIntValue, muted); } -void AudioVolumeManagerSetSystemVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetSystemVolumeLevelFuzzTest() { vector testNetworkIds = { "LocalDevice", "RemoteDevice", "NetworkDevice1", }; - uint32_t index = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); AudioDeviceDescriptor deviceDescriptor; - deviceDescriptor.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + deviceDescriptor.deviceType_ = g_fuzzUtils.GetData(); deviceDescriptor.networkId_ = testNetworkIds[index % testNetworkIds.size()]; - int32_t testVolumeLevel = static_cast(size); + int32_t testVolumeLevel = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->SetActiveDeviceDescriptor(deviceDescriptor); audioAdapterManager->SetSystemVolumeLevel(STREAM_MUSIC, testVolumeLevel); } -void AudioVolumeManagerSetDoubleRingVolumeDbFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetDoubleRingVolumeDbFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - audioAdapterManager_->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - int32_t volumeLevel = static_cast(size); - audioAdapterManager_->useNonlinearAlgo_ = static_cast(static_cast(size) % NUM_2); + uint32_t index = g_fuzzUtils.GetData(); + audioAdapterManager_->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + int32_t volumeLevel = g_fuzzUtils.GetData(); + audioAdapterManager_->useNonlinearAlgo_ = g_fuzzUtils.GetData(); audioAdapterManager_->SetDoubleRingVolumeDb(streamType, volumeLevel); } -void AudioVolumeManagerSetInnerStreamMuteFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetInnerStreamMuteFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - StreamUsage streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()]; - bool mute = static_cast(static_cast(size) % NUM_2); + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + StreamUsage streamUsage = g_fuzzUtils.GetData(); + bool mute = g_fuzzUtils.GetData(); audioAdapterManager_->SetInnerStreamMute(streamType, mute, streamUsage); } -void AudioVolumeManagerSetStreamMuteFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetStreamMuteFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - StreamUsage streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()]; - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - bool mute = static_cast(static_cast(size) % NUM_2); + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + StreamUsage streamUsage = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); + bool mute = g_fuzzUtils.GetData(); audioAdapterManager_->SetStreamMute(streamType, mute, streamUsage, deviceType); } -void AudioVolumeManagerSetSinkMuteFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetSinkMuteFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - static uint32_t step = 0; - step += static_cast(size); vector sinkNames = { "Speaker", "Offload_Speaker", @@ -301,182 +202,169 @@ void AudioVolumeManagerSetSinkMuteFuzzTest(const uint8_t *rawData, size_t size) "RemoteCastInnerCapturer", "test", }; - uint32_t index = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); string sinkName = sinkNames[index % sinkNames.size()]; - bool isMute = static_cast(static_cast(size) % NUM_2); - bool isSync = static_cast(step % NUM_2); + bool isMute = g_fuzzUtils.GetData(); + bool isSync = g_fuzzUtils.GetData(); audioAdapterManager_->SetSinkMute(sinkName, isMute, isSync); } -void AudioVolumeManagerSelectDeviceFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSelectDeviceFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - vector testDeviceRoles = { - DEVICE_ROLE_NONE, - INPUT_DEVICE, - OUTPUT_DEVICE, - DEVICE_ROLE_MAX, - }; - uint32_t index = static_cast(size); - DeviceRole deviceRole = testDeviceRoles[index % testDeviceRoles.size()]; - InternalDeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + DeviceRole deviceRole = g_fuzzUtils.GetData(); + InternalDeviceType deviceType = g_fuzzUtils.GetData(); audioAdapterManager_->SelectDevice(deviceRole, deviceType, "test"); } -void AudioVolumeManagerSetDeviceActiveFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetDeviceActiveFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - vector testDeviceFlags = { - NONE_DEVICES_FLAG, - OUTPUT_DEVICES_FLAG, - INPUT_DEVICES_FLAG, - ALL_DEVICES_FLAG, - DISTRIBUTED_OUTPUT_DEVICES_FLAG, - DISTRIBUTED_INPUT_DEVICES_FLAG, - ALL_DISTRIBUTED_DEVICES_FLAG, - ALL_L_D_DEVICES_FLAG, - DEVICE_FLAG_MAX, - }; - uint32_t index = static_cast(size); - InternalDeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - bool active = static_cast(static_cast(size) % NUM_2); - DeviceFlag flag = testDeviceFlags[index % testDeviceFlags.size()]; + InternalDeviceType deviceType = g_fuzzUtils.GetData(); + bool active = g_fuzzUtils.GetData(); + DeviceFlag flag = g_fuzzUtils.GetData(); audioAdapterManager_->SetDeviceActive(deviceType, "test", active, flag); } -void AudioVolumeManagerAdjustBluetoothVoiceAssistantVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerAdjustBluetoothVoiceAssistantVolumeFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - InternalDeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - bool isA2dpSwitchToSco = static_cast(static_cast(size) % NUM_2); + InternalDeviceType deviceType = g_fuzzUtils.GetData(); + bool isA2dpSwitchToSco = g_fuzzUtils.GetData(); audioAdapterManager_->AdjustBluetoothVoiceAssistantVolume(deviceType, isA2dpSwitchToSco); } -void AudioVolumeManagerSetVolumeForSwitchDeviceFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetVolumeForSwitchDeviceFuzzTest() { vector testNetworkIds = { "LocalDevice", "RemoteDevice", "NetworkDevice1", }; - uint32_t index = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); AudioDeviceDescriptor deviceDescriptor; - deviceDescriptor.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + deviceDescriptor.deviceType_ = g_fuzzUtils.GetData(); deviceDescriptor.networkId_ = testNetworkIds[index % testNetworkIds.size()]; auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->SetVolumeForSwitchDevice(deviceDescriptor); } -void AudioVolumeManagerSaveRingerModeInfoFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSaveRingerModeInfoFuzzTest() { vector testAudioRingerModers = { RINGER_MODE_SILENT, RINGER_MODE_VIBRATE, RINGER_MODE_NORMAL, }; - uint32_t index = static_cast(size); - AudioRingerMode ringMode = testAudioRingerModers[index % testAudioRingerModers.size()]; - + AudioRingerMode ringMode = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->SaveRingerModeInfo(ringMode, "test", "invocationTimeTest"); } -void AudioVolumeManagerGetSinkIdInfoAndIdTypeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetSinkIdInfoAndIdTypeFuzzTest() { vector testAdapterNames = { "primary", "a2dp", "testAdapter", }; - uint32_t index = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); std::shared_ptr pipeInfo = std::make_shared(); pipeInfo->adapterName_ = testAdapterNames[index % testAdapterNames.size()]; - pipeInfo->routeFlag_ = static_cast(size); + pipeInfo->routeFlag_ = g_fuzzUtils.GetData(); std::string idInfo; HdiIdType idType; auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetSinkIdInfoAndIdType(pipeInfo, idInfo, idType); } -void AudioVolumeManagerOpenNotPaAudioPortFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerOpenNotPaAudioPortFuzzTest() { - vector testAudioPipeRoles = { - PIPE_ROLE_OUTPUT, - PIPE_ROLE_INPUT, - PIPE_ROLE_NONE, - }; - uint32_t index = static_cast(size); std::shared_ptr pipeInfo = std::make_shared(); - pipeInfo->pipeRole_ = testAudioPipeRoles[index % testAudioPipeRoles.size()]; - pipeInfo->routeFlag_ = static_cast(size); + CHECK_AND_RETURN(pipeInfo != nullptr); + pipeInfo->pipeRole_ = g_fuzzUtils.GetData(); + pipeInfo->routeFlag_ = g_fuzzUtils.GetData(); uint32_t paIndex = 0; auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->audioServerProxy_ = AudioServerProxy::GetInstance().GetAudioServerProxy(); audioAdapterManager->OpenNotPaAudioPort(pipeInfo, paIndex); } -void AudioVolumeManagerSetAudioVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetAudioVolumeFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - float volumeDb = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + float volumeDb = g_fuzzUtils.GetData(); audioAdapterManager_->SetAudioVolume(streamType, volumeDb); } -void AudioVolumeManagerNotifyAccountsChangedFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerNotifyAccountsChangedFuzzTest() { - int id = static_cast(size); + int id = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->NotifyAccountsChanged(id); } -void AudioVolumeManagerDoRestoreDataFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerDoRestoreDataFuzzTest() { auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->DoRestoreData(); audioAdapterManager->GetSafeVolumeLevel(); audioAdapterManager->GetSafeVolumeTimeout(); } -void AudioVolumeManagerSetFirstBootFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetFirstBootFuzzTest() { - bool isFirst = static_cast(static_cast(size) % NUM_2); + bool isFirst = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->SetFirstBoot(isFirst); } -void AudioVolumeManagerSafeVolumeDumpFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSafeVolumeDumpFuzzTest() { std::string dumpString = "test"; auto audioAdapterManager = std::make_shared(); - audioAdapterManager->isSafeBoot_ = static_cast(static_cast(size) % NUM_2); + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->isSafeBoot_ = g_fuzzUtils.GetData(); audioAdapterManager->SafeVolumeDump(dumpString); } -void AudioVolumeManagerSetVgsVolumeSupportedFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetVgsVolumeSupportedFuzzTest() { - uint32_t index = static_cast(size); - bool isVgsSupported = static_cast(static_cast(size) % NUM_2); + uint32_t index = g_fuzzUtils.GetData(); + bool isVgsSupported = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); - audioAdapterManager->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); audioAdapterManager->SetVgsVolumeSupported(isVgsSupported); audioAdapterManager->IsVgsVolumeSupported(); } -void AudioVolumeManagerUpdateVolumeForLowLatencyFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerUpdateVolumeForLowLatencyFuzzTest() { - uint32_t index = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); - audioAdapterManager->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); audioAdapterManager->UpdateVolumeForLowLatency(); } -void AudioVolumeManagerUpdateSinkArgsFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerUpdateSinkArgsFuzzTest() { AudioModuleInfo info; info.name = "hello"; @@ -487,13 +375,14 @@ void AudioVolumeManagerUpdateSinkArgsFuzzTest(const uint8_t *rawData, size_t siz info.networkId = "ASD**G124"; info.deviceType = "AE00"; info.extra = "1:13:2"; - info.needEmptyChunk = static_cast(static_cast(size) % NUM_2); + info.needEmptyChunk = g_fuzzUtils.GetData(); std::string ret {}; auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->UpdateSinkArgs(info, ret); } -void AudioVolumeManagerGetModuleArgsFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetModuleArgsFuzzTest() { vector testLib = { AudioAdapterManager::HDI_SINK, @@ -515,13 +404,14 @@ void AudioVolumeManagerGetModuleArgsFuzzTest(const uint8_t *rawData, size_t size info.networkId = "ASD**G124"; info.deviceType = "AE00"; info.extra = "1:13:2"; - info.lib = testLib[static_cast(size) % testLib.size()]; - info.needEmptyChunk = static_cast(static_cast(size) % NUM_2); + info.lib = testLib[g_fuzzUtils.GetData() % testLib.size()]; + info.needEmptyChunk = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetModuleArgs(info); } -void AudioVolumeManagerGetHdiSinkIdInfoFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetHdiSinkIdInfoFuzzTest() { vector testClassName = { "CALSS", @@ -530,18 +420,19 @@ void AudioVolumeManagerGetHdiSinkIdInfoFuzzTest(const uint8_t *rawData, size_t s AudioModuleInfo info; info.name = "hello"; info.adapterName = "world"; - info.className = testClassName[static_cast(size) % testClassName.size()]; + info.className = testClassName[g_fuzzUtils.GetData() % testClassName.size()]; info.fileName = "sink.so"; info.sinkLatency = "300ms"; info.networkId = "ASD**G124"; info.deviceType = "AE00"; info.extra = "1:13:2"; - info.needEmptyChunk = static_cast(static_cast(size) % NUM_2); + info.needEmptyChunk = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetHdiSinkIdInfo(info); } -void AudioVolumeManagerGetHdiSourceIdInfoFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetHdiSourceIdInfoFuzzTest() { vector testClassName = { "primary", @@ -551,28 +442,30 @@ void AudioVolumeManagerGetHdiSourceIdInfoFuzzTest(const uint8_t *rawData, size_t AudioModuleInfo info; info.name = "hello"; info.adapterName = "world"; - info.className = testClassName[static_cast(size) % testClassName.size()]; + info.className = testClassName[g_fuzzUtils.GetData() % testClassName.size()]; info.fileName = "sink.so"; info.sinkLatency = "300ms"; info.networkId = "ASD**G124"; info.deviceType = "AE00"; info.extra = "1:13:2"; info.sourceType = "SOURCE_TYPE_WAKEUP"; - info.needEmptyChunk = static_cast(static_cast(size) % NUM_2); + info.needEmptyChunk = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetHdiSourceIdInfo(info); } -void AudioVolumeManagerGetVolumeKeyForKvStoreFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetVolumeKeyForKvStoreFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetVolumeKeyForKvStore(deviceType, streamType); } -void AudioVolumeManagerGetStreamIDByTypeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetStreamIDByTypeFuzzTest() { vector testStreamTypes = { "music", @@ -586,111 +479,124 @@ void AudioVolumeManagerGetStreamIDByTypeFuzzTest(const uint8_t *rawData, size_t "ultrasonic", "camcorder", }; - std::string streamType = testStreamTypes[static_cast(size) % testStreamTypes.size()]; + std::string streamType = testStreamTypes[g_fuzzUtils.GetData() % testStreamTypes.size()]; auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetStreamIDByType(streamType); } -void AudioVolumeManagerGetDeviceCategoryFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetDeviceCategoryFuzzTest() { - DeviceType deviceType = g_testDeviceTypes[static_cast(size) % g_testDeviceTypes.size()]; + DeviceType deviceType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetDeviceCategory(deviceType); } -void AudioVolumeManagerDeleteAudioPolicyKvStoreFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerDeleteAudioPolicyKvStoreFuzzTest() { - bool isFirstBoot = static_cast(static_cast(size) % NUM_2); + bool isFirstBoot = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->InitAudioPolicyKvStore(isFirstBoot); audioAdapterManager->DeleteAudioPolicyKvStore(); } -void AudioVolumeManagerUpdateSafeVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerUpdateSafeVolumeFuzzTest() { - uint32_t index = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); - audioAdapterManager->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); audioAdapterManager->UpdateSafeVolume(); } -void AudioVolumeManagerInitVolumeMapFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerInitVolumeMapFuzzTest() { - bool isFirstBoot = static_cast(static_cast(size) % NUM_2); + bool isFirstBoot = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->InitVolumeMap(isFirstBoot); } -void AudioVolumeManagerGetDefaultVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetDefaultVolumeLevelFuzzTest() { - uint32_t index = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); std::unordered_map volumeLevelMapTemp; - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - int32_t volumeLevel = static_cast(size); + AudioStreamType streamType = g_fuzzUtils.GetData(); + int32_t volumeLevel = g_fuzzUtils.GetData(); volumeLevelMapTemp.insert({streamType, volumeLevel}); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - AudioVolumeType volumeType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + DeviceType deviceType = g_fuzzUtils.GetData(); + AudioVolumeType volumeType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetDefaultVolumeLevel(volumeLevelMapTemp, volumeType, deviceType); } -void AudioVolumeManagerResetRemoteCastDeviceVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerResetRemoteCastDeviceVolumeFuzzTest() { - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->defaultVolumeTypeList_.push_back(streamType); audioAdapterManager->ResetRemoteCastDeviceVolume(); } -void AudioVolumeManagerInitRingerModeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerInitRingerModeFuzzTest() { - bool isFirstBoot = static_cast(static_cast(size) % NUM_2); + bool isFirstBoot = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->isNeedCopyRingerModeData_ = !isFirstBoot; audioAdapterManager->ReInitKVStore(); audioAdapterManager->InitRingerMode(isFirstBoot); } -void AudioVolumeManagerHandleDistributedVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerHandleDistributedVolumeFuzzTest() { - uint32_t index = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); AudioDeviceDescriptor deviceDescriptor; - deviceDescriptor.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + deviceDescriptor.deviceType_ = g_fuzzUtils.GetData(); deviceDescriptor.networkId_ = "testNetworkId"; - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + AudioStreamType streamType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->HandleDistributedVolume(streamType); } -void AudioVolumeManagerInitMuteStatusMapFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerInitMuteStatusMapFuzzTest() { - bool isFirstBoot = static_cast(static_cast(size) % NUM_2); + bool isFirstBoot = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->InitMuteStatusMap(isFirstBoot); } -void AudioVolumeManagerCheckAndDealMuteStatusFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerCheckAndDealMuteStatusFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->currentActiveDevice_.deviceType_ = deviceType; audioAdapterManager->CheckAndDealMuteStatus(deviceType, streamType); } -void AudioVolumeManagerSetVolumeCallbackAfterCloneFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetVolumeCallbackAfterCloneFuzzTest() { - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->defaultVolumeTypeList_.push_back(streamType); audioAdapterManager->SetVolumeCallbackAfterClone(); } -void AudioVolumeManagerOpenPaAudioPortFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerOpenPaAudioPortFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); audioAdapterManager_->ConnectServiceAdapter(); audioAdapterManager_->audioServerProxy_ = AudioServerProxy::GetInstance().GetAudioServerProxy(); @@ -699,119 +605,125 @@ void AudioVolumeManagerOpenPaAudioPortFuzzTest(const uint8_t *rawData, size_t si PIPE_ROLE_INPUT, PIPE_ROLE_NONE, }; - uint32_t index = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); std::shared_ptr pipeInfo = std::make_shared(); + CHECK_AND_RETURN(pipeInfo != nullptr); pipeInfo->pipeRole_ = testAudioPipeRoles[index % testAudioPipeRoles.size()]; uint32_t paIndex = 0; audioAdapterManager_->OpenPaAudioPort(pipeInfo, paIndex, "test"); } -void AudioVolumeManagerCloneMuteStatusMapFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerCloneMuteStatusMapFuzzTest() { - uint32_t index = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); - audioAdapterManager->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); audioAdapterManager->CloneMuteStatusMap(); } -void AudioVolumeManagerLoadMuteStatusMapFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerLoadMuteStatusMapFuzzTest() { - uint32_t index = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); - audioAdapterManager->isNeedCopyMuteData_ = static_cast(static_cast(size) % NUM_2); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->isNeedCopyMuteData_ = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); audioAdapterManager->defaultVolumeTypeList_.push_back(streamType); audioAdapterManager->LoadMuteStatusMap(); } -void AudioVolumeManagerInitSafeStatusFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerInitSafeStatusFuzzTest() { - bool isFirstBoot = static_cast(static_cast(size) % NUM_2); + bool isFirstBoot = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->InitSafeStatus(isFirstBoot); } -void AudioVolumeManagerInitSafeTimeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerInitSafeTimeFuzzTest() { - bool isFirstBoot = static_cast(static_cast(size) % NUM_2); + bool isFirstBoot = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->InitSafeTime(isFirstBoot); } -void AudioVolumeManagerConvertSafeTimeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerConvertSafeTimeFuzzTest() { auto audioAdapterManager = std::make_shared(); - audioAdapterManager->safeActiveTime_ = static_cast(size); - audioAdapterManager->safeActiveBtTime_ = static_cast(size / NUM_2); + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->safeActiveTime_ = g_fuzzUtils.GetData(); + audioAdapterManager->safeActiveBtTime_ = g_fuzzUtils.GetData(); audioAdapterManager->ConvertSafeTime(); } -void AudioVolumeManagerGetCurrentDeviceSafeStatusFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetCurrentDeviceSafeStatusFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetCurrentDeviceSafeStatus(deviceType); } -void AudioVolumeManagerGetCurentDeviceSafeTimeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetCurentDeviceSafeTimeFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetCurentDeviceSafeTime(deviceType); } -void AudioVolumeManagerGetRestoreVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetRestoreVolumeLevelFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetRestoreVolumeLevel(deviceType); } -void AudioVolumeManagerSetDeviceSafeStatusFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetDeviceSafeStatusFuzzTest() { - static const vector testSafeStatus = { - SAFE_UNKNOWN, - SAFE_INACTIVE, - SAFE_ACTIVE, - }; - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - SafeStatus status = testSafeStatus[index % testSafeStatus.size()]; + DeviceType deviceType = g_fuzzUtils.GetData(); + SafeStatus status = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->SetDeviceSafeStatus(deviceType, status); } -void AudioVolumeManagerSetDeviceSafeTimeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetDeviceSafeTimeFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - int64_t time = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); + int64_t time = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->SetDeviceSafeTime(deviceType, time); } -void AudioVolumeManagerSetRestoreVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetRestoreVolumeLevelFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - int32_t volume = static_cast(size); + DeviceType deviceType = g_fuzzUtils.GetData(); + int32_t volume = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->SetRestoreVolumeLevel(deviceType, volume); } -void AudioVolumeManagerGetMuteKeyForKvStoreFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetMuteKeyForKvStoreFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetMuteKeyForKvStore(deviceType, streamType); } -void AudioVolumeManagerSetSystemSoundUriFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetSystemSoundUriFuzzTest() { static const std::vector testSystemSoundKey = { "ringtone_for_sim_card_0", @@ -820,13 +732,14 @@ void AudioVolumeManagerSetSystemSoundUriFuzzTest(const uint8_t *rawData, size_t "system_tone_for_sim_card_1", "system_tone_for_notification" }; - std::string key = testSystemSoundKey[static_cast(size) % testSystemSoundKey.size()]; + std::string key = testSystemSoundKey[g_fuzzUtils.GetData() % testSystemSoundKey.size()]; std::string uri = "test"; auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->SetSystemSoundUri(key, uri); } -void AudioVolumeManagerGetSystemSoundUriFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetSystemSoundUriFuzzTest() { static const std::vector testSystemSoundKey = { "ringtone_for_sim_card_0", @@ -835,344 +748,342 @@ void AudioVolumeManagerGetSystemSoundUriFuzzTest(const uint8_t *rawData, size_t "system_tone_for_sim_card_1", "system_tone_for_notification" }; - std::string key = testSystemSoundKey[static_cast(size) % testSystemSoundKey.size()]; + std::string key = testSystemSoundKey[g_fuzzUtils.GetData() % testSystemSoundKey.size()]; auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetSystemSoundUri(key); } -void AudioVolumeManagerGetSystemVolumeInDbFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetSystemVolumeInDbFuzzTest() { - int32_t volumeLevel = static_cast(size); - uint32_t index = static_cast(size); - AudioVolumeType volumeType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + int32_t volumeLevel = g_fuzzUtils.GetData(); + AudioVolumeType volumeType = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); - audioAdapterManager->useNonlinearAlgo_ = static_cast(static_cast(size) % NUM_2); + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->useNonlinearAlgo_ = g_fuzzUtils.GetData(); audioAdapterManager->GetSystemVolumeInDb(volumeType, volumeLevel, deviceType); } -void AudioVolumeManagerGetPositionInVolumePointsFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetPositionInVolumePointsFuzzTest() { - static uint32_t step = 0; - step += static_cast(size); VolumePoint volumePoint1; - volumePoint1.index = static_cast(size); - volumePoint1.dbValue = static_cast(size) / NUM_2; + volumePoint1.index = g_fuzzUtils.GetData(); + volumePoint1.dbValue = g_fuzzUtils.GetData(); VolumePoint volumePoint2; - volumePoint2.index = step; - volumePoint2.dbValue = step / NUM_2; - std::vector volumePoints; + volumePoint2.index = g_fuzzUtils.GetData(); + volumePoint2.dbValue = g_fuzzUtils.GetData(); + std::vector volumePoints = {}; volumePoints.push_back(volumePoint1); volumePoints.push_back(volumePoint2); - int32_t idx = static_cast(size); auto audioAdapterManager = std::make_shared(); - audioAdapterManager->GetPositionInVolumePoints(volumePoints, idx); + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->GetPositionInVolumePoints(volumePoints, 0); } -void AudioVolumeManagerInitVolumeMapIndexFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerInitVolumeMapIndexFuzzTest() { - AudioStreamType streamType = g_testAudioStreamTypes[static_cast(size) % g_testAudioStreamTypes.size()]; + AudioStreamType streamType = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->defaultVolumeTypeList_.push_back(streamType); audioAdapterManager->InitVolumeMapIndex(); } -void AudioVolumeManagerUpdateVolumeMapIndexFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerUpdateVolumeMapIndexFuzzTest() { - static const vector testDeviceVolumeTypes = { - EARPIECE_VOLUME_TYPE, - SPEAKER_VOLUME_TYPE, - HEADSET_VOLUME_TYPE, - }; - uint32_t index = static_cast(size); + uint32_t index = g_fuzzUtils.GetData(); VolumePoint volumePoint; - volumePoint.index = static_cast(size); - volumePoint.dbValue = static_cast(size) / NUM_2; + volumePoint.index = g_fuzzUtils.GetData(); + volumePoint.dbValue = g_fuzzUtils.GetData(); std::vector volumePoints; volumePoints.push_back(volumePoint); std::shared_ptr deviceVolumeInfoPtr = std::make_shared(); - deviceVolumeInfoPtr->deviceType = testDeviceVolumeTypes[index % testDeviceVolumeTypes.size()]; + CHECK_AND_RETURN(deviceVolumeInfoPtr != nullptr); + deviceVolumeInfoPtr->deviceType = g_fuzzUtils.GetData(); deviceVolumeInfoPtr->volumePoints = volumePoints; DeviceVolumeInfoMap deviceVolumeInfoMap; deviceVolumeInfoMap.insert({deviceVolumeInfoPtr->deviceType, deviceVolumeInfoPtr}); std::shared_ptr streamVolumeInfoPtr = std::make_shared(); - streamVolumeInfoPtr->streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - streamVolumeInfoPtr->maxLevel = static_cast(size) | 1; - streamVolumeInfoPtr->minLevel = static_cast(size); - streamVolumeInfoPtr->defaultLevel = static_cast(size) / NUM_2; + CHECK_AND_RETURN(streamVolumeInfoPtr != nullptr); + streamVolumeInfoPtr->streamType = g_fuzzUtils.GetData(); + streamVolumeInfoPtr->maxLevel = g_fuzzUtils.GetData() | 1; + streamVolumeInfoPtr->minLevel = g_fuzzUtils.GetData(); + streamVolumeInfoPtr->defaultLevel = g_fuzzUtils.GetData(); streamVolumeInfoPtr->deviceVolumeInfos = deviceVolumeInfoMap; auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->streamVolumeInfos_.insert({streamVolumeInfoPtr->streamType, streamVolumeInfoPtr}); audioAdapterManager->UpdateVolumeMapIndex(); } -void AudioVolumeManagerSetAbsVolumeSceneFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetAbsVolumeSceneFuzzTest() { - uint32_t index = static_cast(size); - bool isAbsVolumeScene = static_cast(static_cast(size) % NUM_2); + uint32_t index = g_fuzzUtils.GetData(); + bool isAbsVolumeScene = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); - audioAdapterManager->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); audioAdapterManager->SetAbsVolumeScene(isAbsVolumeScene); } -void AudioVolumeManagerSetAbsVolumeMuteFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetAbsVolumeMuteFuzzTest() { - uint32_t index = static_cast(size); - bool mute = static_cast(static_cast(size) % NUM_2); + uint32_t index = g_fuzzUtils.GetData(); + bool mute = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); - audioAdapterManager->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); audioAdapterManager->SetAbsVolumeMute(mute); } -void AudioVolumeManagerSetAppVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetAppVolumeLevelFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - audioAdapterManager_->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - int32_t randIntValue = static_cast(size); - audioAdapterManager_->SetAppVolumeLevel(randIntValue, randIntValue / NUM_2); + uint32_t index = g_fuzzUtils.GetData(); + audioAdapterManager_->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); + int32_t randIntValue = g_fuzzUtils.GetData(); + audioAdapterManager_->SetAppVolumeLevel(randIntValue, randIntValue); } -void AudioVolumeManagerSetAdjustVolumeForZoneFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetAdjustVolumeForZoneFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - int32_t zoneId = static_cast(size); + int32_t zoneId = g_fuzzUtils.GetData(); audioAdapterManager_->SetAdjustVolumeForZone(zoneId); } -void AudioVolumeManagerSetZoneMuteFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetZoneMuteFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - int32_t zoneId = static_cast(size); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - StreamUsage streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()]; - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - bool mute = static_cast(static_cast(size) % NUM_2); + int32_t zoneId = g_fuzzUtils.GetData(); + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + StreamUsage streamUsage = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); + bool mute = g_fuzzUtils.GetData(); audioAdapterManager_->SetZoneMute(zoneId, streamType, mute, streamUsage, deviceType); } -void AudioVolumeManagerGetZoneMuteFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetZoneMuteFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - int32_t zoneId = static_cast(size); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + int32_t zoneId = g_fuzzUtils.GetData(); + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); audioAdapterManager_->GetZoneMute(zoneId, streamType); } -void AudioVolumeManagerGetZoneVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetZoneVolumeLevelFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - int32_t zoneId = static_cast(size); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + int32_t zoneId = g_fuzzUtils.GetData(); + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); audioAdapterManager_->GetZoneVolumeLevel(zoneId, streamType); } -void AudioVolumeManagerSetZoneVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetZoneVolumeLevelFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - int32_t zoneId = static_cast(size); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - int32_t volumeLevel = static_cast(size); + int32_t zoneId = g_fuzzUtils.GetData(); + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + int32_t volumeLevel = g_fuzzUtils.GetData(); audioAdapterManager_->SetZoneVolumeLevel(zoneId, streamType, volumeLevel); } -void AudioVolumeManagerGetDeviceVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetDeviceVolumeFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); audioAdapterManager_->GetDeviceVolume(deviceType, streamType); } -void AudioVolumeManagerHandleRingerModeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerHandleRingerModeFuzzTest() { - vector testAudioRingerModers = { - RINGER_MODE_SILENT, - RINGER_MODE_VIBRATE, - RINGER_MODE_NORMAL, - }; - uint32_t index = static_cast(size); - AudioRingerMode ringMode = testAudioRingerModers[index % testAudioRingerModers.size()]; + uint32_t index = g_fuzzUtils.GetData(); + AudioRingerMode ringMode = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->HandleRingerMode(ringMode); } -void AudioVolumeManagerSetAppVolumeDbFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetAppVolumeDbFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - int32_t appUid = static_cast(size); + int32_t appUid = g_fuzzUtils.GetData(); audioAdapterManager_->SetAppVolumeDb(appUid); } -void AudioVolumeManagerSetAppVolumeMutedDBFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetAppVolumeMutedDBFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - int32_t appUid = static_cast(size); - bool muted = static_cast(static_cast(size) % NUM_2); + int32_t appUid = g_fuzzUtils.GetData(); + bool muted = g_fuzzUtils.GetData(); audioAdapterManager_->SetAppVolumeMutedDB(appUid, muted); } -void AudioVolumeManagerGetAppVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetAppVolumeLevelFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - int32_t appUid = static_cast(size); - int32_t volumeLevel = static_cast(size); + int32_t appUid = g_fuzzUtils.GetData(); + int32_t volumeLevel = g_fuzzUtils.GetData(); audioAdapterManager_->GetAppVolumeLevel(appUid, volumeLevel); } -void AudioVolumeManagerSetPersistMicMuteStateFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetPersistMicMuteStateFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - bool mute = static_cast(static_cast(size) % NUM_2); + bool mute = g_fuzzUtils.GetData(); audioAdapterManager_->SetPersistMicMuteState(mute); } -void AudioVolumeManagerSetSourceOutputStreamMuteFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetSourceOutputStreamMuteFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - int32_t uid = static_cast(size); - bool setMute = static_cast(static_cast(size) % NUM_2); + int32_t uid = g_fuzzUtils.GetData(); + bool setMute = g_fuzzUtils.GetData(); audioAdapterManager_->SetSourceOutputStreamMute(uid, setMute); } -void AudioVolumeManagerGetStreamMuteFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetStreamMuteFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + uint32_t index = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); audioAdapterManager_->GetStreamMute(streamType); } -void AudioVolumeManagerGetAppMuteFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerGetAppMuteFuzzTest() { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); audioAdapterManager_->Init(); - int32_t appUid = static_cast(size); + int32_t appUid = g_fuzzUtils.GetData(); audioAdapterManager_->GetAppMute(appUid); } -void AudioVolumeManagerSetRingerModeFuzzTest(const uint8_t *rawData, size_t size) +void AudioVolumeManagerSetRingerModeFuzzTest() { - vector testAudioRingerModers = { - RINGER_MODE_SILENT, - RINGER_MODE_VIBRATE, - RINGER_MODE_NORMAL, - }; - uint32_t index = static_cast(size); - AudioRingerMode ringMode = testAudioRingerModers[index % testAudioRingerModers.size()]; + uint32_t index = g_fuzzUtils.GetData(); + AudioRingerMode ringMode = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->SetRingerMode(ringMode); } -} // namespace AudioStandard -} // namesapce OHOS -OHOS::AudioStandard::TestPtr g_testPtrs[] = { - OHOS::AudioStandard::AudioVolumeManagerIsAppVolumeMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSaveSpecifiedDeviceVolumeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerHandleStreamMuteStatusFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetOffloadVolumeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetOffloadSessionIdFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerConnectServiceAdapterFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerHandleKvDataFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerReInitKVStoreFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSaveRingtoneVolumeToLocalFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetAppVolumeMutedFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetSystemVolumeLevelFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetDoubleRingVolumeDbFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetInnerStreamMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetStreamMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetSinkMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSelectDeviceFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetDeviceActiveFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerAdjustBluetoothVoiceAssistantVolumeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSaveRingerModeInfoFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetSinkIdInfoAndIdTypeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerOpenNotPaAudioPortFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerUpdateSinkArgsFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetModuleArgsFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetHdiSinkIdInfoFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetHdiSourceIdInfoFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetVolumeKeyForKvStoreFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetStreamIDByTypeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetDeviceCategoryFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerDeleteAudioPolicyKvStoreFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerUpdateSafeVolumeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerInitVolumeMapFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetDefaultVolumeLevelFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerResetRemoteCastDeviceVolumeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerInitRingerModeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerHandleDistributedVolumeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerInitMuteStatusMapFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerCheckAndDealMuteStatusFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetVolumeCallbackAfterCloneFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerOpenPaAudioPortFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerCloneMuteStatusMapFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerLoadMuteStatusMapFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerInitSafeStatusFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerInitSafeTimeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerConvertSafeTimeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetCurrentDeviceSafeStatusFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetCurentDeviceSafeTimeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetRestoreVolumeLevelFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetDeviceSafeStatusFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetDeviceSafeTimeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetRestoreVolumeLevelFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetMuteKeyForKvStoreFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetSystemSoundUriFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetSystemSoundUriFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetSystemVolumeInDbFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetPositionInVolumePointsFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerInitVolumeMapIndexFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerUpdateVolumeMapIndexFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetAbsVolumeSceneFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetAbsVolumeMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetAudioVolumeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerNotifyAccountsChangedFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerDoRestoreDataFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetFirstBootFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSafeVolumeDumpFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetVgsVolumeSupportedFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetAppVolumeLevelFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetAdjustVolumeForZoneFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetZoneMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetZoneMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetZoneMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetZoneVolumeLevelFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetZoneVolumeLevelFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetDeviceVolumeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerHandleRingerModeFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetAppVolumeDbFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetAppVolumeMutedDBFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetAppVolumeLevelFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetPersistMicMuteStateFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetSourceOutputStreamMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetStreamMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerGetAppMuteFuzzTest, - OHOS::AudioStandard::AudioVolumeManagerSetRingerModeFuzzTest, +vector g_testPtrs = { + AudioVolumeManagerIsAppVolumeMuteFuzzTest, + AudioVolumeManagerSaveSpecifiedDeviceVolumeFuzzTest, + AudioVolumeManagerHandleStreamMuteStatusFuzzTest, + AudioVolumeManagerSetOffloadVolumeFuzzTest, + AudioVolumeManagerSetOffloadSessionIdFuzzTest, + AudioVolumeManagerConnectServiceAdapterFuzzTest, + AudioVolumeManagerHandleKvDataFuzzTest, + AudioVolumeManagerReInitKVStoreFuzzTest, + AudioVolumeManagerSaveRingtoneVolumeToLocalFuzzTest, + AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest, + AudioVolumeManagerSetAppVolumeMutedFuzzTest, + AudioVolumeManagerSetSystemVolumeLevelFuzzTest, + AudioVolumeManagerSetDoubleRingVolumeDbFuzzTest, + AudioVolumeManagerSetInnerStreamMuteFuzzTest, + AudioVolumeManagerSetStreamMuteFuzzTest, + AudioVolumeManagerSetSinkMuteFuzzTest, + AudioVolumeManagerSelectDeviceFuzzTest, + AudioVolumeManagerSetDeviceActiveFuzzTest, + AudioVolumeManagerAdjustBluetoothVoiceAssistantVolumeFuzzTest, + AudioVolumeManagerSetVolumeForSwitchDeviceFuzzTest, + AudioVolumeManagerSaveRingerModeInfoFuzzTest, + AudioVolumeManagerGetSinkIdInfoAndIdTypeFuzzTest, + AudioVolumeManagerOpenNotPaAudioPortFuzzTest, + AudioVolumeManagerUpdateSinkArgsFuzzTest, + AudioVolumeManagerGetModuleArgsFuzzTest, + AudioVolumeManagerGetHdiSinkIdInfoFuzzTest, + AudioVolumeManagerGetHdiSourceIdInfoFuzzTest, + AudioVolumeManagerGetVolumeKeyForKvStoreFuzzTest, + AudioVolumeManagerGetStreamIDByTypeFuzzTest, + AudioVolumeManagerGetDeviceCategoryFuzzTest, + AudioVolumeManagerDeleteAudioPolicyKvStoreFuzzTest, + AudioVolumeManagerUpdateSafeVolumeFuzzTest, + AudioVolumeManagerInitVolumeMapFuzzTest, + AudioVolumeManagerGetDefaultVolumeLevelFuzzTest, + AudioVolumeManagerResetRemoteCastDeviceVolumeFuzzTest, + AudioVolumeManagerInitRingerModeFuzzTest, + AudioVolumeManagerHandleDistributedVolumeFuzzTest, + AudioVolumeManagerInitMuteStatusMapFuzzTest, + AudioVolumeManagerCheckAndDealMuteStatusFuzzTest, + AudioVolumeManagerSetVolumeCallbackAfterCloneFuzzTest, + AudioVolumeManagerOpenPaAudioPortFuzzTest, + AudioVolumeManagerCloneMuteStatusMapFuzzTest, + AudioVolumeManagerLoadMuteStatusMapFuzzTest, + AudioVolumeManagerInitSafeStatusFuzzTest, + AudioVolumeManagerInitSafeTimeFuzzTest, + AudioVolumeManagerConvertSafeTimeFuzzTest, + AudioVolumeManagerGetCurrentDeviceSafeStatusFuzzTest, + AudioVolumeManagerGetCurentDeviceSafeTimeFuzzTest, + AudioVolumeManagerGetRestoreVolumeLevelFuzzTest, + AudioVolumeManagerSetDeviceSafeStatusFuzzTest, + AudioVolumeManagerSetDeviceSafeTimeFuzzTest, + AudioVolumeManagerSetRestoreVolumeLevelFuzzTest, + AudioVolumeManagerGetMuteKeyForKvStoreFuzzTest, + AudioVolumeManagerSetSystemSoundUriFuzzTest, + AudioVolumeManagerGetSystemSoundUriFuzzTest, + AudioVolumeManagerGetSystemVolumeInDbFuzzTest, + AudioVolumeManagerGetPositionInVolumePointsFuzzTest, + AudioVolumeManagerInitVolumeMapIndexFuzzTest, + AudioVolumeManagerUpdateVolumeMapIndexFuzzTest, + AudioVolumeManagerSetAbsVolumeSceneFuzzTest, + AudioVolumeManagerSetAbsVolumeMuteFuzzTest, + AudioVolumeManagerSetAudioVolumeFuzzTest, + AudioVolumeManagerNotifyAccountsChangedFuzzTest, + AudioVolumeManagerDoRestoreDataFuzzTest, + AudioVolumeManagerSetFirstBootFuzzTest, + AudioVolumeManagerSafeVolumeDumpFuzzTest, + AudioVolumeManagerSetVgsVolumeSupportedFuzzTest, + AudioVolumeManagerSetAppVolumeLevelFuzzTest, + AudioVolumeManagerSetAdjustVolumeForZoneFuzzTest, + AudioVolumeManagerSetZoneMuteFuzzTest, + AudioVolumeManagerSetZoneMuteFuzzTest, + AudioVolumeManagerGetZoneMuteFuzzTest, + AudioVolumeManagerGetZoneVolumeLevelFuzzTest, + AudioVolumeManagerSetZoneVolumeLevelFuzzTest, + AudioVolumeManagerGetDeviceVolumeFuzzTest, + AudioVolumeManagerHandleRingerModeFuzzTest, + AudioVolumeManagerSetAppVolumeDbFuzzTest, + AudioVolumeManagerSetAppVolumeMutedDBFuzzTest, + AudioVolumeManagerGetAppVolumeLevelFuzzTest, + AudioVolumeManagerSetPersistMicMuteStateFuzzTest, + AudioVolumeManagerSetSourceOutputStreamMuteFuzzTest, + AudioVolumeManagerGetStreamMuteFuzzTest, + AudioVolumeManagerGetAppMuteFuzzTest, + AudioVolumeManagerSetRingerModeFuzzTest, }; +} // namespace AudioStandard +} // namesapce OHOS /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { - /* Run your code on data */ - if (data == nullptr || size <= 1) { + if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) { return 0; } - uint32_t len = OHOS::AudioStandard::GetArrLength(g_testPtrs); - if (len > 0) { - uint8_t firstByte = *data % len; - if (firstByte >= len) { - return 0; - } - data = data + 1; - size = size - 1; - g_testPtrs[firstByte](data, size); - } + + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testPtrs); return 0; } \ No newline at end of file diff --git a/test/fuzztest/audioadaptorbluetooth_fuzzer/audio_adaptor_bluetooth_fuzzer.cpp b/test/fuzztest/audioadaptorbluetooth_fuzzer/audio_adaptor_bluetooth_fuzzer.cpp index b77b91ae3d..6691a61723 100644 --- a/test/fuzztest/audioadaptorbluetooth_fuzzer/audio_adaptor_bluetooth_fuzzer.cpp +++ b/test/fuzztest/audioadaptorbluetooth_fuzzer/audio_adaptor_bluetooth_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -133,7 +133,6 @@ void InitFuzzTest() attr.channel = CHANNEL; attr.format = SAMPLE_S16LE; attr.sampleRate = GetData(); - attr.channel = GetData(); attr.format = GetData(); attr.channelLayout = COMMON_UINT64_NUM; attr.deviceType = GetData(); @@ -151,11 +150,6 @@ void RenderFrameFuzzTest() GetAdaptorBlueToothSink()->RenderFrame(data, len, writeLen); } -void StartFuzzTest() -{ - GetAdaptorBlueToothSink()->Start(); -} - void SetVolumeFuzzTest() { float left = GetData(); @@ -189,37 +183,16 @@ void GetTransactionIdFuzzTest() void StopFuzzTest() { - GetAdaptorBlueToothSink()->Stop(); -} - -void PauseFuzzTest() -{ + GetAdaptorBlueToothSink()->Start(); GetAdaptorBlueToothSink()->Pause(); -} - -void ResumeFuzzTest() -{ GetAdaptorBlueToothSink()->Resume(); -} - -void ResetFuzzTest() -{ GetAdaptorBlueToothSink()->Reset(); -} - -void FlushFuzzTest() -{ GetAdaptorBlueToothSink()->Flush(); -} - -void SuspendRenderSinkFuzzTest() -{ GetAdaptorBlueToothSink()->SuspendRenderSink(); -} - -void RestoreRenderSinkFuzzTest() -{ GetAdaptorBlueToothSink()->RestoreRenderSink(); + g_renderId = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_BLUETOOTH, HDI_ID_INFO_MMAP, + GetData()); + GetAdaptorBlueToothSink()->Stop(); } void GetPresentationPositionFuzzTest() @@ -242,18 +215,11 @@ void SetPaPowerFuzzTest() GetAdaptorBlueToothSink()->SetPaPower(flag); } -void ReleaseRenderIdFuzzTest() -{ - g_renderId = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_BLUETOOTH, HDI_ID_INFO_MMAP, - true); -} - -typedef void (*TestFuncs[22])(); +typedef void (*TestFuncs[15])(); TestFuncs g_testFuncs = { InitFuzzTest, RenderFrameFuzzTest, - StartFuzzTest, IsInitedFuzzTest, SetAudioSceneFuzzTest, SetOutputRoutesFuzzTest, @@ -263,15 +229,9 @@ TestFuncs g_testFuncs = { SetVolumeFuzzTest, GetVolumeFuzzTest, GetTransactionIdFuzzTest, - SuspendRenderSinkFuzzTest, - RestoreRenderSinkFuzzTest, GetPresentationPositionFuzzTest, ResetOutputRouteForDisconnectFuzzTest, SetPaPowerFuzzTest, - PauseFuzzTest, - ResumeFuzzTest, - ResetFuzzTest, - FlushFuzzTest, StopFuzzTest, }; diff --git a/test/fuzztest/audiocapturersession_fuzzer/audio_capturer_session_fuzzer.cpp b/test/fuzztest/audiocapturersession_fuzzer/audio_capturer_session_fuzzer.cpp index 47eefbf920..a62a20e098 100644 --- a/test/fuzztest/audiocapturersession_fuzzer/audio_capturer_session_fuzzer.cpp +++ b/test/fuzztest/audiocapturersession_fuzzer/audio_capturer_session_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024-2025 Huawei Device Co., Ltd. + * Copyright (c) 2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -30,13 +30,12 @@ void LoadInnerCapturerSinkFuzzTest() std::string moduleName = "moduleName"; AudioStreamInfo streamInfo; session.LoadInnerCapturerSink(moduleName, streamInfo); -} - -void UnloadInnerCapturerSinkFuzzTest() -{ - AudioCapturerSession& session = AudioCapturerSession::GetInstance(); - std::string moduleName = "moduleName"; session.UnloadInnerCapturerSink(moduleName); + AudioModuleInfo audioModuleInfo; + session.ConstructWakeupAudioModuleInfo(streamInfo, audioModuleInfo); + std::shared_ptr pipeInfo = std::make_shared(); + CHECK_AND_RETURN(pipeInfo != nullptr); + session.FillWakeupStreamPropInfo(streamInfo, pipeInfo, audioModuleInfo); } void HandleRemoteCastDeviceFuzzTest() @@ -55,24 +54,11 @@ void FindRunningNormalSessionFuzzTest() session.FindRunningNormalSession(sessionId, runningSessionInfo); } -void ConstructWakeupAudioModuleInfoFuzzTest() -{ - AudioCapturerSession& session = AudioCapturerSession::GetInstance(); - AudioStreamInfo streamInfo; - AudioModuleInfo audioModuleInfo; - session.ConstructWakeupAudioModuleInfo(streamInfo, audioModuleInfo); -} - void SetWakeUpAudioCapturerFuzzTest() { AudioCapturerSession& session = AudioCapturerSession::GetInstance(); InternalAudioCapturerOptions options; session.SetWakeUpAudioCapturer(options); -} - -void SetWakeUpAudioCapturerFromAudioServerFuzzTest() -{ - AudioCapturerSession& session = AudioCapturerSession::GetInstance(); AudioProcessConfig config; session.SetWakeUpAudioCapturerFromAudioServer(config); } @@ -80,51 +66,25 @@ void SetWakeUpAudioCapturerFromAudioServerFuzzTest() void CloseWakeUpAudioCapturerFuzzTest() { AudioCapturerSession& session = AudioCapturerSession::GetInstance(); + session.GetInputDeviceTypeForReload(); session.CloseWakeUpAudioCapturer(); } -void FillWakeupStreamPropInfoFuzzTest() -{ - AudioCapturerSession& session = AudioCapturerSession::GetInstance(); - AudioStreamInfo streamInfo; - AudioModuleInfo audioModuleInfo; - std::shared_ptr pipeInfo; - session.FillWakeupStreamPropInfo(streamInfo, pipeInfo, audioModuleInfo); -} - void IsVoipDeviceChangedFuzzTest() { AudioCapturerSession& session = AudioCapturerSession::GetInstance(); AudioDeviceDescriptor inputDevice; AudioDeviceDescriptor outputDevice; session.IsVoipDeviceChanged(inputDevice, outputDevice); -} - -void SetInputDeviceTypeForReloadFuzzTest() -{ - AudioCapturerSession& session = AudioCapturerSession::GetInstance(); - AudioDeviceDescriptor inputDevice; session.SetInputDeviceTypeForReload(inputDevice); } -void GetInputDeviceTypeForReloadFuzzTest() -{ - AudioCapturerSession& session = AudioCapturerSession::GetInstance(); - session.GetInputDeviceTypeForReload(); -} - void GetEnhancePropByNameV3FuzzTest() { AudioCapturerSession& session = AudioCapturerSession::GetInstance(); AudioEffectPropertyArrayV3 propertyArray; std::string propName = "propName"; session.GetEnhancePropByNameV3(propertyArray, propName); -} - -void ReloadSourceForEffectFuzzTest() -{ - AudioCapturerSession& session = AudioCapturerSession::GetInstance(); - AudioEffectPropertyArrayV3 propertyArray; AudioEffectPropertyArrayV3 newPropertyArray; session.ReloadSourceForEffect(propertyArray, newPropertyArray); } @@ -135,11 +95,6 @@ void GetEnhancePropByNameFuzzTest() AudioEnhancePropertyArray propertyArray; std::string propName = "propName"; session.GetEnhancePropByName(propertyArray, propName); -} - -void ReloadSourceForEffectDifferentArgsFuzzTest() -{ - AudioCapturerSession& session = AudioCapturerSession::GetInstance(); AudioEnhancePropertyArray oldPropertyArray; AudioEnhancePropertyArray newPropertyArray; session.ReloadSourceForEffect(oldPropertyArray, newPropertyArray); @@ -147,21 +102,13 @@ void ReloadSourceForEffectDifferentArgsFuzzTest() vector g_testFuncs = { LoadInnerCapturerSinkFuzzTest, - UnloadInnerCapturerSinkFuzzTest, HandleRemoteCastDeviceFuzzTest, FindRunningNormalSessionFuzzTest, - ConstructWakeupAudioModuleInfoFuzzTest, SetWakeUpAudioCapturerFuzzTest, - SetWakeUpAudioCapturerFromAudioServerFuzzTest, CloseWakeUpAudioCapturerFuzzTest, - FillWakeupStreamPropInfoFuzzTest, IsVoipDeviceChangedFuzzTest, - SetInputDeviceTypeForReloadFuzzTest, - GetInputDeviceTypeForReloadFuzzTest, GetEnhancePropByNameV3FuzzTest, - ReloadSourceForEffectFuzzTest, GetEnhancePropByNameFuzzTest, - ReloadSourceForEffectDifferentArgsFuzzTest, }; } // namespace AudioStandard } // namesapce OHOS diff --git a/test/fuzztest/audioresourceservice_fuzzer/audio_resource_service_fuzzer.cpp b/test/fuzztest/audioresourceservice_fuzzer/audio_resource_service_fuzzer.cpp index 5140345861..7eaa4135b6 100644 --- a/test/fuzztest/audioresourceservice_fuzzer/audio_resource_service_fuzzer.cpp +++ b/test/fuzztest/audioresourceservice_fuzzer/audio_resource_service_fuzzer.cpp @@ -26,6 +26,9 @@ using namespace std; FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); const std::u16string FORMMGR_INTERFACE_TOKEN = u"IAudioPolicy"; const int32_t TEST_RTG_ID = 2; +const int32_t NUM_1 = 1; +const int32_t NUM_2 = 2; +const int32_t NUM_3 = 3; typedef void (*TestFuncs)(); @@ -39,6 +42,16 @@ public: int Dump(int fd, const std::vector &args) { return 0; }; }; +class AudioWorkgroupCallbackForMonitorTest : public AudioWorkgroupCallbackForMonitor { +public: + AudioWorkgroupCallbackForMonitorTest() = default; + ~AudioWorkgroupCallbackForMonitorTest() override + { + AUDIO_INFO_LOG("AudioWorkgroupCallbackForMonitorTest destroyed"); + } + void OnWorkgroupChange(const AudioWorkgroupChangeInfo &info) override {} +}; + void ResourceServiceCreateAudioWorkgroupFuzzTest() { int32_t pid = g_fuzzUtils.GetData(); @@ -89,30 +102,156 @@ void ResourceServiceOnWorkgroupRemoteDiedFuzzTest() void ResourceServiceReleaseWorkgroupDeathRecipientFuzzTest() { std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + CHECK_AND_RETURN(workgroup != nullptr); sptr remoteObj = new RemoteObjectTestStub(); + CHECK_AND_RETURN(remoteObj != nullptr); + AudioResourceService::GetInstance()->deathRecipientMap_[workgroup] = + std::make_pair(remoteObj, new AudioResourceService::AudioWorkgroupDeathRecipient()); AudioResourceService::GetInstance()->ReleaseWorkgroupDeathRecipient(workgroup, remoteObj); } void ResourceServiceWorkgroupRendererMonitorFuzzTest() { + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + if (!workgroup) { + return; + } + workgroup->callback = std::make_shared(); + if (!workgroup->callback) { + return; + } auto audioResourceService = AudioResourceService::GetInstance(); int32_t testPid = g_fuzzUtils.GetData(); if (audioResourceService == nullptr) { return; } + int32_t pid = g_fuzzUtils.GetData(); audioResourceService->audioWorkgroupMap_[testPid].permission = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[testPid].groups[pid] = {workgroup}; audioResourceService->WorkgroupRendererMonitor(testPid, true); } void ResourceServiceDumpAudioWorkgroupMapFuzzTest() { + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + if (!workgroup) { + return; + } auto audioResourceService = AudioResourceService::GetInstance(); if (audioResourceService == nullptr) { return; } + int32_t pid = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[0].groups[pid] = {workgroup}; audioResourceService->DumpAudioWorkgroupMap(); } +void AudioWorkgroupCheckFuzzTest() +{ + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + if (!workgroup) { + return; + } + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[pid].groups[TEST_RTG_ID] = {workgroup}; + audioResourceService->AudioWorkgroupCheck(pid); + pid = g_fuzzUtils.GetData() + 1; + audioResourceService->AudioWorkgroupCheck(pid); +} + +void CreateAudioWorkgroupFuzzTest() +{ + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + sptr object = new RemoteObjectTestStub(); + if (object == nullptr) { + return; + } + audioResourceService->CreateAudioWorkgroup(pid, object); +} + +void ReleaseAudioWorkgroupFuzzTest() +{ + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + if (!workgroup) { + return; + } + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId] = {workgroup}; + audioResourceService->ReleaseAudioWorkgroup(pid, workgroupId); +} + +void AddThreadToGroupFuzzTest() +{ + std::shared_ptr workgroup1 = std::make_shared(TEST_RTG_ID); + std::shared_ptr workgroup2 = std::make_shared(TEST_RTG_ID); + std::shared_ptr workgroup3 = std::make_shared(TEST_RTG_ID); + std::shared_ptr workgroup4 = std::make_shared(TEST_RTG_ID); + if (!workgroup1 || !workgroup2 || !workgroup3 || !workgroup4) { + return; + } + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); + int32_t tokenId = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId] = {workgroup1}; + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId + NUM_1] = {workgroup2}; + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId + NUM_2] = {workgroup3}; + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId + NUM_3] = {workgroup4}; + audioResourceService->AddThreadToGroup(pid, workgroupId, tokenId); + audioResourceService->RemoveThreadFromGroup(pid, workgroupId, tokenId); +} + +void StartGroupFuzzTest() +{ + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + if (!workgroup) { + return; + } + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); + uint64_t startTime = g_fuzzUtils.GetData(); + uint64_t deadlineTime = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId] = {workgroup}; + audioResourceService->StartGroup(pid, workgroupId, startTime, deadlineTime); + audioResourceService->StopGroup(pid, workgroupId); +} + +void GetThreadsNumPerProcessFuzzTest() +{ + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + if (!workgroup) { + return; + } + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId] = {workgroup}; + audioResourceService->GetThreadsNumPerProcess(pid); +} + vector g_testFuncs = { ResourceServiceCreateAudioWorkgroupFuzzTest, ResourceServiceAudioWorkgroupDeathRecipientFuzzTest, @@ -121,6 +260,12 @@ vector g_testFuncs = { ResourceServiceReleaseWorkgroupDeathRecipientFuzzTest, ResourceServiceWorkgroupRendererMonitorFuzzTest, ResourceServiceDumpAudioWorkgroupMapFuzzTest, + AudioWorkgroupCheckFuzzTest, + CreateAudioWorkgroupFuzzTest, + ReleaseAudioWorkgroupFuzzTest, + AddThreadToGroupFuzzTest, + StartGroupFuzzTest, + GetThreadsNumPerProcessFuzzTest, }; } // namespace AudioStandard diff --git a/test/fuzztest/audioserversup_fuzzer/BUILD.gn b/test/fuzztest/audioserversup_fuzzer/BUILD.gn new file mode 100644 index 0000000000..366bb9f9d8 --- /dev/null +++ b/test/fuzztest/audioserversup_fuzzer/BUILD.gn @@ -0,0 +1,66 @@ +# Copyright (c) 2022-2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../config.gni") + +ohos_fuzztest("AudioServerSupFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../audioserversup_fuzzer" + + include_dirs = [ + "../../../frameworks/native/audioinnercall/include", + "../../../services/audio_service/server/include", + "../../../services/audio_policy/client/include", + ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + sources = [ "audio_server_sup_fuzzer.cpp" ] + + configs = [ "../../../services/audio_service:audio_service_config" ] + cflags_cc = [ "-std=c++20" ] + + deps = [ + "../../../services/audio_service/idl:audio_framework_interface", + "../../../services/audio_policy:audio_policy_client", + "../../../services/audio_service:audio_service_static", + ] + external_deps = [ + "access_token:libaccesstoken_sdk", + "c_utils:utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "ipc:ipc_single", + "qos_manager:concurrent_task_client", + "safwk:system_ability_fwk", + ] + + defines = [] + if (use_libfuzzer || use_clang_coverage) { + defines += [ "TEST_COVERAGE" ] + } +} + +group("fuzztest") { + testonly = true + deps = [ ":AudioServerSupFuzzTest" ] +} diff --git a/test/fuzztest/audioserversup_fuzzer/audio_server_sup_fuzzer.cpp b/test/fuzztest/audioserversup_fuzzer/audio_server_sup_fuzzer.cpp new file mode 100644 index 0000000000..38d166b407 --- /dev/null +++ b/test/fuzztest/audioserversup_fuzzer/audio_server_sup_fuzzer.cpp @@ -0,0 +1,518 @@ +/* +* Copyright (c) 2025 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include + +#include "audio_log.h" +#include "audio_server.h" +#include "audio_policy_manager_listener_stub_impl.h" +#include "../fuzz_utils.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); + +const int32_t SYSTEM_ABILITY_ID = 3001; +const int32_t MEDIA_SERVICE_UID = 1013; +const bool RUN_ON_CREATE = false; +const std::string PCM_DUMP_KEY = "PCM_DUMP"; + +typedef void (*TestFuncs)(); + +void AudioServerSetReleaseFlagFuzzTest() +{ + bool flag = g_fuzzUtils.GetData(); + uint32_t sessionId = g_fuzzUtils.GetData(); + std::shared_ptr pipeinfoGuard = std::make_shared(sessionId); + if (pipeinfoGuard == nullptr) { + return; + } + pipeinfoGuard->SetReleaseFlag(flag); +} + +void RemoveRendererDataTransferCallbackFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + auto callback = make_shared(); + if (callback == nullptr) { + return; + } + audioServer->audioDataTransferCbMap_[pid] = callback; + audioServer->RemoveRendererDataTransferCallback(pid); +} + +void RegisterDataTransferCallbackFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + sptr listener = new (std::nothrow) AudioPolicyManagerListenerStubImpl(); + if (listener == nullptr) { + return; + } + sptr object = listener->AsObject(); + if (object == nullptr) { + AUDIO_INFO_LOG("AudioServer:set listener object is nullptr"); + return; + } + audioServer->RegisterDataTransferCallback(object); +} + +void UnregisterDataTransferMonitorParamFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + int32_t callbackId = g_fuzzUtils.GetData(); + audioServer->UnregisterDataTransferMonitorParam(callbackId); +} + +void OnDataTransferStateChangeFuzzTest() +{ + std::shared_ptr callback = + std::make_shared(); + if (callback == nullptr) { + return; + } + int32_t callbackId = g_fuzzUtils.GetData(); + AudioRendererDataTransferStateChangeInfo info; + callback->OnDataTransferStateChange(callbackId, info); +} + +void GetPcmDumpParameterFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + std::vector subKeys; + std::string subKey = "test"; + subKeys.push_back(subKey); + std::vector> result; + std::pair pair; + pair.first = "test"; + pair.second = "test"; + result.push_back(pair); + audioServer->GetPcmDumpParameter(subKeys, result); +} + +void InnerCheckCaptureLimitFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + #ifdef HAS_FEATURE_INNERCAPTURER + AudioPlaybackCaptureConfig config; + int32_t innerCapId = g_fuzzUtils.GetData(); + audioServer->InnerCheckCaptureLimit(config, innerCapId); + #endif +} + +void SetParameterCallbackFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + sptr listener = new (std::nothrow) AudioPolicyManagerListenerStubImpl(); + if (listener == nullptr) { + return; + } + sptr object = listener->AsObject(); + if (object == nullptr) { + AUDIO_INFO_LOG("AudioServer:set listener object is nullptr"); + return; + } + audioServer->SetParameterCallback(object); +} + +void SetWakeupSourceCallbackFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + sptr listener = new (std::nothrow) AudioPolicyManagerListenerStubImpl(); + if (listener == nullptr) { + return; + } + sptr object = listener->AsObject(); + if (object == nullptr) { + AUDIO_INFO_LOG("AudioServer:set listener object is nullptr"); + return; + } + audioServer->SetWakeupSourceCallback(object); +} + +void CheckInnerRecorderPermissionFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + AudioProcessConfig config; + config.capturerInfo.sourceType = SOURCE_TYPE_REMOTE_CAST; + audioServer->CheckInnerRecorderPermission(config); + config.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE; + config.innerCapMode = MODERN_INNER_CAP; + audioServer->CheckInnerRecorderPermission(config); +} + +void SetForegroundListFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + std::string foreground = "test"; + std::vector list; + list.push_back(foreground); + audioServer->SetForegroundList(list); +} + +void SendInterruptEventToAudioServerFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioServer->SendInterruptEventToAudioServer(sessionId, interruptEvent); +} + +void CheckVoiceCallRecorderPermissionFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + Security::AccessToken::AccessTokenID tokenId = Security::AccessToken::INVALID_TOKENID; + audioServer->CheckVoiceCallRecorderPermission(tokenId); +} + +void NotifyStreamVolumeChangedFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + int32_t streamType = g_fuzzUtils.GetData(); + float volume = g_fuzzUtils.GetData(); + audioServer->NotifyStreamVolumeChanged(streamType, volume); +} + +void ResetRouteForDisconnectFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + int32_t type = g_fuzzUtils.GetData(); + audioServer->ResetRouteForDisconnect(type); +} + +void GetMaxAmplitudeFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + bool isOutputDevice = g_fuzzUtils.GetData(); + std::string deviceClass = "test"; + int32_t sourceType = g_fuzzUtils.GetData(); + float maxAmplitude = g_fuzzUtils.GetData(); + audioServer->GetMaxAmplitude(isOutputDevice, deviceClass, sourceType, maxAmplitude); +} + +void ResetAudioEndpointFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + audioServer->ResetAudioEndpoint(); +} + +void ReportEventFuzzTest() +{ + std::shared_ptr callback = + std::make_shared(); + if (callback == nullptr) { + return; + } + int32_t callbackId = g_fuzzUtils.GetData(); + AudioRendererDataTransferStateChangeInfo info; + info.stateChangeType = DATA_TRANS_STOP; + callback->OnDataTransferStateChange(callbackId, info); +} + +void GetOfflineAudioEffectChainsFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + std::string effectChain = "test"; + std::vector effectChains; + effectChains.push_back(effectChain); + audioServer->GetOfflineAudioEffectChains(effectChains); +} + +void GetAllSinkInputsFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + std::vector sinkInputs = {}; + audioServer->GetAllSinkInputs(sinkInputs); +} + +void DestroyHdiPortFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + uint32_t id = g_fuzzUtils.GetData(); + audioServer->DestroyHdiPort(id); +} + +void SetBtHdiInvalidStateFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + audioServer->SetBtHdiInvalidState(); +} + +void ForceStopAudioStreamFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + vector stopTypes = { + STOP_ALL, + STOP_RENDER, + STOP_RECORD + }; + int32_t audioType = stopTypes[g_fuzzUtils.GetData() % stopTypes.size()]; + audioServer->ForceStopAudioStream(audioType); +} + +void GetExtraParametersInnerFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + std::string mainKey = PCM_DUMP_KEY; + audioServer->isAudioParameterParsed_ = g_fuzzUtils.GetData(); + std::vector subKeys = {"key1", "key2"}; + std::vector> result; + audioServer->audioParameterKeys = { + { + PCM_DUMP_KEY, { + {"Key1", {"Value1", "Value2"}} + } + } + }; + audioServer->GetExtraParametersInner(mainKey, subKeys, result); +} + +void GetAudioParameterInnerFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + std::string networkId = LOCAL_NETWORK_ID; + vector keys = { + NONE, + VOLUME, + INTERRUPT, + PARAM_KEY_STATE, + A2DP_SUSPEND_STATE, + BT_HEADSET_NREC, + BT_WBS, + A2DP_OFFLOAD_STATE, + GET_DP_DEVICE_INFO, + GET_PENCIL_INFO, + GET_UWB_INFO, + USB_DEVICE, + PERF_INFO, + MMI, + PARAM_KEY_LOWPOWER, + }; + AudioParamKey key = keys[g_fuzzUtils.GetData() % keys.size()]; + std::string condition = ""; + audioServer->GetAudioParameterInner(networkId, key, condition); +} + +void SetAudioMonoStateFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + bool audioMono = g_fuzzUtils.GetData(); + audioServer->SetAudioMonoState(audioMono); +} + +void SetAudioBalanceValueFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + float rawBalance = g_fuzzUtils.GetData(); + float audioBalance = std::clamp(rawBalance, -1.0f, 1.0f); + audioServer->SetAudioBalanceValue(audioBalance); +} + +void ResetRecordConfigFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + AudioProcessConfig config; + config.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE; + config.callerUid = g_fuzzUtils.GetData(); + audioServer->ResetRecordConfig(config); + config.callerUid = MEDIA_SERVICE_UID; + audioServer->ResetRecordConfig(config); +} + +void CheckRendererFormatFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + AudioProcessConfig config; + config.rendererInfo.streamUsage = static_cast(STREAM_USAGE_MAX + 1); + audioServer->CheckRendererFormat(config); +} + +void CheckStreamInfoFormatFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + AudioProcessConfig config; + config.streamInfo.samplingRate = g_fuzzUtils.GetData(); + config.streamInfo.format = static_cast(SAMPLE_F32LE + 1); + audioServer->CheckStreamInfoFormat(config); + config.streamInfo.format = g_fuzzUtils.GetData(); + config.streamInfo.encoding = static_cast(ENCODING_EAC3 + 1); + audioServer->CheckStreamInfoFormat(config); + config.streamInfo.encoding = g_fuzzUtils.GetData(); + config.streamInfo.channelLayout = static_cast(CH_LAYOUT_HOA_ORDER3_FUMA + 1); + audioServer->CheckStreamInfoFormat(config); + config.streamInfo.channelLayout = g_fuzzUtils.GetData(); + config.audioMode = AUDIO_MODE_PLAYBACK; + config.streamInfo.channels = static_cast(CHANNEL_16 + 1); + audioServer->CheckStreamInfoFormat(config); + config.audioMode = AUDIO_MODE_RECORD; + config.streamInfo.channels = static_cast(CHANNEL_6 + 1); + audioServer->CheckStreamInfoFormat(config); + config.streamInfo.channels = g_fuzzUtils.GetData(); + audioServer->CheckStreamInfoFormat(config); +} + +void CheckRecorderFormatFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + AudioProcessConfig config; + config.capturerInfo.sourceType = static_cast(SOURCE_TYPE_LIVE + 1); + audioServer->CheckRecorderFormat(config); + config.capturerInfo.capturerFlags = AUDIO_FLAG_MMAP; + audioServer->CheckRecorderFormat(config); +} + +void CheckConfigFormatFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + AudioProcessConfig config; + config.audioMode = g_fuzzUtils.GetData(); + audioServer->CheckConfigFormat(config); + config.audioMode = static_cast(AUDIO_MODE_RECORD + 1); + audioServer->CheckConfigFormat(config); +} + +vector g_testFuncs = { + AudioServerSetReleaseFlagFuzzTest, + RemoveRendererDataTransferCallbackFuzzTest, + RegisterDataTransferCallbackFuzzTest, + UnregisterDataTransferMonitorParamFuzzTest, + OnDataTransferStateChangeFuzzTest, + GetPcmDumpParameterFuzzTest, + InnerCheckCaptureLimitFuzzTest, + SetParameterCallbackFuzzTest, + SetWakeupSourceCallbackFuzzTest, + CheckInnerRecorderPermissionFuzzTest, + SetForegroundListFuzzTest, + SendInterruptEventToAudioServerFuzzTest, + CheckVoiceCallRecorderPermissionFuzzTest, + NotifyStreamVolumeChangedFuzzTest, + ResetRouteForDisconnectFuzzTest, + GetMaxAmplitudeFuzzTest, + ResetAudioEndpointFuzzTest, + ReportEventFuzzTest, + GetOfflineAudioEffectChainsFuzzTest, + GetAllSinkInputsFuzzTest, + DestroyHdiPortFuzzTest, + SetBtHdiInvalidStateFuzzTest, + ForceStopAudioStreamFuzzTest, + GetExtraParametersInnerFuzzTest, + GetAudioParameterInnerFuzzTest, + SetAudioMonoStateFuzzTest, + SetAudioBalanceValueFuzzTest, + ResetRecordConfigFuzzTest, + CheckRendererFormatFuzzTest, + CheckStreamInfoFormatFuzzTest, + CheckRecorderFormatFuzzTest, + CheckConfigFormatFuzzTest, +}; + +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} diff --git a/test/fuzztest/audioserversup_fuzzer/project.xml b/test/fuzztest/audioserversup_fuzzer/project.xml new file mode 100644 index 0000000000..66e1dcac47 --- /dev/null +++ b/test/fuzztest/audioserversup_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/audioservicesup_fuzzer/BUILD.gn b/test/fuzztest/audioservicesup_fuzzer/BUILD.gn new file mode 100644 index 0000000000..2b3adc5bf4 --- /dev/null +++ b/test/fuzztest/audioservicesup_fuzzer/BUILD.gn @@ -0,0 +1,59 @@ +# Copyright (c) 2025 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../config.gni") + +ohos_fuzztest("AudioServiceSupFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../audioservicesup_fuzzer" + + include_dirs = [ "../../../services/audio_service/server/include" ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + sources = [ "audio_service_sup_fuzzer.cpp" ] + + configs = [ "../../../services/audio_service:audio_service_config" ] + cflags_cc = [ "-std=c++20" ] + + deps = [ + "../../../services/audio_service/idl:audio_framework_interface", + "../../../services/audio_service:audio_process_service_static", + ] + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "ipc:ipc_single", + ] + + defines = [] + if (audio_framework_feature_inner_capturer) { + defines += [ "HAS_FEATURE_INNERCAPTURER" ] + } + if (audio_framework_feature_low_latency) { + defines += [ "SUPPORT_LOW_LATENCY" ] + } +} + +group("fuzztest") { + testonly = true + deps = [ ":AudioServiceSupFuzzTest" ] +} diff --git a/test/fuzztest/audioservicesup_fuzzer/audio_service_sup_fuzzer.cpp b/test/fuzztest/audioservicesup_fuzzer/audio_service_sup_fuzzer.cpp new file mode 100644 index 0000000000..fa42658a9d --- /dev/null +++ b/test/fuzztest/audioservicesup_fuzzer/audio_service_sup_fuzzer.cpp @@ -0,0 +1,143 @@ +/* +* Copyright (c) 2025 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include + +#include "audio_log.h" +#include "audio_service.h" +#include "../fuzz_utils.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); + +typedef void (*TestFuncs)(); + +void DisableLoopbackFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + audioService->DisableLoopback(); +} + +void SendInterruptEventToAudioServiceFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->SendInterruptEventToAudioService(sessionId, interruptEvent); +} + +void UpdateResumeInterruptEventMapFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->resumeInterruptEventMap_[sessionId] = interruptEvent; + interruptEvent.hintType = INTERRUPT_HINT_RESUME; + audioService->SendInterruptEventToAudioService(sessionId, interruptEvent); +} + +void UpdatePauseInterruptEventMapFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->pauseInterruptEventMap_[sessionId] = interruptEvent; + interruptEvent.hintType = INTERRUPT_HINT_PAUSE; + audioService->SendInterruptEventToAudioService(sessionId, interruptEvent); +} + +void RemoveResumeInterruptEventMapFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->resumeInterruptEventMap_[sessionId] = interruptEvent; + audioService->RemoveResumeInterruptEventMap(sessionId); +} + +void IsStreamInterruptResumeFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->resumeInterruptEventMap_[sessionId] = interruptEvent; + audioService->IsStreamInterruptResume(sessionId); +} + +void RemovePauseInterruptEventMapFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->pauseInterruptEventMap_[sessionId] = interruptEvent; + audioService->RemovePauseInterruptEventMap(sessionId); +} + +void IsStreamInterruptPauseFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->pauseInterruptEventMap_[sessionId] = interruptEvent; + audioService->IsStreamInterruptPause(sessionId); +} + +vector g_testFuncs = { + DisableLoopbackFuzzTest, + SendInterruptEventToAudioServiceFuzzTest, + UpdateResumeInterruptEventMapFuzzTest, + UpdatePauseInterruptEventMapFuzzTest, + RemoveResumeInterruptEventMapFuzzTest, + IsStreamInterruptResumeFuzzTest, + RemovePauseInterruptEventMapFuzzTest, + IsStreamInterruptPauseFuzzTest, +}; + +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} diff --git a/test/fuzztest/audioservicesup_fuzzer/project.xml b/test/fuzztest/audioservicesup_fuzzer/project.xml new file mode 100644 index 0000000000..66e1dcac47 --- /dev/null +++ b/test/fuzztest/audioservicesup_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + -- Gitee