diff --git a/services/audio_policy/test/unittest/audio_policy_manager_unit_test/src/audio_policy_manager_unit_test.cpp b/services/audio_policy/test/unittest/audio_policy_manager_unit_test/src/audio_policy_manager_unit_test.cpp
index 687c6566f23b6d88a9b5f28105ae8d5cc92479ba..c02785990d33cde21ac0fc6712b14a38983923df 100644
--- a/services/audio_policy/test/unittest/audio_policy_manager_unit_test/src/audio_policy_manager_unit_test.cpp
+++ b/services/audio_policy/test/unittest/audio_policy_manager_unit_test/src/audio_policy_manager_unit_test.cpp
@@ -809,5 +809,24 @@ HWTEST(AudioPolicyManager, SetNearlinkDeviceVolume_002, TestSize.Level1)
     auto result = audioPolicyManager_->SetNearlinkDeviceVolume(macAddress, volumeType, volume, updateUi);
     EXPECT_EQ(result, ERROR);
 }
+
+/**
+* @tc.name  : Test AudioPolicyManager.
+* @tc.number: SelectOutputDevice_001.
+* @tc.desc  : Test SetNearlinkDeviceVolume.
+*/
+HWTEST(AudioPolicyManager, SelectOutputDevice_001, TestSize.Level1)
+{
+    auto audioPolicyManager_ = std::make_shared<AudioPolicyManager>();
+    ASSERT_TRUE(audioPolicyManager_ != nullptr);
+    sptr<AudioRendererFilter> audioRendererFilter;
+    std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors01;
+    auto ret = audioPolicyManager_->SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors01);
+    EXPECT_EQ(ret, -1);
+    
+    std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors02(21); // SelectOutputDevice接口中存在直接使用魔鬼数字20作为if的判断条件
+    ret = audioPolicyManager_->SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors02);
+    EXPECT_EQ(ret, -1);
+}
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/test/unittest/audio_endpoint_unit_test/src/audio_endpoint_plus_unit_test.cpp b/services/audio_service/test/unittest/audio_endpoint_unit_test/src/audio_endpoint_plus_unit_test.cpp
index d4bdc5020bcd8f8a836d3039fc10c2bbf728e202..73a58f852b5a076c80755019da9f69606426b0ea 100644
--- a/services/audio_service/test/unittest/audio_endpoint_unit_test/src/audio_endpoint_plus_unit_test.cpp
+++ b/services/audio_service/test/unittest/audio_endpoint_unit_test/src/audio_endpoint_plus_unit_test.cpp
@@ -1875,5 +1875,68 @@ HWTEST_F(AudioEndpointPlusUnitTest, ProcessToDupStream_001, TestSize.Level1)
     audioEndpointnIner->ProcessToDupStream(audioDataList, dstStreamData, innerCapId);
     EXPECT_EQ(innerCapId, 1);
 }
