diff --git a/test/fuzztest/audioecmanager_fuzzer/audio_ec_manager_fuzzer.cpp b/test/fuzztest/audioecmanager_fuzzer/audio_ec_manager_fuzzer.cpp
index 0aceda9919ae47c41ef0be8b591e9866b6b9219c..e99bcda38d5820f3955bc7ebfcee12e061e834e9 100644
--- a/test/fuzztest/audioecmanager_fuzzer/audio_ec_manager_fuzzer.cpp
+++ b/test/fuzztest/audioecmanager_fuzzer/audio_ec_manager_fuzzer.cpp
@@ -43,56 +43,31 @@
 #include "audio_spatialization_service.h"
 #include "suspend/sync_sleep_callback_ipc_interface_code.h"
 #include "hibernate/sync_hibernate_callback_ipc_interface_code.h"
+#include "../fuzz_utils.h"
 
 namespace OHOS {
 namespace AudioStandard {
 using namespace std;
 
+FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance();
 static const uint8_t* RAW_DATA = nullptr;
 static size_t g_dataSize = 0;
 static size_t g_pos;
 const size_t THRESHOLD = 10;
-const uint8_t TESTSIZE = 3;
 
 typedef void (*TestFuncs)();
 
-template<class T>
-T GetData()
-{
-    T object {};
-    size_t objectSize = sizeof(object);
-    if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
-        return object;
-    }
-    errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
-    if (ret != EOK) {
-        return {};
-    }
-    g_pos += objectSize;
-    return object;
-}
-
-template<class T>
-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]);
-}
-
 void GetEcSamplingRateFuzzTest()
 {
     std::vector<const char*> deviceList = {
         USB_CLASS,
         DP_CLASS,
     };
-    uint32_t deviceListCount = GetData<uint32_t>() % deviceList.size();
+    uint32_t deviceListCount = g_fuzzUtils.GetData<uint32_t>() % deviceList.size();
     string halName = deviceList[deviceListCount];
     std::shared_ptr<PipeStreamPropInfo> outModuleInfo = std::make_shared<PipeStreamPropInfo>();
     AudioEcManager& ecManager(AudioEcManager::GetInstance());
-    outModuleInfo->sampleRate_ = GetData<uint32_t>();
+    outModuleInfo->sampleRate_ = g_fuzzUtils.GetData<uint32_t>();
     ecManager.GetEcSamplingRate(halName, outModuleInfo);
 }
 
@@ -102,13 +77,13 @@ void GetEcChannelsFuzzTest()
         USB_CLASS,
         DP_CLASS,
     };
-    uint32_t deviceListCount = GetData<uint32_t>() % deviceList.size();
+    uint32_t deviceListCount = g_fuzzUtils.GetData<uint32_t>() % deviceList.size();
     string halName = deviceList[deviceListCount];
     std::shared_ptr<PipeStreamPropInfo> outModuleInfo = std::make_shared<PipeStreamPropInfo>();
     AudioEcManager& ecManager(AudioEcManager::GetInstance());
     outModuleInfo->channelLayout_ = CH_LAYOUT_STEREO;
-    std::vector<std::string> insertList = {"", to_string(GetData<uint32_t>())};
-    uint32_t insertListCount = GetData<uint32_t>() % insertList.size();
+    std::vector<std::string> insertList = {"", to_string(g_fuzzUtils.GetData<uint32_t>())};
+    uint32_t insertListCount = g_fuzzUtils.GetData<uint32_t>() % insertList.size();
     ecManager.dpSinkModuleInfo_.channels = insertList[insertListCount];
     ecManager.GetEcChannels(halName, outModuleInfo);
 }
@@ -119,54 +94,280 @@ void GetEcFormatFuzzTest()
         USB_CLASS,
         DP_CLASS,
     };
-    uint32_t deviceListCount = GetData<uint32_t>() % deviceList.size();
+    uint32_t deviceListCount = g_fuzzUtils.GetData<uint32_t>() % deviceList.size();
     string halName = deviceList[deviceListCount];
     std::shared_ptr<PipeStreamPropInfo> outModuleInfo = std::make_shared<PipeStreamPropInfo>();
     AudioEcManager& ecManager(AudioEcManager::GetInstance());
     outModuleInfo->format_ = SAMPLE_S32LE;
-    std::vector<std::string> insertList = {"", to_string(GetData<uint32_t>())};
-    uint32_t insertListCount = GetData<uint32_t>() % insertList.size();
+    std::vector<std::string> insertList = {"", to_string(g_fuzzUtils.GetData<uint32_t>())};
+    uint32_t insertListCount = g_fuzzUtils.GetData<uint32_t>() % insertList.size();
     ecManager.dpSinkModuleInfo_.format = insertList[insertListCount];
     ecManager.GetEcFormat(halName, outModuleInfo);
 }
 
