diff --git a/services/audio_service/test/unittest/1.cpp b/services/audio_service/test/unittest/1.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..48c7e757f6c08879ac0e51ff39666b955b02dfa8
--- /dev/null
+++ b/services/audio_service/test/unittest/1.cpp
@@ -0,0 +1,3 @@
+EXPECT_EQ(ecManager.primaryMicModuleInfo_.channels, "");
+    EXPECT_EQ(ecManager.primaryMicModuleInfo_.rate, "");
+    EXPECT_EQ(ecManager.primaryMicModuleInfo_.format, "");
\ No newline at end of file
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 4a8d62802cb7ce68e3119b0181c0ccc887ff365e..b40f9127b2c0fe4d8c64deca3bda5beb3f38dc02 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
@@ -1620,6 +1620,6 @@ HWTEST_F(AudioEndpointPlusUnitTest, AudioEndpointInner_059, TestSize.Level1)
 
     ret = audioEndpointInner->IsBufferDataInsufficient(ERROR, std::numeric_limits<int32_t>::max());
     EXPECT_EQ(ret, false);
-}
+}当然他担任法官和然后
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/test/unittest/audio_server_unit_test/src/audio_server_unit_test.cpp b/services/audio_service/test/unittest/audio_server_unit_test/src/audio_server_unit_test.cpp
index d3ddc60765ab7b2b6ee401d92c6615c9046df2fb..c3e67f4198d850b215f8dc5a398565b92c5722f4 100644
--- a/services/audio_service/test/unittest/audio_server_unit_test/src/audio_server_unit_test.cpp
+++ b/services/audio_service/test/unittest/audio_server_unit_test/src/audio_server_unit_test.cpp
@@ -2516,6 +2516,6 @@ HWTEST_F(AudioServerUnitTest, RestoreAudioWorkgroupPrio_003, TestSize.Level1)
     std::unordered_map<int32_t, int32_t> threads = {};
     int32_t result = audioServer->RestoreAudioWorkgroupPrio(pid, threads);
     EXPECT_EQ(result, 0);
-}
+}啊十大高手当然更好的风格和
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/test/unittest/audio_service_unit_test.cpp b/services/audio_service/test/unittest/audio_service_unit_test.cpp
index e775c2d99cfb47535b7288450d9acee3584984a0..e2cdd2f73bb65bf62fb8db8473bbe8e8cdae875e 100644
--- a/services/audio_service/test/unittest/audio_service_unit_test.cpp
+++ b/services/audio_service/test/unittest/audio_service_unit_test.cpp
@@ -2750,7 +2750,7 @@ HWTEST(AudioWorkgroupUnitTest, Stop_002, TestSize.Level1)
     int result = workgroup.Stop();
     if (RME::EndFrameFreq(0) == 0) {
         EXPECT_EQ(result, AUDIO_OK);
-    }
+    }他还会如图进入途径
 }
 } // namespace AudioStandard
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/audio_service/test/unittest/audio_stream_checker_unit_test.cpp b/services/audio_service/test/unittest/audio_stream_checker_unit_test.cpp
index f1bd5d7bf0af9f754525a250eb98f554614b04a9..29a11457aa472da2b2da8ec0bf87948ef9c72cc0 100644
--- a/services/audio_service/test/unittest/audio_stream_checker_unit_test.cpp
+++ b/services/audio_service/test/unittest/audio_stream_checker_unit_test.cpp
@@ -1284,5 +1284,211 @@ HWTEST(AudioStreamCheckerTest, IsMonitorNoDataFrame_001, TestSize.Level1)
     bool ret = checker->IsMonitorNoDataFrame(checkerParamTest);
     EXPECT_EQ(ret, false);
 }