+
+/*
+ * @tc.name  : Test ProcessToDupStream API
+ * @tc.type  : FUNC
+ * @tc.number: HandleDisableFastCap_001
+ * @tc.desc  : Test AudioEndpointInner::HandleDisableFastCap()
+ */
+HWTEST_F(AudioEndpointPlusUnitTest, ProcessToDupStream_001, TestSize.Level1)
+{
+    AudioEndpoint::EndpointType type = AudioEndpoint::TYPE_MMAP;
+    uint64_t id = 123;
+    AudioProcessConfig clientConfig = {};
+    auto audioEndpointInner = std::make_shared<AudioEndpointInner>(type, id, clientConfig);
+    ASSERT_NE(audioEndpointInner, nullptr);
+    CaptureInfo captureInfo;
+    
+    EXPECT_EQ(audioEndpointInner->HandleDisableFastCap(captureInfo), SUCCESS);
+}
+
+/*
+ * @tc.name  : Test AudioEndpointInner API
+ * @tc.type  : FUNC
+ * @tc.number: AudioEndpointInner_008
+ * @tc.desc  : Test AudioEndpointInner::HandleRendererDataParams()
+ */
+HWTEST_F(AudioEndpointPlusUnitTest, AudioEndpointInner_008, TestSize.Level1)
+{
+    AudioEndpoint::EndpointType type = AudioEndpoint::TYPE_MMAP;
+    uint64_t id = 123;
+    AudioProcessConfig clientConfig = {};
+    auto audioEndpointInner = std::make_shared<AudioEndpointInner>(type, id, clientConfig);
+
+    ASSERT_NE(audioEndpointInner, nullptr);
+
+    AudioStreamData srcData;
+    AudioStreamData dstData;
+    srcData.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
+    dstData.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
+
+    srcData.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
+    srcData.streamInfo.channels = AudioChannel::MONO;
+    audioEndpointInner->HandleRendererDataParams(srcData, dstData);
+
+    srcData.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
+    srcData.streamInfo.channels = AudioChannel::CHANNEL_3;
+    audioEndpointInner->HandleRendererDataParams(srcData, dstData);
+
+    srcData.streamInfo.format = AudioSampleFormat::SAMPLE_S32LE;
+    srcData.streamInfo.channels = AudioChannel::MONO;
+    audioEndpointInner->HandleRendererDataParams(srcData, dstData);
+
+    srcData.streamInfo.format = AudioSampleFormat::SAMPLE_S32LE;
+    srcData.streamInfo.channels = AudioChannel::STEREO;
+    audioEndpointInner->HandleRendererDataParams(srcData, dstData);
+
+    srcData.streamInfo.format = AudioSampleFormat::SAMPLE_S32LE;
+    srcData.streamInfo.channels = AudioChannel::CHANNEL_3;
+    audioEndpointInner->HandleRendererDataParams(srcData, dstData);
+
+    srcData.streamInfo.format = AudioSampleFormat::SAMPLE_S24LE;
+    srcData.streamInfo.channels = AudioChannel::CHANNEL_3;
+    audioEndpointInner->HandleRendererDataParams(srcData, dstData);
+}
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/test/unittest/audio_resource_service_unit_test.cpp b/services/audio_service/test/unittest/audio_resource_service_unit_test.cpp
index 2b22517db254dc15410fdd7049994d1e57765c2f..00b08d918ff7ee585adb31cb08b2c5fee261d616 100644
--- a/services/audio_service/test/unittest/audio_resource_service_unit_test.cpp
+++ b/services/audio_service/test/unittest/audio_resource_service_unit_test.cpp
@@ -56,6 +56,7 @@ AudioResourceService::AudioWorkgroupDeathRecipient deathRecipient;
 AudioResourceService audioResourceService;
 const int32_t testRtgId = 2;
 static constexpr int32_t AUDIO_MAX_PROCESS = 2;
+static constexpr int32_t AUDIO_MAX_GRP_PER_PROCESS = 4;
 
 class RemoteObjectTestStub : public IRemoteObject {
 public:
@@ -796,6 +797,64 @@ HWTEST(AudioResourceServiceUnitTest, AudioWorkgroupCheck_004, TestSize.Level0)
     EXPECT_EQ(audioResourceService.AudioWorkgroupCheck(pid), SUCCESS);
 }
 