-TestFuncs g_testFuncs[TESTSIZE] = {
-    GetEcSamplingRateFuzzTest,
-    GetEcChannelsFuzzTest,
-    GetEcFormatFuzzTest,
-};
+void CloseNormalSourceFuzzTest()
+{
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.CloseNormalSource();
+}
+
+void UpdateEnhanceEffectStateFuzzTest()
+{
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    SourceType source = g_fuzzUtils.GetData<SourceType>();
+    ecManager.UpdateEnhanceEffectState(source);
+}
+
+void UpdateStreamCommonInfoFuzzTest()
+{
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    int32_t ecEnableState = g_fuzzUtils.GetData<bool>();
+    int32_t micRefEnableState = 0;
+    ecManager.Init(ecEnableState, micRefEnableState);
+    AudioModuleInfo moduleInfo;
+    PipeStreamPropInfo targetInfo;
+    SourceType sourceType = g_fuzzUtils.GetData<SourceType>();
+    ecManager.UpdateStreamCommonInfo(moduleInfo, targetInfo, sourceType);
+}
+
+void GetPipeNameByDeviceForEcFuzzTest()
+{
+    std::vector<string> roleList = {
+        "source",
+        "role_source",
+    };
+    size_t index = g_fuzzUtils.GetData<size_t>() % roleList.size();
+    DeviceType deviceType = g_fuzzUtils.GetData<DeviceType>();
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.GetPipeNameByDeviceForEc(roleList[index], deviceType);
+}
+
+void GetPipeInfoByDeviceTypeForEcFuzzTest()
+{
+    std::vector<string> roleList = {
+        "source",
+        "role_source",
+    };
+    size_t index = g_fuzzUtils.GetData<size_t>() % roleList.size();
+    DeviceType deviceType = g_fuzzUtils.GetData<DeviceType>();
+    std::shared_ptr<AdapterPipeInfo> pipeInfo = std::make_shared<AdapterPipeInfo>();
+    CHECK_AND_RETURN(pipeInfo != nullptr);
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.GetPipeInfoByDeviceTypeForEc(roleList[index], deviceType, pipeInfo);
+}
 
-bool FuzzTest(const uint8_t* rawData, size_t size)
+void GetEcTypeFuzzTest()
 {
-    if (rawData == nullptr) {
-        return false;
-    }
+    DeviceType inputDevice = g_fuzzUtils.GetData<DeviceType>();
+    DeviceType outputDevice = g_fuzzUtils.GetData<DeviceType>();
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.GetEcType(inputDevice, outputDevice);
+}
 
-    // initialize data
-    RAW_DATA = rawData;
-    g_dataSize = size;
-    g_pos = 0;
+void UpdateAudioEcInfoFuzzTest()
+{
+    AudioDeviceDescriptor inputDevice;
+    AudioDeviceDescriptor outputDevice;
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    int32_t ecEnableState = g_fuzzUtils.GetData<bool>();
+    int32_t micRefEnableState = 0;
+    ecManager.Init(ecEnableState, micRefEnableState);
+    ecManager.UpdateAudioEcInfo(inputDevice, outputDevice);
+}
 
-    uint32_t code = GetData<uint32_t>();
-    uint32_t len = GetArrLength(g_testFuncs);
-    if (len > 0) {
-        g_testFuncs[code % len]();
-    } else {
-        AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
-    }
+void ShouldOpenMicRefFuzzTest()
+{
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    SourceType source = g_fuzzUtils.GetData<SourceType>();
+    int32_t ecEnableState = 0;
+    int32_t micRefEnableState = g_fuzzUtils.GetData<bool>();
+    ecManager.Init(ecEnableState, micRefEnableState);
+    ecManager.ShouldOpenMicRef(source);
+}
 
-    return true;
+void GetAudioEcInfoFuzzTest()
+{
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.GetAudioEcInfo();
+    ecManager.ResetAudioEcInfo();
 }
