diff --git a/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/BUILD.gn b/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/BUILD.gn
index 3e39547c03a5d7f493ee3dc412df32f6442ed7d5..e355c13d4012035635ba5bfed387903f62e4a681 100644
--- a/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/BUILD.gn
+++ b/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/BUILD.gn
@@ -27,6 +27,8 @@ ohos_fuzztest("SinkServiceInitSinkFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "-Dprivate=public",
+    "-Dprotected=public",
   ]
   sources = [ "sinkserviceinitsink_fuzzer.cpp" ]
 
diff --git a/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/sinkserviceinitsink_fuzzer.cpp b/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/sinkserviceinitsink_fuzzer.cpp
index 37088a4e7b590ca5e11d6dd093533a1b8c33399f..72d70e2b40e8b5415f3bba68173145318e09a66a 100644
--- a/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/sinkserviceinitsink_fuzzer.cpp
+++ b/services/audiomanager/test/fuzztest/sinkserviceinitsink_fuzzer/sinkserviceinitsink_fuzzer.cpp
@@ -19,6 +19,7 @@
 #include <cstdint>
 #include <fuzzer/FuzzedDataProvider.h>
 
+#include "daudio_constants.h"
 #include "daudio_sink_service.h"
 #include "daudio_sink_ipc_callback.h"
 #include "if_system_ability_manager.h"
@@ -42,6 +43,69 @@ void SinkServiceInitSinkFuzzTest(const uint8_t* data, size_t size)
 
     dAudioSinkService->InitSink(params, dAudioSinkIpcCallback);
 }
+
+void SinkServiceOnStartFuzzTest(const uint8_t* data, size_t size)
+{
+    if (data == nullptr || size < sizeof(int32_t)) {
+        return;
+    }
+
+    FuzzedDataProvider fdp(data, size);
+    int32_t saId = fdp.ConsumeIntegral<int32_t>();
+    bool runOnCreate = fdp.ConsumeBool();
+
+    auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
+    dAudioSinkService->OnStart();
+}
+
+void SinkServiceOnStopFuzzTest(const uint8_t* data, size_t size)
+{
+    if (data == nullptr || size < sizeof(int32_t)) {
+        return;
+    }
+
+    FuzzedDataProvider fdp(data, size);
+    int32_t saId = fdp.ConsumeIntegral<int32_t>();
+    bool runOnCreate = fdp.ConsumeBool();
+
+    auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
+    dAudioSinkService->OnStop();
+}
+
+void SinkServiceInitFuzzTest(const uint8_t* data, size_t size)
+{
+    if (data == nullptr || size < sizeof(int32_t)) {
+        return;
+    }
+
+    FuzzedDataProvider fdp(data, size);
+    int32_t saId = fdp.ConsumeIntegral<int32_t>();
+    bool runOnCreate = fdp.ConsumeBool();
+
+    auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
+    dAudioSinkService->Init();
+}
+
+void SinkServiceDumpFuzzTest(const uint8_t* data, size_t size)
+{
+    if (data == nullptr || size == 0) {
+        return;
+    }
+
+    FuzzedDataProvider fdp(data, size);
+    int32_t fd = fdp.ConsumeIntegral<int32_t>();
+    size_t argsCount = fdp.ConsumeIntegralInRange<size_t>(0, 10);
+    std::vector<std::u16string> args;
+
+    for (size_t i = 0; i < argsCount; ++i) {
+        std::string utf8Str = fdp.ConsumeRandomLengthString(100);
+        std::u16string utf16Str(utf8Str.begin(), utf8Str.end());
+        args.emplace_back(utf16Str);
+    }
+
+    auto dAudioSinkService = std::make_shared<DAudioSinkService>(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, true);
+    dAudioSinkService->Dump(fd, args);
+}
 }
 }
 
@@ -50,6 +114,10 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
     /* Run your code on data */
     OHOS::DistributedHardware::SinkServiceInitSinkFuzzTest(data, size);
+    OHOS::DistributedHardware::SinkServiceOnStartFuzzTest(data, size);
+    OHOS::DistributedHardware::SinkServiceOnStopFuzzTest(data, size);
+    OHOS::DistributedHardware::SinkServiceInitFuzzTest(data, size);
+    OHOS::DistributedHardware::SinkServiceDumpFuzzTest(data, size);
     return 0;
 }
 
