audio test case

Signed-off-by: Nliuhonggang123 <honggang.liu@huawei.com>
Change-Id: Ib18675ab4cb76d5f85b3621995333232206dac43

hdf/BUILD.gn

@@ -15,6 +15,7 @@ group("hdfacttest") {
   testonly = true
   if (is_standard_system) {
     deps = [
+      "audio:hdf_xtstest_audio",
       "input:hdf_xtstest_input",
       "sensor:hdf_xtstest_sensor",
       "wlan/wifi:hdf_xtstest_wifi",

hdf/audio/BUILD.gn

+# Copyright (c) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/ohos_var.gni")
+import("//drivers/adapter/uhdf2/uhdf.gni")
+import("//test/xts/tools/build/suite.gni")
+
+#################################group#########################################
+group("hdf_xtstest_audio") {
+  if (!defined(ohos_lite)) {
+    testonly = true
+  }
+  deps = []
+
+  deps += [ "hdi:hdi" ]
+}
+###############################################################################

hdf/audio/Test.json

+{
+    "kits": [
+        {
+            "push": [
+                "hdf_xtstest_audio->/data/local/tmp/hdf_xtstest_audio"
+            ],
+            "type": "PushKit"
+        }
+    ],
+    "driver": {
+        "native-test-timeout": "120000",
+        "type": "CppTest",
+        "module-name": "hdf_xtstest_audio",
+        "runtime-hint": "1s",
+        "native-test-device-path": "/data/local/tmp"
+    },
+    "description": "Configuration for hdf_xtstest_audio Tests"
+}
\ No newline at end of file

hdf/audio/common/hdi_common/include/audio_hdi_common.h

+/**
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @addtogroup Audio
+ * @{
+ *
+ * @brief Defines audio-related APIs, including custom data types and functions for loading drivers,
+ * accessing a driver adapter, and rendering and capturing audios.
+ *
+ * @since 1.0
+ * @version 1.0
+ */
+
+/**
+ * @file audio_adapter.h
+ *
+ * @brief Declares APIs for operations related to the audio adapter.
+ *
+ * @since 1.0
+ * @version 1.0
+ */
+
+#ifndef AUDIO_HDI_COMMON_H
+#define AUDIO_HDI_COMMON_H
+
+#include <gtest/gtest.h>
+#include "audio_adapter.h"
+#include "audio_internal.h"
+#include "audio_types.h"
+#include "hdf_io_service_if.h"
+#include "hdf_sbuf.h"
+#include "audio_proxy_manager.h"
+
+namespace HMOS {
+namespace Audio {
+#ifdef AUDIO_ADM_SO
+    const std::string FUNCTION_NAME = "GetAudioManagerFuncs";
+    const std::string RESOLVED_PATH = "//system/lib/libhdi_audio.z.so";
+    using TestAudioManager = struct AudioManager;
+    const int IS_ADM = true;
+#endif
+#ifdef AUDIO_MPI_SO
+    const std::string FUNCTION_NAME = "GetAudioManagerFuncs";
+    const std::string RESOLVED_PATH = "//system/lib/libhdi_audio.z.so";
+    using TestAudioManager = struct AudioManager;
+    const int IS_ADM = false;
+#endif
+#ifdef AUDIO_ADM_SERVICE
+    const std::string FUNCTION_NAME = "GetAudioProxyManagerFuncs";
+    const std::string RESOLVED_PATH = "//system/lib/libaudio_hdi_proxy_server.z.so";
+    using TestAudioManager = struct AudioProxyManager;
+    const int IS_ADM = true;
+#endif
+#ifdef AUDIO_MPI_SERVICE
+    const std::string FUNCTION_NAME = "GetAudioProxyManagerFuncs";
+    const std::string RESOLVED_PATH = "//system/lib/libaudio_hdi_proxy_server.z.so";
+    using TestAudioManager = struct AudioProxyManager;
+    const int IS_ADM = false;
+#endif
+#ifdef __LITEOS__
+    const std::string FUNCTION_NAME = "GetAudioManagerFuncs";
+    const std::string RESOLVED_PATH = "/usr/lib/libhdi_audio.so";
+    using TestAudioManager = struct AudioManager;
+    const int IS_ADM = true;
+    const std::string AUDIO_FILE = "/userdata/audiorendertest.wav";
+    const std::string LOW_LATENCY_AUDIO_FILE = "/userdata/lowlatencyrendertest.wav";
+    const std::string AUDIO_CAPTURE_FILE = "/userdata/audiocapture.wav";
+    const std::string AUDIO_LOW_LATENCY_CAPTURE_FILE = "/userdata/lowlatencycapturetest.wav";
+#else
+    const std::string AUDIO_FILE = "//bin/audiorendertest.wav";
+    const std::string LOW_LATENCY_AUDIO_FILE = "//bin/lowlatencyrendertest.wav";
+    const std::string AUDIO_CAPTURE_FILE = "//bin/audiocapture.wav";
+    const std::string AUDIO_LOW_LATENCY_CAPTURE_FILE = "//bin/lowlatencycapturetest.wav";
+#endif
+
+const std::string AUDIO_RIFF = "RIFF";
+const std::string AUDIO_WAVE = "WAVE";
+const std::string AUDIO_DATA = "data";
+const uint32_t INT_32_MAX = 0x7fffffff;
+const uint32_t INDEX_END = 555;
+const uint32_t MOVE_RIGHT_NUM = 3;
+const int MOVE_LEFT_NUM = 8;
+const int CHANNELCOUNT = 2;
+const int SAMPLERATE = 48000;
+const int DEEP_BUFFER_RENDER_PERIOD_SIZE = 4096;
+const float GAIN_MIN = 0;
+const float GAIN_MAX = 15;
+const uint64_t INITIAL_VALUE = 0;
+const int BUFFER_LENTH = 1024 * 16;
+const int FILE_CAPTURE_SIZE = 1024 * 1024 * 1;
+const uint64_t MEGABYTE = 1024;
+const int FRAME_SIZE = 1024;
+const int FRAME_COUNT = 4;
+const int ADAPTER_COUNT = 32;
+const int TRY_NUM_FRAME = 20;
+const int AUDIO_ADAPTER_MAX_NUM = 3;
+const int64_t SECTONSEC = 1000000000;
+const int MICROSECOND = 1000000;
+const std::string HDF_CONTROL_SERVICE = "hdf_audio_control";
+const std::string HDF_RENDER_SERVICE = "hdf_audio_render";
+const std::string HDF_CAPTURE_SERVICE = "hdf_audio_capture";
+
+const int AUDIODRV_CTL_ELEM_IFACE_DAC = 0; /* virtual dac device */
+const int AUDIODRV_CTL_ELEM_IFACE_ADC = 1; /* virtual adc device */
+const int AUDIODRV_CTL_ELEM_IFACE_GAIN = 2; /* virtual adc device */
+const int AUDIODRV_CTL_ELEM_IFACE_MIXER = 3; /* virtual mixer device */
+const int AUDIODRV_CTL_ELEM_IFACE_ACODEC = 4; /* Acodec device */
+const int AUDIODRV_CTL_ELEM_IFACE_PGA = 5; /* PGA device */
+const int AUDIODRV_CTL_ELEM_IFACE_AIAO = 6; /* AIAO device */
+
+enum ControlDispMethodCmd {
+    AUDIODRV_CTRL_IOCTRL_ELEM_INFO,
+    AUDIODRV_CTRL_IOCTRL_ELEM_READ,
+    AUDIODRV_CTRL_IOCTRL_ELEM_WRITE,
+    AUDIODRV_CTRL_IOCTRL_ELEM_BUTT,
+};
+
+enum AudioPCMBit {
+    PCM_8_BIT  = 8,
+    PCM_16_BIT = 16,
+    PCM_24_BIT = 24,
+    PCM_32_BIT = 32,
+};
+
+struct AudioCtlElemId {
+    const char *cardServiceName;
+    int32_t iface;
+    const char *itemName; /* ASCII name of item */
+};
+
+struct AudioCtlElemValue {
+    struct AudioCtlElemId id;
+    int32_t value[2];
+};
+
+struct AudioHeadInfo {
+    uint32_t testFileRiffId;
+    uint32_t testFileRiffSize;
+    uint32_t testFileFmt;
+    uint32_t audioFileFmtId;
+    uint32_t audioFileFmtSize;
+    uint16_t audioFileFormat;
+    uint16_t audioChannelNum;
+    uint32_t audioSampleRate;
+    uint32_t audioByteRate;
+    uint16_t audioBlockAlign;
+    uint16_t audioBitsPerSample;
+    uint32_t dataId;
+    uint32_t dataSize;
+};
+
+struct AudioCharacteristic {
+    bool setmute;
+    bool getmute;
+    float setvolume;
+    float getvolume;
+    float setgain;
+    float getgain;
+    float gainthresholdmin;
+    float gainthresholdmax;
+    uint64_t getframes;
+    uint64_t getframesize;
+    uint64_t getframecount;
+    uint32_t getcurrentchannelId;
+    enum AudioChannelMode setmode;
+    enum AudioChannelMode getmode;
+    bool supported;
+    uint32_t latencyTime;
+};
+
+struct PrepareAudioPara {
+    TestAudioManager *manager;
+    enum AudioPortDirection portType;
+    const char *adapterName;
+    struct AudioAdapter *adapter;
+    struct AudioPort *audioPort;
+    void *self;
+    void *result;
+    pthread_t tids;
+    enum AudioPortPin pins;
+    const char *path;
+    struct AudioRender *render;
+    struct AudioCapture *capture;
+    struct AudioHeadInfo headInfo;
+    struct AudioAdapterDescriptor *desc;
+    struct AudioAdapterDescriptor *descs;
+    char *frame;
+    uint64_t requestBytes;
+    uint64_t replyBytes;
+    uint64_t fileSize;
+    struct AudioSampleAttributes attrs;
+    struct AudioCharacteristic character;
+    struct AudioSampleAttributes attrsValue;
+    struct AudioSceneDescriptor scenes;
+    struct AudioPortCapability capability;
+    enum AudioPortPassthroughMode mode;
+    struct AudioTimeStamp time;
+    struct timeval start;
+    struct timeval end;
+    long delayTime;
+    long totalTime;
+    float averageDelayTime;
+    struct AudioDeviceDescriptor devDesc;
+};
+
+int32_t InitAttrs(struct AudioSampleAttributes &attrs);
+
+int32_t InitDevDesc(struct AudioDeviceDescriptor &devDesc, const uint32_t portId, enum AudioPortPin pins);
+
+int32_t SwitchAdapter(struct AudioAdapterDescriptor *descs, const std::string &adapterNameCase,
+    enum AudioPortDirection portFlag, struct AudioPort *&audioPort, int size);
+
+uint32_t PcmFormatToBits(enum AudioFormat format);
+
+uint32_t PcmFramesToBytes(const struct AudioSampleAttributes attrs);
+
+int32_t WavHeadAnalysis(struct AudioHeadInfo &wavHeadInfo, FILE *file, struct AudioSampleAttributes &attrs);
+
+int32_t GetAdapters(TestAudioManager *manager, struct AudioAdapterDescriptor **descs, int &size);
+
+int32_t GetLoadAdapter(TestAudioManager *manager, enum AudioPortDirection portType,
+    const std::string &adapterName, struct AudioAdapter **adapter, struct AudioPort *&audioPort);
+
+int32_t AudioCreateRender(TestAudioManager *manager, enum AudioPortPin pins, const std::string &adapterName,
+    struct AudioAdapter **adapter, struct AudioRender **render);
+
+int32_t AudioCreateCapture(TestAudioManager *manager, enum AudioPortPin pins, const std::string &adapterName,
+    struct AudioAdapter **adapter, struct AudioCapture **capture);
+
+int32_t FrameStart(struct AudioHeadInfo wavHeadInfo, struct AudioRender *render, FILE *file,
+    struct AudioSampleAttributes attrs);
+
+int32_t FrameStartCapture(struct AudioCapture *capture, FILE *file, const struct AudioSampleAttributes attrs);
+
+int32_t RenderFramePrepare(const std::string &path, char *&frame, uint64_t &numRead);
+
+void FrameStatus(int status);
+
+int32_t StartRecord(struct AudioCapture *capture, FILE *file, uint64_t filesize);
+
+int32_t WriteIdToBuf(struct HdfSBuf *sBuf, struct AudioCtlElemId id);
+
+int32_t WriteEleValueToBuf(struct HdfSBuf *sBuf, struct AudioCtlElemValue elemvalue);
+
+int32_t PowerOff(struct AudioCtlElemValue firstElemValue, struct AudioCtlElemValue secondElemValue);
+
+int32_t CheckRegisterStatus(const struct AudioCtlElemId firstId, const struct AudioCtlElemId secondId,
+    const int firstStatus, const int secondStatus);
+
+int32_t AudioCreateStartRender(TestAudioManager *manager, struct AudioRender **render, struct AudioAdapter **adapter,
+    const std::string &adapterName);
+
+int32_t AudioRenderStartAndOneFrame(struct AudioRender *render);
+
+int32_t StopAudio(struct PrepareAudioPara &audiopara);
+
+int32_t ThreadRelease(struct PrepareAudioPara &audiopara);
+
+int32_t AudioCreateStartCapture(TestAudioManager *manager, struct AudioCapture **capture,
+    struct AudioAdapter **adapter, const std::string &adapterName);
+
+int32_t AudioCaptureStartAndOneFrame(struct AudioCapture *capture);
+
+int32_t PlayAudioFile(struct PrepareAudioPara &audiopara);
+
+int32_t RecordAudio(struct PrepareAudioPara &audiopara);
+
+int32_t InitAttrsUpdate(struct AudioSampleAttributes &attrs, enum AudioFormat format, uint32_t channelCount,
+    uint32_t sampleRate);
+
+int32_t AudioRenderSetGetSampleAttributes(struct AudioSampleAttributes attrs, struct AudioSampleAttributes &attrsValue,
+    struct AudioRender *render);
+
+int32_t AudioCaptureSetGetSampleAttributes(struct AudioSampleAttributes attrs, struct AudioSampleAttributes &attrsValue,
+    struct AudioCapture *capture);
+
+int32_t InitMmapDesc(FILE *fp, struct AudioMmapBufferDescripter &desc, int32_t &reqSize, bool flag);
+
+int32_t PlayMapAudioFile(struct PrepareAudioPara &audiopara);
+
+int32_t RecordMapAudio(struct PrepareAudioPara &audiopara);
+}
+}
+#endif // AUDIO_HDI_COMMON_H
+

hdf/audio/hdi/BUILD.gn

+# Copyright (c) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/ohos_var.gni")
+import("//drivers/adapter/uhdf2/uhdf.gni")
+import("//drivers/peripheral/audio/audio.gni")
+import("//test/xts/tools/build/suite.gni")
+
+###########################end###########################
+group("hdi") {
+  if (!defined(ohos_lite)) {
+    testonly = true
+  }
+  deps = [
+    "adapter:hdf_audio_hdi_adapter_test",
+    "capture:hdf_audio_hdi_capture_test",
+    "render:hdf_audio_hdi_render_test",
+  ]
+}

hdf/audio/hdi/adapter/BUILD.gn

+# Copyright (c) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/ohos_var.gni")
+import("//drivers/adapter/uhdf2/uhdf.gni")
+import("//drivers/peripheral/audio/audio.gni")
+import("//test/xts/tools/build/suite.gni")
+
+###########################NOT LITEOS##############################
+module_output_path = "hdf/audio"
+
+###########################hdf_audio_hdi_adapter_test#####################
+ohos_moduletest_suite("hdf_audio_hdi_adapter_test") {
+  module_out_path = module_output_path
+  sources = [
+    "../../common/hdi_common/src/audio_hdi_common.cpp",
+    "src/audio_hdiadapter_test.cpp",
+  ]
+
+  include_dirs = [
+    "//drivers/peripheral/audio/hal/hdi_passthrough/include",
+    "//drivers/peripheral/audio/interfaces/include",
+    "//drivers/peripheral/audio/hal/hdi_binder/proxy/include",
+    "//drivers/adapter/uhdf2/include/hdi",
+    "//drivers/adapter/uhdf2/shared/include",
+    "//drivers/adapter/uhdf2/osal/include",
+    "//drivers/framework/include/core",
+    "//drivers/framework/include/utils",
+    "//drivers/framework/include/osal",
+    "//drivers/framework/include",
+    "//drivers/framework/utils/include",
+    "//third_party/bounds_checking_function/include",
+    "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include",
+    "//third_party/googletest/googletest/include/gtest",
+    "//drivers/peripheral/audio/test/systemtest/hdi/adapter/include",
+  ]
+  cflags = [
+    "-Wall",
+    "-Wextra",
+    "-Werror",
+    "-fsigned-char",
+    "-fno-common",
+    "-fno-strict-aliasing",
+  ]
+  deps = [
+    "//third_party/googletest:gmock_main",
+    "//third_party/googletest:gtest_main",
+  ]
+  defines = []
+  if (enable_audio_adm_so) {
+    defines += [ "AUDIO_ADM_SO" ]
+  }
+  if (enable_audio_mpi_so) {
+    defines += [ "AUDIO_MPI_SO" ]
+  }
+  if (enable_audio_adm_service) {
+    defines += [ "AUDIO_ADM_SERVICE" ]
+  }
+  if (enable_audio_mpi_service) {
+    defines += [ "AUDIO_MPI_SERVICE" ]
+  }
+}
+###########################end###########################

hdf/audio/hdi/adapter/Test.json

+{
+    "kits": [
+        {
+            "push": [
+                "hdf_audio_hdi_adapter_test->/data/local/tmp/hdf_audio_hdi_adapter_test"
+            ],
+            "type": "PushKit"
+        }
+    ],
+    "driver": {
+        "native-test-timeout": "120000",
+        "type": "CppTest",
+        "module-name": "hdf_audio_hdi_adapter_test",
+        "runtime-hint": "1s",
+        "native-test-device-path": "/data/local/tmp"
+    },
+    "description": "Configuration for hdf_audio_hdi_adapter_test Tests"
+}
\ No newline at end of file

hdf/audio/hdi/adapter/include/audio_hdiadapter_test.h

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_HDIADAPTER_TEST_H
+#define AUDIO_HDIADAPTER_TEST_H
+
+#endif

hdf/audio/hdi/capture/BUILD.gn

+# Copyright (c) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/ohos_var.gni")
+import("//drivers/adapter/uhdf2/uhdf.gni")
+import("//drivers/peripheral/audio/audio.gni")
+import("//test/xts/tools/build/suite.gni")
+
+###########################systemtest##############################
+module_output_path = "hdf/audio"
+
+###########################hdf_audio_hdi_capture_test#####################
+ohos_moduletest_suite("hdf_audio_hdi_capture_test") {
+  module_out_path = module_output_path
+  sources = [
+    "../../common/hdi_common/src/audio_hdi_common.cpp",
+    "src/audio_hdicapture_attr_test.cpp",
+    "src/audio_hdicapture_control_test.cpp",
+    "src/audio_hdicapture_scene_test.cpp",
+    "src/audio_hdicapture_test.cpp",
+    "src/audio_hdicapture_volume_test.cpp",
+  ]
+
+  include_dirs = [
+    "//drivers/peripheral/audio/hal/hdi_passthrough/include",
+    "//drivers/peripheral/audio/interfaces/include",
+    "//drivers/peripheral/audio/hal/hdi_binder/proxy/include",
+    "//drivers/adapter/uhdf2/include/hdi",
+    "//drivers/adapter/uhdf2/shared/include",
+    "//drivers/framework/include/core",
+    "//drivers/framework/include/utils",
+    "//drivers/framework/include/osal",
+    "//drivers/framework/include",
+    "//third_party/bounds_checking_function/include",
+    "//drivers/framework/utils/include",
+    "//drivers/adapter/uhdf2/osal/include",
+    "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include",
+    "//third_party/googletest/googletest/include/gtest",
+    "//drivers/peripheral/audio/test/systemtest/hdi/capture/include",
+  ]
+  cflags = [
+    "-Wall",
+    "-Wextra",
+    "-Werror",
+    "-fsigned-char",
+    "-fno-common",
+    "-fno-strict-aliasing",
+  ]
+  deps = [
+    "//third_party/googletest:gmock_main",
+    "//third_party/googletest:gtest_main",
+  ]
+  defines = []
+  if (enable_audio_adm_so) {
+    defines += [ "AUDIO_ADM_SO" ]
+  }
+  if (enable_audio_mpi_so) {
+    defines += [ "AUDIO_MPI_SO" ]
+  }
+  if (enable_audio_adm_service) {
+    defines += [ "AUDIO_ADM_SERVICE" ]
+  }
+  if (enable_audio_mpi_service) {
+    defines += [ "AUDIO_MPI_SERVICE" ]
+  }
+}

hdf/audio/hdi/capture/Test.json

+{
+    "kits": [
+        {
+            "push": [
+                "hdf_audio_hdi_capture_test->/data/local/tmp/hdf_audio_hdi_capture_test"
+            ],
+            "type": "PushKit"
+        }
+    ],
+    "driver": {
+        "native-test-timeout": "120000",
+        "type": "CppTest",
+        "module-name": "hdf_audio_hdi_capture_test",
+        "runtime-hint": "1s",
+        "native-test-device-path": "/data/local/tmp"
+    },
+    "description": "Configuration for hdf_audio_hdi_capture_test Tests"
+}
\ No newline at end of file

hdf/audio/hdi/capture/include/audio_hdicapture_attr_test.h

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_HDICAPTURE_ATTR_TEST_H
+#define AUDIO_HDICAPTURE_ATTR_TEST_H
+
+#endif

hdf/audio/hdi/capture/include/audio_hdicapture_control_test.h

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_HDICAPTURE_CONTROL_TEST_H
+#define AUDIO_HDICAPTURE_CONTROL_TEST_H
+
+#endif

hdf/audio/hdi/capture/include/audio_hdicapture_scene_test.h

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_HDICAPTURE_SCENE_TEST_H
+#define AUDIO_HDICAPTURE_SCENE_TEST_H
+
+#endif

hdf/audio/hdi/capture/include/audio_hdicapture_test.h

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_HDICAPTURE_TEST_H
+#define AUDIO_HDICAPTURE_TEST_H
+
+#endif

hdf/audio/hdi/capture/include/audio_hdicapture_volume_test.h

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_HDICAPTURE_VOLUME_TEST_H
+#define AUDIO_HDICAPTURE_VOLUME_TEST_H
+
+#endif

hdf/audio/hdi/capture/src/audio_hdicapture_scene_test.cpp

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @addtogroup Audio
+ * @{
+ *
+ * @brief Defines audio-related APIs, including custom data types and functions for capture drivers function.
+ * accessing a driver adapter, and capturing audios.
+ *
+ * @since 1.0
+ * @version 1.0
+ */
+
+/**
+ * @file audio_hdi_common.h
+ *
+ * @brief Declares APIs for operations related to the capturing audio adapter.
+ *
+ * @since 1.0
+ * @version 1.0
+ */
+
+#include "audio_hdi_common.h"
+#include "audio_hdicapture_scene_test.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace HMOS::Audio;
+
+namespace {
+const string ADAPTER_NAME_HDMI = "hdmi";
+const string ADAPTER_NAME_USB = "usb";
+const string ADAPTER_NAME_INTERNAL = "internal";
+
+class AudioHdiCaptureSceneTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase(void);
+    void SetUp();
+    void TearDown();
+    static TestAudioManager *(*GetAudioManager)();
+    static void *handleSo;
+#ifdef AUDIO_MPI_SO
+    static int32_t (*SdkInit)();
+    static void (*SdkExit)();
+    static void *sdkSo;
+#endif
+    int32_t AudioCaptureStart(const string path, struct AudioCapture *capture) const;
+};
+
+TestAudioManager *(*AudioHdiCaptureSceneTest::GetAudioManager)() = nullptr;
+void *AudioHdiCaptureSceneTest::handleSo = nullptr;
+#ifdef AUDIO_MPI_SO
+    int32_t (*AudioHdiCaptureSceneTest::SdkInit)() = nullptr;
+    void (*AudioHdiCaptureSceneTest::SdkExit)() = nullptr;
+    void *AudioHdiCaptureSceneTest::sdkSo = nullptr;
+#endif
+
+void AudioHdiCaptureSceneTest::SetUpTestCase(void)
+{
+#ifdef AUDIO_MPI_SO
+    char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so";
+    sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
+    if (sdkSo == nullptr) {
+        return;
+    }
+    SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
+    if (SdkInit == nullptr) {
+        return;
+    }
+    SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
+    if (SdkExit == nullptr) {
+        return;
+    }
+    SdkInit();
+#endif
+    char absPath[PATH_MAX] = {0};
+    if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
+        return;
+    }
+    handleSo = dlopen(absPath, RTLD_LAZY);
+    if (handleSo == nullptr) {
+        return;
+    }
+    GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
+    if (GetAudioManager == nullptr) {
+        return;
+    }
+}
+
+void AudioHdiCaptureSceneTest::TearDownTestCase(void)
+{
+#ifdef AUDIO_MPI_SO
+    SdkExit();
+    if (sdkSo != nullptr) {
+        dlclose(sdkSo);
+        sdkSo = nullptr;
+    }
+    if (SdkInit != nullptr) {
+        SdkInit = nullptr;
+    }
+    if (SdkExit != nullptr) {
+        SdkExit = nullptr;
+    }
+#endif
+    if (handleSo != nullptr) {
+        dlclose(handleSo);
+        handleSo = nullptr;
+    }
+    if (GetAudioManager != nullptr) {
+        GetAudioManager = nullptr;
+    }
+}
+int32_t AudioHdiCaptureSceneTest::AudioCaptureStart(const string path, struct AudioCapture *capture) const
+{
+    int32_t ret = -1;
+    struct AudioSampleAttributes attrs = {};
+
+    ret = InitAttrs(attrs);
+    if (ret < 0) {
+        return ret;
+    }
+    FILE *file = fopen(path.c_str(), "wb+");
+    if (file == nullptr) {
+        return HDF_FAILURE;
+    }
+    ret = FrameStartCapture(capture, file, attrs);
+    (void)fclose(file);
+    return ret;
+}
+void AudioHdiCaptureSceneTest::SetUp(void) {}
+void AudioHdiCaptureSceneTest::TearDown(void) {}
+
+/**
+* @tc.name   Test AudioCaptureCheckSceneCapability API and check scene's capability
+* @tc.number  SUB_Audio_HDI_CaptureCheckSceneCapability_0001
+* @tc.desc  Test AudioCaptureCheckSceneCapability interface,return 0 if check scene's capability successful.
+*/
+HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0001, Function | MediumTest | Level1)
+{
+    int32_t ret = -1;
+    bool supported = false;
+    struct AudioSceneDescriptor scenes = {};
+    struct AudioAdapter *adapter = nullptr;
+    struct AudioCapture *capture = nullptr;
+    ASSERT_NE(nullptr, GetAudioManager);
+    TestAudioManager* manager = GetAudioManager();
+    ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
+    ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
+    scenes.scene.id = 0;
+    scenes.desc.pins = PIN_IN_MIC;
+    ret = capture->scene.CheckSceneCapability(capture, &scenes, &supported);
+    EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
+    EXPECT_TRUE(supported);
+
+    adapter->DestroyCapture(adapter, capture);
+    manager->UnloadAdapter(manager, adapter);
+}
+/**
+* @tc.name   Test checking scene's capability where the scene is not configured in the json.
+* @tc.number  SUB_Audio_HDI_CaptureCheckSceneCapability_0002
+* @tc.desc  Test AudioCreateCapture interface,return -1 if the scene is not configured in the json.
+*/
+HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0002, Function | MediumTest | Level1)
+{
+    int32_t ret = -1;
+    bool supported = true;
+    struct AudioSceneDescriptor scenes = {};
+    struct AudioAdapter *adapter = nullptr;
+    struct AudioCapture *capture = nullptr;
+    ASSERT_NE(nullptr, GetAudioManager);
+    TestAudioManager* manager = GetAudioManager();
+    ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
+    ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
+    scenes.scene.id = 5;
+    scenes.desc.pins = PIN_IN_MIC;
+    ret = capture->scene.CheckSceneCapability(capture, &scenes, &supported);
+    EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
+
+    adapter->DestroyCapture(adapter, capture);
+    manager->UnloadAdapter(manager, adapter);
+}
+/**
+* @tc.name   Test checking scene's capability where the capture is empty
+* @tc.number  SUB_Audio_HDI_CaptureCheckSceneCapability_0003
+* @tc.desc  Test AudioCreateCapture interface,return -1 if the capture is empty.
+*/
+HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0003, Function | MediumTest | Level1)
+{
+    int32_t ret = -1;
+    bool supported = true;
+    struct AudioSceneDescriptor scenes = {};
+    struct AudioAdapter *adapter = nullptr;
+    struct AudioCapture *capture = nullptr;
+    struct AudioCapture *captureNull = nullptr;
+    ASSERT_NE(nullptr, GetAudioManager);
+    TestAudioManager* manager = GetAudioManager();
+    ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
+    ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
+    scenes.scene.id = 0;
+    scenes.desc.pins = PIN_IN_MIC;
+    ret = capture->scene.CheckSceneCapability(captureNull, &scenes, &supported);
+    EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
+
+    ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
+    EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
+
+    capture->control.Stop((AudioHandle)capture);
+    adapter->DestroyCapture(adapter, capture);
+    manager->UnloadAdapter(manager, adapter);
+}
+/**
+* @tc.name   Test checking scene's capability where the scene is empty
+* @tc.number  SUB_Audio_HDI_CaptureCheckSceneCapability_0004
+* @tc.desc  Test AudioCreateCapture interface,return -1 if the scene is empty.
+*/
+HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0004, Function | MediumTest | Level1)
+{
+    int32_t ret = -1;
+    bool supported = true;
+    struct AudioSceneDescriptor *scenes = nullptr;
+    struct AudioAdapter *adapter = nullptr;
+    struct AudioCapture *capture = nullptr;
+    ASSERT_NE(nullptr, GetAudioManager);
+    TestAudioManager* manager = GetAudioManager();
+    ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
+    ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
+
+    ret = capture->scene.CheckSceneCapability(capture, scenes, &supported);
+    EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
+
+    ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
+    EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
+
+    capture->control.Stop((AudioHandle)capture);
+    adapter->DestroyCapture(adapter, capture);
+    manager->UnloadAdapter(manager, adapter);
+}
+/**
+* @tc.name   Test checking scene's capability where the parameter supported is empty.
+* @tc.number  SUB_Audio_HDI_CaptureCheckSceneCapability_0005
+* @tc.desc  Test AudioCreateCapture interface,return -1 if the parameter supported is empty.
+*/
+HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0005, Function | MediumTest | Level1)
+{
+    int32_t ret = -1;
+    struct AudioSceneDescriptor scenes = {};
+    struct AudioAdapter *adapter = nullptr;
+    struct AudioCapture *capture = nullptr;
+    ASSERT_NE(nullptr, GetAudioManager);
+    TestAudioManager* manager = GetAudioManager();
+    ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
+    ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
+
+    scenes.scene.id = 0;
+    scenes.desc.pins = PIN_IN_MIC;
+    ret = capture->scene.CheckSceneCapability(capture, &scenes, nullptr);
+    EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
+
+    adapter->DestroyCapture(adapter, capture);
+    manager->UnloadAdapter(manager, adapter);
+}
+/**
+* @tc.name  Test AudioCaptureSelectScene API via legal input
+* @tc.number  SUB_Audio_HDI_AudioCaptureSelectScene_0001
+* @tc.desc  Test AudioCaptureSelectScene interface,return 0 if select capture's scene successful.
+*/
+HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0001, Function | MediumTest | Level1)
+{
+    int32_t ret = -1;
+    struct AudioSceneDescriptor scenes = {};
+    struct AudioAdapter *adapter = nullptr;
+    struct AudioCapture *capture = nullptr;
+    ASSERT_NE(nullptr, GetAudioManager);
+    TestAudioManager* manager = GetAudioManager();
+    ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
+    ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
+    scenes.scene.id = 0;
+    scenes.desc.pins = PIN_IN_MIC;
+    ret = capture->scene.SelectScene(capture, &scenes);
+    EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
+
+    adapter->DestroyCapture(adapter, capture);
+    manager->UnloadAdapter(manager, adapter);
+}
+/**
+* @tc.name  Test AudioCaptureSelectScene API after capture start.
+* @tc.number  SUB_Audio_HDI_AudioCaptureSelectScene_0002
+* @tc.desc  Test AudioCaptureSelectScene, return 0 if select capture's scene successful after capture start.
+*/
+HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0002, Function | MediumTest | Level1)
+{
+    int32_t ret = -1;
+    struct AudioSceneDescriptor scenes = {};
+    struct AudioAdapter *adapter = nullptr;
+    struct AudioCapture *capture = nullptr;
+    ASSERT_NE(nullptr, GetAudioManager);
+    TestAudioManager* manager = GetAudioManager();
+    ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
+    ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
+
+    ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
+    EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
+
+    scenes.scene.id = 0;
+    scenes.desc.pins = PIN_IN_MIC;
+    ret = capture->scene.SelectScene(capture, &scenes);
+    EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
+
+    capture->control.Stop((AudioHandle)capture);
+    adapter->DestroyCapture(adapter, capture);
+    manager->UnloadAdapter(manager, adapter);
+}
+/**
+* @tc.name  Test AudioCaptureSelectScene API where the parameter handle is empty.
+* @tc.number  SUB_Audio_HDI_AudioCaptureSelectScene_0003
+* @tc.desc  Test AudioCaptureSelectScene, return -1 if the parameter handle is empty.
+*/
+HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0003, Function | MediumTest | Level1)
+{
+    int32_t ret = -1;
+    struct AudioSceneDescriptor scenes = {};
+    struct AudioAdapter *adapter = nullptr;
+    struct AudioCapture *capture = nullptr;
+    struct AudioCapture *captureNull = nullptr;
+    ASSERT_NE(nullptr, GetAudioManager);
+    TestAudioManager* manager = GetAudioManager();
+    ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
+    ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
+
+    scenes.scene.id = 0;
+    scenes.desc.pins = PIN_IN_MIC;
+    ret = capture->scene.SelectScene(captureNull, &scenes);
+    EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
+
+    adapter->DestroyCapture(adapter, capture);
+    manager->UnloadAdapter(manager, adapter);
+}
+/**
+* @tc.name  Test AudioCaptureSelectScene API where the parameter scene is empty.
+* @tc.number  SUB_Audio_HDI_AudioCaptureSelectScene_0004
+* @tc.desc  Test AudioCaptureSelectScene, return -1 if the parameter scene is empty.
+*/
+HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0004, Function | MediumTest | Level1)
+{
+    int32_t ret = -1;
+    struct AudioSceneDescriptor *scenes = nullptr;
+    struct AudioAdapter *adapter = nullptr;
+    struct AudioCapture *capture = nullptr;
+    ASSERT_NE(nullptr, GetAudioManager);
+    TestAudioManager* manager = GetAudioManager();
+    ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
+    ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
+
+    ret = capture->scene.SelectScene(capture, scenes);
+    EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
+
+    adapter->DestroyCapture(adapter, capture);
+    manager->UnloadAdapter(manager, adapter);
+}
+/**
+* @tc.name  Test AudioCaptureSelectScene API where the scene is not configured in the json.
+* @tc.number  SUB_Audio_HDI_AudioCaptureSelectScene_0005
+* @tc.desc  Test AudioCaptureSelectScene, return -1 if the scene is not configured in the json.
+*/
+HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0005, Function | MediumTest | Level1)
+{
+    int32_t ret = -1;
+    struct AudioSceneDescriptor scenes = {};
+    struct AudioAdapter *adapter = nullptr;
+    struct AudioCapture *capture = nullptr;
+    ASSERT_NE(nullptr, GetAudioManager);
+    TestAudioManager* manager = GetAudioManager();
+    ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
+    ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
+
+    scenes.scene.id = 5;
+    scenes.desc.pins = PIN_OUT_HDMI;
+    ret = capture->scene.SelectScene(capture, &scenes);
+    EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
+
+    adapter->DestroyCapture(adapter, capture);
+    manager->UnloadAdapter(manager, adapter);
+}
+}
\ No newline at end of file