+
+void PresetArmIdleInputFuzzTest()
+{
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    int32_t ecEnableState = g_fuzzUtils.GetData<bool>();
+    ecManager.Init(ecEnableState, 0);
+    ecManager.PresetArmIdleInput("AA:BB:CC:DD:EE:FF");
+}
+
+void ActivateArmDeviceFuzzTest()
+{
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    int32_t ecEnableState = g_fuzzUtils.GetData<bool>();
+    ecManager.Init(ecEnableState, 0);
+    DeviceRole role = g_fuzzUtils.GetData<DeviceRole>();
+    ecManager.ActivateArmDevice("AA:BB:CC:DD:EE:FF", role);
+}
+
+void CloseUsbArmDeviceFuzzTest()
+{
+    AudioDeviceDescriptor device;
+    device.deviceRole_ = g_fuzzUtils.GetData<DeviceRole>();
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.CloseUsbArmDevice(device);
+}
+
+void UpdateArmModuleInfoFuzzTest()
+{
+    std::vector<std::string> addressList = {
+        "12:34:56:78:90:AB",
+        "AA:BB:CC:DD:EE:FF",
+        "",
+        "invalid_address"
+    };
+    uint32_t addressIndex = g_fuzzUtils.GetData<uint32_t>() % addressList.size();
+    std::string address = addressList[addressIndex];
+    DeviceRole role = g_fuzzUtils.GetData<DeviceRole>();
+    AudioModuleInfo moduleInfo;
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    int32_t ecEnableState = g_fuzzUtils.GetData<bool>();
+    int32_t micRefEnableState = 0;
+    ecManager.Init(ecEnableState, micRefEnableState);
+    ecManager.UpdateArmModuleInfo(address, role, moduleInfo);
+}
+
+void GetTargetSourceTypeAndMatchingFlagFuzzTest()
+{
+    SourceType source = g_fuzzUtils.GetData<SourceType>();
+    SourceType targetSource;
+    bool useMatchingPropInfo = g_fuzzUtils.GetData<bool>();
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.GetTargetSourceTypeAndMatchingFlag(source, targetSource, useMatchingPropInfo);
+}
+
+void ReloadSourceForSessionFuzzTest()
+{
+    SessionInfo sessionInfo;
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.ReloadSourceForSession(sessionInfo);
+}
+
+void FetchTargetInfoForSessionAddFuzzTest()
+{
+    SessionInfo sessionInfo;
+    sessionInfo.sourceType = g_fuzzUtils.GetData<SourceType>();
+    sessionInfo.channels = g_fuzzUtils.GetData<uint32_t>();
+    sessionInfo.rate = g_fuzzUtils.GetData<uint32_t>();
+    PipeStreamPropInfo targetInfo;
+    SourceType targetSourceType = g_fuzzUtils.GetData<SourceType>();
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    int32_t ecEnableState = g_fuzzUtils.GetData<bool>();
+    int32_t micRefEnableState = 0;
+    ecManager.Init(ecEnableState, micRefEnableState);
+    AudioModuleInfo moduleInfo;
+    std::vector<std::string> OpenMicSpeakerList = {
+        "1",
+        "OpenMicSpeaker"
+    };
+    uint32_t index = g_fuzzUtils.GetData<uint32_t>() % OpenMicSpeakerList.size();
+    moduleInfo.OpenMicSpeaker = OpenMicSpeakerList[index];
+    ecManager.SetPrimaryMicModuleInfo(moduleInfo);
+    ecManager.FetchTargetInfoForSessionAdd(sessionInfo, targetInfo, targetSourceType);
+}
+
+void SetDpSinkModuleInfoFuzzTest()
+{
+    AudioModuleInfo moduleInfo;
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.SetDpSinkModuleInfo(moduleInfo);
+}
+
+void GetSourceOpenedFuzzTest()
+{
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.GetSourceOpened();
+}
+
+void GetMicRefFeatureEnableFuzzTest()
+{
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.GetMicRefFeatureEnable();
+}
+
+void GetHalNameForDeviceFuzzTest()
+{
+    std::vector<string> roleList = {
+        "source",
+        "role_source",
+    };
+    size_t index = g_fuzzUtils.GetData<size_t>() % roleList.size();
+    DeviceType deviceType = g_fuzzUtils.GetData<DeviceType>();
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.GetHalNameForDevice(roleList[index], deviceType);
+}
+
+void PrepareNormalSourceFuzzTest()
+{
+    AudioModuleInfo moduleInfo;
+    std::shared_ptr<AudioStreamDescriptor> streamDesc = std::make_shared<AudioStreamDescriptor>();
+    CHECK_AND_RETURN(streamDesc != nullptr);
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.PrepareNormalSource(moduleInfo, streamDesc);
+}
+
+void GetOpenedNormalSourceSessionIdFuzzTest()
+{
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    ecManager.GetOpenedNormalSourceSessionId();
+}
+
+void ReloadNormalSourceFuzzTest()
+{
+    SessionInfo sessionInfo;
+    PipeStreamPropInfo targetInfo;
+    SourceType targetSource = g_fuzzUtils.GetData<SourceType>();
+    AudioEcManager& ecManager(AudioEcManager::GetInstance());
+    int32_t ecEnableState = g_fuzzUtils.GetData<bool>();
+    int32_t micRefEnableState = 0;
+    ecManager.Init(ecEnableState, micRefEnableState);
+    ecManager.ReloadNormalSource(sessionInfo, targetInfo, targetSource);
+}
+
+vector<TestFuncs> g_testFuncs = {
+    GetEcSamplingRateFuzzTest,
+    GetEcChannelsFuzzTest,
+    GetEcFormatFuzzTest,
+    CloseNormalSourceFuzzTest,
+    UpdateEnhanceEffectStateFuzzTest,
+    UpdateStreamCommonInfoFuzzTest,
+    GetPipeNameByDeviceForEcFuzzTest,
+    GetPipeInfoByDeviceTypeForEcFuzzTest,
+    GetEcTypeFuzzTest,
+    UpdateAudioEcInfoFuzzTest,
+    ShouldOpenMicRefFuzzTest,
+    GetAudioEcInfoFuzzTest,
+    PresetArmIdleInputFuzzTest,
+    ActivateArmDeviceFuzzTest,
+    CloseUsbArmDeviceFuzzTest,
+    UpdateArmModuleInfoFuzzTest,
+    GetTargetSourceTypeAndMatchingFlagFuzzTest,
+    ReloadSourceForSessionFuzzTest,
+    FetchTargetInfoForSessionAddFuzzTest,
+    SetDpSinkModuleInfoFuzzTest,
+    GetSourceOpenedFuzzTest,
+    GetMicRefFeatureEnableFuzzTest,
+    GetHalNameForDeviceFuzzTest,
+    PrepareNormalSourceFuzzTest,
+    GetOpenedNormalSourceSessionIdFuzzTest,
+    ReloadNormalSourceFuzzTest,
+};
+
 } // namespace AudioStandard
 } // namesapce OHOS
 
 /* Fuzzer entry point */
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    if (size < OHOS::AudioStandard::THRESHOLD) {
-        return 0;
-    }
-
-    OHOS::AudioStandard::FuzzTest(data, size);
+    OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs);
     return 0;
 }