diff --git a/services/audiomanager/test/fuzztest/sinkstubdaudiosinkstub_fuzzer/sinkstubdaudiosinkstub_fuzzer.cpp b/services/audiomanager/test/fuzztest/sinkstubdaudiosinkstub_fuzzer/sinkstubdaudiosinkstub_fuzzer.cpp
index cc87dd160dbd9be7dba7c55b35ac01c046b33d6d..21f6bc240d32b2cfc381e53e9c4445fb594e0031 100644
--- a/services/audiomanager/test/fuzztest/sinkstubdaudiosinkstub_fuzzer/sinkstubdaudiosinkstub_fuzzer.cpp
+++ b/services/audiomanager/test/fuzztest/sinkstubdaudiosinkstub_fuzzer/sinkstubdaudiosinkstub_fuzzer.cpp
@@ -20,6 +20,7 @@
 #include <random>
 #include <fuzzer/FuzzedDataProvider.h>
 
+#include "daudio_sink_ipc_callback_proxy.h"
 #include "daudio_sink_stub.h"
 #include "daudio_sink_service.h"
 
@@ -27,6 +28,10 @@
 #include "if_system_ability_manager.h"
 #include "iservice_registry.h"
 
+inline std::string ConsumeRandomString(FuzzedDataProvider& fdp, size_t maxLength)
+{
+    return fdp.ConsumeRandomLengthString(maxLength);
+}
 namespace OHOS {
 namespace DistributedHardware {
 void SinkStubDaudioSinkStubFuzzTest(const uint8_t* data, size_t size)
@@ -227,6 +232,49 @@ void SinkStubStopDistributedHardwareInnerFuzzTest(const uint8_t* data, size_t si
     pdata.WriteString(resultData);
     dAudioSinkService->StopDistributedHardwareInner(pdata, reply, option);
 }
+
+void SinkStubInitSinkInnerFuzzTest(const uint8_t* data, size_t size)
+{
+    if ((data == nullptr) || (size < (sizeof(int32_t)))) {
+        return;
+    }
+    FuzzedDataProvider fdp(data, size);
+
+    int32_t saId = fdp.ConsumeIntegral<int32_t>();
+    bool runOnCreate = fdp.ConsumeBool();
+    auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
+
+    MessageParcel pdata;
+    MessageParcel reply;
+    MessageOption option;
+
+    std::string param = fdp.ConsumeRandomLengthString(100);
+    sptr<IRemoteObject> remoteObject = nullptr;
+    pdata.WriteString(param);
+    pdata.WriteRemoteObject(remoteObject);
+    dAudioSinkService->InitSinkInner(pdata, reply, option);
+}
+
+void SinkStubReleaseSinkInnerFuzzTest(const uint8_t* data, size_t size)
+{
+    if (data == nullptr || size == 0) {
+        return;
+    }
+    FuzzedDataProvider fdp(data, size);
+
+    int32_t saId = fdp.ConsumeIntegral<int32_t>();
+    bool runOnCreate = fdp.ConsumeBool();
+    auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
+
+    MessageParcel pdata;
+    MessageParcel reply;
+    MessageOption option;
+
+    std::string dummyData = ConsumeRandomString(fdp, 100);
+    pdata.WriteString(dummyData);
+
+    dAudioSinkService->ReleaseSinkInner(pdata, reply, option);
+}
 }
 }
 
@@ -241,5 +289,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     OHOS::DistributedHardware::SinkStubPauseDistributedHardwareInnerFuzzTest(data, size);
     OHOS::DistributedHardware::SinkStubResumeDistributedHardwareInnerFuzzTest(data, size);
     OHOS::DistributedHardware::SinkStubStopDistributedHardwareInnerFuzzTest(data, size);
+    OHOS::DistributedHardware::SinkStubInitSinkInnerFuzzTest(data, size);
+    OHOS::DistributedHardware::SinkStubReleaseSinkInnerFuzzTest(data, size);
     return 0;
 }
diff --git a/services/audiomanager/test/fuzztest/sourceservicedaudionotify_fuzzer/BUILD.gn b/services/audiomanager/test/fuzztest/sourceservicedaudionotify_fuzzer/BUILD.gn
index b9723e07c1381c640e56a319e66600626aa66759..9f64632c773f6ecb67c4259ca4bc203c979a7438 100644
--- a/services/audiomanager/test/fuzztest/sourceservicedaudionotify_fuzzer/BUILD.gn
+++ b/services/audiomanager/test/fuzztest/sourceservicedaudionotify_fuzzer/BUILD.gn
@@ -27,6 +27,8 @@ ohos_fuzztest("SourceServiceDAudioNotifyFuzzTest") {
     "-O0",
     "-Wno-unused-variable",
     "-fno-omit-frame-pointer",
+    "-Dprivate=public",
+    "-Dprotected=public",
   ]
   sources = [ "sourceservicedaudionotify_fuzzer.cpp" ]
 