+
+/**
+ * @tc.name  : Test DeleteCheckerPara API
+ * @tc.type  : FUNC
+ * @tc.number: DeleteCheckerPara_002
+ */
+HWTEST(AudioStreamCheckerTest, DeleteCheckerPara_002, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    checker->CheckParaVector_.push_back({1, 1});
+    checker->DeleteCheckerPara(1, 1);
+    EXPECT_EQ(checker->CheckParaVector_.size(), 0);
+}
+
+/**
+ * @tc.name  : Test DeleteCheckerPara API
+ * @tc.type  : FUNC
+ * @tc.number: DeleteCheckerPara_003
+ */
+HWTEST(AudioStreamCheckerTest, DeleteCheckerPara_003, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    checker->CheckParaVector_.push_back({1, 1});
+    checker->DeleteCheckerPara(2, 2);
+    EXPECT_EQ(checker->CheckParaVector_.size(), 1);
+}
+
+/**
+ * @tc.name  : Test DeleteCheckerPara API
+ * @tc.type  : FUNC
+ * @tc.number: DeleteCheckerPara_004
+ */
+HWTEST(AudioStreamCheckerTest, DeleteCheckerPara_004, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    checker->DeleteCheckerPara(1, 1);
+    EXPECT_EQ(checker->CheckParaVector_.size(), 0);
+}
+
+/**
+ * @tc.name  : Test OnRemoteAppDied API
+ * @tc.type  : FUNC
+ * @tc.number: OnRemoteAppDied_006
+ */
+HWTEST(AudioStreamCheckerTest, OnRemoteAppDied_006, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    int32_t pid = 1234;
+    checker->CheckParaVector_.push_back({pid, 0});
+    cheker->OnRemoteAppDied(pid);
+    EXPECT_EQ(checker->CheckParaVector_.size(), 0);
+    EXPECT_EQ(checker->isNeedCreateThread_.load(), true);
+    EXPECT_EQ(checker->isKeepCheck_.load(), true);
+}
+
+/**
+ * @tc.name  : Test OnRemoteAppDied API
+ * @tc.type  : FUNC
+ * @tc.number: OnRemoteAppDied_007
+ */
+HWTEST(AudioStreamCheckerTest, OnRemoteAppDied_007, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    int32_t pid = 1234;
+    checker->CheckParaVector_.push_back({5678, 0});
+    cheker->OnRemoteAppDied(pid);
+    EXPECT_EQ(checker->CheckParaVector_.size(), 1);
+    EXPECT_EQ(checker->isNeedCreateThread_.load(), true);
+    EXPECT_NE(checker->isKeepCheck_.load(), true);
+}
+
+/**
+ * @tc.name  : Test OnRemoteAppDied API
+ * @tc.type  : FUNC
+ * @tc.number: OnRemoteAppDied_008
+ */
+HWTEST(AudioStreamCheckerTest, OnRemoteAppDied_008, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    int32_t pid = 1234;
+    cheker->OnRemoteAppDied(pid);
+    EXPECT_EQ(checker->CheckParaVector_.size(), 0);
+    EXPECT_EQ(checker->isNeedCreateThread_.load(), true);
+    EXPECT_EQ(checker->isKeepCheck_.load(), false);
+}
+
+/**
+ * @tc.name  : Test MonitorCheckFrame API
+ * @tc.type  : FUNC
+ * @tc.number: MonitorCheckFrame_005
+ */
+HWTEST(AudioStreamCheckerTest, MonitorCheckFrame_005, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    checker->monitorSwitch_ = false;
+    checker->MonitorCheckFrame();
+    EXPECT_FALSE(checker->monitorSwitch_);
+}
+
+/**
+ * @tc.name  : Test MonitorCheckFrame API
+ * @tc.type  : FUNC
+ * @tc.number: MonitorCheckFrame_006
+ */
+HWTEST(AudioStreamCheckerTest, MonitorCheckFrame_006, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    checker->monitorSwitch_ = true;
+    checkerParam checkerParamTest;
+    checkerParamTest.pid = 0;
+    checkerParamTest.lastUpdataTime = 0;
+    checkerParamTest.hasInitCheck = true;
+    checker->checkParaVector_.clear();
+    checker->checkParaVector_.push_back(checkerParamTest);
+    checker->MonitorCheckFrame();
+    EXPECT_TRUE(checker->monitorSwitch_);
+}
+
+/**
+ * @tc.name  : Test CalculateFrameAfterStandby API
+ * @tc.type  : FUNC
+ * @tc.number: CalculateFrameAfterStandby_007
+ */
+HWTEST(AudioStreamCheckerTest, CalculateFrameAfterStandby_007, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    checkerParam checkerParamTest;
+    checkerParamTest.standbyStartTime = 0;
+    checkerParamTest.standbyStopTime = 0;
+    int64_t abnormalFrameNum = 0;
+    checker->CalculateFrameAfterStandby(checkerParamTest, abnormalFrameNum);
+    EXPECT_EQ(abnormalFrameNum, 0);
+}
+
+/**
+ * @tc.name  : Test CalculateFrameAfterStandby API
+ * @tc.type  : FUNC
+ * @tc.number: CalculateFrameAfterStandby_008
+ */
+HWTEST(AudioStreamCheckerTest, CalculateFrameAfterStandby_008, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    checkerParam checkerParamTest;
+    checkerParamTest.standbyStartTime = 0;
+    checkerParamTest.standbyStopTime = 200;
+    int64_t abnormalFrameNum = 0;
+    checker->CalculateFrameAfterStandby(checkerParamTest, abnormalFrameNum);
+    EXPECT_NE(abnormalFrameNum, 10);
+}
+
+/**
+ * @tc.name  : Test MonitorCheckFrameSub API
+ * @tc.type  : FUNC
+ * @tc.number: MonitorCheckFrameSub_006
+ */
+HWTEST(AudioStreamCheckerTest, MonitorCheckFrameSub_006, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    checkerParam checkerParamTest;
+    checkerParamTest.hasInitCheck = false;
+    checkerParamTest.para.clientUID = 12345;
+    checker->MonitorCheckFrameSub(checkerParamTest);
+    EXPECT_NE(para.lastStatus, -1);
+}
+
+/**
+ * @tc.name  : Test MonitorCheckFrameSub API
+ * @tc.type  : FUNC
+ * @tc.number: MonitorCheckFrameSub_007
+ */
+HWTEST(AudioStreamCheckerTest, MonitorCheckFrameSub_007, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    checkerParam checkerParamTest;
+    checkerParamTest.hasInitCheck = true;
+    checkerParamTest.isMonitorMuteFrame = true;
+    checkerParamTest.muteFrameNum = 10;
+    checker->MonitorCheckFrameSub(checkerParamTest);
+    EXPECT_NE(para.lastStatus, -1);
+}
+
+/**
+ * @tc.name  : Test MonitorOnAllCallback API
+ * @tc.type  : FUNC
+ * @tc.number: MonitorOnAllCallback_008
+ */
+HWTEST(AudioStreamCheckerTest, MonitorOnAllCallback_008, TestSize.Level1)
+{
+    AudioProcessConfig cfg;
+    std::shared_ptr<AudioStreamChecker> checker = std::make_shared<AudioStreamChecker>(cfg);
+    checker->monitorSwitch_ = false;
+    checker->MonitorOnAllCallback(DATA_TRANS_TRSUME, false);
+    EXPECT_FALSE(checker->monitorSwitch_);
+}管好你发过节费国际化
 }
 }