diff --git a/test/fuzztest/audiovolumemanager_fuzzer/audio_volume_manager_fuzzer.cpp b/test/fuzztest/audiovolumemanager_fuzzer/audio_volume_manager_fuzzer.cpp
index d78e1654bccb7cfdb037d3d093f34e540cdfaf3f..7a49ea4fae19cec1ad503cd5e535b15a6487c26c 100644
--- a/test/fuzztest/audiovolumemanager_fuzzer/audio_volume_manager_fuzzer.cpp
+++ b/test/fuzztest/audiovolumemanager_fuzzer/audio_volume_manager_fuzzer.cpp
@@ -14,94 +14,18 @@
  */
 
 #include "audio_volume_manager.h"
+#include "../fuzz_utils.h"
 using namespace std;
 
 namespace OHOS {
 namespace AudioStandard {
 
-const int32_t NUM_2 = 2;
-const int32_t SAFE_VOLUME_LIMIT = 100;
-const int32_t RESTORE_VOLUME_NOTIFICATION_ID = 116000;
-const int32_t INCREASE_VOLUME_NOTIFICATION_ID = 116001;
-const uint32_t NOTIFICATION_BANNER_FLAG = 1 << 9;
-typedef void (*TestPtr)(const uint8_t *, size_t);
-
-const vector<AudioStreamType> 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,
-};
-
-const vector<DeviceType> 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
-};
-
-template<class T>
-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]);
-}
+const std::string AUDIO_RESTORE_VOLUME_EVENT = "AUDIO_RESTORE_VOLUME_EVENT";
+const std::string AUDIO_INCREASE_VOLUME_EVENT = "AUDIO_INCREASE_VOLUME_EVENT";
+FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance();
+typedef void (*TestPtr)();
 