diff --git a/services/audiomanager/test/fuzztest/sourceservicedaudionotify_fuzzer/sourceservicedaudionotify_fuzzer.cpp b/services/audiomanager/test/fuzztest/sourceservicedaudionotify_fuzzer/sourceservicedaudionotify_fuzzer.cpp
index 4500a3c5ef2acfbe65e73176d91f34716b016538..925e883ab65009c790290e6cb997eaf74ac04c91 100644
--- a/services/audiomanager/test/fuzztest/sourceservicedaudionotify_fuzzer/sourceservicedaudionotify_fuzzer.cpp
+++ b/services/audiomanager/test/fuzztest/sourceservicedaudionotify_fuzzer/sourceservicedaudionotify_fuzzer.cpp
@@ -19,6 +19,7 @@
 #include <cstdint>
 #include <fuzzer/FuzzedDataProvider.h>
 
+#include "daudio_constants.h"
 #include "daudio_source_service.h"
 #include "if_system_ability_manager.h"
 #include "iservice_registry.h"
@@ -43,6 +44,68 @@ void SourceServiceDAudioNotifyFuzzTest(const uint8_t* data, size_t size)
 
     dAudioSourceService->DAudioNotify(devId, dhId, eventType, eventContent);
 }
+
+void SourceServiceOnStartFuzzTest(const uint8_t* data, size_t size)
+{
+    if (data == nullptr || size < sizeof(int32_t)) {
+        return;
+    }
+    FuzzedDataProvider fdp(data, size);
+
+    int32_t saId = fdp.ConsumeIntegral<int32_t>();
+    bool runOnCreate = fdp.ConsumeBool();
+
+    auto dAudioSourceService = std::make_shared<DAudioSourceService>(saId, runOnCreate);
+    dAudioSourceService->OnStart();
+}
+
+void SourceServiceOnStopFuzzTest(const uint8_t* data, size_t size)
+{
+    if (data == nullptr || size < sizeof(int32_t)) {
+        return;
+    }
+    FuzzedDataProvider fdp(data, size);
+
+    int32_t saId = fdp.ConsumeIntegral<int32_t>();
+    bool runOnCreate = fdp.ConsumeBool();
+
+    auto dAudioSourceService = std::make_shared<DAudioSourceService>(saId, runOnCreate);
+    dAudioSourceService->OnStop();
+}
+
+void SourceServiceInitFuzzTest(const uint8_t* data, size_t size)
+{
+    if (data == nullptr || size < sizeof(int32_t)) {
+        return;
+    }
+    FuzzedDataProvider fdp(data, size);
+
+    int32_t saId = fdp.ConsumeIntegral<int32_t>();
+    bool runOnCreate = fdp.ConsumeBool();
+
+    auto dAudioSourceService = std::make_shared<DAudioSourceService>(saId, runOnCreate);
+    dAudioSourceService->Init();
+}
+
+void SourceServiceDumpFuzzTest(const uint8_t* data, size_t size)
+{
+    if (data == nullptr || size == 0) {
+        return;
+    }
+    FuzzedDataProvider fdp(data, size);
+
+    int32_t fd = fdp.ConsumeIntegral<int32_t>();
+    size_t argsCount = fdp.ConsumeIntegralInRange<size_t>(0, 10);
+    std::vector<std::u16string> args;
+    for (size_t i = 0; i < argsCount; ++i) {
+        std::string utf8Str = fdp.ConsumeRandomLengthString(100);
+        std::u16string utf16Str(utf8Str.begin(), utf8Str.end());
+        args.emplace_back(utf16Str);
+    }
+
+    auto dAudioSourceService = std::make_shared<DAudioSourceService>(DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID, true);
+    dAudioSourceService->Dump(fd, args);
+}
 }
 }
 
@@ -51,6 +114,10 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
     /* Run your code on data */
     OHOS::DistributedHardware::SourceServiceDAudioNotifyFuzzTest(data, size);
+    OHOS::DistributedHardware::SourceServiceOnStartFuzzTest(data, size);
+    OHOS::DistributedHardware::SourceServiceOnStopFuzzTest(data, size);
+    OHOS::DistributedHardware::SourceServiceInitFuzzTest(data, size);
+    OHOS::DistributedHardware::SourceServiceDumpFuzzTest(data, size);
     return 0;
 }