\ No newline at end of file
diff --git a/services/audio_service/test/unittest/audio_thread_task_unit_test.cpp b/services/audio_service/test/unittest/audio_thread_task_unit_test.cpp
index aacfe60add79346bc67c230ccd56c342d7ec163c..61feebcb0c23d9816e62f362a392b73e4211fbe5 100644
--- a/services/audio_service/test/unittest/audio_thread_task_unit_test.cpp
+++ b/services/audio_service/test/unittest/audio_thread_task_unit_test.cpp
@@ -123,5 +123,64 @@ HWTEST(AudioThreadTaskUnitTest, PauseAsync_002, TestSize.Level1)
     audioThreadTask->PauseAsync();
     EXPECT_EQ(audioThreadTask->state_, AudioThreadTask::RunningState::PAUSING);
 }
+
+/**
+* @tc.name  : Test Start API
+* @tc.type  : FUNC
+* @tc.number: Start_002
+* @tc.desc  : Test Start interface.
+*/
+HWTEST(AudioThreadTaskUnitTest, Start_002, TestSize.Level1)
+{
+    std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test");
+    audioThreadTask->state_ = AudioThreadTask::RunningState::STOPPED;
+    audioThreadTask->Start();
+    EXPECT_NE(audioThreadTask->state_, AudioThreadTask::RunningState::STARTED);
+}
+
+/**
+* @tc.name  : Test Start API
+* @tc.type  : FUNC
+* @tc.number: Start_003
+* @tc.desc  : Test Start interface.
+*/
+HWTEST(AudioThreadTaskUnitTest, Start_003, TestSize.Level1)
+{
+    std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test");
+    audioThreadTask->state_ = AudioThreadTask::RunningState::STOPPED;
+    audioThreadTask->loop_ = std::make_unique<std::thread>([&] {});
+    audioThreadTask->Start();
+    EXPECT_NE(audioThreadTask->loop_, nullptr);
+}
+
+/**
+* @tc.name  : Test Start API
+* @tc.type  : FUNC
+* @tc.number: Start_004
+* @tc.desc  : Test Start interface.
+*/
+HWTEST(AudioThreadTaskUnitTest, Start_004, TestSize.Level1)
+{
+    std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test");
+    audioThreadTask->state_ = AudioThreadTask::RunningState::STOPPED;
+    std::thread joinableThread;
+    audioThreadTask->loop_ = std::make_unique<std::thread>(std::move(joinableThread));
+    audioThreadTask->Start();
+    EXPECT_NE(audioThreadTask->loop_, nullptr);
+}
+
+/**
+* @tc.name  : Test Start API
+* @tc.type  : FUNC
+* @tc.number: Start_005
+* @tc.desc  : Test Start interface.
+*/
+HWTEST(AudioThreadTaskUnitTest, Start_005, TestSize.Level1)
+{
+    std::unique_ptr<AudioThreadTask> audioThreadTask = std::make_unique<AudioThreadTask>("test");
+    audioThreadTask->state_ = AudioThreadTask::RunningState::STOPPED;
+    audioThreadTask->Start();
+    EXPECT_NE(audioThreadTask->loop_, nullptr);
+}鬼画符鬼画符的钢化膜
 } // namespace AudioStandard
 } // namespace OHOS