-void AudioVolumeManagerInitSharedVolumeFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerInitSharedVolumeFuzzTest()
 {
     std::shared_ptr<AudioSharedMemory> buffer;
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
@@ -109,252 +33,171 @@ void AudioVolumeManagerInitSharedVolumeFuzzTest(const uint8_t *rawData, size_t s
     audioVolumeManager.InitSharedVolume(buffer);
 }
 
-void AudioVolumeManagerSetVoiceRingtoneMuteFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerSetVoiceRingtoneMuteFuzzTest()
 {
-    bool isMute = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
+    bool isMute = g_fuzzUtils.GetData<bool>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.SetVoiceRingtoneMute(isMute);
 }
 
-void AudioVolumeManagerHandleAbsBluetoothVolumeFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerHandleAbsBluetoothVolumeFuzzTest()
 {
     std::string macAddress = "11:22:33:44:55:66";
-    int32_t volumeLevel = static_cast<int32_t>(size);
-    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
-    vector<DeviceCategory> testDeviceCategory = {
-        CATEGORY_DEFAULT,
-        BT_HEADPHONE,
-        BT_SOUNDBOX,
-        BT_CAR,
-        BT_GLASSES,
-        BT_WATCH,
-        BT_HEARAID,
-        BT_UNWEAR_HEADPHONE,
-    };
-
-    audioVolumeManager.isBtFirstBoot_ = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
-    uint32_t index = static_cast<uint32_t>(size) % testDeviceCategory.size();
-    audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = testDeviceCategory[index];
+    int32_t volumeLevel = g_fuzzUtils.GetData<int32_t>();
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
+    audioVolumeManager.isBtFirstBoot_ = g_fuzzUtils.GetData<bool>();
+    audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = g_fuzzUtils.GetData<DeviceCategory>();
     audioVolumeManager.HandleAbsBluetoothVolume(macAddress, volumeLevel);
 }
 
-void AudioVolumeManagerIsWiredHeadSetFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerIsWiredHeadSetFuzzTest()
 {
-    uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
-    DeviceType deviceType = g_testDeviceTypes[index];
+    DeviceType deviceType = g_fuzzUtils.GetData<DeviceType>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.IsWiredHeadSet(deviceType);
 }
 
-void AudioVolumeManagerIsBlueToothFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerIsBlueToothFuzzTest()
 {
-    uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
-    DeviceType deviceType = g_testDeviceTypes[index];
+    DeviceType deviceType = g_fuzzUtils.GetData<DeviceType>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.IsBlueTooth(deviceType);
 }
 
-void AudioVolumeManagerCheckMixActiveMusicTimeFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerCheckMixActiveMusicTimeFuzzTest()
 {
-    int32_t safeVolume = static_cast<int32_t>(size) % SAFE_VOLUME_LIMIT;
+    int32_t safeVolume = g_fuzzUtils.GetData<int32_t>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
-    audioVolumeManager.activeSafeTimeBt_ = static_cast<int64_t>(size);
-    audioVolumeManager.activeSafeTime_ = static_cast<int64_t>(size);
+    audioVolumeManager.activeSafeTimeBt_ = 0;
+    audioVolumeManager.activeSafeTime_ = g_fuzzUtils.GetData<int64_t>();
     audioVolumeManager.CheckMixActiveMusicTime(safeVolume);
 }
 
-void AudioVolumeManagerCheckBlueToothActiveMusicTimeFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerCheckBlueToothActiveMusicTimeFuzzTest()
 {
-    int32_t safeVolume = static_cast<int32_t>(size) % SAFE_VOLUME_LIMIT;
+    int32_t safeVolume = g_fuzzUtils.GetData<int32_t>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.startSafeTimeBt_ = 0;
-    audioVolumeManager.activeSafeTimeBt_ = static_cast<int64_t>(size);
-    audioVolumeManager.activeSafeTime_ = static_cast<int64_t>(size);
+    audioVolumeManager.activeSafeTimeBt_ = 0;
+    audioVolumeManager.activeSafeTime_ = g_fuzzUtils.GetData<int64_t>();
     audioVolumeManager.CheckBlueToothActiveMusicTime(safeVolume);
 }
 
-void AudioVolumeManagerCheckWiredActiveMusicTimeFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerCheckWiredActiveMusicTimeFuzzTest()
 {
-    int32_t safeVolume = static_cast<int32_t>(size) % SAFE_VOLUME_LIMIT;
+    int32_t safeVolume = g_fuzzUtils.GetData<int32_t>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.startSafeTimeBt_ = 0;
-    audioVolumeManager.activeSafeTimeBt_ = static_cast<int64_t>(size);
-    audioVolumeManager.activeSafeTime_ = static_cast<int64_t>(size);
+    audioVolumeManager.activeSafeTimeBt_ = 0;
+    audioVolumeManager.activeSafeTime_ = g_fuzzUtils.GetData<int64_t>();
     audioVolumeManager.CheckWiredActiveMusicTime(safeVolume);
 }
 
-void AudioVolumeManagerRestoreSafeVolumeFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerRestoreSafeVolumeFuzzTest()
 {
-    uint32_t index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
-    AudioStreamType streamType = g_testStreamTypes[index];
-    int32_t safeVolume = static_cast<int32_t>(size) % SAFE_VOLUME_LIMIT;
+    AudioStreamType streamType = g_fuzzUtils.GetData<AudioStreamType>();
+    int32_t safeVolume = g_fuzzUtils.GetData<int32_t>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.RestoreSafeVolume(streamType, safeVolume);
 }
 
-void AudioVolumeManagerSetSafeVolumeCallbackFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerSetSafeVolumeCallbackFuzzTest()
 {
-    uint32_t index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
-    AudioStreamType streamType = g_testStreamTypes[index];
+    AudioStreamType streamType = g_fuzzUtils.GetData<AudioStreamType>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
     audioVolumeManager.audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
 
     audioVolumeManager.SetSafeVolumeCallback(streamType);
 }
 
-void AudioVolumeManagerChangeDeviceSafeStatusFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerChangeDeviceSafeStatusFuzzTest()
 {
-    vector<SafeStatus> testSafeStatus = {
-        SAFE_UNKNOWN,
-        SAFE_INACTIVE,
-        SAFE_ACTIVE,
-    };
-
-    uint32_t index = static_cast<uint32_t>(size) % testSafeStatus.size();
-    SafeStatus safeStatus = testSafeStatus[index];
+    SafeStatus safeStatus = g_fuzzUtils.GetData<SafeStatus>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.ChangeDeviceSafeStatus(safeStatus);
 }
 
-void AudioVolumeManagerSetAbsVolumeSceneAsyncFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerSetAbsVolumeSceneAsyncFuzzTest()
 {
     std::string macAddress = "11:22:33:44:55:66";
-    bool support = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
+    bool support = g_fuzzUtils.GetData<bool>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.audioActiveDevice_.SetActiveBtDeviceMac(macAddress);
     audioVolumeManager.SetAbsVolumeSceneAsync(macAddress, support);
 }
 
-void AudioVolumeManagerDealWithEventVolumeFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerDealWithEventVolumeFuzzTest()
 {
-    vector<int32_t> testNotificationIds = {
-        RESTORE_VOLUME_NOTIFICATION_ID,
-        INCREASE_VOLUME_NOTIFICATION_ID,
-        NOTIFICATION_BANNER_FLAG,
-    };
-    uint32_t index = static_cast<uint32_t>(size) % testNotificationIds.size();
-    int32_t notificationId = testNotificationIds[index];
+    int32_t notificationId = g_fuzzUtils.GetData<int32_t>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
-
-    vector<DeviceCategory> testDeviceCategory = {
-        CATEGORY_DEFAULT,
-        BT_HEADPHONE,
-        BT_SOUNDBOX,
-        BT_CAR,
-        BT_GLASSES,
-        BT_WATCH,
-        BT_HEARAID,
-        BT_UNWEAR_HEADPHONE,
-    };
-    index = static_cast<uint32_t>(size) % testDeviceCategory.size();
-    audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = testDeviceCategory[index];
-
-    index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
-    audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceType_ = g_testDeviceTypes[index];
-
+    audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceCategory_ = g_fuzzUtils.GetData<DeviceCategory>();
+    audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData<DeviceType>();
     audioVolumeManager.DealWithEventVolume(notificationId);
 }
 
-void AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest()
 {
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.UpdateSafeVolumeByS4();
 }
 
-void AudioVolumeManagerSetDeviceAbsVolumeSupportedFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerSetDeviceAbsVolumeSupportedFuzzTest()
 {
     std::string macAddress = "11:22:33:44:55:66";
-    bool support = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
+    bool support = g_fuzzUtils.GetData<bool>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.audioActiveDevice_.SetActiveBtDeviceMac(macAddress);
     audioVolumeManager.SetDeviceAbsVolumeSupported(macAddress, support);
 }
 
-void AudioVolumeManagerSetStreamMuteFuzzTest(const uint8_t *rawData, size_t size)
-{
-    vector<StreamUsage> 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,
-    };
-    uint32_t index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
-    AudioVolumeType streamType = g_testStreamTypes[index];
-    bool mute = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
-    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
-
-    index = static_cast<uint32_t>(size) % testStreamUsages.size();
-    StreamUsage streamUsage = testStreamUsages[index];
-    index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
-    DeviceType deviceType = g_testDeviceTypes[index];
+void AudioVolumeManagerSetStreamMuteFuzzTest()
+{
+    AudioVolumeType streamType = g_fuzzUtils.GetData<AudioVolumeType>();
+    bool mute = g_fuzzUtils.GetData<bool>();
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    StreamUsage streamUsage = g_fuzzUtils.GetData<StreamUsage>();
+    DeviceType deviceType = g_fuzzUtils.GetData<DeviceType>();
+    std::string macAddress = "11:22:33:44:55:66";
+    audioVolumeManager.audioActiveDevice_.SetActiveBtDeviceMac(macAddress);
+    A2dpDeviceConfigInfo a2dpDeviceConfigInfo;
+    a2dpDeviceConfigInfo.absVolumeSupport = g_fuzzUtils.GetData<bool>();
+    audioVolumeManager.audioA2dpDevice_.connectedA2dpDeviceMap_.insert({macAddress, a2dpDeviceConfigInfo});
     audioVolumeManager.SetStreamMute(streamType, mute, streamUsage, deviceType);
 }
 
-void AudioVolumeManagerGetMaxVolumeLevelFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerGetMaxVolumeLevelFuzzTest()
 {
-    uint32_t index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
-    AudioVolumeType streamType = g_testStreamTypes[index];
+    AudioVolumeType streamType = g_fuzzUtils.GetData<AudioVolumeType>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.GetMaxVolumeLevel(streamType);
 }
 
-void AudioVolumeManagerGetMinVolumeLevelFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerGetMinVolumeLevelFuzzTest()
 {
-    uint32_t index = static_cast<uint32_t>(size) % g_testStreamTypes.size();
-    AudioVolumeType streamType = g_testStreamTypes[index];
+    AudioVolumeType streamType = g_fuzzUtils.GetData<AudioVolumeType>();
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.GetMinVolumeLevel(streamType);
 }
 
-void AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest()
 {
-    vector<DeviceRole> testDeviceRoles = {
-        DEVICE_ROLE_NONE,
-        INPUT_DEVICE,
-        OUTPUT_DEVICE,
-        DEVICE_ROLE_MAX,
-    };
     auto audioVolumeManager = std::make_shared<AudioVolumeManager>();
-    uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
-    DeviceType deviceType = g_testDeviceTypes[index];
-    index = static_cast<uint32_t>(size) % testDeviceRoles.size();
-    DeviceRole deviceRole = testDeviceRoles[index];
+    DeviceType deviceType = g_fuzzUtils.GetData<DeviceType>();
+    DeviceRole deviceRole = g_fuzzUtils.GetData<DeviceRole>();
 
     std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>(
         deviceType, deviceRole);
@@ -362,7 +205,7 @@ void AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest(const uint8_t *rawData, si
     audioVolumeManager->GetAllDeviceVolumeInfo();
 }
 
-void AudioVolumeManagerInitFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerInitFuzzTest()
 {
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
     std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler = std::make_shared<AudioPolicyServerHandler>();
@@ -371,64 +214,220 @@ void AudioVolumeManagerInitFuzzTest(const uint8_t *rawData, size_t size)
     audioVolumeManager.Init(audioPolicyServerHandler);
 }
 
-void AudioVolumeManagerInitKVStoreFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerInitKVStoreFuzzTest()
 {
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
     audioVolumeManager.InitKVStore();
 }
 
-void AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest(const uint8_t *rawData, size_t size)
+void AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest()
 {
     AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
 
-    audioVolumeManager.ForceVolumeKeyControlType(static_cast<AudioVolumeType>(size), size);
+    AudioVolumeType volumeType = g_fuzzUtils.GetData<AudioVolumeType>();
+    int32_t duration = g_fuzzUtils.GetData<int32_t>();
+    audioVolumeManager.forceControlVolumeTypeMonitor_ = make_shared<ForceControlVolumeTypeMonitor>();
+    audioVolumeManager.ForceVolumeKeyControlType(volumeType, duration);
 }
 
-} // namespace AudioStandard
-} // namesapce OHOS
+void AudioVolumeManagerSetAdjustVolumeForZoneFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    int32_t zoneId = g_fuzzUtils.GetData<int32_t>();
+    audioVolumeManager.SetAdjustVolumeForZone(zoneId);
+}
+
+void AudioVolumeManagerGetSystemVolumeLevelFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    AudioStreamType streamType = g_fuzzUtils.GetData<AudioStreamType>();
+    int32_t zoneId = g_fuzzUtils.GetData<int32_t>();
+    bool flag = g_fuzzUtils.GetData<bool>();
+    audioVolumeManager.SetRingerModeMute(flag);
+    audioVolumeManager.GetSystemVolumeLevel(streamType, zoneId);
+}
+
+void AudioVolumeManagerCheckToCloseNotificationFuzzTest()
+{
+    bool isPCVolumeEnable = g_fuzzUtils.GetData<bool>();
+    VolumeUtils::SetPCVolumeEnable(isPCVolumeEnable);
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    AudioStreamType streamType = g_fuzzUtils.GetData<AudioStreamType>();
+    int32_t volumeLevel = g_fuzzUtils.GetData<int32_t>();
+    audioVolumeManager.increaseNIsShowing_ = g_fuzzUtils.GetData<bool>();
+    audioVolumeManager.restoreNIsShowing_ = g_fuzzUtils.GetData<bool>();
+    audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData<DeviceType>();
+    audioVolumeManager.CheckToCloseNotification(streamType, volumeLevel);
+}
+
+void AudioVolumeManagerSetAppVolumeMutedFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    int32_t appUid = g_fuzzUtils.GetData<int32_t>();
+    bool muted = g_fuzzUtils.GetData<bool>();
+    audioVolumeManager.SetAppVolumeMuted(appUid, muted);
+}
+
+void AudioVolumeManagerIsAppVolumeMuteFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    int32_t appUid = g_fuzzUtils.GetData<int32_t>();
+    bool owned = g_fuzzUtils.GetData<bool>();
+    bool isMute;
+    audioVolumeManager.IsAppVolumeMute(appUid, owned, isMute);
+}
+
+void AudioVolumeManagerHandleNearlinkDeviceAbsVolumeFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    AudioStreamType streamType = g_fuzzUtils.GetData<AudioStreamType>();
+    int32_t volumeLevel = g_fuzzUtils.GetData<int32_t>();
+    DeviceType curOutputDeviceType = g_fuzzUtils.GetData<DeviceType>();
+    audioVolumeManager.audioActiveDevice_.currentActiveDevice_.macAddress_ = "11:22:33:44:55:66";
+    bool isClear = g_fuzzUtils.GetData<bool>();
+    if (isClear) {
+        audioVolumeManager.audioActiveDevice_.currentActiveDevice_.macAddress_.clear();
+    }
+    audioVolumeManager.HandleNearlinkDeviceAbsVolume(streamType, volumeLevel, curOutputDeviceType);
+}
+
+void AudioVolumeManagerSetA2dpDeviceVolumeFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    std::string macAddress = "11:22:33:44:55:66";
+    int32_t volumeLevel = g_fuzzUtils.GetData<int32_t>();
+    bool internalCall = g_fuzzUtils.GetData<bool>();
+    bool isAdd = g_fuzzUtils.GetData<bool>();
+    A2dpDeviceConfigInfo a2dpDeviceConfigInfo;
+    if (isAdd) {
+        audioVolumeManager.audioA2dpDevice_.connectedA2dpDeviceMap_.insert({macAddress, a2dpDeviceConfigInfo});
+    }
+    audioVolumeManager.SetA2dpDeviceVolume(macAddress, volumeLevel, internalCall);
+    audioVolumeManager.audioA2dpDevice_.connectedA2dpDeviceMap_.clear();
+}
+
+void AudioVolumeManagerCancelSafeVolumeNotificationFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    int32_t notificationId = g_fuzzUtils.GetData<int32_t>();
+    audioVolumeManager.CancelSafeVolumeNotification(notificationId);
+}
+
+void AudioVolumeManagerSetRestoreVolumeLevelFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    DeviceType deviceType = g_fuzzUtils.GetData<DeviceType>();
+    int32_t curDeviceVolume = g_fuzzUtils.GetData<int32_t>();
+    audioVolumeManager.SetRestoreVolumeLevel(deviceType, curDeviceVolume);
+}
 