+/**
+ * @tc.name  : Test WorkgroupRendererMonitor
+ * @tc.type  : FUNC
+ * @tc.number: WorkgroupRendererMonitor
+ * @tc.desc  : Test WorkgroupRendererMonitor when find workgroup
+ */
+HWTEST(AudioResourceServiceUnitTest, WorkgroupRendererMonitor_002, TestSize.Level0)
+{
+    int32_t testPid = 321;
+    audioResourceService.audioWorkgroupMap_[testPid].permission = false;
+    audioResourceService.WorkgroupRendererMonitor(testPid, true);
+
+    EXPECT_TRUE(audioResourceService.audioWorkgroupMap_[testPid].permission);
+}
+
+/**
+ * @tc.name  : Test deathRecipient
+ * @tc.type  : FUNC
+ * @tc.number: OnWorkgroupRemoteDied_001
+ * @tc.desc  : Test OnWorkgroupRemoteDied when called
+ */
+HWTEST(AudioResourceServiceUnitTest, OnWorkgroupRemoteDied_001, TestSize.Level0)
+{
+    std::shared_ptr<AudioWorkgroup> workgroup = std::make_shared<AudioWorkgroup>(testRtgId);
+    std::shared_ptr<AudioWorkgroup> workGroup = std::make_shared<AudioWorkgroup>(testRtgId);
+    sptr<IRemoteObject> remoteObj = nullptr;
+
+    audioResourceService.audioWorkgroupMap_[10].groups[testRtgId] = {workGroup};
+    audioResourceService.OnWorkgroupRemoteDied(workgroup, remoteObj);
+    EXPECT_EQ(audioResourceService.audioWorkgroupMap_[10].groups.count(testRtgId), 1);
+}
+
+/**
+ * @tc.name  : Test AudioWorkgroupCheck
+ * @tc.type  : FUNC
+ * @tc.number: AudioWorkgroupCheck
+ * @tc.desc  : Test ReleaseWorkgroupDeathRecipient when find workgroup
+ */
+HWTEST(AudioResourceServiceUnitTest, AudioWorkgroupCheck_008, TestSize.Level0)
+{
+    int32_t pid = 4321;
+    for (int i = 0; i <= AUDIO_MAX_GRP_PER_PROCESS; i++) {
+        audioResourceService.audioWorkgroupMap_[pid].groups[i] = nullptr;
+    }
+    EXPECT_TRUE(audioResourceService.IsProcessInWorkgroup(pid));
+    EXPECT_EQ(audioResourceService.AudioWorkgroupCheck(pid), ERR_NOT_SUPPORTED);
+
+    pid = 532;
+    audioResourceService.audioWorkgroupMap_[pid].groups[pid] = nullptr;
+    audioResourceService.audioWorkgroupMap_[pid].hasSystemPermission = false;
+
+    for (int i = 0; i <= AUDIO_MAX_PROCESS; i++) {
+        audioResourceService.audioWorkgroupMap_[i].groups[i] = nullptr;
+    }
+    EXPECT_FALSE(audioResourceService.IsProcessInWorkgroup(pid + 1));
+    EXPECT_EQ(audioResourceService.AudioWorkgroupCheck(pid + 1), ERR_NOT_SUPPORTED);
+}
+
 /**
  * @tc.name  : AudioWorkgroupCheck
  * @tc.type  : FUNC
diff --git a/services/audio_service/test/unittest/audio_server_dump_unit_test/src/audio_server_hpae_dump_unit_test.cpp b/services/audio_service/test/unittest/audio_server_dump_unit_test/src/audio_server_hpae_dump_unit_test.cpp
index 797670bd6bddd45b0102404756876ec1e1d7f498..3f1f9954c1854cdc3c33a7bb430e2cb98c2dfb25 100644
--- a/services/audio_service/test/unittest/audio_server_dump_unit_test/src/audio_server_hpae_dump_unit_test.cpp
+++ b/services/audio_service/test/unittest/audio_server_dump_unit_test/src/audio_server_hpae_dump_unit_test.cpp
@@ -87,12 +87,43 @@ TEST_F(HpaeAudioServerHpaeDumpTest, HpaeAudioServerHpaeDumpTest_002)
 
     HpaeSinkSourceInfo sourceInfo = { "Built_in_mic", "" };
     audioServerHpaeDump_->devicesInfo_.sourceInfos.push_back(sourceInfo);
-    dumpString = "";
+    dumpString.clear();
     audioServerHpaeDump_->RecordSourceDump(dumpString);
     EXPECT_EQ(dumpString.empty(), false);
 
     std::queue<std::u16string> argQue;
-    dumpString = "";
+    dumpString.clear();
+    audioServerHpaeDump_->ArgDataDump(dumpString, argQue);
+    EXPECT_EQ(dumpString.empty(), false);
+}
+
+TEST_F(HpaeAudioServerHpaeDumpTest, ArgDataDump_001)
+{
+    bool isTrue = audioServerHpaeDump_->GetDevicesInfo();
+    EXPECT_EQ(isTrue, true);
+    std::string dumpString;
+
+    std::queue<std::u16string> argQue;
+    argQue.push(u"-h");
+    dumpString.clear();
+    audioServerHpaeDump_->ArgDataDump(dumpString, argQue);
+    EXPECT_EQ(dumpString.empty(), false);
+
+    argQue.pop();
+    argQue.push(u"-p");
+    dumpString.clear();
+    audioServerHpaeDump_->ArgDataDump(dumpString, argQue);
+    EXPECT_EQ(dumpString.empty(), false);
+
+    argQue.pop();
+    argQue.push(u"-f");
+    dumpString.clear();
+    audioServerHpaeDump_->ArgDataDump(dumpString, argQue);
+    EXPECT_EQ(dumpString.empty(), false);
+
+    argQue.pop();
+    argQue.push(u"-m");
+    dumpString.clear();
     audioServerHpaeDump_->ArgDataDump(dumpString, argQue);
     EXPECT_EQ(dumpString.empty(), false);
 }
diff --git a/services/audio_service/test/unittest/client/i_audio_stream_unit_test.cpp b/services/audio_service/test/unittest/client/i_audio_stream_unit_test.cpp
index 5d60c467d0b4427be784146c592b22c40263d4a0..16ddb254963663a5813d769e8a52bbae9948fbe7 100644
--- a/services/audio_service/test/unittest/client/i_audio_stream_unit_test.cpp
+++ b/services/audio_service/test/unittest/client/i_audio_stream_unit_test.cpp
@@ -24,6 +24,7 @@
 #include "audio_policy_manager.h"
 #include "capturer_in_client.h"
 #include "renderer_in_client.h"
+#include "capturer_in_client_inner.h"
 
 using namespace testing::ext;
 
@@ -117,5 +118,87 @@ HWTEST(IAudioStreamUnitTest, IsStreamSupported_002, TestSize.Level1)
     bool result = IAudioStream::IsStreamSupported(streamFlags, params);
     EXPECT_FALSE(result);
 }
+
+/**
+ * @tc.name  : Test GetByteSizePerFrame API
+ * @tc.type  : FUNC
+ * @tc.number: GetByteSizePerFrame_004
+ * @tc.desc  : Test GetByteSizePerFrame interface.
+ */
+HWTEST(IAudioStreamUnitTest, GetByteSizePerFrame_004, TestSize.Level1)
+{
+    AudioStreamParams params = {SAMPLE_RATE_48000, 100, SAMPLE_F32LE, 0};
+    size_t result = 0;
+    int32_t ret = IAudioStream::GetByteSizePerFrame(params, result);
+    EXPECT_EQ(ret, ERR_INVALID_PARAM);
+
+    params = {SAMPLE_RATE_48000, 100, SAMPLE_S32LE, 17};
+    ret = IAudioStream::GetByteSizePerFrame(params, result);
+    EXPECT_EQ(ret, ERR_INVALID_PARAM);
+
+    params = {SAMPLE_RATE_48000, 100, SAMPLE_S32LE, 5};
+    ret = IAudioStream::GetByteSizePerFrame(params, result);
+    EXPECT_EQ(ret, SUCCESS);
+}
+
+/**
+ * @tc.name  : Test IsStreamSupported API
+ * @tc.type  : FUNC
+ * @tc.number: IsPlaybackChannelRelatedInfoValid_001
+ * @tc.desc  : Test IsPlaybackChannelRelatedInfoValid interface.
+ */
+HWTEST(IAudioStreamUnitTest, IsPlaybackChannelRelatedInfoValid_001, TestSize.Level1)
+{
+    std::shared_ptr<CapturerInClientInner> capturerInClientInner_ =
+        std::make_shared<CapturerInClientInner>(AudioStreamType::STREAM_MUSIC, 0);
+    std::uint8_t audioChannel = 100;
+    std::uint64_t channelLayout = 100;
+    EXPECT_FALSE(capturerInClientInner_->IsPlaybackChannelRelatedInfoValid(audioChannel, channelLayout));
+
+    audioChannel = 2;
+    channelLayout = 100;
+    EXPECT_FALSE(capturerInClientInner_->IsPlaybackChannelRelatedInfoValid(audioChannel, channelLayout));
+}
+
+/**
+ * @tc.name  : Test IsStreamSupported API
+ * @tc.type  : FUNC
+ * @tc.number: IsPlaybackChannelRelatedInfoValid_001
+ * @tc.desc  : Test IsPlaybackChannelRelatedInfoValid interface.
+ */
+HWTEST(IAudioStreamUnitTest, IsRecordChannelRelatedInfoValid_001, TestSize.Level1)
+{
+    std::shared_ptr<CapturerInClientInner> capturerInClientInner_ =
+        std::make_shared<CapturerInClientInner>(AudioStreamType::STREAM_MUSIC, 0);
+    std::uint8_t audioChannel = 2;
+    std::uint64_t channelLayout = 100;
+    EXPECT_FALSE(capturerInClientInner_->IsRecordChannelRelatedInfoValid(audioChannel, channelLayout));
+}
+
+/**
+ * @tc.name  : Test IsStreamSupported API
+ * @tc.type  : FUNC
+ * @tc.number: IsStreamSupported_003
+ * @tc.desc  : Test IsStreamSupported interface.
+ */
+HWTEST(IAudioStreamUnitTest, IsStreamSupported_003, TestSize.Level1)
+{
+    int32_t streamFlags = STREAM_FLAG_FAST;
+    std::uint8_t channels = 0;
+    std::uint8_t format = SAMPLE_S16LE;
+    AudioStreamParams params = {SAMPLE_RATE_11025, SAMPLE_S16LE, format, channels};
+    bool result = IAudioStream::IsStreamSupported(streamFlags, params);
+    EXPECT_FALSE(result);
+
+    channels = 2;
+    format = SAMPLE_S16LE;
+    params = {SAMPLE_RATE_48000, SAMPLE_S16LE, format, channels};
+    result = IAudioStream::IsStreamSupported(streamFlags, params);
+    EXPECT_TRUE(result);
+
+    
+    result = IAudioStream::IsStreamSupported(2, params);
+    EXPECT_TRUE(result);
+}
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/test/unittest/common/audio_volume_unit_test.cpp b/services/audio_service/test/unittest/common/audio_volume_unit_test.cpp
index 8064d9efa53bf6ca2dee96d6b08e2e713bc91724..0c05c86012e86766eb8e9cd917fc80346095a247 100644
--- a/services/audio_service/test/unittest/common/audio_volume_unit_test.cpp
+++ b/services/audio_service/test/unittest/common/audio_volume_unit_test.cpp
@@ -1633,5 +1633,99 @@ HWTEST_F(AudioVolumeUnitTest, SetAppRingMuted_004, TestSize.Level1)
     audioVolumeTest->appVolume_.clear();
     audioVolumeTest->streamVolume_.clear();
 }