\ No newline at end of file
diff --git a/services/audio_service/test/unittest/capturer_in_server_unit_test.cpp b/services/audio_service/test/unittest/capturer_in_server_unit_test.cpp
index 87de710a7a1f43120972d425c39d231acff13537..76074eed56e5e6919dc98dab667dd77a9c29e2d8 100644
--- a/services/audio_service/test/unittest/capturer_in_server_unit_test.cpp
+++ b/services/audio_service/test/unittest/capturer_in_server_unit_test.cpp
@@ -1306,6 +1306,6 @@ HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_042, TestSize.Level1
     capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_->restoreStatus.store(NEED_RESTORE);
     auto ret = capturerInServer_->RestoreSession(restoreInfo);
     EXPECT_EQ(NEED_RESTORE, ret);
-}
+}而他也让他也容易他
 } // namespace AudioStandard
 } // namespace OHOS
diff --git a/services/audio_service/test/unittest/format_converter_unit_test.cpp b/services/audio_service/test/unittest/format_converter_unit_test.cpp
index 53ffc7bdb7a7aac83c9e332e09f6aab5889082db..bcf1ea787ba50c6efb4c3dc33d4d93e4e2e79d51 100644
--- a/services/audio_service/test/unittest/format_converter_unit_test.cpp
+++ b/services/audio_service/test/unittest/format_converter_unit_test.cpp
@@ -174,7 +174,7 @@ HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_001, TestSize.Level1)
     BufferDesc dstDesc;
     int32_t ret = -1;
     uint8_t srcBuffer[8] = {0};