-OHOS::AudioStandard::TestPtr g_testPtrs[] = {
-    OHOS::AudioStandard::AudioVolumeManagerInitSharedVolumeFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerSetVoiceRingtoneMuteFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerHandleAbsBluetoothVolumeFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerIsWiredHeadSetFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerIsBlueToothFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerCheckMixActiveMusicTimeFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerCheckBlueToothActiveMusicTimeFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerCheckWiredActiveMusicTimeFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerRestoreSafeVolumeFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerSetSafeVolumeCallbackFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerChangeDeviceSafeStatusFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerSetAbsVolumeSceneAsyncFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerDealWithEventVolumeFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerSetDeviceAbsVolumeSupportedFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerSetStreamMuteFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerGetMaxVolumeLevelFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerGetMinVolumeLevelFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerInitFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerInitKVStoreFuzzTest,
-    OHOS::AudioStandard::AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest,
+void AudioVolumeManagerCheckLowerDeviceVolumeFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    DeviceType deviceType = g_fuzzUtils.GetData<DeviceType>();
+    audioVolumeManager.CheckLowerDeviceVolume(deviceType);
+}
+
+void AudioVolumeManagerOnReceiveEventFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    AAFwk::Want want;
+    EventFwk::CommonEventData eventData;
+    std::string action;
+    bool isRestore = g_fuzzUtils.GetData<bool>();
+    if (isRestore) {
+        action = AUDIO_RESTORE_VOLUME_EVENT;
+    } else {
+        action = AUDIO_INCREASE_VOLUME_EVENT;
+    }
+    want.SetAction(action);
+    eventData.SetWant(want);
+    audioVolumeManager.OnReceiveEvent(eventData);
+}
+
+void AudioVolumeManagerSetDeviceSafeVolumeStatusFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    audioVolumeManager.userSelect_ = g_fuzzUtils.GetData<bool>();
+    audioVolumeManager.audioActiveDevice_.currentActiveDevice_.deviceType_ = g_fuzzUtils.GetData<DeviceType>();
+    audioVolumeManager.SetDeviceSafeVolumeStatus();
+}
+
+void AudioVolumeManagerDisableSafeMediaVolumeFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    audioVolumeManager.DisableSafeMediaVolume();
+}
+
+void AudioVolumeManagerResetRingerModeMuteFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    audioVolumeManager.ResetRingerModeMute();
+}
+
+void AudioVolumeManagerGetLoadFlagFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    bool isLoad = g_fuzzUtils.GetData<bool>();
+    audioVolumeManager.SetDefaultDeviceLoadFlag(isLoad);
+    audioVolumeManager.GetLoadFlag();
+}
+
+void AudioVolumeManagerOnTimerExpiredFuzzTest()
+{
+    AudioVolumeManager& audioVolumeManager(AudioVolumeManager::GetInstance());
+    audioVolumeManager.OnTimerExpired();
+    audioVolumeManager.GetForceControlVolumeType();
+}
+
+vector<TestFuncs> g_testFuncs = {
+    AudioVolumeManagerInitSharedVolumeFuzzTest,
+    AudioVolumeManagerSetVoiceRingtoneMuteFuzzTest,
+    AudioVolumeManagerHandleAbsBluetoothVolumeFuzzTest,
+    AudioVolumeManagerIsWiredHeadSetFuzzTest,
+    AudioVolumeManagerIsBlueToothFuzzTest,
+    AudioVolumeManagerCheckMixActiveMusicTimeFuzzTest,
+    AudioVolumeManagerCheckBlueToothActiveMusicTimeFuzzTest,
+    AudioVolumeManagerCheckWiredActiveMusicTimeFuzzTest,
+    AudioVolumeManagerRestoreSafeVolumeFuzzTest,
+    AudioVolumeManagerSetSafeVolumeCallbackFuzzTest,
+    AudioVolumeManagerChangeDeviceSafeStatusFuzzTest,
+    AudioVolumeManagerSetAbsVolumeSceneAsyncFuzzTest,
+    AudioVolumeManagerDealWithEventVolumeFuzzTest,
+    AudioVolumeManagerUpdateSafeVolumeByS4FuzzTest,
+    AudioVolumeManagerSetDeviceAbsVolumeSupportedFuzzTest,
+    AudioVolumeManagerSetStreamMuteFuzzTest,
+    AudioVolumeManagerGetMaxVolumeLevelFuzzTest,
+    AudioVolumeManagerGetMinVolumeLevelFuzzTest,
+    AudioVolumeManagerGetAllDeviceVolumeInfoFuzzTest,
+    AudioVolumeManagerInitFuzzTest,
+    AudioVolumeManagerInitKVStoreFuzzTest,
+    AudioVolumeManagerForceVolumeKeyControlTypeFuzzTest,
+    AudioVolumeManagerSetAdjustVolumeForZoneFuzzTest,
+    AudioVolumeManagerGetSystemVolumeLevelFuzzTest,
+    AudioVolumeManagerCheckToCloseNotificationFuzzTest,
+    AudioVolumeManagerSetAppVolumeMutedFuzzTest,
+    AudioVolumeManagerIsAppVolumeMuteFuzzTest,
+    AudioVolumeManagerHandleNearlinkDeviceAbsVolumeFuzzTest,
+    AudioVolumeManagerSetA2dpDeviceVolumeFuzzTest,
+    AudioVolumeManagerCancelSafeVolumeNotificationFuzzTest,
+    AudioVolumeManagerSetRestoreVolumeLevelFuzzTest,
+    AudioVolumeManagerCheckLowerDeviceVolumeFuzzTest,
+    AudioVolumeManagerOnReceiveEventFuzzTest,
+    AudioVolumeManagerSetDeviceSafeVolumeStatusFuzzTest,
+    AudioVolumeManagerDisableSafeMediaVolumeFuzzTest,
+    AudioVolumeManagerResetRingerModeMuteFuzzTest,
+    AudioVolumeManagerGetLoadFlagFuzzTest,
+    AudioVolumeManagerOnTimerExpiredFuzzTest,
 };
 
+} // 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