• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 /**
17  * @addtogroup Audio
18  * @{
19  *
20  * @brief Test audio-related APIs, including custom data types and functions for loading drivers,
21  * accessing a driver ADM interface lib,and rendering audios
22  *
23  * @since 1.0
24  * @version 1.0
25  */
26 
27 /**
28  * @file audio_lib_common.h
29  *
30  * @brief Declares APIs for operations related to the audio ADM interface lib.
31  *
32  * @since 1.0
33  * @version 1.0
34  */
35 #include "audio_lib_common.h"
36 #include "audio_librender_test.h"
37 
38 using namespace std;
39 using namespace testing::ext;
40 using namespace HMOS::Audio;
41 
42 namespace {
43 const string BIND_CONTROL = "control";
44 const string BIND_RENDER = "render";
45 const string BIND_NAME_ERROR = "rendor";
46 const string ADAPTER_NAME_USB = "usb";
47 
48 class AudioLibRenderTest : public testing::Test {
49 public:
50     static void SetUpTestCase(void);
51     static void TearDownTestCase(void);
52     void SetUp();
53     void TearDown();
54     static struct DevHandle *(*BindServiceRenderSo)(const char *);
55     static int32_t (*InterfaceLibOutputRender)(struct DevHandle *, int, struct AudioHwRenderParam *);
56     static int32_t (*InterfaceLibCtlRender)(struct DevHandle *, int, struct AudioHwRenderParam *);
57     static void (*CloseServiceRenderSo)(struct DevHandle *);
58     static void *PtrHandle;
59 #ifdef AUDIO_MPI_SO
60     static int32_t (*SdkInit)();
61     static void (*SdkExit)();
62 #endif
63     uint32_t PcmBytesToFrames(const struct AudioFrameRenderMode &frameRenderMode, uint64_t bytes) const;
64     int32_t FrameLibStart(FILE *file, struct AudioSampleAttributes attrs,
65         struct AudioHeadInfo wavHeadInfo, struct AudioHwRender *hwRender) const;
66     int32_t LibStartAndStream(const std::string path, struct AudioSampleAttributes attrs,
67         struct DevHandle *handle, struct AudioHwRender *hwRender, struct AudioHeadInfo wavHeadInfo) const;
68     int32_t LibHwOutputRender(struct AudioHwRender *hwRender, struct DevHandle *handlerender) const;
69     int32_t BindServiceAndHwRender(struct AudioHwRender *&hwRender,
70         const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const;
71 };
72 
73 struct DevHandle *(*AudioLibRenderTest::BindServiceRenderSo)(const char *) = nullptr;
74 int32_t (*AudioLibRenderTest::InterfaceLibOutputRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr;
75 int32_t (*AudioLibRenderTest::InterfaceLibCtlRender)(struct DevHandle *, int, struct AudioHwRenderParam *) = nullptr;
76 void (*AudioLibRenderTest::CloseServiceRenderSo)(struct DevHandle *) = nullptr;
77 void *AudioLibRenderTest::PtrHandle = nullptr;
78 #ifdef AUDIO_MPI_SO
79     int32_t (*AudioLibRenderTest::SdkInit)() = nullptr;
80     void (*AudioLibRenderTest::SdkExit)() = nullptr;
81 #endif
82 
SetUpTestCase(void)83 void AudioLibRenderTest::SetUpTestCase(void)
84 {
85     char resolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
86     PtrHandle = dlopen(resolvedPath, RTLD_LAZY);
87     if (PtrHandle == nullptr) {
88         return;
89     }
90     BindServiceRenderSo = (struct DevHandle* (*)(const char *))dlsym(PtrHandle, "AudioBindServiceRender");
91     InterfaceLibOutputRender = (int32_t (*)(struct DevHandle *, int,
92         struct AudioHwRenderParam *))dlsym(PtrHandle, "AudioInterfaceLibOutputRender");
93     InterfaceLibCtlRender = (int32_t (*)(struct DevHandle *, int,
94         struct AudioHwRenderParam *))dlsym(PtrHandle, "AudioInterfaceLibCtlRender");
95     CloseServiceRenderSo = (void (*)(struct DevHandle *))dlsym(PtrHandle, "AudioCloseServiceRender");
96     if (BindServiceRenderSo == nullptr || CloseServiceRenderSo == nullptr ||
97         InterfaceLibCtlRender == nullptr || InterfaceLibOutputRender == nullptr) {
98         dlclose(PtrHandle);
99         return;
100     }
101 #ifdef AUDIO_MPI_SO
102     SdkInit = (int32_t (*)())(dlsym(PtrHandle, "MpiSdkInit"));
103     if (SdkInit == nullptr) {
104         return;
105     }
106     SdkExit = (void (*)())(dlsym(PtrHandle, "MpiSdkExit"));
107     if (SdkExit == nullptr) {
108         return;
109     }
110     SdkInit();
111 #endif
112 }
113 
TearDownTestCase(void)114 void AudioLibRenderTest::TearDownTestCase(void)
115 {
116     if (BindServiceRenderSo != nullptr) {
117         BindServiceRenderSo = nullptr;
118     }
119     if (CloseServiceRenderSo != nullptr) {
120         CloseServiceRenderSo = nullptr;
121     }
122     if (InterfaceLibOutputRender != nullptr) {
123         InterfaceLibOutputRender = nullptr;
124     }
125     if (InterfaceLibCtlRender != nullptr) {
126         InterfaceLibCtlRender = nullptr;
127     }
128 #ifdef AUDIO_MPI_SO
129     SdkExit();
130     if (SdkInit != nullptr) {
131         SdkInit = nullptr;
132     }
133     if (SdkExit != nullptr) {
134         SdkExit = nullptr;
135     }
136 #endif
137     if (PtrHandle != nullptr) {
138         dlclose(PtrHandle);
139         PtrHandle = nullptr;
140     }
141 }
142 
SetUp(void)143 void AudioLibRenderTest::SetUp(void) {}
144 
TearDown(void)145 void AudioLibRenderTest::TearDown(void) {}
146 
PcmBytesToFrames(const struct AudioFrameRenderMode & frameRenderMode,uint64_t bytes) const147 uint32_t AudioLibRenderTest::PcmBytesToFrames(const struct AudioFrameRenderMode &frameRenderMode, uint64_t bytes) const
148 {
149     uint32_t replyByte = static_cast<uint32_t>(bytes);
150     return replyByte / (frameRenderMode.attrs.channelCount * (PcmFormatToBits(frameRenderMode.attrs.format) >>
151                         MOVE_RIGHT_NUM));
152 }
153 
154 /**
155  * @brief Reading audio file frame.
156  *
157  * @param file audio file path
158  * @param AudioSampleAttributes
159  * @param struct AudioHeadInfo wavHeadInfo
160  * @param struct AudioHwRender *hwRender
161  *
162  * @return Returns <b>0</b> if the initialization is successful; returns a negative value otherwise.
163  */
FrameLibStart(FILE * file,struct AudioSampleAttributes attrs,struct AudioHeadInfo wavHeadInfo,struct AudioHwRender * hwRender) const164 int32_t AudioLibRenderTest::FrameLibStart(FILE *file, struct AudioSampleAttributes attrs,
165     struct AudioHeadInfo wavHeadInfo, struct AudioHwRender *hwRender) const
166 {
167     if (hwRender == nullptr) {
168         return HDF_FAILURE;
169     }
170     size_t numRead = 0;
171     uint32_t remainingDataSize = wavHeadInfo.dataSize;
172     uint32_t bufferSize = PcmFramesToBytes(attrs);
173     if (bufferSize <= 0) {
174         return HDF_FAILURE;
175     }
176     hwRender->renderParam.frameRenderMode.buffer = (char *)calloc(1, bufferSize);
177     if (hwRender->renderParam.frameRenderMode.buffer == nullptr) {
178         return HDF_FAILURE;
179     }
180 
181     uint32_t readSize = (remainingDataSize > bufferSize) ? bufferSize : remainingDataSize;
182     numRead = fread(hwRender->renderParam.frameRenderMode.buffer, readSize, 1, file);
183     if (numRead < 1) {
184         free(hwRender->renderParam.frameRenderMode.buffer);
185         hwRender->renderParam.frameRenderMode.buffer = nullptr;
186         return HDF_FAILURE;
187     }
188     hwRender->renderParam.frameRenderMode.bufferSize = readSize;
189     hwRender->renderParam.frameRenderMode.bufferFrameSize =
190         PcmBytesToFrames(hwRender->renderParam.frameRenderMode, readSize);
191     return HDF_SUCCESS;
192 }
193 
LibStartAndStream(const std::string path,struct AudioSampleAttributes attrs,struct DevHandle * handle,struct AudioHwRender * hwRender,struct AudioHeadInfo wavHeadInfo) const194 int32_t AudioLibRenderTest::LibStartAndStream(const std::string path, struct AudioSampleAttributes attrs,
195     struct DevHandle *handle, struct AudioHwRender *hwRender, struct AudioHeadInfo wavHeadInfo) const
196 {
197     int ret = -1;
198     if (handle == nullptr || hwRender == nullptr) {
199         return HDF_FAILURE;
200     }
201     if (InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam) ||
202         InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam) ||
203         InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam) ||
204         InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam)) {
205         return HDF_FAILURE;
206     }
207     char absPath[PATH_MAX] = {0};
208     if (realpath(path.c_str(), absPath) == nullptr) {
209         return HDF_FAILURE;
210     }
211     FILE *file = fopen(absPath, "rb");
212     if (file == nullptr) {
213         return HDF_FAILURE;
214     }
215     if (WavHeadAnalysis(wavHeadInfo, file, attrs)) {
216         fclose(file);
217         return HDF_FAILURE;
218     }
219     ret = FrameLibStart(file, attrs, wavHeadInfo, hwRender);
220     if (ret < 0) {
221         fclose(file);
222         return HDF_FAILURE;
223     }
224     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, &hwRender->renderParam);
225     if (ret < 0) {
226         fclose(file);
227         free(hwRender->renderParam.frameRenderMode.buffer);
228         hwRender->renderParam.frameRenderMode.buffer = nullptr;
229         return HDF_FAILURE;
230     }
231     fclose(file);
232     free(hwRender->renderParam.frameRenderMode.buffer);
233     hwRender->renderParam.frameRenderMode.buffer = nullptr;
234     return HDF_SUCCESS;
235 }
236 
LibHwOutputRender(struct AudioHwRender * hwRender,struct DevHandle * handlerender) const237 int32_t AudioLibRenderTest::LibHwOutputRender(struct AudioHwRender *hwRender, struct DevHandle *handlerender) const
238 {
239     if (hwRender == nullptr || handlerender == nullptr) {
240         return HDF_FAILURE;
241     }
242     if (InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam) ||
243         InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam) ||
244         InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam) ||
245         InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam)) {
246         return HDF_FAILURE;
247     }
248     return HDF_SUCCESS;
249 }
250 
BindServiceAndHwRender(struct AudioHwRender * & hwRender,const std::string BindName,const std::string adapterNameCase,struct DevHandle * & handle) const251 int32_t AudioLibRenderTest::BindServiceAndHwRender(struct AudioHwRender *&hwRender,
252     const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const
253 {
254     handle = BindServiceRenderSo(BindName.c_str());
255     if (handle == nullptr) {
256         return HDF_FAILURE;
257     }
258     hwRender = (struct AudioHwRender *)calloc(1, sizeof(*hwRender));
259     if (hwRender == nullptr) {
260         CloseServiceRenderSo(handle);
261         return HDF_FAILURE;
262     }
263     if (InitHwRender(hwRender, adapterNameCase)) {
264         CloseServiceRenderSo(handle);
265         free(hwRender);
266         hwRender = nullptr;
267         return HDF_FAILURE;
268     }
269     return HDF_SUCCESS;
270 }
271 /**
272 * @tc.name  test BindServiceRenderSo API via legal input.
273 * @tc.number  SUB_Audio_InterfaceLib_BindServiceRender_0001
274 * @tc.desc  test Binding succeeded Service which service Name is control_service and close Service.
275 * @tc.author: zhouyongxiao
276 */
277 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0001, TestSize.Level1)
278 {
279     struct DevHandle *handle = nullptr;
280     handle = BindServiceRenderSo(BIND_CONTROL.c_str());
281     ASSERT_NE(nullptr, handle);
282     CloseServiceRenderSo(handle);
283 }
284 /**
285 * @tc.name  test BindServiceRenderSo API via invalid input.
286 * @tc.number  SUB_Audio_InterfaceLib_BindServiceRender_0002
287 * @tc.desc  test Binding failed service, where the service name is wrong.
288 * @tc.author: zhouyongxiao
289 */
290 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0002, TestSize.Level1)
291 {
292     struct DevHandle *handle = nullptr;
293     handle = BindServiceRenderSo(BIND_NAME_ERROR.c_str());
294     if (handle != nullptr) {
295         CloseServiceRenderSo(handle);
296         ASSERT_EQ(nullptr, handle);
297     }
298     EXPECT_EQ(nullptr, handle);
299 }
300 /**
301 * @tc.name  test BindServiceRenderSo API via nullptr input.
302 * @tc.number  SUB_Audio_InterfaceLib_BindServiceRender_0003
303 * @tc.desc  test Binding failed Service, nullptr pointer passed in.
304 * @tc.author: zhouyongxiao
305 */
306 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0003, TestSize.Level1)
307 {
308     struct DevHandle *handle = nullptr;
309     char *bindNameNull = nullptr;
310     handle = BindServiceRenderSo(bindNameNull);
311     if (handle != nullptr) {
312         CloseServiceRenderSo(handle);
313         ASSERT_EQ(nullptr, handle);
314     }
315     EXPECT_EQ(nullptr, handle);
316 }
317 /**
318 * @tc.name  test BindServiceRenderSo API via binding service name lens is 25.
319 * @tc.number  SUB_Audio_InterfaceLib_BindServiceRender_0004
320 * @tc.desc  test Binding failed Service, Log printing 'service name not support!' and 'Failed to get service!'.
321 * @tc.author: zhouyongxiao
322 */
323 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0004, TestSize.Level1)
324 {
325     struct DevHandle *handle = nullptr;
326     string bindNameLen = "renderrenderedededededede";
327     handle = BindServiceRenderSo(bindNameLen.c_str());
328     if (handle != nullptr) {
329         CloseServiceRenderSo(handle);
330         ASSERT_EQ(nullptr, handle);
331     }
332     EXPECT_EQ(nullptr, handle);
333 }
334 /**
335 * @tc.name  test BindServiceRenderSo API via binding service name lens is 26.
336 * @tc.number  SUB_Audio_InterfaceLib_BindServiceRender_0005
337 * @tc.desc  test Binding failed Service, Log printing 'Failed to snprintf_s'.
338 * @tc.author: zhouyongxiao
339 */
340 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_BindServiceRender_0005, TestSize.Level1)
341 {
342     struct DevHandle *handle = nullptr;
343     string bindNameLen = "renderrenderededededededer";
344     handle = BindServiceRenderSo(bindNameLen.c_str());
345     if (handle != nullptr) {
346         CloseServiceRenderSo(handle);
347         ASSERT_EQ(nullptr, handle);
348     }
349     EXPECT_EQ(nullptr, handle);
350 }
351 /**
352 * @tc.name  test InterfaceLibCtlRender API via writing volume value of AcodecIn is normal value and reading
353 *    this value.
354 * @tc.number  SUB_Audio_InterfaceLibCtlRender_Volume_AcodecIn_Write_Read_0001
355 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
356 * @tc.author: zhouyongxiao
357 */
358 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Volume_AcodecIn_Write_Read_0001, TestSize.Level1)
359 {
360     int32_t ret = -1;
361     float volumeValue = 0;
362     float volumeThresholdValueMaxIn = 0;
363     float volumeThresholdValueMinIn = 0;
364     float volumeBoundaryValueIn = 127.9;
365     struct DevHandle *handle = nullptr;
366     struct AudioHwRender *hwRender = nullptr;
367     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
368     ASSERT_EQ(HDF_SUCCESS, ret);
369 
370     hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN;
371     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam);
372     EXPECT_EQ(HDF_SUCCESS, ret);
373     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
374     EXPECT_EQ(HDF_SUCCESS, ret);
375     volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
376     volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
377 
378     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMaxIn - 1;
379     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
380     EXPECT_EQ(HDF_SUCCESS, ret);
381     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
382     EXPECT_EQ(HDF_SUCCESS, ret);
383     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
384     EXPECT_EQ(126, volumeValue);
385 
386     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMinIn + 1;
387     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
388     EXPECT_EQ(HDF_SUCCESS, ret);
389     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
390     EXPECT_EQ(HDF_SUCCESS, ret);
391     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
392     if (IS_ADM) {
393         EXPECT_EQ(41, volumeValue);
394     } else {
395         EXPECT_EQ(1, volumeValue);
396     }
397     hwRender->renderParam.renderMode.ctlParam.volume = volumeBoundaryValueIn;
398     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
399     EXPECT_EQ(HDF_SUCCESS, ret);
400     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
401     EXPECT_EQ(HDF_SUCCESS, ret);
402     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
403     EXPECT_EQ(127, volumeValue);
404     CloseServiceRenderSo(handle);
405     free(hwRender);
406     hwRender = nullptr;
407 }
408 /**
409 * @tc.name  test InterfaceLibCtlRender API via writing volume value of AcodecIn is boundary value and reading
410 *    this value.
411 * @tc.number  SUB_Audio_InterfaceLibCtlRender_Volume_AcodecIn_Write_Read_0002
412 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
413 * @tc.author: zhouyongxiao
414 */
415 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Volume_AcodecIn_Write_Read_0002, TestSize.Level1)
416 {
417     int32_t ret = -1;
418     struct AudioHwRender *hwRender = nullptr;
419     struct DevHandle *handle = nullptr;
420     float volumeThresholdValueMaxIn = 0;
421     float volumeThresholdValueMinIn = 0;
422     float volumeValue = 0;
423     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
424     ASSERT_EQ(HDF_SUCCESS, ret);
425 
426     hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN;
427     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam);
428     EXPECT_EQ(HDF_SUCCESS, ret);
429 
430     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
431     EXPECT_EQ(HDF_SUCCESS, ret);
432     volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
433     volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
434 
435     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMinIn;
436     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
437     EXPECT_EQ(HDF_SUCCESS, ret);
438     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
439     EXPECT_EQ(HDF_SUCCESS, ret);
440     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
441     if (IS_ADM == false) {
442         EXPECT_EQ(0, volumeValue);
443     } else {
444         EXPECT_EQ(40, volumeValue);
445     }
446 
447     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMaxIn;
448     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
449     EXPECT_EQ(HDF_SUCCESS, ret);
450     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
451     EXPECT_EQ(HDF_SUCCESS, ret);
452     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
453     EXPECT_EQ(127, volumeValue);
454 
455     CloseServiceRenderSo(handle);
456     free(hwRender);
457     hwRender = nullptr;
458 }
459 /**
460 * @tc.name  test InterfaceLibCtlRender API via writing volume value is invalid value of AcodecIn.
461 * @tc.number  SUB_Audio_InterfaceLibCtlRender_Volume_AcodecIn_Write_Read_0003
462 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
463 * @tc.author: zhouyongxiao
464 */
465 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Volume_AcodecIn_Write_Read_0003, TestSize.Level1)
466 {
467     int32_t ret = -1;
468     struct DevHandle *handle = nullptr;
469     struct AudioHwRender *hwRender = nullptr;
470     float volumeThresholdValueMaxIn = 0;
471     float volumeThresholdValueMinIn = 0;
472 
473     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
474     ASSERT_EQ(HDF_SUCCESS, ret);
475     hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN;
476     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam);
477     EXPECT_EQ(HDF_SUCCESS, ret);
478 
479     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
480     EXPECT_EQ(HDF_SUCCESS, ret);
481     volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
482     volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
483 
484     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMaxIn + 1;
485     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
486     EXPECT_EQ(HDF_FAILURE, ret);
487 
488     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMinIn - 1;
489     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
490     EXPECT_EQ(HDF_FAILURE, ret);
491 
492     CloseServiceRenderSo(handle);
493     free(hwRender);
494     hwRender = nullptr;
495 }
496 
497 /**
498 * @tc.name  test InterfaceLibCtlRender API via writing GetVolthreshold value that
499 *    Hardware equipment of Acodec_ChangeIn.
500 * @tc.number  SUB_Audio_InterfaceLibCtlRender_GetVolthresholdRead_0002
501 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ.
502 * @tc.author: zhouyongxiao
503 */
504 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GetVolthresholdRead_0002, TestSize.Level1)
505 {
506     int32_t ret = -1;
507     float volumeThresholdValueMaxIn = 0;
508     float volumeThresholdValueMinIn = 0;
509     float expMax = 127;
510     float expMix = 40;
511     struct AudioHwRender *hwRender = nullptr;
512     struct DevHandle *handle = nullptr;
513     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
514     ASSERT_EQ(HDF_SUCCESS, ret);
515     hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN;
516     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam);
517     EXPECT_EQ(HDF_SUCCESS, ret);
518 
519     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
520     EXPECT_EQ(HDF_SUCCESS, ret);
521     volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
522     volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
523     EXPECT_EQ(expMax, volumeThresholdValueMaxIn);
524     if (IS_ADM == false) {
525         EXPECT_EQ(0, volumeThresholdValueMinIn);
526     } else {
527         EXPECT_EQ(expMix, volumeThresholdValueMinIn);
528     }
529     CloseServiceRenderSo(handle);
530     free(hwRender);
531     hwRender = nullptr;
532 }
533 /**
534 * @tc.name  test InterfaceLibCtlRender API via writing ChannelMode value is normal value and reading this value.
535 * @tc.number  SUB_Audio_InterfaceLibCtlRender_ChannelMode_Write_Read_0001
536 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE
537 *    and AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ.
538 * @tc.author: zhouyongxiao
539 */
540 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_ChannelMode_Write_Read_0001, TestSize.Level1)
541 {
542     int32_t ret = -1;
543     float channelModeExc = 1;
544     struct DevHandle *handle = nullptr;
545     struct DevHandle *handleRender = nullptr;
546     struct AudioHwRender *impl = nullptr;
547     ret = BindServiceAndHwRender(impl, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
548     ASSERT_EQ(HDF_SUCCESS, ret);
549     handleRender = BindServiceRenderSo(BIND_RENDER.c_str());
550     if (handleRender == nullptr) {
551         CloseServiceRenderSo(handle);
552         free(impl);
553         impl = nullptr;
554         ASSERT_NE(nullptr, handleRender);
555     }
556     ret = LibHwOutputRender(impl, handleRender);
557     EXPECT_EQ(HDF_SUCCESS, ret);
558     if (impl != nullptr) {
559         impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_BOTH_RIGHT;
560         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam);
561         EXPECT_EQ(HDF_SUCCESS, ret);
562         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam);
563         EXPECT_EQ(HDF_SUCCESS, ret);
564         channelModeExc = impl->renderParam.frameRenderMode.mode;
565         EXPECT_EQ(AUDIO_CHANNEL_BOTH_RIGHT, channelModeExc);
566 
567         impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_RIGHT_MUTE;
568         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam);
569         EXPECT_EQ(HDF_SUCCESS, ret);
570         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam);
571         EXPECT_EQ(HDF_SUCCESS, ret);
572         channelModeExc = impl->renderParam.frameRenderMode.mode;
573         EXPECT_EQ(AUDIO_CHANNEL_RIGHT_MUTE, channelModeExc);
574     }
575     CloseServiceRenderSo(handleRender);
576     CloseServiceRenderSo(handle);
577     free(impl);
578     impl = nullptr;
579 }
580 /**
581 * @tc.name  test InterfaceLibCtlRender API via writing ChannelMode value is boundary value and reading this value.
582 * @tc.number  SUB_Audio_InterfaceLibCtlRender_ChannelMode_Write_Read_0002
583 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE
584 *    and AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ.
585 * @tc.author: zhouyongxiao
586 */
587 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_ChannelMode_Write_Read_0002, TestSize.Level1)
588 {
589     int32_t ret = -1;
590     float channelModeExc = 1;
591     struct DevHandle *handleRender = nullptr;
592     struct DevHandle *handle = nullptr;
593     struct AudioHwRender *impl = nullptr;
594     ret = BindServiceAndHwRender(impl, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
595     ASSERT_EQ(HDF_SUCCESS, ret);
596     handleRender = BindServiceRenderSo(BIND_RENDER.c_str());
597     if (handleRender == nullptr) {
598         free(impl);
599         impl = nullptr;
600         CloseServiceRenderSo(handle);
601         ASSERT_NE(nullptr, handleRender);
602     }
603     ret = LibHwOutputRender(impl, handleRender);
604     EXPECT_EQ(HDF_SUCCESS, ret);
605     if (impl != nullptr){
606         impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_NORMAL;
607         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam);
608         EXPECT_EQ(HDF_SUCCESS, ret);
609         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam);
610         EXPECT_EQ(HDF_SUCCESS, ret);
611         channelModeExc = impl->renderParam.frameRenderMode.mode;
612         EXPECT_EQ(AUDIO_CHANNEL_NORMAL, channelModeExc);
613 
614         impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_BOTH_MUTE;
615         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam);
616         EXPECT_EQ(HDF_SUCCESS, ret);
617         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam);
618         EXPECT_EQ(HDF_SUCCESS, ret);
619         channelModeExc = impl->renderParam.frameRenderMode.mode;
620         EXPECT_EQ(AUDIO_CHANNEL_BOTH_MUTE, channelModeExc);
621     }
622     CloseServiceRenderSo(handleRender);
623     CloseServiceRenderSo(handle);
624     free(impl);
625     impl = nullptr;
626 }
627 /**
628 * @tc.name  test InterfaceLibCtlRender API via writing mute value that include 1 and 0 and reading mute value.
629 * @tc.number  SUB_Audio_InterfaceLibCtlRender_MuteWrite_Read_0001
630 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_MUTE_WRITE and AUDIODRV_CTL_IOCTL_MUTE_READ.
631 * @tc.author: zhouyongxiao
632 */
633 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_MuteWrite_Read_0001, TestSize.Level1)
634 {
635     int32_t ret = -1;
636     bool muteValue = 1;
637     bool wishValue = 0;
638     bool expectedValue = 1;
639     struct DevHandle *handle = nullptr;
640     struct AudioHwRender *hwRender = nullptr;
641     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
642     ASSERT_EQ(HDF_SUCCESS, ret);
643 
644     hwRender->renderParam.renderMode.ctlParam.mute = 0;
645     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam);
646     EXPECT_EQ(HDF_SUCCESS, ret);
647     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam);
648     EXPECT_EQ(HDF_SUCCESS, ret);
649     muteValue = hwRender->renderParam.renderMode.ctlParam.mute;
650     EXPECT_EQ(wishValue, muteValue);
651     hwRender->renderParam.renderMode.ctlParam.mute = 1;
652     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam);
653     EXPECT_EQ(HDF_SUCCESS, ret);
654     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam);
655     EXPECT_EQ(HDF_SUCCESS, ret);
656     muteValue = hwRender->renderParam.renderMode.ctlParam.mute;
657     EXPECT_EQ(expectedValue, muteValue);
658     CloseServiceRenderSo(handle);
659     free(hwRender);
660     hwRender = nullptr;
661 }
662 /**
663 * @tc.name  test InterfaceLibCtlRender API via writing mute value that include 2 and reading mute value.
664 * @tc.number  SUB_Audio_InterfaceLibCtlRender_MuteWrite_Read_0002
665 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_MUTE_WRITE and AUDIODRV_CTL_IOCTL_MUTE_READ.
666 * @tc.author: zhouyongxiao
667 */
668 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_MuteWrite_Read_0002, TestSize.Level1)
669 {
670     int32_t ret = -1;
671     bool muteValue = 0;
672     bool wishValue = 0;
673     bool expectedValue = 1;
674     struct DevHandle *handle = nullptr;
675     struct AudioHwRender *hwRender = nullptr;
676     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
677     ASSERT_EQ(HDF_SUCCESS, ret);
678 
679     hwRender->renderParam.renderMode.ctlParam.mute = 2;
680     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam);
681     EXPECT_EQ(HDF_SUCCESS, ret);
682     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam);
683     EXPECT_EQ(HDF_SUCCESS, ret);
684     muteValue = hwRender->renderParam.renderMode.ctlParam.mute;
685     EXPECT_EQ(expectedValue, muteValue);
686     hwRender->renderParam.renderMode.ctlParam.mute = 0;
687     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam);
688     EXPECT_EQ(HDF_SUCCESS, ret);
689     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam);
690     EXPECT_EQ(HDF_SUCCESS, ret);
691     muteValue = hwRender->renderParam.renderMode.ctlParam.mute;
692     EXPECT_EQ(wishValue, muteValue);
693     CloseServiceRenderSo(handle);
694     free(hwRender);
695     hwRender = nullptr;
696 }
697 /**
698 * @tc.name  test InterfaceLibCtlRender API via selecting scene.
699 * @tc.number  SUB_Audio_InterfaceLib_CtlRender_SelectScene_0001
700 * @tc.desc  test InterfaceLibCtlRender,cmdId is AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE.
701 * @tc.author: zhouyongxiao
702 */
703 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLib_CtlRender_SelectScene_0001, TestSize.Level1)
704 {
705     int32_t ret = -1;
706     struct DevHandle *handle = nullptr;
707     struct AudioHwRender *hwRender = nullptr;
708     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
709     ASSERT_EQ(HDF_SUCCESS, ret);
710 
711     struct AudioSceneDescriptor scene = {
712         .scene.id = 0,
713         .desc.pins = PIN_OUT_HEADSET,
714     };
715     hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceNum = 1;
716     ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].deviceSwitch,
717         PATHPLAN_COUNT, "Dacl enable");
718     hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].value = 0;
719     hwRender->renderParam.frameRenderMode.attrs.type = (enum AudioCategory)(scene.scene.id);
720     hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = scene.desc.pins;
721 
722     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE, &hwRender->renderParam);
723     EXPECT_EQ(HDF_SUCCESS, ret);
724 
725     CloseServiceRenderSo(handle);
726     free(hwRender);
727     hwRender = nullptr;
728 }
729 /**
730 * @tc.name  test InterfaceLibCtlRender API via writing normal gain value.
731 * @tc.number  SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0001
732 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ.
733 * @tc.author: zhouyongxiao
734 */
735 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0001, TestSize.Level1)
736 {
737     int32_t ret = -1;
738     struct AudioHwRender *hwRender = nullptr;
739     struct DevHandle *handle = nullptr;
740     float gainValue = 0;
741     float gainThresholdValueMax, gainThresholdValueMin;
742     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
743     ASSERT_EQ(HDF_SUCCESS, ret);
744 
745     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
746     EXPECT_EQ(HDF_SUCCESS, ret);
747     gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
748     gainThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
749     ret = InitHwRenderMode(hwRender->renderParam.renderMode);
750     EXPECT_EQ(HDF_SUCCESS, ret);
751 
752     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMax - 1;
753     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
754     EXPECT_EQ(HDF_SUCCESS, ret);
755     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
756     EXPECT_EQ(HDF_SUCCESS, ret);
757     gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
758     EXPECT_EQ(gainThresholdValueMax - 1, gainValue);
759     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMin + 1;
760     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
761     EXPECT_EQ(HDF_SUCCESS, ret);
762     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
763     EXPECT_EQ(HDF_SUCCESS, ret);
764     gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
765     EXPECT_EQ(gainThresholdValueMin + 1, gainValue);
766     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = 2.3;
767     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
768     EXPECT_EQ(HDF_SUCCESS, ret);
769     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
770     EXPECT_EQ(HDF_SUCCESS, ret);
771     gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
772     EXPECT_EQ(2, gainValue);
773     CloseServiceRenderSo(handle);
774     free(hwRender);
775     hwRender = nullptr;
776 }
777 /**
778 * @tc.name  test InterfaceLibCtlRender API via writing boundary value of gain and reading gain value.
779 * @tc.number  SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0002
780 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ.
781 * @tc.author: zhouyongxiao
782 */
783 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0002, TestSize.Level1)
784 {
785     int32_t ret = -1;
786     float gainValue = 0;
787     float gainThresholdValueMax, gainThresholdValueMin;
788     struct DevHandle *handle = nullptr;
789     struct AudioHwRender *hwRender = nullptr;
790     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
791     ASSERT_EQ(HDF_SUCCESS, ret);
792 
793     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
794     EXPECT_EQ(HDF_SUCCESS, ret);
795     gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
796     gainThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
797     ret = InitHwRenderMode(hwRender->renderParam.renderMode);
798     EXPECT_EQ(HDF_SUCCESS, ret);
799     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMin;
800     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
801     EXPECT_EQ(HDF_SUCCESS, ret);
802     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
803     EXPECT_EQ(HDF_SUCCESS, ret);
804     gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
805     EXPECT_EQ(gainThresholdValueMin, gainValue);
806     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMax;
807     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
808     EXPECT_EQ(HDF_SUCCESS, ret);
809     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
810     EXPECT_EQ(HDF_SUCCESS, ret);
811     gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
812     EXPECT_EQ(gainThresholdValueMax, gainValue);
813     CloseServiceRenderSo(handle);
814     free(hwRender);
815     hwRender = nullptr;
816 }
817 /**
818 * @tc.name  test InterfaceLibCtlRender API via writing gain invalid value.
819 * @tc.number  SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0003
820 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ.
821 * @tc.author: zhouyongxiao
822 */
823 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GainWrite_Read_0003, TestSize.Level1)
824 {
825     int32_t ret = -1;
826     float gainThresholdValueMax, gainThresholdValueMin;
827     struct AudioHwRender *hwRender = nullptr;
828     struct DevHandle *handle = nullptr;
829     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
830     ASSERT_EQ(HDF_SUCCESS, ret);
831 
832     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
833     EXPECT_EQ(HDF_SUCCESS, ret);
834     gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
835     gainThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
836     ret = InitHwRenderMode(hwRender->renderParam.renderMode);
837     EXPECT_EQ(HDF_SUCCESS, ret);
838     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMax + 1;
839     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
840     EXPECT_EQ(HDF_FAILURE, ret);
841     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMin - 1;
842     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
843     EXPECT_EQ(HDF_FAILURE, ret);
844     CloseServiceRenderSo(handle);
845     free(hwRender);
846     hwRender = nullptr;
847 }
848 /**
849 * @tc.name  test InterfaceLibCtlRender API via getting gainthreshold value.
850 * @tc.number  SUB_Audio_InterfaceLibCtlRender_GetGainthresholdRead_0001
851 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ.
852 * @tc.author: zhouyongxiao
853 */
854 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_GetGainthresholdRead_0001, TestSize.Level1)
855 {
856     int32_t ret = -1;
857     float gainThresholdValueMaxGet, gainThresholdValueMinGet;
858     float expMax = 10;
859     float expMix = 0;
860     struct DevHandle *handle = nullptr;
861     struct AudioHwRender *hwRender = nullptr;
862     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
863     ASSERT_EQ(HDF_SUCCESS, ret);
864 
865     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
866     EXPECT_EQ(HDF_SUCCESS, ret);
867     gainThresholdValueMaxGet = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
868     gainThresholdValueMinGet = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
869     EXPECT_LT(expMax, gainThresholdValueMaxGet);
870     EXPECT_EQ(expMix, gainThresholdValueMinGet);
871     CloseServiceRenderSo(handle);
872     free(hwRender);
873     hwRender = nullptr;
874 }
875 /**
876 * @tc.name  test InterfaceLibCtlRender API via using Acodec_ChangeIn.
877 * @tc.number  SUB_Audio_InterfaceLibCtlRender_Acodec_ChangeIn_0001
878 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN.
879 * @tc.author: zhouyongxiao
880 */
881 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Acodec_ChangeIn_0001, TestSize.Level1)
882 {
883     int32_t ret = -1;
884     struct DevHandle *handle = nullptr;
885     struct AudioHwRender *hwRender = nullptr;
886     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
887     ASSERT_EQ(HDF_SUCCESS, ret);
888 
889     hwRender->renderParam.renderMode.hwInfo.card = AUDIO_SERVICE_IN;
890     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN, &hwRender->renderParam);
891     EXPECT_EQ(HDF_SUCCESS, ret);
892     CloseServiceRenderSo(handle);
893     free(hwRender);
894     hwRender = nullptr;
895 }
896 /**
897 * @tc.name  test InterfaceLibCtlRender API via inputting invalid cmdid.
898 * @tc.number  SUB_Audio_InterfaceLibCtlRender_Abnormal_0001
899 * @tc.desc  test InterfaceLibCtlRender, cmdId is invalid eg 50,so return -1.
900 * @tc.author: zhouyongxiao
901 */
902 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Abnormal_0001, TestSize.Level1)
903 {
904     int32_t ret = -1;
905     struct DevHandle *handle = nullptr;
906     struct AudioHwRender *hwRender = nullptr;
907     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME_USB, handle);
908     ASSERT_EQ(HDF_SUCCESS, ret);
909 
910     ret = InterfaceLibCtlRender(handle, 50, &hwRender->renderParam);
911     if (ret == 0) {
912         CloseServiceRenderSo(handle);
913         free(hwRender);
914         hwRender = nullptr;
915         ASSERT_EQ(HDF_FAILURE, ret);
916     }
917     EXPECT_EQ(HDF_FAILURE, ret);
918     CloseServiceRenderSo(handle);
919     free(hwRender);
920     hwRender = nullptr;
921 }
922 /**
923 * @tc.name  test InterfaceLibCtlRender API via inputting handleData invalid.
924 * @tc.number  SUB_Audio_InterfaceLibCtlRender_Abnormal_0002
925 * @tc.desc  test InterfaceLibCtlRender, handleData is nullptr,so return -1.
926 * @tc.author: zhouyongxiao
927 */
928 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibCtlRender_Abnormal_0002, TestSize.Level1)
929 {
930     int32_t ret = -1;
931     struct DevHandle *handle = nullptr;
932     struct AudioHwRenderParam *handleData = nullptr;
933     handle = BindServiceRenderSo(BIND_CONTROL.c_str());
934     ASSERT_NE(nullptr, handle);
935     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, handleData);
936     if (ret == 0) {
937         CloseServiceRenderSo(handle);
938         ASSERT_EQ(HDF_FAILURE, ret);
939     }
940     EXPECT_EQ(HDF_FAILURE, ret);
941     CloseServiceRenderSo(handle);
942 }
943 
944 /**
945 * @tc.name  test InterfaceLibOutputRender API via cmdid is AUDIO_DRV_PCM_IOCTL_HW_PARAMS.
946 * @tc.number  SUB_Audio_InterfaceLibOutputRender_HwParams_0001
947 * @tc.desc  test Audio lib Interface OutputRender.return 0 if the Interface call successful.
948 * @tc.author: zhouyongxiao
949 */
950 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_HwParams_0001, TestSize.Level1)
951 {
952     int32_t ret = -1;
953     struct DevHandle *handle = nullptr;
954     struct AudioHwRender *hwRender = nullptr;
955     ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle);
956     ASSERT_EQ(HDF_SUCCESS, ret);
957 
958     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
959     EXPECT_EQ(HDF_SUCCESS, ret);
960     CloseServiceRenderSo(handle);
961     free(hwRender);
962     hwRender = nullptr;
963 }
964 /**
965 * @tc.name  test InterfaceLibOutputRender API via cmdid is AUDIO_DRV_PCM_IOCTL_PREPARE.
966 * @tc.number  SUB_Audio_InterfaceLibOutputRender_Prepare_0001
967 * @tc.desc  test Audio lib Interface OutputRender.return 0 if the Interface call successful.
968 * @tc.author: zhouyongxiao
969 */
970 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Prepare_0001, TestSize.Level1)
971 {
972     int32_t ret = -1;
973     struct AudioHwRender *hwRender = nullptr;
974     struct DevHandle *handle = nullptr;
975     ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle);
976     ASSERT_EQ(HDF_SUCCESS, ret);
977 
978     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
979     EXPECT_EQ(HDF_SUCCESS, ret);
980     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam);
981     EXPECT_EQ(HDF_SUCCESS, ret);
982     CloseServiceRenderSo(handle);
983     free(hwRender);
984     hwRender = nullptr;
985 }
986 /**
987 * @tc.name  test InterfaceLibOutputRender API via cmdid is AUDIO_DRV_PCM_IOCTRL_START.
988 * @tc.number  SUB_Audio_InterfaceLibOutputRender_Start_0001
989 * @tc.desc  test Audio lib Interface OutputRender.return 0 if the Interface call successful.
990 * @tc.author: zhouyongxiao
991 */
992 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Start_0001, TestSize.Level1)
993 {
994     int32_t ret = -1;
995     struct DevHandle *handle = nullptr;
996     struct AudioHwRender *hwRender = nullptr;
997     ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle);
998     ASSERT_EQ(HDF_SUCCESS, ret);
999 
1000     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
1001     EXPECT_EQ(HDF_SUCCESS, ret);
1002     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam);
1003     EXPECT_EQ(HDF_SUCCESS, ret);
1004     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam);
1005     EXPECT_EQ(HDF_SUCCESS, ret);
1006     CloseServiceRenderSo(handle);
1007     free(hwRender);
1008     hwRender = nullptr;
1009 }
1010 /**
1011 * @tc.name  test InterfaceLibOutputRender API via cmdid is AUDIO_DRV_PCM_IOCTL_WRITE and AUDIO_DRV_PCM_IOCTRL_STOP.
1012 * @tc.number  SUB_Audio_InterfaceLibOutputRender_Write_Stop_0001
1013 * @tc.desc  test Audio lib Interface OutputRender and Normal data flow distribution.
1014 * @tc.author: zhouyongxiao
1015 */
1016 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Write_Stop_0001, TestSize.Level1)
1017 {
1018     struct DevHandle *handle = nullptr;
1019     struct AudioHeadInfo wavHeadInfo = {};
1020     struct AudioHwRender *hwRender = nullptr;
1021     int32_t ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle);
1022     ASSERT_EQ(HDF_SUCCESS, ret);
1023     ret = LibHwOutputRender(hwRender, handle);
1024     EXPECT_EQ(HDF_SUCCESS, ret);
1025     char absPath[PATH_MAX] = {0};
1026     if (realpath(AUDIO_FILE.c_str(), absPath) == nullptr) {
1027         free(hwRender);
1028         CloseServiceRenderSo(handle);
1029         ASSERT_NE(nullptr, realpath(AUDIO_FILE.c_str(), absPath));
1030     }
1031     FILE *file = fopen(absPath, "rb");
1032     if (file == nullptr) {
1033         free(hwRender);
1034         CloseServiceRenderSo(handle);
1035         ASSERT_NE(nullptr, file);
1036     }
1037     if (hwRender != nullptr) {
1038         ret = WavHeadAnalysis(wavHeadInfo, file, hwRender->renderParam.frameRenderMode.attrs);
1039         if (ret < 0) {
1040             free(hwRender);
1041             fclose(file);
1042             CloseServiceRenderSo(handle);
1043             ASSERT_EQ(HDF_SUCCESS, ret);
1044         }
1045         ret = FrameLibStart(file, hwRender->renderParam.frameRenderMode.attrs, wavHeadInfo, hwRender);
1046         EXPECT_EQ(HDF_SUCCESS, ret);
1047         ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, &hwRender->renderParam);
1048         EXPECT_EQ(HDF_SUCCESS, ret);
1049         ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
1050         EXPECT_EQ(HDF_SUCCESS, ret);
1051         ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
1052         EXPECT_EQ(HDF_SUCCESS, ret);
1053         if (hwRender->renderParam.frameRenderMode.buffer != nullptr) {
1054             free(hwRender->renderParam.frameRenderMode.buffer);
1055         }
1056         free(hwRender);
1057     }
1058     CloseServiceRenderSo(handle);
1059     fclose(file);
1060 }
1061 /**
1062 * @tc.name  test InterfaceLibCtlRender and InterfaceLibOutputRender API via Serial
1063     transmission of data flow and control flow.
1064 * @tc.number  SUB_Audio_InterfaceLibOutputRender_Write_0001
1065 * @tc.desc  test Audio lib Interface CtlRender and OutputRender, Data stream and control stream send successful.
1066 * @tc.author: zhouyongxiao
1067 */
1068 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Write_0001, TestSize.Level1)
1069 {
1070     int32_t ret = -1;
1071     float muteValue = 0;
1072     float expectedValue = 0;
1073     struct DevHandle *handler = nullptr;
1074     struct DevHandle *handlec = nullptr;
1075     struct AudioHeadInfo wavHeadInfo = {};
1076     struct AudioHwRender *hwRender = nullptr;
1077     ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handler);
1078     ASSERT_EQ(HDF_SUCCESS, ret);
1079     handlec = BindServiceRenderSo(BIND_CONTROL.c_str());
1080     if (handlec == nullptr) {
1081         CloseServiceRenderSo(handler);
1082         free(hwRender);
1083         hwRender = nullptr;
1084         ASSERT_NE(nullptr, handlec);
1085     }
1086     if (hwRender != nullptr) {
1087         hwRender->renderParam.renderMode.ctlParam.mute = muteValue;
1088         ret = InterfaceLibCtlRender(handlec, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam);
1089         EXPECT_EQ(HDF_SUCCESS, ret);
1090         ret = InterfaceLibCtlRender(handlec, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam);
1091         EXPECT_EQ(HDF_SUCCESS, ret);
1092         expectedValue = hwRender->renderParam.renderMode.ctlParam.mute;
1093         EXPECT_EQ(expectedValue, muteValue);
1094 
1095         ret = LibStartAndStream(AUDIO_FILE, hwRender->renderParam.frameRenderMode.attrs,
1096             handler, hwRender, wavHeadInfo);
1097         if (ret < 0) {
1098             CloseServiceRenderSo(handler);
1099             CloseServiceRenderSo(handlec);
1100             free(hwRender);
1101             ASSERT_EQ(HDF_SUCCESS, ret);
1102         }
1103     ret = InterfaceLibOutputRender(handler, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
1104     EXPECT_EQ(HDF_SUCCESS, ret);
1105     ret = InterfaceLibOutputRender(handler, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
1106     EXPECT_EQ(HDF_SUCCESS, ret);
1107     }
1108     CloseServiceRenderSo(handler);
1109     CloseServiceRenderSo(handlec);
1110     free(hwRender);
1111     hwRender = nullptr;
1112 }
1113 /**
1114 * @tc.name  test InterfaceLibOutputRender API via pause.
1115 * @tc.number  SUB_Audio_InterfaceLibCtlRender_Pause_0001
1116 * @tc.desc  test InterfaceLibOutputRender,cmdId is AUDIODRV_CTL_IOCTL_PAUSE_WRITE.
1117 * @tc.author: zhouyongxiao
1118 */
1119 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Pause_0001, TestSize.Level1)
1120 {
1121     int32_t ret = -1;
1122     struct DevHandle *handle = nullptr;
1123     struct AudioHwRender *hwRender = nullptr;
1124     ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle);
1125     ASSERT_EQ(HDF_SUCCESS, ret);
1126     ret = LibHwOutputRender(hwRender, handle);
1127     EXPECT_EQ(HDF_SUCCESS, ret);
1128     hwRender->renderParam.renderMode.ctlParam.pause = 1;
1129     ret = InterfaceLibOutputRender(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, &hwRender->renderParam);
1130     EXPECT_EQ(HDF_SUCCESS, ret);
1131     CloseServiceRenderSo(handle);
1132     free(hwRender);
1133     hwRender = nullptr;
1134 }
1135 /**
1136 * @tc.name  test InterfaceLibOutputRender API via resuming.
1137 * @tc.number  SUB_Audio_InterfaceLib_CtlRender_Resume_0001
1138 * @tc.desc  test InterfaceLibOutputRender,cmdId is AUDIODRV_CTL_IOCTL_PAUSE_WRITE.
1139 * @tc.author: zhouyongxiao
1140 */
1141 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Resume_0001, TestSize.Level1)
1142 {
1143     int32_t ret = -1;
1144     struct DevHandle *handle = nullptr;
1145     struct AudioHwRender *hwRender = nullptr;
1146     ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle);
1147     ASSERT_EQ(HDF_SUCCESS, ret);
1148     ret = LibHwOutputRender(hwRender, handle);
1149     EXPECT_EQ(HDF_SUCCESS, ret);
1150     hwRender->renderParam.renderMode.ctlParam.pause = 0;
1151     ret = InterfaceLibOutputRender(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, &hwRender->renderParam);
1152     EXPECT_EQ(HDF_SUCCESS, ret);
1153     CloseServiceRenderSo(handle);
1154     free(hwRender);
1155     hwRender = nullptr;
1156 }
1157 /**
1158 * @tc.name  test InterfaceLibOutputRender API via setting the cmdId is invalid.
1159 * @tc.number  SUB_Audio_InterfaceLibOutputRender__Abnormal_0001
1160 * @tc.desc  test Audio lib Interface OutputRender via cmdid is invalid and cmdid is 30,so Interface return -1.
1161 * @tc.author: zhouyongxiao
1162 */
1163 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Abnormal_0001, TestSize.Level1)
1164 {
1165     int32_t ret = -1;
1166     struct DevHandle *handle = nullptr;
1167     struct AudioHwRender *hwRender = nullptr;
1168     ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME_USB, handle);
1169     ASSERT_EQ(HDF_SUCCESS, ret);
1170 
1171     ret = InterfaceLibOutputRender(handle, 30, &hwRender->renderParam);
1172     EXPECT_EQ(HDF_FAILURE, ret);
1173     CloseServiceRenderSo(handle);
1174     free(hwRender);
1175     hwRender = nullptr;
1176 }
1177 /**
1178 * @tc.name  test InterfaceLibOutputRender API via inputting handleData is nullptr.
1179 * @tc.number  SUB_Audio_InterfaceLibOutputRender_Abnormal_0002
1180 * @tc.desc  test Audio lib Interface OutputRender, handleData is nullptr.
1181 * @tc.author: zhouyongxiao
1182 */
1183 HWTEST_F(AudioLibRenderTest, SUB_Audio_InterfaceLibOutputRender_Abnormal_0002, TestSize.Level1)
1184 {
1185     int32_t ret = -1;
1186     struct DevHandle *handle = nullptr;
1187     struct AudioHwRenderParam *handleData = nullptr;
1188     handle = BindServiceRenderSo(BIND_RENDER.c_str());
1189     ASSERT_NE(nullptr, handle);
1190     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, handleData);
1191     EXPECT_EQ(HDF_FAILURE, ret);
1192     CloseServiceRenderSo(handle);
1193 }
1194 }