From 7fa1516e3066f17c43626eb1e5efee41ad4869db Mon Sep 17 00:00:00 2001 From: zhangwenting Date: Fri, 22 Aug 2025 18:10:54 +0800 Subject: [PATCH] Add audio framework fuzz test Signed-off-by: zhangwenting Change-Id: I50679d13fde5ef44acc116f6d8ceffcd5c53dded --- .../audioadaptermanager_fuzzer/BUILD.gn | 19 + .../audio_adapter_manager_fuzzer.cpp | 1293 +++++++++-------- .../volume_data_maintainer_fuzzer.cpp | 425 +++--- 3 files changed, 876 insertions(+), 861 deletions(-) diff --git a/test/fuzztest/audioadaptermanager_fuzzer/BUILD.gn b/test/fuzztest/audioadaptermanager_fuzzer/BUILD.gn index d8a59aca57..a96d9f1ef8 100644 --- a/test/fuzztest/audioadaptermanager_fuzzer/BUILD.gn +++ b/test/fuzztest/audioadaptermanager_fuzzer/BUILD.gn @@ -14,6 +14,7 @@ import("//build/config/features.gni") import("//build/test.gni") import("../../../config.gni") +import("../../../bluetooth_part.gni") ohos_fuzztest("AudioAdapterManagerFuzzTest") { module_out_path = "audio_framework/audio_framework_route" @@ -41,14 +42,32 @@ ohos_fuzztest("AudioAdapterManagerFuzzTest") { "../../../services/audio_policy:audio_policy_service_static", ] external_deps = [ + "ability_runtime:wantagent_innerkits", + "access_token:libaccesstoken_sdk", + "background_task_mgr:bgtaskmgr_innerkits", + "bundle_framework:appexecfwk_core", "c_utils:utils", + "common_event_service:cesfwk_innerkits", "data_share:datashare_consumer", "eventhandler:libeventhandler", + "hdf_core:libhdf_ipc_adapter", + "hdf_core:libhdi", + "hdf_core:libpub_utils", "hilog:libhilog", "kv_store:distributeddata_inner", + "media_foundation:media_monitor_client", "os_account:os_account_innerkits", + "power_manager:power_setting", + "power_manager:powermgr_client", + "samgr:samgr_proxy", + "safwk:system_ability_fwk", ] + if (bluetooth_part_enable == true) { + deps += [ "../../../frameworks/native/bluetoothclient:audio_bluetooth_client" ] + external_deps += [ "bluetooth:btframework" ] + } + defines = [] } diff --git a/test/fuzztest/audioadaptermanager_fuzzer/audio_adapter_manager_fuzzer.cpp b/test/fuzztest/audioadaptermanager_fuzzer/audio_adapter_manager_fuzzer.cpp index 488f2e5d38..b47e67c794 100644 --- a/test/fuzztest/audioadaptermanager_fuzzer/audio_adapter_manager_fuzzer.cpp +++ b/test/fuzztest/audioadaptermanager_fuzzer/audio_adapter_manager_fuzzer.cpp @@ -13,284 +13,191 @@ * limitations under the License. */ +#include "audio_log.h" #include "audio_adapter_manager.h" #include "audio_server_proxy.h" +#include "audio_zone_service.h" +#include "../fuzz_utils.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, -}; - -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, -}; - -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, -}; - -template -uint32_t GetArrLength(T& arr) -{ - if (arr == nullptr) { - AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__); - return 0; - } - return sizeof(arr) / sizeof(arr[0]); -} +static shared_ptr audioAdapterManager_ = make_shared(); +static bool g_isInit = false; +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +const int32_t DEFAULT_TEST_VOLUME_LEVEL = 10; +typedef void (*TestPtr)(); -void AudioVolumeManagerIsAppVolumeMuteFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerIsAppVolumeMuteFuzzTest() { - 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); + int32_t appUid = g_fuzzUtils.GetData(); + bool owned = g_fuzzUtils.GetData(); + bool isMute = g_fuzzUtils.GetData(); AudioAdapterManager::GetInstance().IsAppVolumeMute(appUid, owned, isMute); } -void AudioVolumeManagerSaveSpecifiedDeviceVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerSaveSpecifiedDeviceVolumeFuzzTest() { - 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); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + audioAdapterManager_->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + int32_t volumeLevel = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); audioAdapterManager_->SaveSpecifiedDeviceVolume(streamType, volumeLevel, deviceType); } -void AudioVolumeManagerHandleStreamMuteStatusFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerHandleStreamMuteStatusFuzzTest() { - 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()]; + 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 AudioAdapterManagerSetOffloadVolumeFuzzTest() { - 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()]; + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + 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 AudioAdapterManagerSetOffloadSessionIdFuzzTest() { - 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) -{ - audioAdapterManager_->Init(); - audioAdapterManager_->ConnectServiceAdapter(); - audioAdapterManager_->InitKVStore(); -} - -void AudioVolumeManagerHandleKvDataFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerHandleKvDataFuzzTest() { - static uint32_t step = 0; - 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); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + 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 AudioAdapterManagerReInitKVStoreFuzzTest() { - audioAdapterManager_->Init(); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } audioAdapterManager_->ReInitKVStore(); } -void AudioVolumeManagerSaveRingtoneVolumeToLocalFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerSaveRingtoneVolumeToLocalFuzzTest() { - 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()]; + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + int32_t volumeLevel = 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 AudioAdapterManagerUpdateSafeVolumeByS4FuzzTest() { - audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - audioAdapterManager_->currentActiveDevice_.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + audioAdapterManager_->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); audioAdapterManager_->UpdateSafeVolumeByS4(); } -void AudioVolumeManagerSetAppVolumeMutedFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerSetAppVolumeMutedFuzzTest() { - audioAdapterManager_->Init(); - int32_t randIntValue = static_cast(size); - bool muted = static_cast(static_cast(size) % NUM_2); - audioAdapterManager_->SetAppVolumeLevel(randIntValue, randIntValue / NUM_2); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + int32_t randIntValue = g_fuzzUtils.GetData(); + bool muted = g_fuzzUtils.GetData(); + int32_t appUid = g_fuzzUtils.GetData(); + audioAdapterManager_->SetAppVolumeLevel(appUid, randIntValue); audioAdapterManager_->SetAppVolumeMuted(randIntValue, muted); } -void AudioVolumeManagerSetSystemVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerSetSystemVolumeLevelFuzzTest() { - vector testNetworkIds = { + static const 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 = DEFAULT_TEST_VOLUME_LEVEL; auto audioAdapterManager = std::make_shared(); audioAdapterManager->SetActiveDeviceDescriptor(deviceDescriptor); audioAdapterManager->SetSystemVolumeLevel(STREAM_MUSIC, testVolumeLevel); } -void AudioVolumeManagerSetDoubleRingVolumeDbFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerSetDoubleRingVolumeDbFuzzTest() { - 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); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + 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 AudioAdapterManagerSetInnerStreamMuteFuzzTest() { - 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); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + 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 AudioAdapterManagerSetStreamMuteFuzzTest() { - 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); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + 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 AudioAdapterManagerSetSinkMuteFuzzTest() { - audioAdapterManager_->Init(); - static uint32_t step = 0; - step += static_cast(size); - vector sinkNames = { + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + static const vector sinkNames = { "Speaker", "Offload_Speaker", "Bt_Speaker", @@ -301,99 +208,83 @@ 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 AudioAdapterManagerSelectDeviceFuzzTest() { - 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()]; + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + 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 AudioAdapterManagerSetDeviceActiveFuzzTest() { - 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()]; + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + 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 AudioAdapterManagerAdjustBluetoothVoiceAssistantVolumeFuzzTest() { - 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); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + InternalDeviceType deviceType = g_fuzzUtils.GetData(); + bool isA2dpSwitchToSco = g_fuzzUtils.GetData(); audioAdapterManager_->AdjustBluetoothVoiceAssistantVolume(deviceType, isA2dpSwitchToSco); } -void AudioVolumeManagerSetVolumeForSwitchDeviceFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerSetVolumeForSwitchDeviceFuzzTest() { - vector testNetworkIds = { + static const 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(); audioAdapterManager->SetVolumeForSwitchDevice(deviceDescriptor); } -void AudioVolumeManagerSaveRingerModeInfoFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerSaveRingerModeInfoFuzzTest() { - 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(); audioAdapterManager->SaveRingerModeInfo(ringMode, "test", "invocationTimeTest"); } -void AudioVolumeManagerGetSinkIdInfoAndIdTypeFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerGetSinkIdInfoAndIdTypeFuzzTest() { - vector testAdapterNames = { + static const vector testAdapterNames = { "primary", "a2dp", "testAdapter", }; - 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->adapterName_ = testAdapterNames[index % testAdapterNames.size()]; - pipeInfo->routeFlag_ = static_cast(size); + pipeInfo->routeFlag_ = g_fuzzUtils.GetData(); std::string idInfo; HdiIdType idType; @@ -401,17 +292,12 @@ void AudioVolumeManagerGetSinkIdInfoAndIdTypeFuzzTest(const uint8_t *rawData, si audioAdapterManager->GetSinkIdInfoAndIdType(pipeInfo, idInfo, idType); } -void AudioVolumeManagerOpenNotPaAudioPortFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerOpenNotPaAudioPortFuzzTest() { - 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(); @@ -419,64 +305,72 @@ void AudioVolumeManagerOpenNotPaAudioPortFuzzTest(const uint8_t *rawData, size_t audioAdapterManager->OpenNotPaAudioPort(pipeInfo, paIndex); } -void AudioVolumeManagerSetAudioVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerSetAudioVolumeFuzzTest() { - audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - float volumeDb = static_cast(size); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + AudioStreamType streamType = g_fuzzUtils.GetData(); + float volumeDb = g_fuzzUtils.GetData(); + std::shared_ptr device = std::make_shared(); + CHECK_AND_RETURN(device != nullptr); + device->deviceType_ = g_fuzzUtils.GetData(); + device->networkId_ = "testNetworkId"; + audioAdapterManager_->volumeDataExtMaintainer_.clear(); + audioAdapterManager_->volumeDataExtMaintainer_.insert({device->GetKey(), std::make_shared()}); audioAdapterManager_->SetAudioVolume(streamType, volumeDb); + audioAdapterManager_->SetAudioVolume(device, streamType, volumeDb); } -void AudioVolumeManagerNotifyAccountsChangedFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerNotifyAccountsChangedFuzzTest() { - 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 AudioAdapterManagerDoRestoreDataFuzzTest() { - auto audioAdapterManager = std::make_shared(); - audioAdapterManager->DoRestoreData(); - audioAdapterManager->GetSafeVolumeLevel(); - audioAdapterManager->GetSafeVolumeTimeout(); + AudioAdapterManager::GetInstance().DoRestoreData(); + AudioAdapterManager::GetInstance().GetSafeVolumeLevel(); + AudioAdapterManager::GetInstance().GetSafeVolumeTimeout(); } -void AudioVolumeManagerSetFirstBootFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerSetFirstBootFuzzTest() { - 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 AudioAdapterManagerSafeVolumeDumpFuzzTest() { std::string dumpString = "test"; - auto audioAdapterManager = std::make_shared(); - audioAdapterManager->isSafeBoot_ = static_cast(static_cast(size) % NUM_2); - audioAdapterManager->SafeVolumeDump(dumpString); + AudioAdapterManager::GetInstance().SafeVolumeDump(dumpString); } -void AudioVolumeManagerSetVgsVolumeSupportedFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerSetVgsVolumeSupportedFuzzTest() { - uint32_t index = static_cast(size); - bool isVgsSupported = static_cast(static_cast(size) % NUM_2); + 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 AudioAdapterManagerUpdateVolumeForLowLatencyFuzzTest() { - uint32_t index = static_cast(size); 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 AudioAdapterManagerUpdateSinkArgsFuzzTest() { AudioModuleInfo info; info.name = "hello"; @@ -487,13 +381,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 AudioAdapterManagerGetModuleArgsFuzzTest() { vector testLib = { AudioAdapterManager::HDI_SINK, @@ -515,13 +410,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 AudioAdapterManagerGetHdiSinkIdInfoFuzzTest() { vector testClassName = { "CALSS", @@ -530,18 +426,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 AudioAdapterManagerGetHdiSourceIdInfoFuzzTest() { vector testClassName = { "primary", @@ -551,28 +448,29 @@ 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 AudioAdapterManagerGetVolumeKeyForKvStoreFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + 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 AudioAdapterManagerGetStreamIDByTypeFuzzTest() { vector testStreamTypes = { "music", @@ -586,232 +484,219 @@ 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 AudioAdapterManagerGetDeviceCategoryFuzzTest() { - 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 AudioAdapterManagerDeleteAudioPolicyKvStoreFuzzTest() { - 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 AudioAdapterManagerUpdateSafeVolumeFuzzTest() { - uint32_t index = static_cast(size); 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 AudioAdapterManagerInitVolumeMapFuzzTest() { - 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 AudioAdapterManagerGetDefaultVolumeLevelFuzzTest() { - uint32_t index = static_cast(size); 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 AudioAdapterManagerResetRemoteCastDeviceVolumeFuzzTest() { - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + 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 AudioAdapterManagerInitRingerModeFuzzTest() { - bool isFirstBoot = static_cast(static_cast(size) % NUM_2); + bool isFirstBoot = g_fuzzUtils.GetData(); auto audioAdapterManager = std::make_shared(); - audioAdapterManager->isNeedCopyRingerModeData_ = !isFirstBoot; + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->isNeedCopyRingerModeData_ = g_fuzzUtils.GetData(); audioAdapterManager->ReInitKVStore(); audioAdapterManager->InitRingerMode(isFirstBoot); } -void AudioVolumeManagerHandleDistributedVolumeFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerHandleDistributedVolumeFuzzTest() { - uint32_t index = static_cast(size); 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 AudioAdapterManagerInitMuteStatusMapFuzzTest() { - 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 AudioAdapterManagerCheckAndDealMuteStatusFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + 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 AudioAdapterManagerSetVolumeCallbackAfterCloneFuzzTest() { - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + 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 AudioAdapterManagerCloneMuteStatusMapFuzzTest() { - audioAdapterManager_->Init(); - audioAdapterManager_->ConnectServiceAdapter(); - audioAdapterManager_->audioServerProxy_ = AudioServerProxy::GetInstance().GetAudioServerProxy(); - 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()]; - uint32_t paIndex = 0; - audioAdapterManager_->OpenPaAudioPort(pipeInfo, paIndex, "test"); -} - -void AudioVolumeManagerCloneMuteStatusMapFuzzTest(const uint8_t *rawData, size_t size) -{ - uint32_t index = static_cast(size); 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 AudioAdapterManagerLoadMuteStatusMapFuzzTest() { - uint32_t index = static_cast(size); 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 AudioAdapterManagerInitSafeStatusFuzzTest() { - 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 AudioAdapterManagerInitSafeTimeFuzzTest() { - 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 AudioAdapterManagerConvertSafeTimeFuzzTest() { 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 AudioAdapterManagerGetCurrentDeviceSafeStatusFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + 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 AudioAdapterManagerGetCurentDeviceSafeTimeFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + 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 AudioAdapterManagerGetRestoreVolumeLevelFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + 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 AudioAdapterManagerSetDeviceSafeStatusFuzzTest() { - 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 AudioAdapterManagerSetDeviceSafeTimeFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - int64_t time = static_cast(size); + 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 AudioAdapterManagerSetRestoreVolumeLevelFuzzTest() { - 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 AudioAdapterManagerGetMuteKeyForKvStoreFuzzTest() { - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + 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 AudioAdapterManagerSetSystemSoundUriFuzzTest() { static const std::vector testSystemSoundKey = { "ringtone_for_sim_card_0", @@ -820,13 +705,15 @@ 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->systemSoundUriMap_.insert({key, uri}); audioAdapterManager->SetSystemSoundUri(key, uri); } -void AudioVolumeManagerGetSystemSoundUriFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerGetSystemSoundUriFuzzTest() { static const std::vector testSystemSoundKey = { "ringtone_for_sim_card_0", @@ -835,344 +722,472 @@ 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->systemSoundUriMap_.insert({key, "testUri"}); audioAdapterManager->GetSystemSoundUri(key); } -void AudioVolumeManagerGetSystemVolumeInDbFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerGetSystemVolumeInDbFuzzTest() { - 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); + audioAdapterManager->useNonlinearAlgo_ = g_fuzzUtils.GetData(); audioAdapterManager->GetSystemVolumeInDb(volumeType, volumeLevel, deviceType); } -void AudioVolumeManagerGetPositionInVolumePointsFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerGetPositionInVolumePointsFuzzTest() { - 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; + 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); + int32_t idx = 0; auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); audioAdapterManager->GetPositionInVolumePoints(volumePoints, idx); } -void AudioVolumeManagerInitVolumeMapIndexFuzzTest(const uint8_t *rawData, size_t size) +void AudioAdapterManagerInitVolumeMapIndexFuzzTest() { - 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 AudioAdapterManagerUpdateVolumeMapIndexFuzzTest() { - static const vector testDeviceVolumeTypes = { - EARPIECE_VOLUME_TYPE, - SPEAKER_VOLUME_TYPE, - HEADSET_VOLUME_TYPE, - }; - uint32_t index = static_cast(size); 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(); + 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 AudioAdapterManagerSetAbsVolumeSceneFuzzTest() { - uint32_t index = static_cast(size); - bool isAbsVolumeScene = static_cast(static_cast(size) % NUM_2); + 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 AudioAdapterManagerSetAbsVolumeMuteFuzzTest() { - uint32_t index = static_cast(size); - bool mute = static_cast(static_cast(size) % NUM_2); + 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 AudioAdapterManagerSetAppVolumeLevelFuzzTest() { - 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); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + audioAdapterManager_->currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData(); + int32_t appUid = g_fuzzUtils.GetData(); + int32_t randIntValue = g_fuzzUtils.GetData(); + audioAdapterManager_->SetAppVolumeLevel(appUid, randIntValue); } - -void AudioVolumeManagerSetAdjustVolumeForZoneFuzzTest(const uint8_t *rawData, size_t size) + +void AudioAdapterManagerSetAdjustVolumeForZoneFuzzTest() { - audioAdapterManager_->Init(); - int32_t zoneId = static_cast(size); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + int32_t zoneId = g_fuzzUtils.GetData(); + std::vector> devices; + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE); + CHECK_AND_RETURN(desc != nullptr); + desc->networkId_ = "LocalDevice"; + devices.push_back(desc); + AudioZoneService::GetInstance().BindDeviceToAudioZone(zoneId, devices); + AudioConnectedDevice::GetInstance().AddConnectedDevice(desc); + AudioZoneService::GetInstance().UpdateDeviceFromGlobalForAllZone(desc); + audioAdapterManager_->volumeDataExtMaintainer_.clear(); + audioAdapterManager_->volumeDataExtMaintainer_.insert({desc->GetKey(), std::make_shared()}); audioAdapterManager_->SetAdjustVolumeForZone(zoneId); } - -void AudioVolumeManagerSetZoneMuteFuzzTest(const uint8_t *rawData, size_t size) + +void AudioAdapterManagerSetZoneMuteFuzzTest() { - 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); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + int32_t zoneId = 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 AudioAdapterManagerGetZoneMuteFuzzTest() { - audioAdapterManager_->Init(); - int32_t zoneId = static_cast(size); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + int32_t zoneId = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); audioAdapterManager_->GetZoneMute(zoneId, streamType); } - -void AudioVolumeManagerGetZoneVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) + +void AudioAdapterManagerGetZoneVolumeLevelFuzzTest() { - audioAdapterManager_->Init(); - int32_t zoneId = static_cast(size); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + int32_t zoneId = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + std::vector> devices; + std::shared_ptr desc = + std::make_shared(DEVICE_TYPE_REMOTE_CAST, OUTPUT_DEVICE); + CHECK_AND_RETURN(desc != nullptr); + desc->networkId_ = "LocalDevice"; + devices.push_back(desc); + AudioZoneService::GetInstance().BindDeviceToAudioZone(zoneId, devices); + AudioConnectedDevice::GetInstance().AddConnectedDevice(desc); + AudioZoneService::GetInstance().UpdateDeviceFromGlobalForAllZone(desc); + audioAdapterManager_->volumeDataExtMaintainer_.clear(); + audioAdapterManager_->volumeDataExtMaintainer_.insert({desc->GetKey(), std::make_shared()}); audioAdapterManager_->GetZoneVolumeLevel(zoneId, streamType); } - -void AudioVolumeManagerSetZoneVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) + +void AudioAdapterManagerSetZoneVolumeLevelFuzzTest() { - 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); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + int32_t zoneId = 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 AudioAdapterManagerGetDeviceVolumeFuzzTest() { - audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + AudioStreamType streamType = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); audioAdapterManager_->GetDeviceVolume(deviceType, streamType); } - -void AudioVolumeManagerHandleRingerModeFuzzTest(const uint8_t *rawData, size_t size) + +void AudioAdapterManagerHandleRingerModeFuzzTest() { - 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->HandleRingerMode(ringMode); } - -void AudioVolumeManagerSetAppVolumeDbFuzzTest(const uint8_t *rawData, size_t size) + +void AudioAdapterManagerSetAppVolumeDbFuzzTest() { - audioAdapterManager_->Init(); - int32_t appUid = static_cast(size); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + int32_t appUid = g_fuzzUtils.GetData(); audioAdapterManager_->SetAppVolumeDb(appUid); } - -void AudioVolumeManagerSetAppVolumeMutedDBFuzzTest(const uint8_t *rawData, size_t size) + +void AudioAdapterManagerSetAppVolumeMutedDBFuzzTest() { - audioAdapterManager_->Init(); - int32_t appUid = static_cast(size); - bool muted = static_cast(static_cast(size) % NUM_2); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + 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 AudioAdapterManagerGetAppVolumeLevelFuzzTest() { - audioAdapterManager_->Init(); - int32_t appUid = static_cast(size); - int32_t volumeLevel = static_cast(size); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + 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 AudioAdapterManagerSetPersistMicMuteStateFuzzTest() { - audioAdapterManager_->Init(); - bool mute = static_cast(static_cast(size) % NUM_2); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + bool mute = g_fuzzUtils.GetData(); audioAdapterManager_->SetPersistMicMuteState(mute); } - -void AudioVolumeManagerSetSourceOutputStreamMuteFuzzTest(const uint8_t *rawData, size_t size) + +void AudioAdapterManagerSetSourceOutputStreamMuteFuzzTest() { - audioAdapterManager_->Init(); - int32_t uid = static_cast(size); - bool setMute = static_cast(static_cast(size) % NUM_2); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + 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 AudioAdapterManagerGetStreamMuteFuzzTest() { - audioAdapterManager_->Init(); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()]; + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + AudioStreamType streamType = g_fuzzUtils.GetData(); + std::shared_ptr device = std::make_shared(); + CHECK_AND_RETURN(device != nullptr); + audioAdapterManager_->volumeDataExtMaintainer_.clear(); + audioAdapterManager_->volumeDataExtMaintainer_.insert({device->GetKey(), std::make_shared()}); audioAdapterManager_->GetStreamMute(streamType); + audioAdapterManager_->GetStreamMute(device, streamType); } - -void AudioVolumeManagerGetAppMuteFuzzTest(const uint8_t *rawData, size_t size) + +void AudioAdapterManagerGetAppMuteFuzzTest() { - audioAdapterManager_->Init(); - int32_t appUid = static_cast(size); + CHECK_AND_RETURN(audioAdapterManager_ != nullptr); + if (!g_isInit) { + g_isInit = audioAdapterManager_->Init(); + } + int32_t appUid = g_fuzzUtils.GetData(); audioAdapterManager_->GetAppMute(appUid); } - -void AudioVolumeManagerSetRingerModeFuzzTest(const uint8_t *rawData, size_t size) + +void AudioAdapterManagerSetRingerModeFuzzTest() { - 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->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, +void AudioAdapterManagerSetDataShareReadyFuzzTest() +{ + auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->SetDataShareReady(std::atomic(g_fuzzUtils.GetData())); +} + +void AudioAdapterManagerSetVolumeDbFuzzTest() +{ + auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); + std::shared_ptr device = std::make_shared(); + CHECK_AND_RETURN(device != nullptr); + audioAdapterManager->volumeDataExtMaintainer_.insert({device->GetKey(), std::make_shared()}); + audioAdapterManager->useNonlinearAlgo_ = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + audioAdapterManager->SetVolumeDb(device, streamType); +} + +void AudioAdapterManagerResetOffloadSessionIdFuzzTest() +{ + auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); + audioAdapterManager->offloadSessionID_ = g_fuzzUtils.GetData(); + audioAdapterManager->ResetOffloadSessionId(); +} + +void AudioAdapterManagerSetStreamMuteInternalFuzzTest() +{ + auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); + std::shared_ptr device = std::make_shared(); + CHECK_AND_RETURN(device != nullptr); + device->deviceType_ = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + bool mute = g_fuzzUtils.GetData(); + StreamUsage streamUsage = g_fuzzUtils.GetData(); + DeviceType deviceType = g_fuzzUtils.GetData(); + audioAdapterManager->handler_ = make_shared(); + audioAdapterManager->volumeDataExtMaintainer_.insert({device->GetKey(), std::make_shared()}); + audioAdapterManager->SetStreamMuteInternal(device, streamType, mute, streamUsage, deviceType); +} + +void AudioAdapterManagerGetStreamVolumeFuzzTest() +{ + auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); + std::shared_ptr device = std::make_shared(); + CHECK_AND_RETURN(device != nullptr); + AudioStreamType streamType = g_fuzzUtils.GetData(); + AudioStreamType streamForVolumeMap = VolumeUtils::GetVolumeTypeFromStreamType(streamType); + shared_ptr volumeDataMaintainer = std::make_shared(); + CHECK_AND_RETURN(volumeDataMaintainer != nullptr); + volumeDataMaintainer->volumeLevelMap_.insert({streamForVolumeMap, g_fuzzUtils.GetData()}); + audioAdapterManager->volumeDataExtMaintainer_.insert({device->GetKey(), volumeDataMaintainer}); + audioAdapterManager->GetStreamVolume(device, streamType); +} + +void AudioAdapterManagerGetStreamMuteInternalFuzzTest() +{ + auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); + std::shared_ptr device = std::make_shared(); + CHECK_AND_RETURN(device != nullptr); + AudioStreamType streamType = g_fuzzUtils.GetData(); + AudioStreamType streamForVolumeMap = VolumeUtils::GetVolumeTypeFromStreamType(streamType); + shared_ptr volumeDataMaintainer = std::make_shared(); + CHECK_AND_RETURN(volumeDataMaintainer != nullptr); + volumeDataMaintainer->volumeLevelMap_.insert({streamForVolumeMap, g_fuzzUtils.GetData()}); + audioAdapterManager->volumeDataExtMaintainer_.insert({device->GetKey(), volumeDataMaintainer}); + audioAdapterManager->GetStreamMuteInternal(device, streamType); +} + +void AudioAdapterManagerGetAllDeviceVolumeInfoFuzzTest() +{ + auto audioAdapterManager = std::make_shared(); + CHECK_AND_RETURN(audioAdapterManager != nullptr); + DeviceType deviceType = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + bool isPCVolumeEnable = g_fuzzUtils.GetData(); + VolumeUtils::SetPCVolumeEnable(isPCVolumeEnable); + audioAdapterManager->GetAllDeviceVolumeInfo(deviceType, streamType); +} + +vector g_testFuncs = { + AudioAdapterManagerIsAppVolumeMuteFuzzTest, + AudioAdapterManagerSaveSpecifiedDeviceVolumeFuzzTest, + AudioAdapterManagerHandleStreamMuteStatusFuzzTest, + AudioAdapterManagerSetOffloadVolumeFuzzTest, + AudioAdapterManagerSetOffloadSessionIdFuzzTest, + AudioAdapterManagerHandleKvDataFuzzTest, + AudioAdapterManagerReInitKVStoreFuzzTest, + AudioAdapterManagerSaveRingtoneVolumeToLocalFuzzTest, + AudioAdapterManagerUpdateSafeVolumeByS4FuzzTest, + AudioAdapterManagerSetAppVolumeMutedFuzzTest, + AudioAdapterManagerSetSystemVolumeLevelFuzzTest, + AudioAdapterManagerSetDoubleRingVolumeDbFuzzTest, + AudioAdapterManagerSetInnerStreamMuteFuzzTest, + AudioAdapterManagerSetStreamMuteFuzzTest, + AudioAdapterManagerSetSinkMuteFuzzTest, + AudioAdapterManagerSelectDeviceFuzzTest, + AudioAdapterManagerSetDeviceActiveFuzzTest, + AudioAdapterManagerAdjustBluetoothVoiceAssistantVolumeFuzzTest, + AudioAdapterManagerSaveRingerModeInfoFuzzTest, + AudioAdapterManagerGetSinkIdInfoAndIdTypeFuzzTest, + AudioAdapterManagerOpenNotPaAudioPortFuzzTest, + AudioAdapterManagerUpdateSinkArgsFuzzTest, + AudioAdapterManagerGetModuleArgsFuzzTest, + AudioAdapterManagerGetHdiSinkIdInfoFuzzTest, + AudioAdapterManagerGetHdiSourceIdInfoFuzzTest, + AudioAdapterManagerGetVolumeKeyForKvStoreFuzzTest, + AudioAdapterManagerGetStreamIDByTypeFuzzTest, + AudioAdapterManagerGetDeviceCategoryFuzzTest, + AudioAdapterManagerDeleteAudioPolicyKvStoreFuzzTest, + AudioAdapterManagerUpdateSafeVolumeFuzzTest, + AudioAdapterManagerInitVolumeMapFuzzTest, + AudioAdapterManagerGetDefaultVolumeLevelFuzzTest, + AudioAdapterManagerResetRemoteCastDeviceVolumeFuzzTest, + AudioAdapterManagerInitRingerModeFuzzTest, + AudioAdapterManagerHandleDistributedVolumeFuzzTest, + AudioAdapterManagerInitMuteStatusMapFuzzTest, + AudioAdapterManagerCheckAndDealMuteStatusFuzzTest, + AudioAdapterManagerSetVolumeCallbackAfterCloneFuzzTest, + AudioAdapterManagerCloneMuteStatusMapFuzzTest, + AudioAdapterManagerLoadMuteStatusMapFuzzTest, + AudioAdapterManagerInitSafeStatusFuzzTest, + AudioAdapterManagerInitSafeTimeFuzzTest, + AudioAdapterManagerConvertSafeTimeFuzzTest, + AudioAdapterManagerGetCurrentDeviceSafeStatusFuzzTest, + AudioAdapterManagerGetCurentDeviceSafeTimeFuzzTest, + AudioAdapterManagerGetRestoreVolumeLevelFuzzTest, + AudioAdapterManagerSetDeviceSafeStatusFuzzTest, + AudioAdapterManagerSetDeviceSafeTimeFuzzTest, + AudioAdapterManagerSetRestoreVolumeLevelFuzzTest, + AudioAdapterManagerGetMuteKeyForKvStoreFuzzTest, + AudioAdapterManagerSetSystemSoundUriFuzzTest, + AudioAdapterManagerGetSystemSoundUriFuzzTest, + AudioAdapterManagerGetSystemVolumeInDbFuzzTest, + AudioAdapterManagerGetPositionInVolumePointsFuzzTest, + AudioAdapterManagerInitVolumeMapIndexFuzzTest, + AudioAdapterManagerUpdateVolumeMapIndexFuzzTest, + AudioAdapterManagerSetAbsVolumeSceneFuzzTest, + AudioAdapterManagerSetAbsVolumeMuteFuzzTest, + AudioAdapterManagerSetAudioVolumeFuzzTest, + AudioAdapterManagerNotifyAccountsChangedFuzzTest, + AudioAdapterManagerDoRestoreDataFuzzTest, + AudioAdapterManagerSetFirstBootFuzzTest, + AudioAdapterManagerSafeVolumeDumpFuzzTest, + AudioAdapterManagerSetVgsVolumeSupportedFuzzTest, + AudioAdapterManagerSetAppVolumeLevelFuzzTest, + AudioAdapterManagerSetAdjustVolumeForZoneFuzzTest, + AudioAdapterManagerSetZoneMuteFuzzTest, + AudioAdapterManagerSetZoneMuteFuzzTest, + AudioAdapterManagerGetZoneMuteFuzzTest, + AudioAdapterManagerGetZoneVolumeLevelFuzzTest, + AudioAdapterManagerSetZoneVolumeLevelFuzzTest, + AudioAdapterManagerGetDeviceVolumeFuzzTest, + AudioAdapterManagerHandleRingerModeFuzzTest, + AudioAdapterManagerSetAppVolumeDbFuzzTest, + AudioAdapterManagerSetAppVolumeMutedDBFuzzTest, + AudioAdapterManagerGetAppVolumeLevelFuzzTest, + AudioAdapterManagerSetPersistMicMuteStateFuzzTest, + AudioAdapterManagerSetSourceOutputStreamMuteFuzzTest, + AudioAdapterManagerGetStreamMuteFuzzTest, + AudioAdapterManagerGetAppMuteFuzzTest, + AudioAdapterManagerSetRingerModeFuzzTest, + AudioAdapterManagerSetDataShareReadyFuzzTest, + AudioAdapterManagerSetVolumeDbFuzzTest, + AudioAdapterManagerResetOffloadSessionIdFuzzTest, + AudioAdapterManagerSetStreamMuteInternalFuzzTest, + AudioAdapterManagerGetStreamVolumeFuzzTest, + AudioAdapterManagerGetStreamMuteInternalFuzzTest, + AudioAdapterManagerGetAllDeviceVolumeInfoFuzzTest, }; +} // 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) { - 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_testFuncs); return 0; } \ No newline at end of file diff --git a/test/fuzztest/volumedatamaintainer_fuzzer/volume_data_maintainer_fuzzer.cpp b/test/fuzztest/volumedatamaintainer_fuzzer/volume_data_maintainer_fuzzer.cpp index df5ae11260..61072c313c 100644 --- a/test/fuzztest/volumedatamaintainer_fuzzer/volume_data_maintainer_fuzzer.cpp +++ b/test/fuzztest/volumedatamaintainer_fuzzer/volume_data_maintainer_fuzzer.cpp @@ -13,172 +13,90 @@ * limitations under the License. */ +#include "audio_info.h" +#include "audio_common_utils.h" #include "volume_data_maintainer.h" +#include "../fuzz_utils.h" using namespace std; namespace OHOS { namespace AudioStandard { -const int32_t NUM_2 = 2; -const int32_t NUM_3 = 3; -typedef void (*TestPtr)(const uint8_t *, size_t); - -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_HEARING_AID, - 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 -}; - -const vector g_testStreamTypes = { - 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, -}; - -template -uint32_t GetArrLength(T& arr) -{ - if (arr == nullptr) { - AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__); - return 0; - } - return sizeof(arr) / sizeof(arr[0]); -} +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); +typedef void (*TestPtr)(); -void VolumeDataMaintainerSaveVolumeFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerSaveVolumeFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType typeRet = g_testDeviceTypes[index]; - index = static_cast(size) % g_testStreamTypes.size(); - AudioStreamType streamTypeRet = g_testStreamTypes[index]; - int32_t volumeLevelRet = static_cast(size); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + DeviceType typeRet = g_fuzzUtils.GetData(); + AudioStreamType streamTypeRet = g_fuzzUtils.GetData(); + int32_t volumeLevelRet = g_fuzzUtils.GetData(); volumeDataMaintainerRet->SaveVolume(typeRet, streamTypeRet, volumeLevelRet); } -void VolumeDataMaintainerGetVolumeFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetVolumeFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceTypeRet = g_testDeviceTypes[index]; - index = static_cast(size) % g_testStreamTypes.size(); - AudioStreamType streamTypeRet = g_testStreamTypes[index]; + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + DeviceType deviceTypeRet = g_fuzzUtils.GetData(); + AudioStreamType streamTypeRet = g_fuzzUtils.GetData(); volumeDataMaintainerRet->GetVolume(deviceTypeRet, streamTypeRet); } -void VolumeDataMaintainerSaveMuteStatusFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerSaveMuteStatusFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceTypeRet = g_testDeviceTypes[index]; - index = static_cast(size) % g_testStreamTypes.size(); - AudioStreamType streamTypeRet = g_testStreamTypes[index]; - bool muteStatusRet = static_cast(static_cast(size) % NUM_2); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + DeviceType deviceTypeRet = g_fuzzUtils.GetData(); + AudioStreamType streamTypeRet = g_fuzzUtils.GetData(); + bool muteStatusRet = g_fuzzUtils.GetData(); volumeDataMaintainerRet->SaveMuteStatus(deviceTypeRet, streamTypeRet, muteStatusRet); } -void VolumeDataMaintainerGetMuteStatusInternalFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetMuteStatusInternalFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceTypeRet = g_testDeviceTypes[index]; - index = static_cast(size) % g_testStreamTypes.size(); - AudioStreamType streamTypeRet = g_testStreamTypes[index]; + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + DeviceType deviceTypeRet = g_fuzzUtils.GetData(); + AudioStreamType streamTypeRet = g_fuzzUtils.GetData(); volumeDataMaintainerRet->GetMuteStatusInternal(deviceTypeRet, streamTypeRet); } -void VolumeDataMaintainerGetMuteTransferStatusFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetMuteTransferStatusFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - int32_t affectedRet; - bool statusRet; + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + int32_t affectedRet = g_fuzzUtils.GetData(); + bool statusRet = g_fuzzUtils.GetData(); volumeDataMaintainerRet->GetMuteAffected(affectedRet); volumeDataMaintainerRet->GetMuteTransferStatus(statusRet); } -void VolumeDataMaintainerGetSafeStatusFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetSafeStatusFuzzTest() { - vector testSafeStatus = { - SAFE_UNKNOWN, - SAFE_INACTIVE, - SAFE_ACTIVE, - }; std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceTypeRet = g_testDeviceTypes[index]; - index = static_cast(size) % testSafeStatus.size(); - SafeStatus safeStatusRet = testSafeStatus[index]; + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + DeviceType deviceTypeRet = g_fuzzUtils.GetData(); + SafeStatus safeStatusRet = g_fuzzUtils.GetData(); volumeDataMaintainerRet->SaveSafeStatus(deviceTypeRet, safeStatusRet); volumeDataMaintainerRet->GetSafeStatus(deviceTypeRet, safeStatusRet); } -void VolumeDataMaintainerGetSafeVolumeTimeFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetSafeVolumeTimeFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceTypeRet = g_testDeviceTypes[index]; - int64_t timeRet = static_cast(size); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + DeviceType deviceTypeRet = g_fuzzUtils.GetData(); + int64_t timeRet = g_fuzzUtils.GetData(); volumeDataMaintainerRet->SaveSafeVolumeTime(deviceTypeRet, timeRet); volumeDataMaintainerRet->GetSafeVolumeTime(deviceTypeRet, timeRet); } -void VolumeDataMaintainerRegisterClonedFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerRegisterClonedFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); std::string keyRet; std::string valueRet; volumeDataMaintainerRet->SaveSystemSoundUrl(keyRet, valueRet); @@ -186,75 +104,71 @@ void VolumeDataMaintainerRegisterClonedFuzzTest(const uint8_t *rawData, size_t s volumeDataMaintainerRet->RegisterCloned(); } -void VolumeDataMaintainerGetMicMuteStateFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetMicMuteStateFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - bool isMuteRet = static_cast(static_cast(size) % NUM_2); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + bool isMuteRet = g_fuzzUtils.GetData(); volumeDataMaintainerRet->SaveMicMuteState(isMuteRet); volumeDataMaintainerRet->GetMicMuteState(isMuteRet); } -void VolumeDataMaintainerGetDeviceTypeNameFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetDeviceTypeNameFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceTypeRet = g_testDeviceTypes[index]; + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + DeviceType deviceTypeRet = g_fuzzUtils.GetData(); volumeDataMaintainerRet->GetDeviceTypeName(deviceTypeRet); } -void VolumeDataMaintainerGetVolumeKeyForDataShareFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetVolumeKeyForDataShareFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceTypeRet = g_testDeviceTypes[index]; - index = static_cast(size) % g_testStreamTypes.size(); - AudioStreamType streamTypeRet = g_testStreamTypes[index]; + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + DeviceType deviceTypeRet = g_fuzzUtils.GetData(); + AudioStreamType streamTypeRet = g_fuzzUtils.GetData(); volumeDataMaintainerRet->GetVolumeKeyForDataShare(deviceTypeRet, streamTypeRet); } -void VolumeDataMaintainerSaveMuteStatusInternalFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerSaveMuteStatusInternalFuzzTest() { std::shared_ptr volumeDataMaintainer = std::make_shared(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceType = g_testDeviceTypes[index]; - index = static_cast(size) % g_testStreamTypes.size(); - AudioStreamType streamType = g_testStreamTypes[index]; - bool muteStatus = static_cast(static_cast(size) % NUM_2); - bool result = volumeDataMaintainer->SaveMuteStatusInternal(deviceType, streamType, muteStatus); + DeviceType deviceType = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); + bool muteStatus = g_fuzzUtils.GetData(); + volumeDataMaintainer->SaveMuteStatusInternal(deviceType, streamType, muteStatus); } -void VolumeDataMaintainerGetAppMuteFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetAppMuteFuzzTest() { std::shared_ptr volumeDataMaintainer = std::make_shared(); - int32_t appUid = static_cast(size); - bool isMute = static_cast(static_cast(size) % NUM_2); + int32_t appUid = g_fuzzUtils.GetData(); + bool isMute = g_fuzzUtils.GetData(); volumeDataMaintainer->appMuteStatusMap_.erase(appUid); volumeDataMaintainer->GetAppMute(appUid, isMute); } -void VolumeDataMaintainerGetAppMuteOwnedFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetAppMuteOwnedFuzzTest() { std::shared_ptr volumeDataMaintainer = std::make_shared(); - int32_t appUid = static_cast(size); - bool isMute = static_cast(static_cast(size) % NUM_2); + int32_t appUid = g_fuzzUtils.GetData(); + bool isMute = g_fuzzUtils.GetData(); int32_t callingUid = IPCSkeleton::GetCallingUid(); - volumeDataMaintainer->appMuteStatusMap_[appUid][callingUid] = !isMute; + volumeDataMaintainer->appMuteStatusMap_[appUid][callingUid] = g_fuzzUtils.GetData(); volumeDataMaintainer->GetAppMuteOwned(appUid, isMute); } -void VolumeDataMaintainerGetDeviceVolumeInternalFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetDeviceVolumeInternalFuzzTest() { std::shared_ptr volumeDataMaintainer = std::make_shared(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceType = g_testDeviceTypes[index]; - index = static_cast(size) % g_testStreamTypes.size(); - AudioStreamType streamType = g_testStreamTypes[index]; + DeviceType deviceType = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); volumeDataMaintainer->GetDeviceVolumeInternal(deviceType, streamType); } -void VolumeDataMaintainerSetMuteAffectedToMuteStatusDataBaseFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerSetMuteAffectedToMuteStatusDataBaseFuzzTest() { std::shared_ptr volumeDataMaintainer = std::make_shared(); std::lock_guard lock(volumeDataMaintainer->volumeMutex_); @@ -262,11 +176,11 @@ void VolumeDataMaintainerSetMuteAffectedToMuteStatusDataBaseFuzzTest(const uint8 volumeDataMaintainer->appVolumeLevelMap_.clear(); volumeDataMaintainer->appMuteStatusMap_.clear(); - int32_t affected = static_cast(size); + int32_t affected = g_fuzzUtils.GetData(); volumeDataMaintainer->SetMuteAffectedToMuteStatusDataBase(affected); } -void VolumeDataMaintainerSetRestoreVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerSetRestoreVolumeLevelFuzzTest() { std::shared_ptr volumeDataMaintainer = std::make_shared(); std::lock_guard lock(volumeDataMaintainer->volumeMutex_); @@ -274,13 +188,12 @@ void VolumeDataMaintainerSetRestoreVolumeLevelFuzzTest(const uint8_t *rawData, s volumeDataMaintainer->appVolumeLevelMap_.clear(); volumeDataMaintainer->appMuteStatusMap_.clear(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceType = g_testDeviceTypes[index]; - int32_t volume = static_cast(size); + DeviceType deviceType = g_fuzzUtils.GetData(); + int32_t volume = g_fuzzUtils.GetData(); volumeDataMaintainer->SetRestoreVolumeLevel(deviceType, volume); } -void VolumeDataMaintainerGetRestoreVolumeLevelFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetRestoreVolumeLevelFuzzTest() { std::shared_ptr volumeDataMaintainer = std::make_shared(); std::lock_guard lock(volumeDataMaintainer->volumeMutex_); @@ -288,114 +201,182 @@ void VolumeDataMaintainerGetRestoreVolumeLevelFuzzTest(const uint8_t *rawData, s volumeDataMaintainer->appVolumeLevelMap_.clear(); volumeDataMaintainer->appMuteStatusMap_.clear(); - uint32_t index = static_cast(size) % g_testDeviceTypes.size(); - DeviceType deviceType = g_testDeviceTypes[index]; - int32_t volume = static_cast(size); + DeviceType deviceType = g_fuzzUtils.GetData(); + int32_t volume = g_fuzzUtils.GetData(); volumeDataMaintainer->GetRestoreVolumeLevel(deviceType, volume); } -void VolumeDataMaintainerGetRingerModeFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetRingerModeFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - int32_t affectedRet = static_cast(size); - bool statusRet = static_cast(static_cast(size) % NUM_2); - uint32_t index = static_cast(size) % NUM_3; - AudioRingerMode ringerModeRet = static_cast(index); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + int32_t affectedRet = g_fuzzUtils.GetData(); + bool statusRet = g_fuzzUtils.GetData(); + AudioRingerMode ringerModeRet = g_fuzzUtils.GetData(); volumeDataMaintainerRet->SetMuteAffectedToMuteStatusDataBase(affectedRet); volumeDataMaintainerRet->SaveMuteTransferStatus(statusRet); volumeDataMaintainerRet->SaveRingerMode(ringerModeRet); volumeDataMaintainerRet->GetRingerMode(ringerModeRet); } -void VolumeDataMaintainerGetDeviceVolumeFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetDeviceVolumeFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - AudioStreamType streamType = g_testStreamTypes[index % g_testStreamTypes.size()]; + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + DeviceType deviceType = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); volumeDataMaintainerRet->GetDeviceVolume(deviceType, streamType); } -void VolumeDataMaintainerSetStreamMuteStatusFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerSetStreamMuteStatusFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testStreamTypes[index % g_testStreamTypes.size()]; - bool muteStatus = static_cast(static_cast(size) % NUM_2); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + AudioStreamType streamType = g_fuzzUtils.GetData(); + bool muteStatus = g_fuzzUtils.GetData(); volumeDataMaintainerRet->SetStreamMuteStatus(streamType, muteStatus); } -void VolumeDataMaintainerGetMuteStatusFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetMuteStatusFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - uint32_t index = static_cast(size); - DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()]; - AudioStreamType streamType = g_testStreamTypes[index % g_testStreamTypes.size()]; + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + DeviceType deviceType = g_fuzzUtils.GetData(); + AudioStreamType streamType = g_fuzzUtils.GetData(); volumeDataMaintainerRet->GetMuteStatus(deviceType, streamType); } -void VolumeDataMaintainerGetStreamMuteFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerGetStreamMuteFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - uint32_t index = static_cast(size); - AudioStreamType streamType = g_testStreamTypes[index % g_testStreamTypes.size()]; + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + AudioStreamType streamType = g_fuzzUtils.GetData(); volumeDataMaintainerRet->GetStreamMute(streamType); } -void VolumeDataMaintainerSetAppVolumeFuzzTest(const uint8_t *rawData, size_t size) +void VolumeDataMaintainerSetAppVolumeFuzzTest() { std::shared_ptr volumeDataMaintainerRet = std::make_shared(); - int32_t appUid = static_cast(size); - int32_t volumeLevel = static_cast(size / NUM_2); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + int32_t appUid = g_fuzzUtils.GetData(); + int32_t volumeLevel = g_fuzzUtils.GetData(); volumeDataMaintainerRet->SetAppVolume(appUid, volumeLevel); } -} // namespace AudioStandard -} // namesapce OHOS +void VolumeDataMaintainerSetDataShareReadyFuzzTest() +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + volumeDataMaintainerRet->SetDataShareReady(std::atomic(g_fuzzUtils.GetData())); +} + +void VolumeDataMaintainerSaveVolumeWithDatabaseVolumeNameFuzzTest() +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + std::string databaseVolumeName = "test_database_volume_name"; + AudioStreamType streamType = g_fuzzUtils.GetData(); + int32_t volumeLevel = g_fuzzUtils.GetData(); + volumeDataMaintainerRet->SaveVolumeWithDatabaseVolumeName(databaseVolumeName, streamType, volumeLevel); +} + +void VolumeDataMaintainerGetVolumeWithDatabaseVolumeNameFuzzTest() +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + std::string databaseVolumeName = "test_database_volume_name"; + AudioStreamType streamType = g_fuzzUtils.GetData(); + volumeDataMaintainerRet->GetVolumeWithDatabaseVolumeName(databaseVolumeName, streamType); +} + +void VolumeDataMaintainerSaveMuteStatusWithDatabaseVolumeNameFuzzTest() +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + std::string databaseVolumeName = "test_database_volume_name"; + AudioStreamType streamType = STREAM_DEFAULT; + bool muteStatus = g_fuzzUtils.GetData(); + VolumeUtils::SetPCVolumeEnable(false); + volumeDataMaintainerRet->SaveMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType, muteStatus); +} + +void VolumeDataMaintainerGetMuteStatusWithDatabaseVolumeNameFuzzTest() +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + std::string databaseVolumeName = "test_database_volume_name"; + AudioStreamType streamType = g_fuzzUtils.GetData(); + volumeDataMaintainerRet->GetMuteStatusWithDatabaseVolumeName(databaseVolumeName, streamType); +} -OHOS::AudioStandard::TestPtr g_testPtrs[] = { - OHOS::AudioStandard::VolumeDataMaintainerSaveVolumeFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetVolumeFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerSaveMuteStatusFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetMuteStatusInternalFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetMuteTransferStatusFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetSafeStatusFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetSafeVolumeTimeFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerRegisterClonedFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetMicMuteStateFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetDeviceTypeNameFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetVolumeKeyForDataShareFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerSaveMuteStatusInternalFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetAppMuteFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetAppMuteOwnedFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetDeviceVolumeInternalFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerSetMuteAffectedToMuteStatusDataBaseFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerSetRestoreVolumeLevelFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetRestoreVolumeLevelFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetRingerModeFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetDeviceVolumeFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerSetStreamMuteStatusFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetMuteStatusFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerGetStreamMuteFuzzTest, - OHOS::AudioStandard::VolumeDataMaintainerSetAppVolumeFuzzTest, +void VolumeDataMaintainerSetAppVolumeMutedFuzzTest() +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + int32_t appUid = g_fuzzUtils.GetData(); + bool muted = g_fuzzUtils.GetData(); + volumeDataMaintainerRet->SetAppVolumeMuted(appUid, muted); +} + +void VolumeDataMaintainerGetVolumeKeyForDatabaseVolumeNameFuzzTest() +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + std::string databaseVolumeName = "test_database_volume_name"; + AudioStreamType streamType = g_fuzzUtils.GetData(); + volumeDataMaintainerRet->GetVolumeKeyForDatabaseVolumeName(databaseVolumeName, streamType); +} + +void VolumeDataMaintainerGetMuteKeyForDatabaseVolumeNameFuzzTest() +{ + std::shared_ptr volumeDataMaintainerRet = std::make_shared(); + CHECK_AND_RETURN(volumeDataMaintainerRet != nullptr); + std::string databaseVolumeName = "test_database_volume_name"; + AudioStreamType streamType = g_fuzzUtils.GetData(); + volumeDataMaintainerRet->GetMuteKeyForDatabaseVolumeName(databaseVolumeName, streamType); +} + +vector g_testFuncs = { + VolumeDataMaintainerSaveVolumeFuzzTest, + VolumeDataMaintainerGetVolumeFuzzTest, + VolumeDataMaintainerSaveMuteStatusFuzzTest, + VolumeDataMaintainerGetMuteStatusInternalFuzzTest, + VolumeDataMaintainerGetMuteTransferStatusFuzzTest, + VolumeDataMaintainerGetSafeStatusFuzzTest, + VolumeDataMaintainerGetSafeVolumeTimeFuzzTest, + VolumeDataMaintainerRegisterClonedFuzzTest, + VolumeDataMaintainerGetMicMuteStateFuzzTest, + VolumeDataMaintainerGetDeviceTypeNameFuzzTest, + VolumeDataMaintainerGetVolumeKeyForDataShareFuzzTest, + VolumeDataMaintainerSaveMuteStatusInternalFuzzTest, + VolumeDataMaintainerGetAppMuteFuzzTest, + VolumeDataMaintainerGetAppMuteOwnedFuzzTest, + VolumeDataMaintainerGetDeviceVolumeInternalFuzzTest, + VolumeDataMaintainerSetMuteAffectedToMuteStatusDataBaseFuzzTest, + VolumeDataMaintainerSetRestoreVolumeLevelFuzzTest, + VolumeDataMaintainerGetRestoreVolumeLevelFuzzTest, + VolumeDataMaintainerGetRingerModeFuzzTest, + VolumeDataMaintainerGetDeviceVolumeFuzzTest, + VolumeDataMaintainerSetStreamMuteStatusFuzzTest, + VolumeDataMaintainerGetMuteStatusFuzzTest, + VolumeDataMaintainerGetStreamMuteFuzzTest, + VolumeDataMaintainerSetAppVolumeFuzzTest, + VolumeDataMaintainerSetDataShareReadyFuzzTest, + VolumeDataMaintainerSaveVolumeWithDatabaseVolumeNameFuzzTest, + VolumeDataMaintainerGetVolumeWithDatabaseVolumeNameFuzzTest, + VolumeDataMaintainerSaveMuteStatusWithDatabaseVolumeNameFuzzTest, + VolumeDataMaintainerGetMuteStatusWithDatabaseVolumeNameFuzzTest, + VolumeDataMaintainerSetAppVolumeMutedFuzzTest, + VolumeDataMaintainerGetVolumeKeyForDatabaseVolumeNameFuzzTest, + VolumeDataMaintainerGetMuteKeyForDatabaseVolumeNameFuzzTest, }; +} // 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) { - 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_testFuncs); return 0; } \ No newline at end of file -- Gitee