hdf/audio/hdi/render/BUILD.gn

+# Copyright (c) 2021 Huawei Device Co., Ltd.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import("//build/ohos_var.gni")
+import("//drivers/adapter/uhdf2/uhdf.gni")
+import("//drivers/peripheral/audio/audio.gni")
+import("//test/xts/tools/build/suite.gni")
+
+###########################systemtest##############################
+module_output_path = "hdf/audio"
+
+###########################hdf_audio_hdi_render_test######################
+ohos_moduletest_suite("hdf_audio_hdi_render_test") {
+  module_out_path = module_output_path
+  sources = [
+    "../../common/hdi_common/src/audio_hdi_common.cpp",
+    "src/audio_hdirender_attr_test.cpp",
+    "src/audio_hdirender_control_test.cpp",
+    "src/audio_hdirender_scene_test.cpp",
+    "src/audio_hdirender_test.cpp",
+    "src/audio_hdirender_volume_test.cpp",
+  ]
+
+  include_dirs = [
+    "//drivers/peripheral/audio/hal/hdi_passthrough/include",
+    "//drivers/peripheral/audio/interfaces/include",
+    "//drivers/peripheral/audio/hal/hdi_binder/proxy/include",
+    "//drivers/adapter/uhdf2/include/hdi",
+    "//drivers/adapter/uhdf2/shared/include",
+    "//drivers/framework/include/core",
+    "//drivers/framework/include/utils",
+    "//drivers/framework/include/osal",
+    "//drivers/framework/include",
+    "//third_party/bounds_checking_function/include",
+    "//drivers/framework/utils/include",
+    "//drivers/adapter/uhdf2/osal/include",
+    "//drivers/peripheral/audio/test/systemtest/common/hdi_common/include",
+    "//third_party/googletest/googletest/include/gtest",
+    "//drivers/peripheral/audio/test/systemtest/hdi/render/include",
+  ]
+  cflags = [
+    "-Wall",
+    "-Wextra",
+    "-Werror",
+    "-fsigned-char",
+    "-fno-common",
+    "-fno-strict-aliasing",
+  ]
+  deps = [
+    "//third_party/googletest:gmock_main",
+    "//third_party/googletest:gtest_main",
+  ]
+  defines = []
+  if (enable_audio_adm_so) {
+    defines += [ "AUDIO_ADM_SO" ]
+  }
+  if (enable_audio_mpi_so) {
+    defines += [ "AUDIO_MPI_SO" ]
+  }
+  if (enable_audio_adm_service) {
+    defines += [ "AUDIO_ADM_SERVICE" ]
+  }
+  if (enable_audio_mpi_service) {
+    defines += [ "AUDIO_MPI_SERVICE" ]
+  }
+}