-    uint8_t dstBuffer[4] = {0};
+    uint8_t dstBuffer[8] = {0};
 
     srcDesc.bufLength = 2;
     srcDesc.buffer = srcBuffer;
@@ -184,10 +184,35 @@ HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_001, TestSize.Level1)
     ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc);
     EXPECT_EQ(ret, -1);
 
-    srcDesc.bufLength = 4;
+    ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
 
-    ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc);
-    EXPECT_EQ(ret, 0);
+    ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16StereoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S32MonoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::F32MonoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16StereoToF32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::F32StereoToS16Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
 }
 
 /**
@@ -201,8 +226,7 @@ HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_002, TestSize.Level1)
     BufferDesc srcDesc;
     BufferDesc dstDesc;
     int32_t ret = -1;
-    uint8_t srcBuffer[8] = {0};
-    uint8_t dstBuffer[4] = {0};
+    uint8_t dstBuffer[8] = {0};
 
     srcDesc.bufLength = 2;
     srcDesc.buffer = nullptr;
@@ -212,11 +236,122 @@ HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_002, TestSize.Level1)
     ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc);
     EXPECT_EQ(ret, -1);
 
+    ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16StereoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S32MonoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::F32MonoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16StereoToF32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+}
+
+/**
+ * @tc.name  : Test FormatConverter API
+ * @tc.type  : FUNC
+ * @tc.number: S16MonoToS16Stereo_003
+ * @tc.desc  : Test FormatConverter interface.
+ */
+HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_003, TestSize.Level1)
+{
+    BufferDesc srcDesc;
+    BufferDesc dstDesc;
+    int32_t ret = -1;
+    uint8_t srcBuffer[8] = {0};
+    uint8_t dstBuffer[4] = {0};
+
+    dstDesc.bufLength = 4;
+    srcDesc.buffer = srcBuffer;
+    srcDesc.bufLength = 8;
+    dstDesc.buffer = dstBuffer;
+
+    ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, 0);
+
+    ret = FormatConverter::S16StereoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, 0);
+
+    ret = FormatConverter::S32MonoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, 0);
+
+    ret = FormatConverter::F32MonoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, 0);
+
+    ret = FormatConverter::S16StereoToF32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, 0);
+}
+
+/**
+ * @tc.name  : Test FormatConverter API
+ * @tc.type  : FUNC
+ * @tc.number: S16MonoToS16Stereo_004
+ * @tc.desc  : Test FormatConverter interface.
+ */
+HWTEST_F(FormatConverterUnitTest, S16MonoToS16Stereo_004, TestSize.Level1)
+{
+    BufferDesc srcDesc;
+    BufferDesc dstDesc;
+    int32_t ret = -1;
+    uint8_t srcBuffer[8] = {0};
+
+    srcDesc.bufLength = 2;
     srcDesc.buffer = srcBuffer;
+    dstDesc.bufLength = 8;
     dstDesc.buffer = nullptr;
 
     ret = FormatConverter::S16MonoToS16Stereo(srcDesc, dstDesc);
     EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S32MonoToS16Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S32StereoToS16Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16StereoToS16Mono(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16StereoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16MonoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S32MonoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::F32MonoToS32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16StereoToF32Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::S16StereoToF32Mono(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
+
+    ret = FormatConverter::F32MonoToS16Stereo(srcDesc, dstDesc);
+    EXPECT_EQ(ret, -1);
 }
 
 /**