diff --git a/audio/test/unittest/common/adapter/audio_adapter_common_test.cpp b/audio/test/unittest/common/adapter/audio_adapter_common_test.cpp
index 64f387c4fa502fdc470820e322d3dfc00f0e6368..c9c859c4b59537789dd17f8c6377c5b26bef2319 100644
--- a/audio/test/unittest/common/adapter/audio_adapter_common_test.cpp
+++ b/audio/test/unittest/common/adapter/audio_adapter_common_test.cpp
@@ -203,6 +203,488 @@ HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid001, TestSize.
     EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
 }
 
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid002, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_NONE;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+    EXPECT_NE(HDF_SUCCESS, ret);
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid003, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_HEADSET;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid004, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_LINEOUT;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+    EXPECT_NE(HDF_SUCCESS, ret);
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid005, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_HDMI;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid006, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_USB;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid007, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_USB_EXT;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid008, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_EARPIECE;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid009, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_BLUETOOTH_SCO;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid010, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_DAUDIO_DEFAULT;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid011, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_HEADPHONE;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid012, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_USB_HEADSET;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid013, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_BLUETOOTH_A2DP;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid014, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_DP;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid015, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_SPEAKER;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    attrs.type = AUDIO_IN_COMMUNICATION;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid016, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_SPEAKER;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    attrs.type = AUDIO_IN_RINGTONE;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid017, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_SPEAKER;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    attrs.type = AUDIO_IN_CALL;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid018, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_SPEAKER;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    attrs.type = AUDIO_MMAP_NOIRQ;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid019, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_SPEAKER;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    attrs.type = AUDIO_OFFLOAD;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid020, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_SPEAKER;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    attrs.type = AUDIO_MULTI_CHANNEL;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid021, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_SPEAKER;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    attrs.type = AUDIO_DP;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid022, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_SPEAKER;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    attrs.type = AUDIO_MMAP_VOIP;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid023, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_SPEAKER;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    attrs.type = AUDIO_IN_NAVIGATION;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid024, TestSize.Level0)
+{
+    struct IAudioRender *render = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_OUT_SPEAKER;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = 0;
+    attrs.streamId = 0;
+    attrs.type = AUDIO_DIRECT;
+    int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
+#ifdef AUDIO_FEATURE_COMMUNITY
+    EXPECT_NE(HDF_SUCCESS, ret);
+#else
+    if (ret != HDF_SUCCESS) {
+        attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
+        ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
+    }
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
+#endif
+}
+
 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterDestroyRenderNull001, TestSize.Level1)
 {
     EXPECT_NE(HDF_SUCCESS, adapter_->DestroyRender(nullptr, renderId_));
@@ -353,6 +835,216 @@ HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid007, TestSize
     EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
 }
 
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid008, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_MIC;
+    InitAttrs(attrs);
+    attrs.sourceType = AUDIO_INPUT_RAW_TYPE;
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid009, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_MIC;
+    InitAttrs(attrs);
+    attrs.sourceType = AUDIO_INPUT_LIVE_TYPE;
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid010, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_MIC;
+    InitAttrs(attrs);
+    attrs.sourceType = AUDIO_INPUT_DEFAULT_TYPE;
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid011, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_MIC;
+    InitAttrs(attrs);
+    attrs.sourceType = AUDIO_INPUT_MIC_TYPE;
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid012, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_MIC;
+    InitAttrs(attrs);
+    attrs.sourceType = AUDIO_INPUT_SPEECH_WAKEUP_TYPE;
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid013, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_MIC;
+    InitAttrs(attrs);
+    attrs.sourceType = AUDIO_INPUT_VOICE_COMMUNICATION_TYPE;
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid014, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_MIC;
+    InitAttrs(attrs);
+    attrs.sourceType = AUDIO_INPUT_VOICE_RECOGNITION_TYPE;
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
+}
+
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid015, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_HS_MIC;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+    EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid016, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_LINEIN;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_NE(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid017, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_USB_EXT;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_NE(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid018, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_BLUETOOTH_SCO_HEADSET;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_NE(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid019, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_DAUDIO_DEFAULT;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_NE(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid020, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_USB_HEADSET;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_NE(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid021, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_PENCIL;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_NE(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid022, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_UWB;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_NE(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+}
+HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid023, TestSize.Level0)
+{
+    struct IAudioCapture *capture = nullptr;
+    struct AudioDeviceDescriptor devicedesc = {};
+    struct AudioSampleAttributes attrs = {};
+    InitDevDesc(devicedesc);
+    devicedesc.desc = const_cast<char*>("primary");
+    devicedesc.pins = PIN_IN_NEARLINK;
+    InitAttrs(attrs);
+    attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
+    EXPECT_NE(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
+}
+
+
 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterDestroyCaptureNull001, TestSize.Level1)
 {
     EXPECT_NE(HDF_SUCCESS, adapter_->DestroyCapture(nullptr, captureId_));
diff --git a/audio/test/unittest/common/types/audio_types_test.cpp b/audio/test/unittest/common/types/audio_types_test.cpp
index edaa96be05392a47323d1e4f74aca059617740a5..768111eb8082997557ba192581bb7ba02c36589a 100644
--- a/audio/test/unittest/common/types/audio_types_test.cpp
+++ b/audio/test/unittest/common/types/audio_types_test.cpp
@@ -35,6 +35,58 @@ void HdfAudioUtTypesTest::TearDown()
 {
 }
 
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioPortDirection001, TestSize.Level0)
+{
+    EXPECT_EQ(PORT_OUT, (AudioPortDirection)(1));
+    EXPECT_EQ(PORT_IN, (AudioPortDirection)(2));
+    EXPECT_EQ(PORT_OUT_IN, (AudioPortDirection)(3));
+}
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioPortPin001, TestSize.Level0)
+{
+    EXPECT_EQ(PIN_NONE, (AudioPortPin)(0));
+    EXPECT_EQ(PIN_OUT_SPEAKER, (AudioPortPin)(1 << 0));
+    EXPECT_EQ(PIN_OUT_HEADSET, (AudioPortPin)(1 << 1));
+    EXPECT_EQ(PIN_OUT_LINEOUT, (AudioPortPin)(1 << 2));
+    EXPECT_EQ(PIN_OUT_HDMI, (AudioPortPin)(1 << 3));
+    EXPECT_EQ(PIN_OUT_USB, (AudioPortPin)(1 << 4));
+    EXPECT_EQ(PIN_OUT_USB_EXT, (AudioPortPin)(1 << 5));
+    EXPECT_EQ(PIN_OUT_EARPIECE, (AudioPortPin)(1 << 5 | 1 << 4));
+    EXPECT_EQ(PIN_OUT_BLUETOOTH_SCO, (AudioPortPin)(1 << 6));
+    EXPECT_EQ(PIN_OUT_DAUDIO_DEFAULT, (AudioPortPin)(1 << 7));
+    EXPECT_EQ(PIN_OUT_HEADPHONE, (AudioPortPin)(1 << 8));
+    EXPECT_EQ(PIN_OUT_USB_HEADSET, (AudioPortPin)(1 << 9));
+    EXPECT_EQ(PIN_OUT_BLUETOOTH_A2DP, (AudioPortPin)(1 << 10));
+    EXPECT_EQ(PIN_OUT_DP, (AudioPortPin)(1 << 11));
+    EXPECT_EQ(PIN_OUT_NEARLINK_SCO, (AudioPortPin)(1 << 12));
+    EXPECT_EQ(PIN_OUT_NEARLINK, (AudioPortPin)(1 << 13));
+    EXPECT_EQ(PIN_IN_MIC, (AudioPortPin)(1 << 27 | 1 << 0));
+    EXPECT_EQ(PIN_IN_HS_MIC, (AudioPortPin)(1 << 27 | 1 << 1));
+    EXPECT_EQ(PIN_IN_LINEIN, (AudioPortPin)(1 << 27 | 1 << 2));
+    EXPECT_EQ(PIN_IN_USB_EXT, (AudioPortPin)(1 << 27 | 1 << 3));
+    EXPECT_EQ(PIN_IN_BLUETOOTH_SCO_HEADSET, (AudioPortPin)(1 << 27 | 1 << 4));
+    EXPECT_EQ(PIN_IN_DAUDIO_DEFAULT, (AudioPortPin)(1 << 27 | 1 << 5));
+    EXPECT_EQ(PIN_IN_USB_HEADSET, (AudioPortPin)(1 << 27 | 1 << 6));
+    EXPECT_EQ(PIN_IN_PENCIL, (AudioPortPin)(1 << 27 | 1 << 7));
+    EXPECT_EQ(PIN_IN_UWB, (AudioPortPin)(1 << 27 | 1 << 8));
+    EXPECT_EQ(PIN_IN_NEARLINK, (AudioPortPin)(1 << 27 | 1 << 9));
+}
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioCategory001, TestSize.Level0)
+{
+    EXPECT_EQ(AUDIO_IN_MEDIA, (AudioCategory)(0));
+    EXPECT_EQ(AUDIO_IN_COMMUNICATION, (AudioCategory)(1));
+    EXPECT_EQ(AUDIO_IN_RINGTONE, (AudioCategory)(2));
+    EXPECT_EQ(AUDIO_IN_CALL, (AudioCategory)(3));
+    EXPECT_EQ(AUDIO_MMAP_NOIRQ, (AudioCategory)(4));
+    EXPECT_EQ(AUDIO_OFFLOAD, (AudioCategory)(5));
+    EXPECT_EQ(AUDIO_MULTI_CHANNEL, (AudioCategory)(6));
+    EXPECT_EQ(AUDIO_DP, (AudioCategory)(7));
+    EXPECT_EQ(AUDIO_MMAP_VOIP, (AudioCategory)(8));
+    EXPECT_EQ(AUDIO_IN_NAVIGATION, (AudioCategory)(9));
+    EXPECT_EQ(AUDIO_DIRECT, (AudioCategory)(10));
+}
+
 HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioFormat001, TestSize.Level0)
 {
     EXPECT_EQ(AUDIO_FORMAT_TYPE_PCM_8_BIT, (AudioFormat)(1 << 0));
@@ -55,6 +107,107 @@ HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioFormat001, TestSize.Level0)
     EXPECT_EQ(AUDIO_FORMAT_TYPE_G726, (AudioFormat)(1 << 25 | 1 << 1 | 1 << 0));
 }
 
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioSampleRatesMask001, TestSize.Level0)
+{
+    EXPECT_EQ(AUDIO_SAMPLE_RATE_MASK_8000, (AudioSampleRatesMask)(1 << 0));
+    EXPECT_EQ(AUDIO_SAMPLE_RATE_MASK_12000, (AudioSampleRatesMask)(1 << 1));
+    EXPECT_EQ(AUDIO_SAMPLE_RATE_MASK_11025, (AudioSampleRatesMask)(1 << 2));
+    EXPECT_EQ(AUDIO_SAMPLE_RATE_MASK_16000, (AudioSampleRatesMask)(1 << 3));
+    EXPECT_EQ(AUDIO_SAMPLE_RATE_MASK_22050, (AudioSampleRatesMask)(1 << 4));
+    EXPECT_EQ(AUDIO_SAMPLE_RATE_MASK_24000, (AudioSampleRatesMask)(1 << 5));
+    EXPECT_EQ(AUDIO_SAMPLE_RATE_MASK_32000, (AudioSampleRatesMask)(1 << 6));
+    EXPECT_EQ(AUDIO_SAMPLE_RATE_MASK_44100, (AudioSampleRatesMask)(1 << 7));
+    EXPECT_EQ(AUDIO_SAMPLE_RATE_MASK_48000, (AudioSampleRatesMask)(1 << 8));
+    EXPECT_EQ(AUDIO_SAMPLE_RATE_MASK_64000, (AudioSampleRatesMask)(1 << 9));
+    EXPECT_EQ(AUDIO_SAMPLE_RATE_MASK_96000, (AudioSampleRatesMask)(1 << 10));
+}
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioPortPassthroughMode001, TestSize.Level0)
+{
+    EXPECT_EQ(PORT_PASSTHROUGH_LPCM, (AudioPortPassthroughMode)(1 << 0));
+    EXPECT_EQ(PORT_PASSTHROUGH_RAW, (AudioPortPassthroughMode)(1 << 1));
+    EXPECT_EQ(PORT_PASSTHROUGH_HBR2LBR, (AudioPortPassthroughMode)(1 << 2));
+    EXPECT_EQ(PORT_PASSTHROUGH_AUTO, (AudioPortPassthroughMode)(1 << 3));
+}
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioSampleFormat001, TestSize.Level0)
+{
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_S8, (AudioSampleFormat)(0));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_S8P, (AudioSampleFormat)(1));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_U8, (AudioSampleFormat)(2));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_U8P, (AudioSampleFormat)(3));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_S16, (AudioSampleFormat)(4));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_S16P, (AudioSampleFormat)(5));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_U16, (AudioSampleFormat)(6));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_U16P, (AudioSampleFormat)(7));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_S24, (AudioSampleFormat)(8));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_S24P, (AudioSampleFormat)(9));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_U24, (AudioSampleFormat)(10));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_U24P, (AudioSampleFormat)(11));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_S32, (AudioSampleFormat)(12));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_S32P, (AudioSampleFormat)(13));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_U32, (AudioSampleFormat)(14));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_U32P, (AudioSampleFormat)(15));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_S64, (AudioSampleFormat)(16));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_S64P, (AudioSampleFormat)(17));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_U64, (AudioSampleFormat)(18));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_U64P, (AudioSampleFormat)(19));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_F32, (AudioSampleFormat)(20));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_F32P, (AudioSampleFormat)(21));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_F64, (AudioSampleFormat)(22));
+    EXPECT_EQ(AUDIO_SAMPLE_FORMAT_F64P, (AudioSampleFormat)(23));
+}
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioChannelMode001, TestSize.Level0)
+{
+    EXPECT_EQ(AUDIO_CHANNEL_NORMAL, (AudioChannelMode)(0));
+    EXPECT_EQ(AUDIO_CHANNEL_BOTH_LEFT, (AudioChannelMode)(1));
+    EXPECT_EQ(AUDIO_CHANNEL_BOTH_RIGHT, (AudioChannelMode)(2));
+    EXPECT_EQ(AUDIO_CHANNEL_EXCHANGE, (AudioChannelMode)(3));
+    EXPECT_EQ(AUDIO_CHANNEL_MIX, (AudioChannelMode)(4));
+    EXPECT_EQ(AUDIO_CHANNEL_LEFT_MUTE, (AudioChannelMode)(5));
+    EXPECT_EQ(AUDIO_CHANNEL_RIGHT_MUTE, (AudioChannelMode)(6));
+    EXPECT_EQ(AUDIO_CHANNEL_BOTH_MUTE, (AudioChannelMode)(7));
+}
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioDrainNotifyType001, TestSize.Level0)
+{
+    EXPECT_EQ(AUDIO_DRAIN_NORMAL_MODE, (AudioDrainNotifyType)(0));
+    EXPECT_EQ(AUDIO_DRAIN_EARLY_MODE, (AudioDrainNotifyType)(1));
+}
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioCallbackType001, TestSize.Level0)
+{
+    EXPECT_EQ(AUDIO_NONBLOCK_WRITE_COMPLETED, (AudioCallbackType)(0));
+    EXPECT_EQ(AUDIO_DRAIN_COMPLETED, (AudioCallbackType)(1));
+    EXPECT_EQ(AUDIO_FLUSH_COMPLETED, (AudioCallbackType)(2));
+    EXPECT_EQ(AUDIO_RENDER_FULL, (AudioCallbackType)(3));
+    EXPECT_EQ(AUDIO_ERROR_OCCUR, (AudioCallbackType)(4));
+}
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioPortRole001, TestSize.Level0)
+{
+    EXPECT_EQ(AUDIO_PORT_UNASSIGNED_ROLE, (AudioPortRole)(0));
+    EXPECT_EQ(AUDIO_PORT_SOURCE_ROLE, (AudioPortRole)(1));
+    EXPECT_EQ(AUDIO_PORT_SINK_ROLE, (AudioPortRole)(2));
+}
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioPortType001, TestSize.Level0)
+{
+    EXPECT_EQ(AUDIO_PORT_UNASSIGNED_TYPE, (AudioPortType)(0));
+    EXPECT_EQ(AUDIO_PORT_DEVICE_TYPE, (AudioPortType)(1));
+    EXPECT_EQ(AUDIO_PORT_MIX_TYPE, (AudioPortType)(2));
+    EXPECT_EQ(AUDIO_PORT_SESSION_TYPE, (AudioPortType)(3));
+}
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioSessionType001, TestSize.Level0)
+{
+    EXPECT_EQ(AUDIO_OUTPUT_STAGE_SESSION, (AudioSessionType)(0));
+    EXPECT_EQ(AUDIO_OUTPUT_MIX_SESSION, (AudioSessionType)(1));
+    EXPECT_EQ(AUDIO_ALLOCATE_SESSION, (AudioSessionType)(2));
+    EXPECT_EQ(AUDIO_INVALID_SESSION, (AudioSessionType)(3));
+}
+
 HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioDeviceType001, TestSize.Level0)
 {
     EXPECT_EQ(AUDIO_LINEOUT, (AudioDeviceType)(1 << 0));
@@ -73,4 +226,48 @@ HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioDeviceType001, TestSize.Level0)
     EXPECT_EQ(AUDIO_ACCESSORY_DEVICE, (AudioDeviceType)(1 << 13));
     EXPECT_EQ(AUDIO_REMOTE_DEVICE, (AudioDeviceType)(1 << 14));
 }
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioEventType001, TestSize.Level0)
+{
+    EXPECT_EQ(AUDIO_DEVICE_ADD, (AudioEventType)(1));
+    EXPECT_EQ(AUDIO_DEVICE_REMOVE, (AudioEventType)(2));
+    EXPECT_EQ(AUDIO_LOAD_SUCCESS, (AudioEventType)(3));
+    EXPECT_EQ(AUDIO_LOAD_FAILURE, (AudioEventType)(4));
+    EXPECT_EQ(AUDIO_UNLOAD, (AudioEventType)(5));
+    EXPECT_EQ(AUDIO_SERVICE_VALID, (AudioEventType)(7));
+    EXPECT_EQ(AUDIO_SERVICE_INVALID, (AudioEventType)(8));
+    EXPECT_EQ(AUDIO_CAPTURE_THRESHOLD, (AudioEventType)(9));
+    EXPECT_EQ(AUDIO_EVENT_UNKNOWN, (AudioEventType)(10));
+}
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioExtParamKey001, TestSize.Level0)
+{
+    EXPECT_EQ(AUDIO_EXT_PARAM_KEY_NONE, (AudioExtParamKey)(0));
+    EXPECT_EQ(AUDIO_EXT_PARAM_KEY_VOLUME, (AudioExtParamKey)(1));
+    EXPECT_EQ(AUDIO_EXT_PARAM_KEY_FOCUS, (AudioExtParamKey)(2));
+    EXPECT_EQ(AUDIO_EXT_PARAM_KEY_BUTTON, (AudioExtParamKey)(3));
+    EXPECT_EQ(AUDIO_EXT_PARAM_KEY_EFFECT, (AudioExtParamKey)(4));
+    EXPECT_EQ(AUDIO_EXT_PARAM_KEY_STATUS, (AudioExtParamKey)(5));
+    EXPECT_EQ(AUDIO_EXT_PARAM_KEY_USB_DEVICE, (AudioExtParamKey)(101));
+    EXPECT_EQ(AUDIO_EXT_PARAM_KEY_PERF_INFO, (AudioExtParamKey)(201));
+    EXPECT_EQ(AUDIO_EXT_PARAM_KEY_MMI, (AudioExtParamKey)(301));
+    EXPECT_EQ(AUDIO_EXT_PARAM_KEY_LOWPOWER, (AudioExtParamKey)(1000));
+}
+
+HWTEST_F(HdfAudioUtTypesTest, HdfAudioTypesAudioInputType001, TestSize.Level0)
+{
+    EXPECT_EQ(AUDIO_INPUT_DEFAULT_TYPE, (AudioInputType)(0));
+    EXPECT_EQ(AUDIO_INPUT_MIC_TYPE, (AudioInputType)(1 << 0));
+    EXPECT_EQ(AUDIO_INPUT_SPEECH_WAKEUP_TYPE, (AudioInputType)(1 << 1));
+    EXPECT_EQ(AUDIO_INPUT_VOICE_COMMUNICATION_TYPE, (AudioInputType)(1 << 2));
+    EXPECT_EQ(AUDIO_INPUT_VOICE_RECOGNITION_TYPE, (AudioInputType)(1 << 3));
+    EXPECT_EQ(AUDIO_INPUT_VOICE_UPLINK_TYPE, (AudioInputType)(1 << 4));
+    EXPECT_EQ(AUDIO_INPUT_VOICE_DOWNLINK_TYPE, (AudioInputType)(1 << 5));
+    EXPECT_EQ(AUDIO_INPUT_VOICE_CALL_TYPE, (AudioInputType)(1 << 6));
+    EXPECT_EQ(AUDIO_INPUT_CAMCORDER_TYPE, (AudioInputType)(1 << 7));
+    EXPECT_EQ(AUDIO_INPUT_EC_TYPE, (AudioInputType)(1 << 8));
+    EXPECT_EQ(AUDIO_INPUT_NOISE_REDUCTION_TYPE, (AudioInputType)(1 << 9));
+    EXPECT_EQ(AUDIO_INPUT_RAW_TYPE, (AudioInputType)(1 << 10));
+    EXPECT_EQ(AUDIO_INPUT_LIVE_TYPE, (AudioInputType)(1 << 11));
+}
 }
\ No newline at end of file