hdf/audio/hdi/render/Test.json

+{
+    "kits": [
+        {
+            "push": [
+                "hdf_audio_hdi_render_test->/data/local/tmp/hdf_audio_hdi_render_test"
+            ],
+            "type": "PushKit"
+        }
+    ],
+    "driver": {
+        "native-test-timeout": "120000",
+        "type": "CppTest",
+        "module-name": "hdf_audio_hdi_render_test",
+        "runtime-hint": "1s",
+        "native-test-device-path": "/data/local/tmp"
+    },
+    "description": "Configuration for hdf_audio_hdi_render_test Tests"
+}
\ No newline at end of file

hdf/audio/hdi/render/include/audio_hdirender_attr_test.h

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_HDIRENDER_ATTR_TEST
+#define AUDIO_HDIRENDER_ATTR_TEST
+
+#endif

hdf/audio/hdi/render/include/audio_hdirender_control_test.h

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_HDIRENDER_CONTROL_TEST_H
+#define AUDIO_HDIRENDER_CONTROL_TEST_H
+
+#endif

hdf/audio/hdi/render/include/audio_hdirender_scene_test.h

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_HDIRENDER_SCENE_TEST_H
+#define AUDIO_HDIRENDER_SCENE_TEST_H
+
+#endif

hdf/audio/hdi/render/include/audio_hdirender_test.h

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_HDIRENDER_TEST_H
+#define AUDIO_HDIRENDER_TEST_H
+
+#endif

hdf/audio/hdi/render/include/audio_hdirender_volume_test.h

+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_HDIRENDER_VOLUME_TEST_H
+#define AUDIO_HDIRENDER_VOLUME_TEST_H
+
+#endif