+
+/**
+ * @tc.name  : Test AudioVolume API
+ * @tc.type  : FUNC
+ * @tc.number: GetVolume_006
+ * @tc.desc  : Test AudioVolume interface.
+ */
+HWTEST_F(AudioVolumeUnitTest, GetVolume_006, TestSize.Level1)
+{
+    uint32_t sessionId = 2;
+    int32_t volumeType = STREAM_VOICE_ASSISTANT;
+    std::string deviceClass = "speaker";
+    int32_t streamType = STREAM_MUSIC;
+    int32_t streamUsage = STREAM_USAGE_MUSIC;
+    int32_t uid = 1000;
+    int32_t pid = 1000;
+    int32_t mode = 1;
+    bool isVKB = true;
+    ASSERT_TRUE(AudioVolume::GetInstance() != nullptr);
+
+    StreamVolumeParams streamVolumeParams = { sessionId, streamType, streamUsage, uid, pid, false, mode, isVKB };
+    AudioVolume::GetInstance()->AddStreamVolume(streamVolumeParams);
+
+    SystemVolume systemVolume(STREAM_MUSIC, "speaker", 0.5f, 5, true);
+    AudioVolume::GetInstance()->SetSystemVolume(systemVolume);
+
+    struct VolumeValues volumes = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
+    float volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes);
+    EXPECT_EQ(volume, 0.0f);
+
+    streamVolumeParams = { sessionId, streamType, streamUsage, uid, pid, true, mode, isVKB };
+    AudioVolume::GetInstance()->AddStreamVolume(streamVolumeParams);
+    volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes);
+    EXPECT_EQ(volumes.volumeStream, 1.0f);
+
+    volumeType = STREAM_SYSTEM;
+    volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes);
+    EXPECT_EQ(volumes.volumeStream, 1.0f);
+
+    volumeType = STREAM_VOICE_CALL;
+    volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes);
+    EXPECT_EQ(volumes.volumeStream, 1.0f);
+
+    volumeType = STREAM_VOICE_COMMUNICATION;
+    volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes);
+    EXPECT_EQ(volumes.volumeStream, 1.0f);
+
+    volumes = {1.0f, 0.0f, 0.0f, 0.0f, 0.0f};
+    volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes);
+    EXPECT_EQ(volumes.volumeStream, 1.0f);
+}
+
+/**
+ * @tc.name  : Test AudioVolume API
+ * @tc.type  : FUNC
+ * @tc.number: GetStreamVolume_002
+ * @tc.desc  : Test AudioVolume interface.
+ */
+HWTEST_F(AudioVolumeUnitTest, GetStreamVolume_002, TestSize.Level1)
+{
+    uint32_t sessionId = 531;
+    int32_t streamType = STREAM_MUSIC;
+    int32_t streamUsage = STREAM_USAGE_MUSIC;
+    int32_t uid = 1000;
+    int32_t pid = 1000;
+    int32_t mode = 1;
+    bool isVKB = true;
+    ASSERT_TRUE(AudioVolume::GetInstance() != nullptr);
+
+    StreamVolumeParams streamVolumeParams = { sessionId, streamType, streamUsage, uid, pid, false, mode, isVKB };
+    AudioVolume::GetInstance()->AddStreamVolume(streamVolumeParams);
+    bool isMuted = true;
+    AudioVolume::GetInstance()->SetStreamVolumeMute(sessionId, isMuted);
+
+    float volumeStream = AudioVolume::GetInstance()->GetStreamVolume(sessionId);
+    EXPECT_EQ(volumeStream, 0.0f);
+
+    volumeStream = AudioVolume::GetInstance()->GetStreamVolume(sessionId + 1);
+    EXPECT_EQ(volumeStream, 1.0f);
+}
+
+/**
+ * @tc.name  : Test GetCurVolume_002 API
+ * @tc.type  : FUNC
+ * @tc.number: GetCurVolume_004
+ * @tc.desc  : Test GetCurVolume_002 interface
+ */
+HWTEST_F(AudioVolumeUnitTest, GetStopFadeoutState_004, TestSize.Level1)
+{
+    uint32_t streamIndex = 1;
+    AudioVolume::GetInstance()->SetStopFadeoutState(streamIndex, 1);
+    uint32_t result = AudioVolume::GetInstance()->GetStopFadeoutState(streamIndex);
+    EXPECT_EQ(result, 1);
+}
 }  // namespace OHOS::AudioStandard
 }  // namespace OHOS